Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
Split login from data extraction when the scout demonstrated a credentialed flow (#7934)
Andrew Neilson16b2efab8b4b
diff --git a/.env.example b/.env.exampleindex 795438b21..08d76de2d 100644--- a/.env.example+++ b/.env.example@@ -15,6 +15,15 @@ OPENAI_API_KEY=""# OPENAI_ORGANIZATION: Your OpenAI org-id. Optional.# OPENAI_ORGANIZATION=""+# ENABLE_XAI: Set to true to enable xAI Grok as a language model provider.+ENABLE_XAI=false+# XAI_API_KEY: Your xAI API key for accessing Grok models.+XAI_API_KEY=""+# XAI_API_BASE: The base URL for xAI's API.+XAI_API_BASE="https://api.x.ai/v1"+# XAI_REASONING_EFFORT: Optional reasoning effort for supported Grok models: low, medium, or high.+XAI_REASONING_EFFORT="medium"+# ENABLE_ANTHROPIC: Set to true to enable Anthropic as a language model provider.ENABLE_ANTHROPIC=false# ANTHROPIC_API_KEY: Your Anthropic API key for accessing models like Claude-3, Claude-4, and Claude-4.5.@@ -86,7 +95,7 @@ YUTORI_TOOL_SET=""# LLM_KEY: The chosen language model to use. This should be one of the models# provided by the enabled LLM providers (e.g., OPENAI_GPT5_5, OPENAI_GPT5_4,-# ANTHROPIC_CLAUDE5_OPUS, ANTHROPIC_CLAUDE5_FABLE, ANTHROPIC_CLAUDE4.7_OPUS,+# XAI_GROK_4_5, ANTHROPIC_CLAUDE5_OPUS, ANTHROPIC_CLAUDE5_FABLE, ANTHROPIC_CLAUDE4.7_OPUS,# ANTHROPIC_CLAUDE4.6_SONNET, GEMINI_3_PRO,# BEDROCK_ANTHROPIC_CLAUDE5_OPUS_INFERENCE_PROFILE,# BEDROCK_ANTHROPIC_CLAUDE5_OPUS_WITH_FALLBACK,diff --git a/alembic/versions/2026_07_31_2340-f3a7c1d9e482_add_action_execution_timestamps.py b/alembic/versions/2026_07_31_2340-f3a7c1d9e482_add_action_execution_timestamps.pynew file mode 100644index 000000000..e3616973b--- /dev/null+++ b/alembic/versions/2026_07_31_2340-f3a7c1d9e482_add_action_execution_timestamps.py@@ -0,0 +1,29 @@+"""add action execution timestamps++Revision ID: f3a7c1d9e482+Revises: 92ebe14532b9+Create Date: 2026-07-31T23:40:00+00:00++"""++from typing import Sequence, Union++import sqlalchemy as sa++from alembic import op++# revision identifiers, used by Alembic.+revision: str = "f3a7c1d9e482"+down_revision: Union[str, None] = "92ebe14532b9"+branch_labels: Union[str, Sequence[str], None] = None+depends_on: Union[str, Sequence[str], None] = None+++def upgrade() -> None:+ op.add_column("actions", sa.Column("started_at", sa.DateTime(), nullable=True))+ op.add_column("actions", sa.Column("finished_at", sa.DateTime(), nullable=True))+++def downgrade() -> None:+ op.drop_column("actions", "finished_at")+ op.drop_column("actions", "started_at")diff --git a/docs/api-reference/openapi.json b/docs/api-reference/openapi.jsonindex 2949a05e9..294a98f45 100644--- a/docs/api-reference/openapi.json+++ b/docs/api-reference/openapi.json@@ -8006,6 +8006,30 @@"title": "Skip Auto Complete Tab","default": false},+ "started_at": {+ "anyOf": [+ {+ "type": "string",+ "format": "date-time"+ },+ {+ "type": "null"+ }+ ],+ "title": "Started At"+ },+ "finished_at": {+ "anyOf": [+ {+ "type": "string",+ "format": "date-time"+ },+ {+ "type": "null"+ }+ ],+ "title": "Finished At"+ },"created_at": {"anyOf": [{diff --git a/docs/developers/self-hosted/llm-configuration.mdx b/docs/developers/self-hosted/llm-configuration.mdxindex 97ece43da..a7fa2ae8c 100644--- a/docs/developers/self-hosted/llm-configuration.mdx+++ b/docs/developers/self-hosted/llm-configuration.mdx@@ -1,10 +1,12 @@---title: LLM Configurationsubtitle: Connect your preferred language model provider-description: Configure LLM providers for self-hosted Skyvern including OpenAI, Anthropic, Azure OpenAI, Google Gemini, AWS Bedrock, Ollama, and OpenAI-compatible endpoints via LiteLLM.+description: Configure LLM providers for self-hosted Skyvern including OpenAI, xAI Grok, Anthropic, Azure OpenAI, Google Gemini, AWS Bedrock, Ollama, and OpenAI-compatible endpoints via LiteLLM.slug: developers/self-hosted/llm-configurationkeywords:- OpenAI+ - xAI+ - Grok- Anthropic- Azure OpenAI- Google Gemini@@ -38,6 +40,7 @@ For most deployments, configure a single provider using `LLM_KEY`. Skyvern also|----------|--------------|-----------------|-------|| **Anthropic** | `ANTHROPIC_CLAUDE4.7_OPUS` | `ANTHROPIC_CLAUDE4.6_SONNET` | Most capable || **OpenAI** | `OPENAI_GPT5_5` | `OPENAI_GPT5_4` | Latest |+| **xAI** | `XAI_GROK_4_5` | `XAI_GROK_4_5` | Grok 4.5 || **Google** | `GEMINI_3_PRO` | `GEMINI_3.0_FLASH` | Latest || **AWS Bedrock** | `BEDROCK_ANTHROPIC_CLAUDE4.7_OPUS_INFERENCE_PROFILE` | `BEDROCK_ANTHROPIC_CLAUDE4.6_SONNET_INFERENCE_PROFILE` | Latest Claude |@@ -93,6 +96,34 @@ OPENAI_ORGANIZATION=org-...---+## xAI Grok++Grok models from [x.ai](https://x.ai/api). Requires an xAI API key.++```bash .env+ENABLE_XAI=true+XAI_API_KEY=xai-...+LLM_KEY=XAI_GROK_4_5+```++### Available models++| LLM_KEY | Notes |+|---------|-------|+| `XAI_GROK_4_5` | Grok 4.5 for coding, agentic tasks, and general chat |++### Optional settings++```bash .env+# Override the default API endpoint+XAI_API_BASE=https://api.x.ai/v1++# Supported values: low, medium, high. Unset to use xAI's default.+XAI_REASONING_EFFORT=medium+```++---+## AnthropicClaude models from [anthropic.com](https://www.anthropic.com/).diff --git a/skyvern/cli/doctor.py b/skyvern/cli/doctor.pyindex 2a58db36f..372b50123 100644--- a/skyvern/cli/doctor.py+++ b/skyvern/cli/doctor.py@@ -486,6 +486,7 @@ def _check_llm_config() -> CheckResult:providers: dict[str, dict[str, str | None]] = {"OPENAI": {"enable": "ENABLE_OPENAI", "key": "OPENAI_API_KEY"},+ "XAI": {"enable": "ENABLE_XAI", "key": "XAI_API_KEY"},"ANTHROPIC": {"enable": "ENABLE_ANTHROPIC", "key": "ANTHROPIC_API_KEY"},"GEMINI": {"enable": "ENABLE_GEMINI", "key": "GEMINI_API_KEY"},"AZURE": {"enable": "ENABLE_AZURE", "key": "AZURE_API_KEY"},diff --git a/skyvern/cli/llm_setup.py b/skyvern/cli/llm_setup.pyindex edcb9ace3..49035eb09 100644--- a/skyvern/cli/llm_setup.py+++ b/skyvern/cli/llm_setup.py@@ -47,6 +47,8 @@ def update_or_add_env_var("ENV": "local","ENABLE_OPENAI": "false","OPENAI_API_KEY": "",+ "ENABLE_XAI": "false",+ "XAI_API_KEY": "","ENABLE_ANTHROPIC": "false","ANTHROPIC_API_KEY": "","ENABLE_AZURE": "false",@@ -117,6 +119,21 @@ def setup_llm_providers(env_path: Path | str | None = None) -> None:else:set_env_var("ENABLE_OPENAI", "false")+ console.print("\n[bold blue]--- xAI Configuration ---[/bold blue]")+ console.print("To enable xAI Grok, you must have an xAI API key.")+ enable_xai = Confirm.ask("Do you want to enable xAI Grok?")+ if enable_xai:+ xai_api_key = ask_secret("Enter your xAI API key")+ if not xai_api_key:+ console.print("[red]Error: xAI API key is required. xAI will not be enabled.[/red]")+ else:+ set_env_var("XAI_API_KEY", xai_api_key)+ set_env_var("ENABLE_XAI", "true")+ enabled_providers.append("xai")+ model_options.append("XAI_GROK_4_5")+ else:+ set_env_var("ENABLE_XAI", "false")+console.print("\n[bold blue]--- Anthropic Configuration ---[/bold blue]")console.print("To enable Anthropic, you must have an Anthropic API key.")enable_anthropic = Confirm.ask("Do you want to enable Anthropic?")diff --git a/skyvern/config.py b/skyvern/config.pyindex ff68b90c4..51a39741a 100644--- a/skyvern/config.py+++ b/skyvern/config.py@@ -424,10 +424,15 @@ class Settings(BaseSettings):ENABLE_VERTEX_AI: bool = FalseENABLE_AZURE_CUA: bool = FalseENABLE_OPENAI_COMPATIBLE: bool = False+ ENABLE_XAI: bool = False# OPENAIOPENAI_API_KEY: str | None = NoneGPT5_REASONING_EFFORT: str | None = "medium"OPENAI_CUA_MODEL: str = "computer-use-preview"+ # xAI+ XAI_API_KEY: str | None = None+ XAI_API_BASE: str = "https://api.x.ai/v1"+ XAI_REASONING_EFFORT: str | None = "medium"# ANTHROPICANTHROPIC_API_KEY: str | None = NoneANTHROPIC_CUA_LLM_KEY: str = "ANTHROPIC_CLAUDE4.6_SONNET"@@ -637,7 +642,7 @@ class Settings(BaseSettings):OP_SERVICE_ACCOUNT_TOKEN: str | None = None# Where credentials are stored: skyvern, bitwarden, azure_vault, gcp, or custom- CREDENTIAL_VAULT_TYPE: str = "bitwarden"+ CREDENTIAL_VAULT_TYPE: str = "skyvern"ENABLE_LOCAL_CREDENTIAL_VAULT: bool | None = NoneLOCAL_CREDENTIAL_VAULT_PATH: str = str(Path.home() / ".skyvern" / "credential_vault")LOCAL_CREDENTIAL_VAULT_KEY: str | None = None@@ -874,6 +879,9 @@ class Settings(BaseSettings):mapping["mercury-2"] = {"llm_key": "INCEPTION_MERCURY_2", "label": "Inception Mercury 2"}+ if self.ENABLE_XAI:+ mapping["grok-4.5"] = {"llm_key": "XAI_GROK_4_5", "label": "Grok 4.5"}+# Their configs are registered only under ENABLE_OPENROUTER, so without it the dropdown# would offer models that resolve to unregistered configs and fail at runtime.if self.ENABLE_OPENROUTER:diff --git a/skyvern/core/script_generations/script_skyvern_page.py b/skyvern/core/script_generations/script_skyvern_page.pyindex dba18f8cf..05f53c29a 100644--- a/skyvern/core/script_generations/script_skyvern_page.py+++ b/skyvern/core/script_generations/script_skyvern_page.py@@ -4,6 +4,7 @@ import asyncioimport inspectimport osimport re+from datetime import datetimefrom pathlib import Pathfrom typing import Any, Callable@@ -39,6 +40,7 @@ from skyvern.forge.sdk.api.files import ()from skyvern.forge.sdk.artifact.models import ArtifactTypefrom skyvern.forge.sdk.core import skyvern_context+from skyvern.forge.sdk.db.datetime_utils import naive_utc_nowfrom skyvern.forge.sdk.db.utils import ACTION_TYPE_TO_CLASSfrom skyvern.forge.sdk.schemas.totp_codes import OTPTypefrom skyvern.forge.sdk.services.credentials import generate_totp_code@@ -274,6 +276,10 @@ class ScriptSkyvernPage(SkyvernPage):except Exception:pass # Don't block action execution if file listing fails+ # Stamped after the download-detection baseline (a listdir plus an awaited storage+ # lookup): the window starts at the action itself, matching finished_at's cut before+ # the post-action scan.+ started_at = naive_utc_now()try:# Wait for page to be ready before executing action# This helps prevent issues where cached actions execute before the page is fully loaded@@ -321,6 +327,7 @@ class ScriptSkyvernPage(SkyvernPage):raisefinally:+ finished_at = naive_utc_now()# Add a small buffer between cached actions to give slow pages time to settleif settings.CACHED_ACTION_DELAY_SECONDS > 0:await asyncio.sleep(settings.CACHED_ACTION_DELAY_SECONDS)@@ -384,6 +391,8 @@ class ScriptSkyvernPage(SkyvernPage):call_error=call.error,download_triggered=download_triggered,downloaded_files=downloaded_files,+ started_at=started_at,+ finished_at=finished_at,)# Auto-create screenshot artifact after execution@@ -452,6 +461,8 @@ class ScriptSkyvernPage(SkyvernPage):call_error: Exception | None = None,download_triggered: bool | None = None,downloaded_files: list[str] | None = None,+ started_at: datetime | None = None,+ finished_at: datetime | None = None,) -> tuple[Action | None, list[ActionResult]]:"""Create an action record and result in the database after execution if task_id and step_id are available.@@ -514,6 +525,8 @@ class ScriptSkyvernPage(SkyvernPage):download=download_triggered,download_triggered=download_triggered,downloaded_files=downloaded_files,+ started_at=started_at,+ finished_at=finished_at,created_by="script",)data_extraction_goal: str | None = Nonediff --git a/skyvern/forge/agent.py b/skyvern/forge/agent.pyindex 09152f247..4314c71ca 100644--- a/skyvern/forge/agent.py+++ b/skyvern/forge/agent.py@@ -110,6 +110,7 @@ from skyvern.forge.sdk.core import skyvern_contextfrom skyvern.forge.sdk.core.hashing import diagnostic_fingerprintfrom skyvern.forge.sdk.core.security import generate_skyvern_webhook_signaturefrom skyvern.forge.sdk.core.skyvern_context import SkyvernContext+from skyvern.forge.sdk.db.datetime_utils import naive_utc_nowfrom skyvern.forge.sdk.db.enums import TaskTypefrom skyvern.forge.sdk.experimentation.enrich_tree import resolve_enrich_tree_for_contextfrom skyvern.forge.sdk.experimentation.llm_prompt_config import resolve_check_user_goal_handler@@ -1856,6 +1857,7 @@ class ForgeAgent:"Detected the signal to reload the page, going to reload and skip the rest of the actions",step_order=step.order,)+ reload_started_at = naive_utc_now()await browser_state.reload_page()context.refresh_working_page = Falseaction_result = ActionSuccess()@@ -1876,6 +1878,8 @@ class ForgeAgent:# _generate_step_actions stamps, and this action never went through it.preflight_action(action, observed_page(), site="internal_refresh")detailed_agent_step_output.actions_and_results[action_idx] = (action, [action_result])+ action.started_at = reload_started_at+ action.finished_at = naive_utc_now()action.action_id = (await app.DATABASE.workflow_params.create_action(action=action)).action_idartifact_tracker.task = asyncio.create_task(self.record_artifacts_after_action(task, step, browser_state, engine, action)@@ -5325,27 +5329,59 @@ class ForgeAgent:LOG.debug("Uploading video artifacts", number_of_video_artifacts=len(video_artifacts))for video_artifact in video_artifacts:if video_artifact.video_artifact_id:- await app.ARTIFACT_MANAGER.update_artifact_data(- artifact_id=video_artifact.video_artifact_id,- organization_id=task.organization_id,- data=video_artifact.video_data,- )+ try:+ if video_artifact.video_file_extension:+ await app.ARTIFACT_MANAGER.update_artifact_data(+ artifact_id=video_artifact.video_artifact_id,+ organization_id=task.organization_id,+ data=video_artifact.video_data,+ file_extension=video_artifact.video_file_extension,+ )+ else:+ await app.ARTIFACT_MANAGER.update_artifact_data(+ artifact_id=video_artifact.video_artifact_id,+ organization_id=task.organization_id,+ data=video_artifact.video_data,+ )+ except Exception:+ LOG.warning(+ "Failed to upload task video artifact",+ task_id=task.task_id,+ organization_id=task.organization_id,+ video_artifact_id=video_artifact.video_artifact_id,+ exc_info=True,+ )continue- # A teardown-attached recording has no pre-registered artifact row.- # Prefer collected video bytes; use the on-disk path only when no bytes were returned.+video_path = video_artifact.video_pathif video_artifact.video_data:- video_artifact.video_artifact_id = await app.ARTIFACT_MANAGER.create_artifact(- step=last_step,- artifact_type=ArtifactType.RECORDING,- data=video_artifact.video_data,- )+ if video_artifact.video_file_extension:+ video_artifact.video_artifact_id = await app.ARTIFACT_MANAGER.create_artifact(+ step=last_step,+ artifact_type=ArtifactType.RECORDING,+ data=video_artifact.video_data,+ file_extension=video_artifact.video_file_extension,+ )+ else:+ video_artifact.video_artifact_id = await app.ARTIFACT_MANAGER.create_artifact(+ step=last_step,+ artifact_type=ArtifactType.RECORDING,+ data=video_artifact.video_data,+ )elif video_path and os.path.exists(video_path):- video_artifact.video_artifact_id = await app.ARTIFACT_MANAGER.create_artifact(- step=last_step,- artifact_type=ArtifactType.RECORDING,- path=video_path,- )+ if video_artifact.video_file_extension:+ video_artifact.video_artifact_id = await app.ARTIFACT_MANAGER.create_artifact(+ step=last_step,+ artifact_type=ArtifactType.RECORDING,+ path=video_path,+ file_extension=video_artifact.video_file_extension,+ )+ else:+ video_artifact.video_artifact_id = await app.ARTIFACT_MANAGER.create_artifact(+ step=last_step,+ artifact_type=ArtifactType.RECORDING,+ path=video_path,+ )else:continuediff --git a/skyvern/forge/agent_functions.py b/skyvern/forge/agent_functions.pyindex 2a065f765..cbcc2cc87 100644--- a/skyvern/forge/agent_functions.py+++ b/skyvern/forge/agent_functions.py@@ -1211,6 +1211,9 @@ class AgentFunction:api_key = settings.SKYVERN_API_KEYreturn api_key if api_key and api_key != "PLACEHOLDER" else None+ async def browser_context_route_handlers_allowed(self, **_: Any) -> bool:+ return True+async def setup_browser_context_extensions(self, browser_context: Any, **kwargs: Any) -> None:"""Attach cloud-only listeners/route handlers to a fresh BrowserContext. OSS no-op."""diff --git a/skyvern/forge/request_logging.py b/skyvern/forge/request_logging.pyindex 9cc104cab..c85a259e3 100644--- a/skyvern/forge/request_logging.py+++ b/skyvern/forge/request_logging.py@@ -248,11 +248,9 @@ async def log_raw_request_middleware(request: Request, call_next: Callable[[Requtry:response = await call_next(request)- # Skip successful reads before buffering the response body: they are- # the bulk of request volume (health checks, status polling) and the- # 4xx/5xx and mutating paths below retain all audit/debugging value.- # Sensitive endpoints (credential/TOTP reads) always keep their- # redacted audit line.+ # Skip successful reads before buffering the response body; 4xx/5xx and+ # mutating paths keep logging, and sensitive endpoints always keep+ # their redacted audit line.if (response.status_code < 400and http_method in _READ_METHODSdiff --git a/skyvern/forge/sdk/api/llm/api_handler_factory.py b/skyvern/forge/sdk/api/llm/api_handler_factory.pyindex 93a8ab077..db35711d8 100644--- a/skyvern/forge/sdk/api/llm/api_handler_factory.py+++ b/skyvern/forge/sdk/api/llm/api_handler_factory.py@@ -834,13 +834,14 @@ class LLMAPIHandlerFactory:parameters, new_budget, llm_config, prompt_name)else:- # Other reasoning-capable models (Deepseek, etc.) - use "low" for all budget values- parameters["reasoning_effort"] = "low"+ is_xai_model = (check_model or "").lower().startswith("xai/")+ reasoning_effort = (parameters.get("reasoning_effort") or "low") if is_xai_model else "low"+ parameters["reasoning_effort"] = reasoning_effortLOG.debug("Applied thinking budget optimization (reasoning_effort)",prompt_name=prompt_name,budget=new_budget,- reasoning_effort="low",+ reasoning_effort=reasoning_effort,model=model_label,)except (AttributeError, KeyError, TypeError) as e:diff --git a/skyvern/forge/sdk/api/llm/config_registry.py b/skyvern/forge/sdk/api/llm/config_registry.pyindex 7b1a56ab7..598b18d7d 100644--- a/skyvern/forge/sdk/api/llm/config_registry.py+++ b/skyvern/forge/sdk/api/llm/config_registry.py@@ -1,3 +1,4 @@+import litellmimport structlogfrom skyvern.config import settings@@ -11,6 +12,53 @@ from skyvern.schemas.llm import LiteLLMParams, LLMConfig, LLMRouterConfigLOG = structlog.get_logger()FLEX_EXECUTION_TIMEOUT_SECONDS = 180.0+XAI_GROK_4_5_MODEL = "xai/grok-4.5"+XAI_GROK_4_5_CONTEXT_WINDOW = 500_000+# xAI publishes no output cap for grok-4.5; match the bound used by the other large reasoning+# models here so LiteLLM's context bookkeeping never assumes 500k of output.+XAI_GROK_4_5_MAX_OUTPUT_TOKENS = 128_000+++def _register_model_cost_overrides() -> None:+ # The pinned LiteLLM version can route xai/grok-4.5, but its price map predates the model.+ litellm.register_model(+ {+ XAI_GROK_4_5_MODEL: {+ "litellm_provider": "xai",+ "mode": "chat",+ "max_input_tokens": XAI_GROK_4_5_CONTEXT_WINDOW,+ "max_output_tokens": XAI_GROK_4_5_MAX_OUTPUT_TOKENS,+ "max_tokens": XAI_GROK_4_5_MAX_OUTPUT_TOKENS,+ "input_cost_per_token": 2e-06,+ "output_cost_per_token": 6e-06,+ "output_cost_per_reasoning_token": 6e-06,+ "supports_function_calling": True,+ "supports_prompt_caching": True,+ "supports_reasoning": True,+ "supports_vision": True,+ "supports_tool_choice": True,+ "supports_web_search": True,+ }+ }+ )+++def _build_xai_grok_4_5_config() -> LLMConfig:+ return LLMConfig(+ XAI_GROK_4_5_MODEL,+ ["XAI_API_KEY"],+ supports_vision=True,+ add_assistant_prefix=False,+ max_completion_tokens=XAI_GROK_4_5_MAX_OUTPUT_TOKENS,+ temperature=settings.LLM_CONFIG_TEMPERATURE,+ reasoning_effort=settings.XAI_REASONING_EFFORT or None,+ litellm_params=LiteLLMParams(+ api_key=settings.XAI_API_KEY,+ api_base=settings.XAI_API_BASE,+ api_version=None,+ model_info={"model_name": XAI_GROK_4_5_MODEL},+ ),+ )class LLMConfigRegistry:@@ -419,6 +467,11 @@ if settings.ENABLE_OPENAI:),)+if settings.ENABLE_XAI:+ _register_model_cost_overrides()++ LLMConfigRegistry.register_config("XAI_GROK_4_5", _build_xai_grok_4_5_config())+if settings.ENABLE_ANTHROPIC:# All Claude 4+ models require temperature=1 when extended thinking is enabled.# The runtime applies thinking optimization to all Anthropic models, so temperature=1diff --git a/skyvern/forge/sdk/artifact/manager.py b/skyvern/forge/sdk/artifact/manager.pyindex ecdb77b78..8c79e0446 100644--- a/skyvern/forge/sdk/artifact/manager.py+++ b/skyvern/forge/sdk/artifact/manager.py@@ -22,6 +22,7 @@ from skyvern.forge.sdk.artifact.signing import (parse_keyring,sign_artifact_url,)+from skyvern.forge.sdk.artifact.utils import replace_file_extensionfrom skyvern.forge.sdk.core import skyvern_contextfrom skyvern.forge.sdk.db.id import generate_artifact_idfrom skyvern.forge.sdk.db.models import ArtifactModel@@ -42,6 +43,29 @@ def _ensure_aware_utc(value: datetime) -> datetime:return value if value.tzinfo is not None else value.replace(tzinfo=UTC)+def _log_artifact_store_task_failure(task: asyncio.Future[None], artifact: Artifact) -> None:+ if task.cancelled():+ LOG.warning(+ "Artifact store task cancelled",+ artifact_id=artifact.artifact_id,+ artifact_type=artifact.artifact_type,+ uri=artifact.uri,+ )+ return++ exception = task.exception()+ if not exception:+ return++ LOG.warning(+ "Artifact store task failed",+ artifact_id=artifact.artifact_id,+ artifact_type=artifact.artifact_type,+ uri=artifact.uri,+ exc_info=(type(exception), exception, exception.__traceback__),+ )++_SCREENSHOT_PREFIX_MAP: dict[ArtifactType, str] = {ArtifactType.SCREENSHOT_LLM: "screenshot_llm",ArtifactType.SCREENSHOT_ACTION: "screenshot_action",@@ -141,7 +165,12 @@ class ArtifactManager:# step_id -> accumulator for step archive artifactsself._step_archives: dict[str, StepArchiveAccumulator] = {}- def _track_upload_aiotask(self, primary_key: str, aio_task: asyncio.Task[None]) -> None:+ def _track_upload_aiotask(+ self,+ primary_key: str,+ aio_task: asyncio.Task[None],+ artifact: Artifact | None = None,+ ) -> None:"""Track a fire-and-forget upload so wait_for_upload_aiotasks can barrier on it.Tasks self-discard on completion: writers key this map by ids no lifecycle ever@@ -152,7 +181,9 @@ class ArtifactManager:self.upload_aiotasks_map[primary_key].append(aio_task)def _discard(task: asyncio.Task[None]) -> None:- if not task.cancelled() and (exc := task.exception()) is not None:+ if artifact is not None:+ _log_artifact_store_task_failure(task, artifact)+ elif not task.cancelled() and (exc := task.exception()) is not None:LOG.warning("Artifact upload task failed",primary_key=primary_key,@@ -296,11 +327,18 @@ class ArtifactManager:artifact_type: ArtifactType,data: bytes | None = None,path: str | None = None,+ file_extension: str | None = None,) -> str:artifact_id = generate_artifact_id()uri = app.STORAGE.build_uri(organization_id=step.organization_id, artifact_id=artifact_id, step=step, artifact_type=artifact_type)+ if artifact_type == ArtifactType.RECORDING:+ recording_extension = file_extension+ if not recording_extension and path:+ recording_extension = os.path.splitext(path)[1].lstrip(".").lower()+ if recording_extension:+ uri = replace_file_extension(uri, recording_extension)file_size = len(data) if data is not None else _safe_file_size_from_path(path)return await self._create_artifact(aio_task_primary_key=step.task_id,@@ -1160,12 +1198,31 @@ class ArtifactManager:organization_id: str | None,data: bytes,primary_key: str = "task_id",+ file_extension: str | None = None,) -> str | None:if not artifact_id or not organization_id:return Noneartifact = await app.DATABASE.artifacts.get_artifact_by_id(artifact_id, organization_id)if not artifact:return None+ if file_extension and artifact.artifact_type == ArtifactType.RECORDING:+ next_uri = replace_file_extension(artifact.uri, file_extension)+ file_size = len(data)+ if next_uri != artifact.uri or artifact.file_size != file_size:+ updated_artifact = await app.DATABASE.artifacts.update_artifact_uri(+ artifact_id=artifact.artifact_id,+ organization_id=organization_id,+ uri=next_uri,+ file_size=file_size,+ )+ if not updated_artifact:+ # Avoid writing prepared bytes under stale metadata, which can create+ # content/extension mismatches for recording artifacts.+ raise RuntimeError(+ f"Failed to update recording artifact metadata before upload: {artifact.artifact_id}"+ )+ artifact = updated_artifact+# Fire and forgetaio_task = asyncio.create_task(app.STORAGE.store_artifact(artifact, data))@@ -1174,7 +1231,7 @@ class ArtifactManager:aio_task_key = artifact[primary_key] or artifact["workflow_run_block_id"] or artifact["run_id"]if not aio_task_key:raise ValueError("artifact must have a task_id, workflow_run_block_id, or run_id to track its upload.")- self._track_upload_aiotask(aio_task_key, aio_task)+ self._track_upload_aiotask(aio_task_key, aio_task, artifact=artifact)return aio_task_keyasync def retrieve_artifact(self, artifact: Artifact) -> bytes | None:diff --git a/skyvern/forge/sdk/artifact/storage/azure.py b/skyvern/forge/sdk/artifact/storage/azure.pyindex d4f00ea72..fc2c4e464 100644--- a/skyvern/forge/sdk/artifact/storage/azure.py+++ b/skyvern/forge/sdk/artifact/storage/azure.py@@ -30,12 +30,14 @@ from skyvern.forge.sdk.artifact.storage.base import (presign_with_sensitive_cap,)from skyvern.forge.sdk.artifact.storage.run_recording_clips import RUN_RECORDING_PATH_SEGMENT, sync_run_recording_clips+from skyvern.forge.sdk.artifact.utils import replace_file_extensionfrom skyvern.forge.sdk.models import Stepfrom skyvern.forge.sdk.schemas.ai_suggestions import AISuggestionfrom skyvern.forge.sdk.schemas.files import FileInfofrom skyvern.forge.sdk.schemas.task_v2 import TaskV2, Thoughtfrom skyvern.forge.sdk.schemas.workflow_runs import WorkflowRunBlockfrom skyvern.utils.script_file_paths import build_script_file_storage_uri+from skyvern.webeye.video_utils import prepare_recording_for_uploadLOG = structlog.get_logger()@@ -770,11 +772,55 @@ class AzureStorage(BaseStorage):date: str | None = None,) -> str:"""Sync a file from local browser session to Azure."""- # Anchor per-run clip offsets to browser close, captured before the upload below.- recording_finalized_at = datetime.now(timezone.utc)uri = self._build_browser_session_uri(organization_id, browser_session_id, artifact_type, remote_path, date)tier = await self._get_storage_tier_for_org(organization_id)tags = await self._get_tags_for_org(organization_id)++ 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)+ 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)+ 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, tier=tier, tags=tags)++ # See s3.py for recording artifact fallback rationale.+ checksum = calculate_sha256_for_file(upload_file_path)+ file_size = _safe_get_file_size(upload_file_path)+ await app.ARTIFACT_MANAGER.create_browser_session_recording_artifact(+ organization_id=organization_id,+ browser_session_id=browser_session_id,+ uri=uri,+ filename=os.path.basename(upload_remote_path),+ checksum=checksum,+ file_size=file_size,+ )++ async def _upload_clip(run_id: str, clip_path: str, filename: str) -> str:+ clip_uri = self._build_browser_session_uri(+ organization_id, browser_session_id, RUN_RECORDING_PATH_SEGMENT, f"{run_id}/{filename}", date+ )+ await self.async_client.upload_file_from_path(clip_uri, clip_path, tier=tier, tags=tags)+ return clip_uri++ try:+ await sync_run_recording_clips(+ organization_id=organization_id,+ browser_session_id=browser_session_id,+ source_path=upload_file_path,+ upload_clip=_upload_clip,+ now=recording_finalized_at,+ )+ except Exception:+ LOG.warning(+ "Run recording clip generation failed", browser_session_id=browser_session_id, exc_info=True+ )+ return uri+await self.async_client.upload_file_from_path(uri, local_file_path, tier=tier, tags=tags)if artifact_type == "downloads":@@ -785,55 +831,16 @@ class AzureStorage(BaseStorage):# propagate so the watcher's bounded retry can recover from a# transient DB outage — both ops are idempotent.is_partial = remote_path.endswith(BROWSER_DOWNLOADING_SUFFIX)- checksum = None if is_partial else calculate_sha256_for_file(local_file_path)- file_size = None if is_partial else _safe_get_file_size(local_file_path)+ download_checksum = None if is_partial else calculate_sha256_for_file(local_file_path)+ download_file_size = None if is_partial else _safe_get_file_size(local_file_path)await app.ARTIFACT_MANAGER.create_browser_session_download_artifact(organization_id=organization_id,browser_session_id=browser_session_id,uri=uri,filename=os.path.basename(remote_path),- checksum=checksum,- file_size=file_size,+ checksum=download_checksum,+ file_size=download_file_size,)- elif artifact_type == "videos":- # Recording uploaded once at session close — see s3.py. Artifact-- # row creation is best-effort: the only caller swallows- # exceptions without retry, so the gated legacy listing fallback- # in ``get_shared_recordings_in_browser_session`` is the safety- # net for missed writes (when the session has no RECORDING rows- # we fall through to the Azure LIST path, so a row-less recording- # still surfaces via the legacy SAS URL).- checksum = calculate_sha256_for_file(local_file_path)- file_size = _safe_get_file_size(local_file_path)- await app.ARTIFACT_MANAGER.create_browser_session_recording_artifact(- organization_id=organization_id,- browser_session_id=browser_session_id,- uri=uri,- filename=os.path.basename(remote_path),- checksum=checksum,- file_size=file_size,- )-- async def _upload_clip(run_id: str, clip_path: str, filename: str) -> str:- clip_uri = self._build_browser_session_uri(- organization_id, browser_session_id, RUN_RECORDING_PATH_SEGMENT, f"{run_id}/{filename}", date- )- await self.async_client.upload_file_from_path(clip_uri, clip_path, tier=tier, tags=tags)- return clip_uri-- try:- await sync_run_recording_clips(- organization_id=organization_id,- browser_session_id=browser_session_id,- source_path=local_file_path,- upload_clip=_upload_clip,- now=recording_finalized_at,- )- except Exception:- LOG.warning(- "Run recording clip generation failed", browser_session_id=browser_session_id, exc_info=True- )-return uriasync def delete_browser_session_file(diff --git a/skyvern/forge/sdk/artifact/storage/gcs.py b/skyvern/forge/sdk/artifact/storage/gcs.pyindex ad8a45520..90c5223a9 100644--- a/skyvern/forge/sdk/artifact/storage/gcs.py+++ b/skyvern/forge/sdk/artifact/storage/gcs.py@@ -35,12 +35,14 @@ from skyvern.forge.sdk.artifact.storage.run_recording_clips import (RUN_RECORDING_PATH_SEGMENT,sync_run_recording_clips,)+from skyvern.forge.sdk.artifact.utils import replace_file_extensionfrom skyvern.forge.sdk.models import Stepfrom skyvern.forge.sdk.schemas.ai_suggestions import AISuggestionfrom skyvern.forge.sdk.schemas.files import FileInfofrom skyvern.forge.sdk.schemas.task_v2 import TaskV2, Thoughtfrom skyvern.forge.sdk.schemas.workflow_runs import WorkflowRunBlockfrom skyvern.utils.script_file_paths import build_script_file_storage_uri+from skyvern.webeye.video_utils import prepare_recording_for_uploadLOG = structlog.get_logger()@@ -788,11 +790,60 @@ class GcsStorage(BaseStorage):date: str | None = None,) -> str:"""Sync a file from local browser session to GCS."""- # Anchor per-run clip offsets to browser close, captured before the upload below.- recording_finalized_at = datetime.now(timezone.utc)uri = self._build_browser_session_uri(organization_id, browser_session_id, artifact_type, remote_path, date)storage_class = await self._get_storage_class_for_org(organization_id)tags = await self._get_tags_for_org(organization_id)++ 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)+ 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)+ 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=storage_class, tags=tags+ )++ # See s3.py for recording artifact fallback rationale.+ checksum = calculate_sha256_for_file(upload_file_path)+ file_size = _safe_get_file_size(upload_file_path)+ await app.ARTIFACT_MANAGER.create_browser_session_recording_artifact(+ organization_id=organization_id,+ browser_session_id=browser_session_id,+ uri=uri,+ filename=os.path.basename(upload_remote_path),+ checksum=checksum,+ file_size=file_size,+ )++ async def _upload_clip(run_id: str, clip_path: str, filename: str) -> str:+ clip_uri = self._build_browser_session_uri(+ organization_id, browser_session_id, RUN_RECORDING_PATH_SEGMENT, f"{run_id}/{filename}", date+ )+ await self.async_client.upload_file_from_path(+ clip_uri, clip_path, storage_class=storage_class, tags=tags+ )+ return clip_uri++ try:+ async with asyncio.timeout(RUN_RECORDING_CLIPS_SYNC_TIMEOUT_SECONDS):+ await sync_run_recording_clips(+ organization_id=organization_id,+ browser_session_id=browser_session_id,+ source_path=upload_file_path,+ upload_clip=_upload_clip,+ now=recording_finalized_at,+ )+ except Exception:+ LOG.warning(+ "Run recording clip generation failed", browser_session_id=browser_session_id, exc_info=True+ )+ return uri+await self.async_client.upload_file_from_path(uri, local_file_path, storage_class=storage_class, tags=tags)if artifact_type == "downloads":@@ -803,58 +854,16 @@ class GcsStorage(BaseStorage):# propagate so the watcher's bounded retry can recover from a# transient DB outage — both ops are idempotent.is_partial = remote_path.endswith(BROWSER_DOWNLOADING_SUFFIX)- checksum = None if is_partial else calculate_sha256_for_file(local_file_path)- file_size = None if is_partial else _safe_get_file_size(local_file_path)+ download_checksum = None if is_partial else calculate_sha256_for_file(local_file_path)+ download_file_size = None if is_partial else _safe_get_file_size(local_file_path)await app.ARTIFACT_MANAGER.create_browser_session_download_artifact(organization_id=organization_id,browser_session_id=browser_session_id,uri=uri,filename=os.path.basename(remote_path),- checksum=checksum,- file_size=file_size,- )- elif artifact_type == "videos":- # Recording uploaded once at session close — see s3.py. Artifact-- # row creation is best-effort: the only caller swallows- # exceptions without retry, so the gated legacy listing fallback- # in ``get_shared_recordings_in_browser_session`` is the safety- # net for missed writes (when the session has no RECORDING rows- # we fall through to the GCS LIST path, so a row-less recording- # still surfaces via the legacy signed URL).- checksum = calculate_sha256_for_file(local_file_path)- file_size = _safe_get_file_size(local_file_path)- await app.ARTIFACT_MANAGER.create_browser_session_recording_artifact(- organization_id=organization_id,- browser_session_id=browser_session_id,- uri=uri,- filename=os.path.basename(remote_path),- checksum=checksum,- file_size=file_size,+ checksum=download_checksum,+ file_size=download_file_size,)-- async def _upload_clip(run_id: str, clip_path: str, filename: str) -> str:- clip_uri = self._build_browser_session_uri(- organization_id, browser_session_id, RUN_RECORDING_PATH_SEGMENT, f"{run_id}/{filename}", date- )- await self.async_client.upload_file_from_path(- clip_uri, clip_path, storage_class=storage_class, tags=tags- )- return clip_uri-- try:- async with asyncio.timeout(RUN_RECORDING_CLIPS_SYNC_TIMEOUT_SECONDS):- await sync_run_recording_clips(- organization_id=organization_id,- browser_session_id=browser_session_id,- source_path=local_file_path,- upload_clip=_upload_clip,- now=recording_finalized_at,- )- except Exception:- LOG.warning(- "Run recording clip generation failed", browser_session_id=browser_session_id, exc_info=True- )-return uriasync def delete_browser_session_file(diff --git a/skyvern/forge/sdk/artifact/storage/recording_test_helpers.py b/skyvern/forge/sdk/artifact/storage/recording_test_helpers.pynew file mode 100644index 000000000..f7c18a5e0--- /dev/null+++ b/skyvern/forge/sdk/artifact/storage/recording_test_helpers.py@@ -0,0 +1,11 @@+from collections.abc import AsyncIterator+from contextlib import asynccontextmanager++from skyvern.webeye.video_utils import PreparedRecordingUpload+++@asynccontextmanager+async def fake_prepared_recording(+ _path: str, prepared_path: str, extension: str = "mp4"+) -> AsyncIterator[PreparedRecordingUpload]:+ yield PreparedRecordingUpload(path=prepared_path, file_extension=extension)diff --git a/skyvern/forge/sdk/artifact/storage/s3.py b/skyvern/forge/sdk/artifact/storage/s3.pyindex 176a6a965..930422c20 100644--- a/skyvern/forge/sdk/artifact/storage/s3.py+++ b/skyvern/forge/sdk/artifact/storage/s3.py@@ -38,6 +38,7 @@ from skyvern.forge.sdk.artifact.storage.run_recording_clips import (RUN_RECORDING_PATH_SEGMENT,sync_run_recording_clips,)+from skyvern.forge.sdk.artifact.utils import replace_file_extensionfrom skyvern.forge.sdk.models import Stepfrom skyvern.forge.sdk.schemas.ai_suggestions import AISuggestionfrom skyvern.forge.sdk.schemas.files import FileInfo@@ -60,12 +61,6 @@ def _safe_get_file_size(path: str) -> int | None:return None-def _replace_file_extension(path: str, extension: str) -> str:- normalized_extension = extension.lstrip(".")- stem, _ = os.path.splitext(path)- return f"{stem}.{normalized_extension}" if normalized_extension else path--class S3Storage(BaseStorage):_PATH_VERSION = "v1"# Cap concurrent head_object fan-out in the legacy listing fallback.@@ -977,7 +972,7 @@ class S3Storage(BaseStorage):# object and artifact metadata reflect the prepared upload file.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)+ upload_remote_path = replace_file_extension(remote_path, prepared_upload.file_extension)uri = self._build_browser_session_uri(organization_id, browser_session_id, artifact_type, upload_remote_path, date)diff --git a/skyvern/forge/sdk/artifact/utils.py b/skyvern/forge/sdk/artifact/utils.pynew file mode 100644index 000000000..fe4b17881--- /dev/null+++ b/skyvern/forge/sdk/artifact/utils.py@@ -0,0 +1,9 @@+import os+++def replace_file_extension(path: str, extension: str) -> str:+ normalized_extension = extension.lstrip(".")+ if not normalized_extension:+ return path+ stem, _ = os.path.splitext(path)+ return f"{stem}.{normalized_extension}"diff --git a/skyvern/forge/sdk/copilot/code_block_synthesis.py b/skyvern/forge/sdk/copilot/code_block_synthesis.pyindex 760604d0a..1bb8505a4 100644--- a/skyvern/forge/sdk/copilot/code_block_synthesis.py+++ b/skyvern/forge/sdk/copilot/code_block_synthesis.py@@ -252,6 +252,85 @@ def first_matched_post_fill_submit_index(return None+_LOGIN_SUBMIT_NAME_PATTERN = re.compile(+ r"^(?:log in|login|sign in|authenticate)(?: now| securely| to continue)?$",+ re.I,+)+_LOGIN_SUBMIT_SELECTOR_PATTERN = re.compile(+ r"^(?:(?:log in|login|sign in|authenticate)(?: submit| button| btn)?|"+ r"(?:submit|button|btn) (?:log in|login|sign in|authenticate))$",+ re.I,+)+++def last_scout_credential_fill_index(trajectory: Sequence[Any]) -> int | None:+ # Boundary past the ENTIRE credential flow, including a runtime-only OTP/MFA fill. Keying only on+ # username/password let an MFA step (fill totp -> verify-click) form a durable entry->commit past+ # the boundary and falsely release the terminal-action gate on a login-only trajectory.+ last_index: int | None = None+ for index, item in enumerate(trajectory):+ if isinstance(item, Mapping) and str(item.get("tool_name") or "").strip() == CREDENTIAL_FILL_TOOL_NAME:+ last_index = index+ return last_index+++def first_stable_login_submit_index(interactions: Sequence[Mapping[str, Any]], credential_index: int) -> int | None:+ for index, interaction in enumerate(interactions[credential_index + 1 :], start=credential_index + 1):+ tool_name = str(interaction.get("tool_name") or "").strip()+ if tool_name == "press_key" and str(interaction.get("key") or "").strip() == "Enter":+ return index+ if tool_name != "click":+ continue+ accessible_name = re.sub(r"[^a-z0-9]+", " ", str(interaction.get("accessible_name") or "").lower()).strip()+ selector = re.sub(r"[^a-z0-9]+", " ", str(interaction.get("selector") or "").lower()).strip()+ if _LOGIN_SUBMIT_NAME_PATTERN.fullmatch(accessible_name) or _LOGIN_SUBMIT_SELECTOR_PATTERN.fullmatch(selector):+ return index+ return None+++def credential_submit_boundary_index(interactions: Sequence[Mapping[str, Any]], credential_index: int) -> int | None:+ """The submit that commits the scout's login: a stable login-submit identity, else the first submit+ after the latest credential fill on that fill's own page. None when neither identifies one."""+ submit_index = first_stable_login_submit_index(interactions, credential_index)+ if submit_index is not None:+ return submit_index+ latest_fill_source_url = str(interactions[credential_index].get("source_url") or "").strip()+ if not latest_fill_source_url:+ return None+ return first_matched_post_fill_submit_index(interactions, credential_index, {latest_fill_source_url})+++def credential_segment_bounds(trajectory: Sequence[Mapping[str, Any]]) -> list[tuple[int, int]] | None:+ """Inclusive trajectory bounds for each durable segment of a credentialed scout: the login flow up+ to its submit, the business steps that follow, and the value read. None when the trajectory carries+ no credential fill or no identifiable submit, which leaves the single-block shape in effect."""+ fill_index = last_scout_credential_fill_index(trajectory)+ if fill_index is None:+ return None+ submit_index = credential_submit_boundary_index(trajectory, fill_index)+ if submit_index is None:+ return None+ last_index = len(trajectory) - 1+ if submit_index >= last_index:+ return None+ first_read = next(+ (+ index+ for index in range(submit_index + 1, len(trajectory))+ if str(trajectory[index].get("tool_name") or "") == "read_value"+ ),+ None,+ )+ bounds = [(0, submit_index)]+ if first_read is None:+ bounds.append((submit_index + 1, last_index))+ else:+ if first_read > submit_index + 1:+ bounds.append((submit_index + 1, first_read - 1))+ bounds.append((first_read, last_index))+ return bounds++def _captcha_boundary_indices(trajectory: Sequence[Mapping[str, Any]]) -> set[int]:"""Return typed challenge points plus credential-associated submit boundaries."""boundaries = {@@ -453,6 +532,10 @@ class SynthesizedCodeBlock:notes: list[str] = field(default_factory=list)diagnostics: SynthesisDiagnostics = field(default_factory=SynthesisDiagnostics)steps: list[dict[str, Any]] = field(default_factory=list)+ # Durable segments of a credentialed trajectory (login / business / read), each synthesized from+ # its own slice so it is self-contained and independently runnable. Empty when the trajectory has+ # no credential boundary, which leaves the single-block shape in effect.+ segments: list[SynthesizedCodeBlock] = field(default_factory=list)interaction_code: str = ""extraction_code: str = ""extraction_fingerprint: str = ""@@ -2104,6 +2187,7 @@ def synthesize_code_block(parameter_binding_snapshot: AuthoringParameterBindingSnapshot | None = None,file_match_transform: SameMonthFileMatchTransform | None = None,emit_read_return: bool = True,+ _segment_pass: bool = False,) -> SynthesizedCodeBlock | None:"""Deterministically synthesize a code block from a scout trajectory, or None if empty."""if not trajectory:@@ -2616,7 +2700,7 @@ def synthesize_code_block(lines.append(f"{action_indent}{_INDENT}{variable} = await page.evaluate({expression!r})")read_bindings.append((output_path, variable))record_emission(trajectory_index, tool_name, "evaluate", "page", line_start=line_start, lane="page_read")- append_step(f"Read {output_path.removeprefix('output.')}", "read", line_start)+ append_step(f"Read {output_path.removeprefix('output.')}", "extract", line_start)emitted += 1continue@@ -2766,6 +2850,9 @@ def synthesize_code_block(parameters.append({"key": credential_param_key, "credential_id": credential_id})lines.append(f"{action_indent}{credential_fill_source(locator, credential_param_key, credential_field)}")record_emission(trajectory_index, tool_name, "fill", locator, line_start=line_start)+ # action_type values are ActionType members held as string literals, the same vocabulary+ # code_block_steps.py uses; there is no credential-fill member, and a fill is text entry.+ append_step(f"Fill {credential_field}", "input_text", line_start)elif tool_name == "select_option":emit_snapshot_recovery(trajectory_index, action_indent)value = str(interaction.get("value") or "").strip()@@ -2944,7 +3031,32 @@ def synthesize_code_block(diagnostics.emitted_interaction_count = emittedcode = "\n".join(lines) + "\n"- return SynthesizedCodeBlock(code=code, parameters=parameters, notes=notes, diagnostics=diagnostics, steps=steps)+ segments: list[SynthesizedCodeBlock] = []+ if not _segment_pass:+ # Each segment is synthesized from its own slice rather than sliced out of the code above, so it+ # carries its own prelude and guards and is valid, correctly scoped, and independently runnable.+ for start, end in credential_segment_bounds(trajectory) or []:+ segment = synthesize_code_block(+ trajectory[start : end + 1],+ strict_selectors=strict_selectors,+ reached_download_target=reached_download_target,+ parameter_binding_snapshot=parameter_binding_snapshot,+ file_match_transform=file_match_transform,+ emit_read_return=emit_read_return,+ _segment_pass=True,+ )+ if segment is None or not segment.diagnostics.emitted_interaction_count:+ segments = []+ break+ segments.append(segment)+ return SynthesizedCodeBlock(+ code=code,+ parameters=parameters,+ notes=notes,+ diagnostics=diagnostics,+ steps=steps,+ segments=segments if len(segments) >= 2 else [],+ )SCOUTED_SPINE_UNDER_BUILD_REASON_CODE = "scouted_spine_under_build"diff --git a/skyvern/forge/sdk/copilot/enforcement.py b/skyvern/forge/sdk/copilot/enforcement.pyindex 4c1d68ed2..a13f91d0e 100644--- a/skyvern/forge/sdk/copilot/enforcement.py+++ b/skyvern/forge/sdk/copilot/enforcement.py@@ -39,11 +39,22 @@ from skyvern.forge.sdk.copilot.code_block_synthesis import (LIVE_SCOUT_CREDENTIAL_FIELDS,ObligationFinding,credential_scout_gap,+ credential_submit_boundary_index,first_matched_post_fill_submit_index,+)+from skyvern.forge.sdk.copilot.code_block_synthesis import (+ first_stable_login_submit_index as _first_stable_login_submit_index,+)+from skyvern.forge.sdk.copilot.code_block_synthesis import (freeze_requested_output_extraction_candidate,is_durable_fallback_entry_target,is_generic_entry_opener_click,is_optional_dismissal_only_trajectory,+)+from skyvern.forge.sdk.copilot.code_block_synthesis import (+ last_scout_credential_fill_index as _last_scout_credential_fill_index,+)+from skyvern.forge.sdk.copilot.code_block_synthesis import (missing_rung_text,render_obligation_findings,render_synthesized_offer_text,@@ -224,15 +235,6 @@ _SYNTHESIZED_BLOCK_PERSISTENCE_MUTATING_TOOLS = frozenset(_SYNTHESIZED_BLOCK_REAUTHORING_TOOLS = frozenset({SYNTHESIZED_BLOCK_PERSISTENCE_TOOL, "update_workflow"})_SYNTHESIZED_BLOCK_COMMIT_TOOLS = frozenset({"click", "press_key"})_POST_RUN_PAGE_PATH_INTERACTION_BUDGET = 4-_LOGIN_SUBMIT_NAME_PATTERN = re.compile(- r"^(?:log in|login|sign in|authenticate)(?: now| securely| to continue)?$",- re.I,-)-_LOGIN_SUBMIT_SELECTOR_PATTERN = re.compile(- r"^(?:(?:log in|login|sign in|authenticate)(?: submit| button| btn)?|"- r"(?:submit|button|btn) (?:log in|login|sign in|authenticate))$",- re.I,-)# Evidence sources confirmable only after a run — excluded from the pre-run scout-coverage gate._PRE_RUN_UNGATED_EVIDENCE_SOURCES = frozenset({"independent_run_evidence", "registered_output_parameter", "registered_artifact_content"}@@ -2451,20 +2453,6 @@ def _credential_password_demand_holds(ctx: Any, interactions: list[dict[str, Anyreturn bool(getattr(ctx, "last_scout_observation_has_password_control", False))-def _first_stable_login_submit_index(interactions: Sequence[Mapping[str, Any]], credential_index: int) -> int | None:- for index, interaction in enumerate(interactions[credential_index + 1 :], start=credential_index + 1):- tool_name = str(interaction.get("tool_name") or "").strip()- if tool_name == "press_key" and str(interaction.get("key") or "").strip() == "Enter":- return index- if tool_name != "click":- continue- accessible_name = re.sub(r"[^a-z0-9]+", " ", str(interaction.get("accessible_name") or "").lower()).strip()- selector = re.sub(r"[^a-z0-9]+", " ", str(interaction.get("selector") or "").lower()).strip()- if _LOGIN_SUBMIT_NAME_PATTERN.fullmatch(accessible_name) or _LOGIN_SUBMIT_SELECTOR_PATTERN.fullmatch(selector):- return index- return None--def _credential_flow_scout_gap_incomplete(ctx: Any, trajectory: list[Any]) -> bool:"""Trajectory- and inventory-scoped mirror of the persist seam's credential scout gate: engagedcredentials (username/password fills) must have every required field filled plus a post-fill@@ -2627,17 +2615,6 @@ def _request_expects_unreached_download(ctx: AgentContext) -> bool:return any(criterion.deliverable_kind == "registered_download" for criterion in _active_completion_criteria(ctx))-def _last_scout_credential_fill_index(trajectory: list[Any]) -> int | None:- # Boundary past the ENTIRE credential flow, including a runtime-only OTP/MFA fill. Keying only on- # username/password let an MFA step (fill totp -> verify-click) form a durable entry->commit past- # the boundary and falsely release the terminal-action gate on a login-only trajectory.- last_index: int | None = None- for index, item in enumerate(trajectory):- if isinstance(item, dict) and str(item.get("tool_name") or "").strip() == CREDENTIAL_FILL_TOOL_NAME:- last_index = index- return last_index--def _trajectory_reaches_post_credential_commit(ctx: AgentContext) -> bool:"""Apply the ordinary reach shapes only to the business spine after the credential submit."""trajectory = ctx.scout_trajectory@@ -2652,14 +2629,7 @@ def _trajectory_reaches_post_credential_commit(ctx: AgentContext) -> bool:include_download=False,allow_intermediate_interactions=True,)- credential_submit_index = _first_stable_login_submit_index(interactions, credential_index)- latest_fill_source_url = str(interactions[credential_index].get("source_url") or "").strip()- if credential_submit_index is None and latest_fill_source_url:- credential_submit_index = first_matched_post_fill_submit_index(- interactions,- credential_index,- {latest_fill_source_url},- )+ credential_submit_index = credential_submit_boundary_index(interactions, credential_index)if credential_submit_index is None:return Falsereturn _trajectory_reaches_generic_goal(diff --git a/skyvern/forge/sdk/copilot/tools/workflow_update.py b/skyvern/forge/sdk/copilot/tools/workflow_update.pyindex b066d1bd8..d910216d9 100644--- a/skyvern/forge/sdk/copilot/tools/workflow_update.py+++ b/skyvern/forge/sdk/copilot/tools/workflow_update.py@@ -4112,17 +4112,19 @@ def _attempt_separated_spine_split(if _browser_surface_contains_full_action_spine(keyed_extraction, reconciled_synthesized):return _SpineSplitOutcome(None, ["extraction_retains_full_spine"], None)- stage_codes = _synthesized_durable_stage_codes(synthesized, source_code=reconciled_synthesized)+ resolved = _resolve_durable_stages(synthesized, source_code=reconciled_synthesized, reconciliation=reconciliation)+ stage_codes = resolved.codesif len(stage_codes) < 2:+ _log_durable_stage_derivation_empty(block_label=label, resolved=resolved)return _SpineSplitOutcome(None, ["insufficient_durable_stages"], len(stage_codes))split_violations = _split_selected_output_owner_into_browser_stages(parsed=parsed,code_block=code_block,- synthesized=synthesized,- synthesized_code=reconciled_synthesized,+ stage_codes=stage_codes,extraction_code=keyed_extraction,parameter_keys=reconciliation.parameter_keys,+ segmented=resolved.segmented,)if split_violations:return _SpineSplitOutcome(None, split_violations, len(stage_codes))@@ -8365,24 +8367,106 @@ def _reconcile_synthesized_parameters(return _SynthesizedParameterReconciliation(parameter_keys, violations, aliases, repair_context)-def _synthesized_durable_stage_codes(synthesized: SynthesizedCodeBlock, *, source_code: str | None = None) -> list[str]:- steps = getattr(synthesized, "steps", None)- if not isinstance(steps, list) or len(steps) < 2:- return []+class _DurableStageCodes(NamedTuple):+ codes: list[str]+ empty_reason: str | None = None+++def _output_owner_is_referenced(parsed: Mapping[str, Any], output_label: str) -> bool:+ """True when another block routes to this label. Splitting inserts stages ahead of the owner but+ leaves the label on the owner, so an inbound jump would enter past the login stages."""+ if not output_label:+ return False++ def walk(node: object) -> bool:+ if isinstance(node, Mapping):+ for key, value in node.items():+ if (+ key in ("next_block_label", "finally_block_label")+ and isinstance(value, str)+ and value.strip() == output_label+ ):+ return True+ if walk(value):+ return True+ return False+ if isinstance(node, list):+ return any(walk(item) for item in node)+ return False++ return walk(parsed.get("workflow_definition"))+++class _ResolvedDurableStages(NamedTuple):+ codes: list[str]+ segmented: bool+ empty_reason: str | None = None+++def _resolve_durable_stages(+ synthesized: SynthesizedCodeBlock,+ *,+ source_code: str,+ reconciliation: _SynthesizedParameterReconciliation | None = None,+) -> _ResolvedDurableStages:+ """Segments synthesized per trajectory slice when the scout logged in, else the per-interaction+ derivation. Segments are generated self-contained, so they need no boundary repair here."""+ if synthesized.segments:+ codes = [textwrap.dedent(segment.code).strip() for segment in synthesized.segments]+ if reconciliation is not None:+ codes = [_apply_parameter_reconciliation_to_code(code, reconciliation) for code in codes]+ return _ResolvedDurableStages(codes, True)+ result = _synthesized_durable_stage_codes(synthesized, source_code=source_code)+ return _ResolvedDurableStages(result.codes, False, result.empty_reason)+++def _log_durable_stage_derivation_empty(*, block_label: str, resolved: _ResolvedDurableStages) -> None:+ LOG.info(+ "copilot_durable_stage_derivation_empty",+ block_label=block_label,+ empty_reason=resolved.empty_reason or "insufficient_stage_count",+ stage_count=len(resolved.codes),+ credential_grouped=resolved.segmented,+ )+++def _stage_reads_unbound_scout_local(stage_code: str) -> bool:+ """Each separated stage becomes an independent CodeBlock with its own scope, so a stage that reads+ a synthesizer-internal local bound by an earlier stage would raise NameError at runtime."""+ try:+ tree = ast.parse(textwrap.dedent(stage_code).strip() or "pass")+ except SyntaxError:+ return False+ bound = {node.id for node in ast.walk(tree) if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Store)}+ return any(+ node.id in _INTERNAL_SCOUT_VARS and node.id not in bound+ for node in ast.walk(tree)+ if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Load)+ )+++def _synthesized_durable_stage_codes(+ synthesized: SynthesizedCodeBlock,+ *,+ source_code: str | None = None,+) -> _DurableStageCodes:+ step_ranges = synthesized.steps+ if not step_ranges:+ return _DurableStageCodes([], "insufficient_steps")lines = textwrap.dedent(source_code if source_code is not None else synthesized.code).strip("\n").splitlines()if not lines:- return []+ return _DurableStageCodes([], "empty_source")ranges: list[tuple[int, int]] = []- for step in steps:+ for step in step_ranges:if not isinstance(step, Mapping):- return []+ return _DurableStageCodes([], "malformed_step")start = _coerce_positive_int(step.get("line_start"))end = _coerce_positive_int(step.get("line_end"))if start is None or end is None or end < start or end > len(lines):- return []+ return _DurableStageCodes([], "invalid_step_line_range")ranges.append((start, end))if ranges != sorted(ranges):- return []+ return _DurableStageCodes([], "unordered_step_ranges")# The witness prelude (runtime charset guards + month helper) sits above the first step range, so the# slice would drop it; each separated stage is an independent CodeBlock that must carry its own guards.prelude = "\n".join(lines[: ranges[0][0] - 1]).strip()@@ -8392,7 +8476,18 @@ def _synthesized_durable_stage_codes(synthesized: SynthesizedCodeBlock, *, sourcif not body:continuestage_codes.append(f"{prelude}\n{body}" if prelude else body)- return stage_codes+ if not stage_codes:+ return _DurableStageCodes([], "empty_stage_bodies")+ # A slice can start inside a nested block and lose its header. Declining leaves the fused block+ # persisted, where emitting it fails the whole update later against a label the model never wrote.+ for code in stage_codes:+ try:+ ast.parse(textwrap.dedent(code).strip() or "pass")+ except SyntaxError:+ return _DurableStageCodes([], "stage_not_parseable")+ if any(_stage_reads_unbound_scout_local(code) for code in stage_codes):+ return _DurableStageCodes([], "stage_reads_cross_stage_local")+ return _DurableStageCodes(stage_codes)def _top_level_block_list_for_selected_code_block(@@ -8420,16 +8515,17 @@ def _split_selected_output_owner_into_browser_stages(*,parsed: Mapping[str, Any],code_block: dict[str, Any],- synthesized: SynthesizedCodeBlock,- synthesized_code: str,+ stage_codes: list[str],extraction_code: str,parameter_keys: list[str],+ segmented: bool,) -> list[str]:block_position = _top_level_block_list_for_selected_code_block(parsed, code_block)if block_position is None:return ["Unable to impose synthesized code block: selected output block insertion point is ambiguous."]blocks, selected_index = block_position- stage_codes = _synthesized_durable_stage_codes(synthesized, source_code=synthesized_code)+ if _output_owner_is_referenced(parsed, str(code_block.get("label") or "").strip()):+ return ["Unable to impose synthesized code block: output owner block is routed to by another block."]if len(stage_codes) < 2:return ["Unable to impose synthesized code block: synthesized browser stage boundaries are ambiguous."]output_label = str(code_block.get("label") or "").strip()@@ -8451,12 +8547,22 @@ def _split_selected_output_owner_into_browser_stages("label": label,"code": code.rstrip() + "\n",}- if parameter_keys:- stage_block["parameter_keys"] = list(parameter_keys)+ # Per-stage keys, never the whole set: broadcasting would grant a stage that reads no+ # credential access to the org's saved credential.+ referenced_keys = _referenced_parameter_keys_in_code(code, parameter_keys) if parameter_keys else []+ if referenced_keys:+ stage_block["parameter_keys"] = referenced_keysstage_blocks.append(stage_block)code_block["code"] = textwrap.dedent(extraction_code).strip() + "\n"code_block.pop("parameter_keys", None)blocks[selected_index : selected_index + 1] = [*stage_blocks, code_block]+ LOG.info(+ "copilot_output_owner_split_into_browser_stages",+ block_label=output_label,+ stage_count=len(stage_codes),+ credential_grouped=segmented,+ stage_labels=stage_labels,+ )return []@@ -8945,11 +9051,20 @@ def _maybe_impose_synthesized_code_block(split_extraction_code = textwrap.dedent(submitted_code).strip()elif preserve_submitted_extraction and reconciled_extraction_suffix:split_extraction_code = reconciled_extraction_suffix- durable_stage_codes = _synthesized_durable_stage_codes(synthesized, source_code=reconciled_synthesized_code)+ resolved_stages = _resolve_durable_stages(+ synthesized, source_code=reconciled_synthesized_code, reconciliation=parameter_reconciliation+ )+ durable_stage_codes = resolved_stages.codes+ split_eligible = metadata_declares_goal_values or resolved_stages.segmented+ if split_eligible and len(durable_stage_codes) < 2:+ _log_durable_stage_derivation_empty(block_label=str(code_block.get("label") or ""), resolved=resolved_stages)+ # A credential fill in the trajectory opens the split on its own: a value-producing subset that+ # carries no credential fill reruns on the scout's authenticated session instead of replaying login.should_split_output_owner = (- metadata_declares_goal_values+ split_eligibleand len(durable_stage_codes) >= 2and (bool(extraction_suffix) or append_selected_extraction or preserve_submitted_extraction)+ and not _output_owner_is_referenced(parsed, str(code_block.get("label") or "").strip()))if should_split_output_owner:if not split_extraction_code:@@ -8977,10 +9092,10 @@ def _maybe_impose_synthesized_code_block(split_violations = _split_selected_output_owner_into_browser_stages(parsed=parsed,code_block=code_block,- synthesized=synthesized,- synthesized_code=reconciled_synthesized_code,+ stage_codes=durable_stage_codes,extraction_code=split_extraction_code,parameter_keys=parameter_reconciliation.parameter_keys,+ segmented=resolved_stages.segmented,)if split_violations:return _SynthesizedCodeImpositionResult(diff --git a/skyvern/forge/sdk/db/models.py b/skyvern/forge/sdk/db/models.pyindex a4b079054..27c928b99 100644--- a/skyvern/forge/sdk/db/models.py+++ b/skyvern/forge/sdk/db/models.py@@ -1136,6 +1136,8 @@ class ActionModel(Base):confidence_float = Column(Numeric, nullable=True)screenshot_artifact_id = Column(String, nullable=True)+ started_at = Column(DateTime, nullable=True)+ finished_at = Column(DateTime, nullable=True)created_at = Column(DateTime, default=datetime.datetime.utcnow, nullable=False)modified_at = Column(DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow, nullable=False)created_by = Column(String, nullable=True)diff --git a/skyvern/forge/sdk/db/repositories/artifacts.py b/skyvern/forge/sdk/db/repositories/artifacts.pyindex 5559a787a..a680f90ee 100644--- a/skyvern/forge/sdk/db/repositories/artifacts.py+++ b/skyvern/forge/sdk/db/repositories/artifacts.py@@ -1,7 +1,7 @@from __future__ import annotationsimport datetime-from typing import TYPE_CHECKING, Callable+from typing import TYPE_CHECKING, Any, Callableimport structlogfrom sqlalchemy import and_, delete, func, or_, select, update@@ -77,6 +77,32 @@ class ArtifactsRepository(BaseRepository):await session.refresh(new_artifact)return convert_to_artifact(new_artifact, self.debug_enabled)+ @db_operation("update_artifact_uri")+ async def update_artifact_uri(+ self,+ artifact_id: str,+ organization_id: str,+ uri: str,+ file_size: int | None = None,+ ) -> Artifact | None:+ update_values: dict[str, Any] = {"uri": uri}+ if file_size is not None:+ update_values["file_size"] = file_size++ async with self.Session() as session:+ query = (+ update(ArtifactModel)+ .where(+ ArtifactModel.artifact_id == artifact_id,+ ArtifactModel.organization_id == organization_id,+ )+ .values(**update_values)+ .returning(ArtifactModel)+ )+ artifact = await session.scalar(query)+ await session.commit()+ return convert_to_artifact(artifact, self.debug_enabled) if artifact else None+@traced(name="skyvern.db.bulk_create_artifacts")@db_operation("bulk_create_artifacts")async def bulk_create_artifacts(diff --git a/skyvern/forge/sdk/db/repositories/workflow_parameters.py b/skyvern/forge/sdk/db/repositories/workflow_parameters.pyindex 9cd79f4c6..45cb74d02 100644--- a/skyvern/forge/sdk/db/repositories/workflow_parameters.py+++ b/skyvern/forge/sdk/db/repositories/workflow_parameters.py@@ -6,7 +6,7 @@ from datetime import datetime, timedelta, timezonefrom typing import Anyimport structlog-from sqlalchemy import select+from sqlalchemy import func, selectfrom sqlalchemy.dialects.postgresql import insert as pg_insertfrom sqlalchemy.orm import defer@@ -1143,6 +1143,8 @@ class WorkflowParametersRepository(BaseRepository):screenshot_artifact_id=action.screenshot_artifact_id,action_json=raw_action_payload,confidence_float=action.confidence_float,+ started_at=action.started_at,+ finished_at=action.finished_at,created_by=action.created_by,)session.add(new_action)@@ -1178,12 +1180,10 @@ class WorkflowParametersRepository(BaseRepository):"screenshot_artifact_id": action.screenshot_artifact_id,"action_json": action.model_dump(),"confidence_float": action.confidence_float,+ "started_at": action.started_at,+ "finished_at": action.finished_at,"created_by": action.created_by,}- if action.created_at is not None:- values["created_at"] = action.created_at- if action.modified_at is not None:- values["modified_at"] = action.modified_atasync with self.Session() as session:stmt = pg_insert(ActionModel).values(**values)stmt = stmt.on_conflict_do_update(@@ -1191,6 +1191,10 @@ class WorkflowParametersRepository(BaseRepository):set_={"screenshot_artifact_id": stmt.excluded.screenshot_artifact_id,"action_json": stmt.excluded.action_json,+ # coalesce: an upsert writer that carries no execution timestamps must+ # never overwrite real stamps with NULL.+ "started_at": func.coalesce(stmt.excluded.started_at, ActionModel.started_at),+ "finished_at": func.coalesce(stmt.excluded.finished_at, ActionModel.finished_at),"modified_at": stmt.excluded.modified_at,},)diff --git a/skyvern/forge/sdk/db/utils.py b/skyvern/forge/sdk/db/utils.pyindex 6ba9b7e87..e512e7479 100644--- a/skyvern/forge/sdk/db/utils.py+++ b/skyvern/forge/sdk/db/utils.py@@ -108,6 +108,8 @@ if TYPE_CHECKING:LOG = structlog.get_logger()+_MODEL_TIMESTAMP_FIELDS = frozenset({"started_at", "finished_at", "created_at", "modified_at"})+def summarize_copilot_chat_title(content: str, max_length: int = 120) -> str:# Collapse the opening message to one line so multi-line prompts read cleanly in the history dropdown.@@ -961,14 +963,16 @@ def hydrate_action(action_model: ActionModel, empty_element_id: bool = False) ->"skyvern_element_hash": action_model.skyvern_element_hash,"skyvern_element_data": action_model.skyvern_element_data,"screenshot_artifact_id": action_model.screenshot_artifact_id,+ "started_at": action_model.started_at,+ "finished_at": action_model.finished_at,"created_at": action_model.created_at,"modified_at": action_model.modified_at,}- # Merge with action_json data, skipping None values+ model_timestamp_fields = _MODEL_TIMESTAMP_FIELDSif action_model.action_json:for key, value in action_model.action_json.items():- if value is not None:+ if value is not None and key not in model_timestamp_fields:action_data[key] = value# Get the appropriate action class and instantiate it. Fall back to base Action on@@ -1013,6 +1017,8 @@ def _hydrate_as_base_action(action_data: dict[str, typing.Any], action_model: Ac"workflow_run_id": action_model.workflow_run_id,"task_id": action_model.task_id,"step_id": action_model.step_id,+ "started_at": action_model.started_at,+ "finished_at": action_model.finished_at,"created_at": action_model.created_at,"modified_at": action_model.modified_at,}diff --git a/skyvern/forge/sdk/routes/credentials.py b/skyvern/forge/sdk/routes/credentials.pyindex 1b599a972..ef73b0c29 100644--- a/skyvern/forge/sdk/routes/credentials.py+++ b/skyvern/forge/sdk/routes/credentials.py@@ -124,6 +124,7 @@ from skyvern.forge.sdk.services.credentials import (normalize_totp_config,parse_totp_config,)+from skyvern.forge.sdk.settings_manager import SettingsManagerfrom skyvern.forge.sdk.workflow.browser_session_persistence import retrieve_persisted_workflow_browser_state_dirfrom skyvern.forge.sdk.workflow.models.parameter import WorkflowParameterTypefrom skyvern.forge.sdk.workflow.models.workflow import WorkflowRequestBody, WorkflowRunStatus@@ -3332,6 +3333,7 @@ async def test_custom_credential_service_connection(async def _get_credential_vault_service(vault_type_override: CredentialVaultType | None = None,) -> CredentialVaultService:+ settings = SettingsManager.get_settings()vault_type = vault_type_override or settings.CREDENTIAL_VAULT_TYPEif vault_type == CredentialVaultType.SKYVERN:if not settings.is_local_credential_vault_enabled():diff --git a/skyvern/forge/sdk/routes/google_oauth.py b/skyvern/forge/sdk/routes/google_oauth.pyindex 0b9df87ff..4d663c61f 100644--- a/skyvern/forge/sdk/routes/google_oauth.py+++ b/skyvern/forge/sdk/routes/google_oauth.py@@ -129,6 +129,7 @@ def _require_scopes_from_token(token_data: dict) -> list[str]:async def google_oauth_authorize(request: CreateGoogleOAuthAuthorizeRequest,current_org: Annotated[Organization, Depends(org_auth_service.get_current_org)],+ current_user_id: Annotated[str | None, Depends(org_auth_service.get_current_user_id_or_none)],) -> GoogleOAuthAuthorizeResponse:"""Kick off the Google OAuth 2.0 authorization flow."""try:@@ -139,6 +140,7 @@ async def google_oauth_authorize(scope_profile=request.scope_profile,app_origin=request.app_origin,credential_id=request.credential_id,+ initiator_id=current_user_id,)except google_oauth_service.CredentialNotReauthorizableError as exc:raise HTTPException(status_code=404, detail=str(exc))@@ -162,14 +164,19 @@ async def google_oauth_authorize(async def google_oauth_callback(request: CreateGoogleOAuthCallbackRequest,current_org: Annotated[Organization, Depends(org_auth_service.get_current_org)],+ current_user_id: Annotated[str | None, Depends(org_auth_service.get_current_user_id_or_none)],) -> GoogleOAuthCredentialResponse:"""Handle the Google OAuth 2.0 authorization callback."""context = await google_oauth_service.load_pending_consent_context(organization_id=current_org.organization_id,- nonce=request.state,+ state=request.state,+ initiator_id=current_user_id,)if context is None or not context.consent_redirect_uri:- raise HTTPException(status_code=400, detail="Unknown or consumed OAuth consent nonce")+ raise HTTPException(+ status_code=400,+ detail="This OAuth consent request is unknown, expired, or was not started by you. Restart the connection.",+ )if not context.consent_code_verifier:raise HTTPException(status_code=400,@@ -224,7 +231,8 @@ async def google_oauth_callback(try:credential = await google_oauth_service.promote_pending_credential(organization_id=current_org.organization_id,- nonce=request.state,+ state=request.state,+ initiator_id=current_user_id,refresh_token=refresh_token,scopes_granted=scopes_granted,)diff --git a/skyvern/forge/sdk/routes/microsoft_oauth.py b/skyvern/forge/sdk/routes/microsoft_oauth.pyindex 401d4b35b..accd05311 100644--- a/skyvern/forge/sdk/routes/microsoft_oauth.py+++ b/skyvern/forge/sdk/routes/microsoft_oauth.py@@ -109,6 +109,7 @@ def _require_scopes_from_token(token_data: dict) -> list[str]:async def microsoft_oauth_authorize(request: CreateMicrosoftOAuthAuthorizeRequest,current_org: Annotated[Organization, Depends(org_auth_service.get_current_org)],+ current_user_id: Annotated[str | None, Depends(org_auth_service.get_current_user_id_or_none)],) -> MicrosoftOAuthAuthorizeResponse:try:start = await microsoft_oauth_service.start_authorization(@@ -117,6 +118,7 @@ async def microsoft_oauth_authorize(credential_name=request.credential_name,scope_profile=request.scope_profile,app_origin=request.app_origin,+ initiator_id=current_user_id,)except InvalidAppOriginError as exc:raise HTTPException(status_code=400, detail=str(exc)) from exc@@ -136,13 +138,18 @@ async def microsoft_oauth_authorize(async def microsoft_oauth_callback(request: CreateMicrosoftOAuthCallbackRequest,current_org: Annotated[Organization, Depends(org_auth_service.get_current_org)],+ current_user_id: Annotated[str | None, Depends(org_auth_service.get_current_user_id_or_none)],) -> MicrosoftOAuthCredentialResponse:context = await microsoft_oauth_service.load_pending_consent_context(organization_id=current_org.organization_id,- nonce=request.state,+ state=request.state,+ initiator_id=current_user_id,)if context is None or not context.consent_redirect_uri:- raise HTTPException(status_code=400, detail="Unknown or consumed OAuth consent nonce")+ raise HTTPException(+ status_code=400,+ detail="This OAuth consent request is unknown, expired, or was not started by you. Restart the connection.",+ )if not context.consent_code_verifier:raise HTTPException(status_code=400,@@ -188,7 +195,8 @@ async def microsoft_oauth_callback(try:credential = await microsoft_oauth_service.promote_pending_credential(organization_id=current_org.organization_id,- nonce=request.state,+ state=request.state,+ initiator_id=current_user_id,refresh_token=refresh_token,scopes_granted=scopes_granted,)diff --git a/skyvern/forge/sdk/services/google_oauth_service.py b/skyvern/forge/sdk/services/google_oauth_service.pyindex f0c687cc3..37d25f44d 100644--- a/skyvern/forge/sdk/services/google_oauth_service.py+++ b/skyvern/forge/sdk/services/google_oauth_service.py@@ -47,6 +47,7 @@ from skyvern.forge.sdk.schemas.google_oauth import (GoogleOAuthClientConfigSafe,GoogleOAuthCredentialBase,)+from skyvern.forge.sdk.services import oauth_consentfrom skyvern.forge.sdk.settings_manager import SettingsManagerLOG = structlog.get_logger()@@ -520,6 +521,7 @@ async def start_authorization(scope_profile: str | None = None,app_origin: str | None = None,credential_id: str | None = None,+ initiator_id: str | None = None,) -> GoogleAuthorizationStart:"""Start the consent flow, build the authorize URL, and persist the PKCE verifier.@@ -536,7 +538,8 @@ async def start_authorization(if app_origin is not None:_validate_app_origin(app_origin, resolved_config.config)- nonce = secrets.token_urlsafe(32)+ state = oauth_consent.generate_consent_state()+ nonce = oauth_consent.consent_nonce(state, initiator_id)# Pre-generate the PKCE verifier so the pending row lands with the verifier# populated in a single DB write — a crash mid-flow can no longer leave a# pending row that the callback would see as missing the verifier.@@ -589,22 +592,24 @@ async def start_authorization(authorize_url, _ = build_authorize_url(redirect_uri=redirect_uri,- state=nonce,+ state=state,scopes=requested_scopes,code_verifier=code_verifier,client_config=resolved_config.config,)- return GoogleAuthorizationStart(authorize_url=authorize_url, state=nonce)+ return GoogleAuthorizationStart(authorize_url=authorize_url, state=state)async def promote_pending_credential(organization_id: str,- nonce: str,+ state: str,+ initiator_id: str | None,refresh_token: str,scopes_granted: str | list[str] | tuple[str, ...] | None,) -> GoogleOAuthCredentialBase:"""Encrypt the refresh token and promote the matching pending row to active."""+ nonce = oauth_consent.consent_nonce(state, initiator_id)_require_encryption()encrypted_token = await encryptor.encrypt(refresh_token, EncryptMethod.AES)now = datetime.datetime.now(datetime.UTC).replace(tzinfo=None)@@ -670,11 +675,15 @@ async def mark_credential_expired()-async def load_pending_consent_context(organization_id: str, nonce: str) -> PendingConsentContext | None:+async def load_pending_consent_context(+ organization_id: str,+ state: str,+ initiator_id: str | None,+) -> PendingConsentContext | None:"""Fetch the redirect_uri + PKCE verifier the callback needs to replay to Google."""return await app.DATABASE.google_oauth.load_pending_by_nonce(organization_id=organization_id,- nonce=nonce,+ nonce=oauth_consent.consent_nonce(state, initiator_id),)diff --git a/skyvern/forge/sdk/services/microsoft_oauth_service.py b/skyvern/forge/sdk/services/microsoft_oauth_service.pyindex c14ae067c..eb76f28d4 100644--- a/skyvern/forge/sdk/services/microsoft_oauth_service.py+++ b/skyvern/forge/sdk/services/microsoft_oauth_service.py@@ -25,6 +25,7 @@ from skyvern.forge.sdk.db.repositories.microsoft_oauth import ( # noqa: F401from skyvern.forge.sdk.encrypt import encryptorfrom skyvern.forge.sdk.encrypt.base import EncryptMethodfrom skyvern.forge.sdk.schemas.microsoft_oauth import MicrosoftOAuthCredentialBase+from skyvern.forge.sdk.services import oauth_consentfrom skyvern.utils.email_validation import SAFE_EMAIL_ADDRESS_PATTERNLOG = structlog.get_logger()@@ -256,6 +257,7 @@ async def start_authorization(scopes_requested: str | list[str] | tuple[str, ...] | None = None,scope_profile: str | None = None,app_origin: str | None = None,+ initiator_id: str | None = None,) -> MicrosoftAuthorizationStart:_require_encryption()_validate_redirect_uri(redirect_uri)@@ -263,7 +265,8 @@ async def start_authorization(_validate_app_origin(app_origin)credential_id = generate_microsoft_oauth_credential_id()- nonce = secrets.token_urlsafe(32)+ state = oauth_consent.generate_consent_state()+ nonce = oauth_consent.consent_nonce(state, initiator_id)code_verifier = secrets.token_urlsafe(64)now = datetime.datetime.now(datetime.UTC).replace(tzinfo=None)requested_scopes = (@@ -284,17 +287,18 @@ async def start_authorization(authorize_url, _ = build_authorize_url(redirect_uri=redirect_uri,- state=nonce,+ state=state,scopes=requested_scopes,code_verifier=code_verifier,)- return MicrosoftAuthorizationStart(authorize_url=authorize_url, state=nonce)+ return MicrosoftAuthorizationStart(authorize_url=authorize_url, state=state)async def promote_pending_credential(organization_id: str,- nonce: str,+ state: str,+ initiator_id: str | None,refresh_token: str,scopes_granted: str | list[str] | tuple[str, ...] | None,) -> MicrosoftOAuthCredentialBase:@@ -303,7 +307,7 @@ async def promote_pending_credential(now = datetime.datetime.now(datetime.UTC).replace(tzinfo=None)return await app.DATABASE.microsoft_oauth.promote_pending_to_active(organization_id=organization_id,- nonce=nonce,+ nonce=oauth_consent.consent_nonce(state, initiator_id),encrypted_refresh_token=encrypted_token,encrypted_method=EncryptMethod.AES,scopes_granted=_coerce_scopes(scopes_granted),@@ -311,10 +315,14 @@ async def promote_pending_credential()-async def load_pending_consent_context(organization_id: str, nonce: str) -> PendingConsentContext | None:+async def load_pending_consent_context(+ organization_id: str,+ state: str,+ initiator_id: str | None,+) -> PendingConsentContext | None:return await app.DATABASE.microsoft_oauth.load_pending_by_nonce(organization_id=organization_id,- nonce=nonce,+ nonce=oauth_consent.consent_nonce(state, initiator_id),)diff --git a/skyvern/forge/sdk/services/oauth_consent.py b/skyvern/forge/sdk/services/oauth_consent.pynew file mode 100644index 000000000..ade57d16e--- /dev/null+++ b/skyvern/forge/sdk/services/oauth_consent.py@@ -0,0 +1,40 @@+"""Binds an OAuth consent challenge to the caller that started it.++The provider echoes ``state`` back to whichever browser completes consent, so ``state``+alone only proves the challenge is live — not that the caller redeeming it is the one who+asked for it. Storing the derived nonce instead of the raw ``state`` makes that binding a+property of the lookup: the callback re-derives the nonce from its own caller identity, and+a challenge started by someone else simply resolves to a row that does not exist.+"""++from __future__ import annotations++import hashlib+import secrets++from skyvern.config import settings++# Callers with no resolvable user (raw API key, no UI session) share this binding; they+# already hold org-wide credentials, so there is no narrower identity to bind them to.+_UNIDENTIFIED_INITIATOR = "\x00unidentified"+_CONSENT_NONCE_KDF_ITERATIONS = 120_000+++def generate_consent_state() -> str:+ """Mint the unguessable ``state`` handed to the OAuth provider."""+ return secrets.token_urlsafe(32)+++def consent_nonce(state: str, initiator_id: str | None) -> str:+ """Derive the consent nonce stored against ``state`` for the caller that started the flow.++ An empty, unknown, or foreign ``state`` derives a nonce that was never stored, so every+ such callback fails the lookup instead of falling through to the token exchange.+ """+ material = f"{initiator_id or _UNIDENTIFIED_INITIATOR}\x00{state}".encode()+ return hashlib.pbkdf2_hmac(+ "sha256",+ settings.SECRET_KEY.encode(),+ material,+ _CONSENT_NONCE_KDF_ITERATIONS,+ ).hex()diff --git a/skyvern/forge/sdk/workflow/models/code_block_recorder.py b/skyvern/forge/sdk/workflow/models/code_block_recorder.pyindex f07b5fd0e..6a183c22f 100644--- a/skyvern/forge/sdk/workflow/models/code_block_recorder.py+++ b/skyvern/forge/sdk/workflow/models/code_block_recorder.py@@ -304,8 +304,8 @@ class _Recorder:raisefinally:duration_ms = int((time.monotonic() - started) * 1000)- action.created_at = started_wall- action.modified_at = naive_utc_now()+ action.started_at = started_wall+ action.finished_at = naive_utc_now()if isinstance(action.output, dict):action.output["duration_ms"] = duration_msself.actions.append(action)diff --git a/skyvern/forge/sdk/workflow/service.py b/skyvern/forge/sdk/workflow/service.pyindex 9521d4d24..323362949 100644--- a/skyvern/forge/sdk/workflow/service.py+++ b/skyvern/forge/sdk/workflow/service.py@@ -9328,17 +9328,34 @@ class WorkflowService:last_step_resolved = Falsefor video_artifact in video_artifacts:if video_artifact.video_artifact_id:- upload_key = await app.ARTIFACT_MANAGER.update_artifact_data(- artifact_id=video_artifact.video_artifact_id,- organization_id=workflow_run.organization_id,- data=video_artifact.video_data,- )+ try:+ if video_artifact.video_file_extension:+ upload_key = await app.ARTIFACT_MANAGER.update_artifact_data(+ artifact_id=video_artifact.video_artifact_id,+ organization_id=workflow_run.organization_id,+ data=video_artifact.video_data,+ file_extension=video_artifact.video_file_extension,+ )+ else:+ upload_key = await app.ARTIFACT_MANAGER.update_artifact_data(+ artifact_id=video_artifact.video_artifact_id,+ organization_id=workflow_run.organization_id,+ data=video_artifact.video_data,+ )+ except Exception:+ LOG.warning(+ "Failed to persist workflow video artifact",+ workflow_id=workflow.workflow_id,+ workflow_run_id=workflow_run.workflow_run_id,+ organization_id=workflow_run.organization_id,+ video_artifact_id=video_artifact.video_artifact_id,+ exc_info=True,+ )+ continueif upload_key:upload_keys.add(upload_key)continue- # A teardown-attached recording has no pre-registered artifact row.- # Prefer collected video bytes; use the on-disk path only when no bytes were returned.video_path = video_artifact.video_pathif not video_artifact.video_data and (not video_path or not os.path.exists(video_path)):continue@@ -9357,17 +9374,33 @@ class WorkflowService:)continueif video_artifact.video_data:- artifact_id = await app.ARTIFACT_MANAGER.create_artifact(- step=last_step,- artifact_type=ArtifactType.RECORDING,- data=video_artifact.video_data,- )+ if video_artifact.video_file_extension:+ artifact_id = await app.ARTIFACT_MANAGER.create_artifact(+ step=last_step,+ artifact_type=ArtifactType.RECORDING,+ data=video_artifact.video_data,+ file_extension=video_artifact.video_file_extension,+ )+ else:+ artifact_id = await app.ARTIFACT_MANAGER.create_artifact(+ step=last_step,+ artifact_type=ArtifactType.RECORDING,+ data=video_artifact.video_data,+ )else:- artifact_id = await app.ARTIFACT_MANAGER.create_artifact(- step=last_step,- artifact_type=ArtifactType.RECORDING,- path=video_path,- )+ if video_artifact.video_file_extension:+ artifact_id = await app.ARTIFACT_MANAGER.create_artifact(+ step=last_step,+ artifact_type=ArtifactType.RECORDING,+ path=video_path,+ file_extension=video_artifact.video_file_extension,+ )+ else:+ artifact_id = await app.ARTIFACT_MANAGER.create_artifact(+ step=last_step,+ artifact_type=ArtifactType.RECORDING,+ path=video_path,+ )video_artifact.video_artifact_id = artifact_idupload_keys.add(last_step.task_id)if upload_keys:diff --git a/skyvern/webeye/actions/actions.py b/skyvern/webeye/actions/actions.pyindex 7c89b7941..cec2d2ade 100644--- a/skyvern/webeye/actions/actions.py+++ b/skyvern/webeye/actions/actions.py@@ -181,6 +181,8 @@ class Action(BaseModel):# bound to what was actually seen rather than to a counter's value.observation_digest: str | None = Field(default=None, exclude=True)+ started_at: datetime | None = None+ finished_at: datetime | None = Nonecreated_at: datetime | None = Nonemodified_at: datetime | None = Nonecreated_by: str | None = Nonediff --git a/skyvern/webeye/actions/handler.py b/skyvern/webeye/actions/handler.pyindex 03e90183a..2b61f2d5a 100644--- a/skyvern/webeye/actions/handler.py+++ b/skyvern/webeye/actions/handler.py@@ -94,6 +94,7 @@ from skyvern.forge.sdk.copilot.block_goal_wrapping import unwrap_goal_fieldsfrom skyvern.forge.sdk.core import skyvern_contextfrom skyvern.forge.sdk.core.hashing import diagnostic_fingerprintfrom skyvern.forge.sdk.core.skyvern_context import PendingFileChooserListener, ensure_context+from skyvern.forge.sdk.db.datetime_utils import naive_utc_nowfrom skyvern.forge.sdk.event.factory import EventStrategyFactoryfrom skyvern.forge.sdk.experimentation.llm_prompt_config import (resolve_check_user_goal_handler,@@ -2730,6 +2731,10 @@ class ActionHandler:# Re-evaluated here, against the page as it is now, before anything downstream looks up a# browser, chooses the download-capturing path or persists a row.preflight_action(action, page, site="handle_action")+ action.started_at = naive_utc_now()+ # Hydrated/cached actions can arrive with a prior finished_at; clear it so the+ # exceptional-exit fallback below stamps this execution, not the previous one.+ action.finished_at = Nonebrowser_state = app.BROWSER_MANAGER.get_for_task(task.task_id, workflow_run_id=task.workflow_run_id)# TODO: maybe support all action types in the future(?)trigger_download_action = (@@ -2888,6 +2893,7 @@ class ActionHandler:LOG.warning("Failed to remove captured download listener", exc_info=True)if not false_click_download_event.done():false_click_download_event.cancel()+ action.finished_at = naive_utc_now()persisted_action = await app.DATABASE.workflow_params.create_action(action=action)action.action_id = persisted_action.action_idreturn results@@ -2998,6 +3004,7 @@ class ActionHandler:else BROWSER_DOWNLOAD_TIMEOUT,)download_triggered = False+ working_page_replaced_after_close = Falsexhr_fallback_moved_paths: set[str] = set()transient_text_observer = TransientPageTextObserver(page,@@ -3022,12 +3029,65 @@ class ActionHandler:page=page,action=action,)+ # The execution window ends when the inner action completes: the download wait+ # below (up to BROWSER_DOWNLOAD_TIMEOUT) is settle observation, excluded to match+ # the cached-script writer's semantics.+ action.finished_at = naive_utc_now()if not results:return results# Let request events already queued by the action enter before closing admission.await asyncio.sleep(0)xhr_capture.seal_in_flight_requests()- # Deliberately reinstall and rescan in case the action replaced the document or exposed initial visible text.+ if browser_state is not None and page.is_closed():+ LOG.warning(+ "Working page closed during download action; recreating it before continuing",+ workflow_run_id=task.workflow_run_id,+ )+ xhr_capture.disable()+ recovered_page: Page | None = None+ recovery_timeout_seconds = (+ float(task.download_timeout) if task.download_timeout is not None else BROWSER_DOWNLOAD_TIMEOUT+ )+ try:+ async with asyncio.timeout(recovery_timeout_seconds):+ recovered_page = await browser_state.new_page()+ await browser_state.navigate_to_url(page=recovered_page, url=page_url_before_download)+ await browser_state.set_active_page(recovered_page)+ except Exception:+ LOG.warning(+ "Failed to recreate working page after download action closed it",+ workflow_run_id=task.workflow_run_id,+ exc_info=True,+ )+ if recovered_page is not None:+ try:+ await recovered_page.close()+ except Exception:+ LOG.warning(+ "Failed to close replacement page after working page recovery failed",+ workflow_run_id=task.workflow_run_id,+ exc_info=True,+ )+ else:+ assert recovered_page is not None+ working_page_replaced_after_close = True+ try:+ _remove_download_listener(page, _capture_download_event)+ except Exception:+ LOG.warning("Failed to remove download listener from closed page", exc_info=True)+ page = recovered_page+ page.on("download", _capture_download_event)+ recovered_text_observer = TransientPageTextObserver(+ page,+ task_id=task.task_id,+ step_id=step.step_id,+ workflow_run_id=task.workflow_run_id,+ )+ recovered_text_observer.events.extend(transient_text_observer.events)+ await transient_text_observer.stop()+ transient_text_observer = recovered_text_observer+ # Deliberately reinstall and rescan in case the action replaced the document or exposed initial+ # visible text.await transient_text_observer.start(scan_initial_visible_state=True)if task.download_timeout is not None:download_wait_hard_timeout_seconds = float(task.download_timeout)@@ -3323,6 +3383,8 @@ class ActionHandler:if isinstance(results[-1], ActionSuccess):results[-1].needs_followup = Trueresults[-1].followup_message = DOWNLOAD_NOT_TRIGGERED_FOLLOWUP_MESSAGE+ if working_page_replaced_after_close:+ results[-1].skip_remaining_actions = Trueaction.download_triggered = Falsereturn resultsresults[-1].download_triggered = True@@ -3350,8 +3412,13 @@ class ActionHandler:post_settle_extra_file_count=len(post_settle_extra_paths),post_settle_extra_files=sorted(os.path.basename(fp) for fp in post_settle_extra_paths),)+ if working_page_replaced_after_close:+ results[-1].skip_remaining_actions = Truereturn resultsfinally:+ # Fallback for exceptional exits that never reached the post-action stamp.+ if action.finished_at is None:+ action.finished_at = naive_utc_now()await eager_blob_capture.aclose()for observed_popup, popup_callback in download_popup_callbacks:try:@@ -3381,15 +3448,20 @@ class ActionHandler:initial_page_count=initial_page_count,page_count_after_download=page_count_after_download,)- if page_count_after_download > initial_page_count:+ extra_page_count = page_count_after_download - initial_page_count+ if extra_page_count > 0:LOG.info(- "Download triggered, closing the extra page",+ "Download triggered, closing extra pages",+ extra_page_count=extra_page_count,)- if page == pages_after_download[-1]:- LOG.warning("The extra page is the current page, closing it")- # close the extra page- await pages_after_download[-1].close()+ for extra_page in reversed(pages_after_download):+ if extra_page_count <= 0:+ break+ if extra_page == page:+ continue+ await extra_page.close()+ extra_page_count -= 1blank_page_urls = {"about:blank", ":"}if page.url in blank_page_urls and page_url_before_download not in blank_page_urls:diff --git a/skyvern/webeye/browser_artifacts.py b/skyvern/webeye/browser_artifacts.pyindex cf2a783f9..33ccfca93 100644--- a/skyvern/webeye/browser_artifacts.py+++ b/skyvern/webeye/browser_artifacts.py@@ -14,6 +14,7 @@ LOG = structlog.get_logger()class VideoArtifact(BaseModel):video_path: str | None = Nonevideo_artifact_id: str | None = None+ video_file_extension: str | None = Nonevideo_data: bytes = b""diff --git a/skyvern/webeye/browser_factory.py b/skyvern/webeye/browser_factory.pyindex ecf6536f1..e59fb38d4 100644--- a/skyvern/webeye/browser_factory.py+++ b/skyvern/webeye/browser_factory.py@@ -29,6 +29,8 @@ from playwright.async_api import Error as PlaywrightErrorfrom playwright.async_api import (Page,Playwright,+ Request,+ Route,Video,)@@ -133,6 +135,103 @@ def sanitize_browser_headers(headers: dict[str, str] | None) -> dict[str, str] |return sanitized or None+def _browser_origin(url: str | None) -> tuple[str, str, int] | None:+ if not url:+ return None+ try:+ parsed = urlparse(url)+ hostname = parsed.hostname+ port = parsed.port+ except ValueError:+ return None++ scheme = parsed.scheme.lower()+ if scheme not in {"http", "https"} or hostname is None:+ return None+ if port is None:+ port = 80 if scheme == "http" else 443+ return scheme, hostname.lower(), port+++def _partition_browser_headers(+ extra_http_headers: dict[str, str] | None,+) -> tuple[dict[str, str] | None, dict[str, str] | None]:+ if not extra_http_headers:+ return None, None++ parsed_headers = parse_extra_headers(extra_http_headers).headers+ caller_headers = app.AGENT_FUNCTION.strip_proxy_session_extra_http_headers(parsed_headers) or {}+ browser_internal_headers = {name: value for name, value in extra_http_headers.items() if name not in caller_headers}+ return sanitize_browser_headers(browser_internal_headers), sanitize_browser_headers(caller_headers)+++async def _apply_origin_scoped_headers(+ browser_context: BrowserContext,+ *,+ target_url: str | None,+ headers: dict[str, str] | None,+ route_handlers_allowed: bool | None,+) -> None:+ scoped_headers = sanitize_browser_headers(headers)+ if not scoped_headers:+ return++ if route_handlers_allowed is not True:+ LOG.warning("Omitting caller HTTP headers because browser context route handlers are not permitted")+ return++ target_origin = _browser_origin(target_url)+ if target_origin is None:+ LOG.warning("Omitting caller HTTP headers because the browser target URL has no valid HTTP origin")+ return++ normalized_headers = {name.lower(): (name, value) for name, value in scoped_headers.items()}+ baseline_headers: dict[str, tuple[str, str] | None] = {}++ async def apply_headers(route: Route, request: Request) -> None:+ request_origin = _browser_origin(request.url)+ request_headers = await request.all_headers()+ request_header_names = {name.lower(): name for name in request_headers}++ if request_origin == target_origin:+ for normalized_name, (name, value) in normalized_headers.items():+ existing_name = request_header_names.get(normalized_name)+ if normalized_name not in baseline_headers:+ if existing_name is not None and request_headers[existing_name] != value:+ baseline_headers[normalized_name] = (existing_name, request_headers[existing_name])+ else:+ baseline_headers[normalized_name] = None+ if existing_name is not None:+ request_headers.pop(existing_name)+ request_headers[name] = value+ await route.fallback(headers=request_headers)+ return++ changed = False+ for normalized_name, (_, scoped_value) in normalized_headers.items():+ existing_name = request_header_names.get(normalized_name)+ if existing_name is None:+ continue++ baseline = baseline_headers.get(normalized_name)+ if normalized_name in baseline_headers:+ request_headers.pop(existing_name)+ if baseline is not None:+ baseline_name, baseline_value = baseline+ request_headers[baseline_name] = baseline_value+ changed = True+ elif request_headers[existing_name] == scoped_value:+ request_headers.pop(existing_name)+ changed = True++ if changed:+ await route.fallback(headers=request_headers)+ else:+ await route.fallback()++ await browser_context.route("**/*", apply_headers)++async def _capture_seed_profile_state(browser_context: BrowserContext, browser_artifacts: BrowserArtifacts, kwargs: dict[str, Any]) -> None:@@ -574,11 +673,13 @@ class BrowserContextFactory:browser_type = settings.BROWSER_TYPEbrowser_context: BrowserContext | None = Nonecleanup_func: BrowserCleanupFunc = None+ browser_internal_headers, scoped_headers = _partition_browser_headers(kwargs.get("extra_http_headers"))+ creator_kwargs = {**kwargs, "extra_http_headers": browser_internal_headers}try:creator = cls._creators.get(browser_type)if not creator:raise UnknownBrowserType(browser_type)- browser_context, browser_artifacts, cleanup_func = await creator(playwright, **kwargs)+ browser_context, browser_artifacts, cleanup_func = await creator(playwright, **creator_kwargs)await restore_session_cookies(browser_context, browser_artifacts.browser_session_dir)# After session cookies so a verified-login heal (banked by the credential living-profile# engine) wins over the profile's own older session cookies on a key clash. Gated on the@@ -591,7 +692,23 @@ class BrowserContextFactory:set_popup_video_listener(browser_context=browser_context, browser_artifacts=browser_artifacts)set_download_file_listener(browser_context=browser_context, **kwargs)set_dialog_handler(browser_context=browser_context)- await app.AGENT_FUNCTION.setup_browser_context_extensions(browser_context=browser_context, **kwargs)+ route_handlers_allowed = None+ if scoped_headers:+ route_handlers_allowed = await app.AGENT_FUNCTION.browser_context_route_handlers_allowed(**kwargs)+ extension_kwargs = {+ **kwargs,+ "_browser_context_route_handlers_allowed": route_handlers_allowed,+ }+ await app.AGENT_FUNCTION.setup_browser_context_extensions(+ browser_context=browser_context,+ **extension_kwargs,+ )+ await _apply_origin_scoped_headers(+ browser_context,+ target_url=cast(str | None, kwargs.get("url")),+ headers=scoped_headers,+ route_handlers_allowed=route_handlers_allowed,+ )proxy_location: ProxyLocationInput = kwargs.get("proxy_location")if isinstance(proxy_location, ProxyLocation):diff --git a/skyvern/webeye/real_browser_manager.py b/skyvern/webeye/real_browser_manager.pyindex bdbc17280..03c123f19 100644--- a/skyvern/webeye/real_browser_manager.py+++ b/skyvern/webeye/real_browser_manager.py@@ -38,7 +38,7 @@ from skyvern.webeye.cdp_frame_publisher import ()from skyvern.webeye.real_browser_state import RealBrowserStatefrom skyvern.webeye.session_cookies import persist_session_cookies-from skyvern.webeye.video_utils import finalize_webm+from skyvern.webeye.video_utils import prepare_recording_for_uploadLOG = structlog.get_logger()@@ -774,20 +774,21 @@ class RealBrowserManager(BrowserManager):for i, video_artifact in enumerate(browser_state.browser_artifacts.video_artifacts):path = video_artifact.video_pathif path and os.path.exists(path=path):- # Only the local Playwright-launched recording path produces WebM- # that needs the remux fix-up. Other producers (e.g. fully formed- # MP4 downloaded from a remote source) are already container-valid- # and would be corrupted by ``finalize_webm`` — read those raw.is_webm = path.lower().endswith(".webm")if finalize and is_webm:- # Remux via ffmpeg so the WebM container has a valid Duration + Cues,- # even when browser_context.close() was killed mid-finalization.- browser_state.browser_artifacts.video_artifacts[i].video_data = await finalize_webm(path)+ async with prepare_recording_for_upload(path) as prepared:+ with open(prepared.path, "rb") as f:+ browser_state.browser_artifacts.video_artifacts[i].video_data = f.read()+ browser_state.browser_artifacts.video_artifacts[+ i+ ].video_file_extension = prepared.file_extensionelse:- # Per-step snapshot while recording is still open — skip ffmpeg: the file is- # partial, so remux would either fail or be thrown away by the final pass.+ # Non-WebM sources are already container-valid; per-step WebM snapshots are still incomplete.with open(path, "rb") as f:browser_state.browser_artifacts.video_artifacts[i].video_data = f.read()+ browser_state.browser_artifacts.video_artifacts[i].video_file_extension = (+ os.path.splitext(path)[1].lstrip(".").lower() or "webm"+ )else:LOG.debug("Video path not found",diff --git a/tests/unit/forge/sdk/artifact/storage/test_azure_storage.py b/tests/unit/forge/sdk/artifact/storage/test_azure_storage.pyindex da9ff3317..8fd02a141 100644--- a/tests/unit/forge/sdk/artifact/storage/test_azure_storage.py+++ b/tests/unit/forge/sdk/artifact/storage/test_azure_storage.py@@ -11,6 +11,7 @@ from skyvern.forge.sdk.api.real_azure import RealAsyncAzureStorageClientfrom skyvern.forge.sdk.artifact.models import Artifact, ArtifactTypefrom skyvern.forge.sdk.artifact.storage.azure import AzureStoragefrom skyvern.forge.sdk.artifact.storage.base import SENSITIVE_SHARE_URL_EXPIRY_HOURS+from skyvern.forge.sdk.artifact.storage.recording_test_helpers import fake_prepared_recording# Test constantsTEST_CONTAINER = "test-azure-container"@@ -68,19 +69,28 @@ class TestAzureStorageBrowserSessionFiles:"""Test syncing a file with date in path (videos/har)."""test_file = tmp_path / "recording.webm"test_file.write_bytes(b"fake video data")-- uri = await azure_storage.sync_browser_session_file(- organization_id=TEST_ORGANIZATION_ID,- browser_session_id=TEST_BROWSER_SESSION_ID,- artifact_type="videos",- local_file_path=str(test_file),- remote_path="recording.webm",- date="2025-01-15",- )-- expected_uri = f"azure://{TEST_CONTAINER}/v1/{settings.ENV}/{TEST_ORGANIZATION_ID}/browser_sessions/{TEST_BROWSER_SESSION_ID}/videos/2025-01-15/recording.webm"+ prepared_file = tmp_path / "recording.mp4"+ prepared_file.write_bytes(b"fake mp4 data")++ with patch(+ "skyvern.forge.sdk.artifact.storage.azure.prepare_recording_for_upload",+ lambda path: fake_prepared_recording(path, str(prepared_file)),+ ):+ with patch("skyvern.forge.sdk.artifact.storage.azure.sync_run_recording_clips", new=AsyncMock()):+ uri = await azure_storage.sync_browser_session_file(+ organization_id=TEST_ORGANIZATION_ID,+ browser_session_id=TEST_BROWSER_SESSION_ID,+ artifact_type="videos",+ local_file_path=str(test_file),+ remote_path="recording.webm",+ date="2025-01-15",+ )++ expected_uri = f"azure://{TEST_CONTAINER}/v1/{settings.ENV}/{TEST_ORGANIZATION_ID}/browser_sessions/{TEST_BROWSER_SESSION_ID}/videos/2025-01-15/recording.mp4"assert uri == expected_uri- azure_storage.async_client.upload_file_from_path.assert_called_once()+ azure_storage.async_client.upload_file_from_path.assert_called_once_with(+ expected_uri, str(prepared_file), tier=StandardBlobTier.HOT, tags={"test": "tag"}+ )async def test_sync_browser_session_file_without_date(self, azure_storage: AzureStorageForTests, tmp_path: Pathdiff --git a/tests/unit/forge/sdk/artifact/storage/test_gcs_storage.py b/tests/unit/forge/sdk/artifact/storage/test_gcs_storage.pyindex c113a63bd..28801135f 100644--- a/tests/unit/forge/sdk/artifact/storage/test_gcs_storage.py+++ b/tests/unit/forge/sdk/artifact/storage/test_gcs_storage.py@@ -12,6 +12,7 @@ from skyvern.forge.sdk.api.real_gcp import RealAsyncGcsStorageClientfrom skyvern.forge.sdk.artifact.models import Artifact, ArtifactTypefrom skyvern.forge.sdk.artifact.storage.base import SENSITIVE_SHARE_URL_EXPIRY_HOURSfrom skyvern.forge.sdk.artifact.storage.gcs import GcsStorage+from skyvern.forge.sdk.artifact.storage.recording_test_helpers import fake_prepared_recordingTEST_BUCKET = "test-gcs-bucket"TEST_ORGANIZATION_ID = "test-org-123"@@ -92,19 +93,28 @@ class TestGcsStorageBrowserSessionFiles:async def test_sync_browser_session_file_with_date(self, gcs_storage: GcsStorageForTests, tmp_path: Path) -> None:test_file = tmp_path / "recording.webm"test_file.write_bytes(b"fake video data")-- uri = await gcs_storage.sync_browser_session_file(- organization_id=TEST_ORGANIZATION_ID,- browser_session_id=TEST_BROWSER_SESSION_ID,- artifact_type="videos",- local_file_path=str(test_file),- remote_path="recording.webm",- date="2025-01-15",- )-- expected_uri = f"gs://{TEST_BUCKET}/v1/{settings.ENV}/{TEST_ORGANIZATION_ID}/browser_sessions/{TEST_BROWSER_SESSION_ID}/videos/2025-01-15/recording.webm"+ prepared_file = tmp_path / "recording.mp4"+ prepared_file.write_bytes(b"fake mp4 data")++ with patch(+ "skyvern.forge.sdk.artifact.storage.gcs.prepare_recording_for_upload",+ lambda path: fake_prepared_recording(path, str(prepared_file)),+ ):+ with patch("skyvern.forge.sdk.artifact.storage.gcs.sync_run_recording_clips", new=AsyncMock()):+ uri = await gcs_storage.sync_browser_session_file(+ organization_id=TEST_ORGANIZATION_ID,+ browser_session_id=TEST_BROWSER_SESSION_ID,+ artifact_type="videos",+ local_file_path=str(test_file),+ remote_path="recording.webm",+ date="2025-01-15",+ )++ expected_uri = f"gs://{TEST_BUCKET}/v1/{settings.ENV}/{TEST_ORGANIZATION_ID}/browser_sessions/{TEST_BROWSER_SESSION_ID}/videos/2025-01-15/recording.mp4"assert uri == expected_uri- gcs_storage.async_client.upload_file_from_path.assert_called_once()+ gcs_storage.async_client.upload_file_from_path.assert_called_once_with(+ expected_uri, str(prepared_file), storage_class=STORAGE_CLASS_STANDARD, tags={}+ )async def test_sync_browser_session_file_without_date(self, gcs_storage: GcsStorageForTests, tmp_path: Pathdiff --git a/tests/unit/forge/sdk/routes/streaming/test_vnc_routed_url.py b/tests/unit/forge/sdk/routes/streaming/test_vnc_routed_url.pyindex 36bfd060d..906b28a71 100644--- a/tests/unit/forge/sdk/routes/streaming/test_vnc_routed_url.py+++ b/tests/unit/forge/sdk/routes/streaming/test_vnc_routed_url.py@@ -13,7 +13,7 @@ from types import SimpleNamespaceimport pytestfrom skyvern.exceptions import MissingRoutedVncAddressError-from skyvern.forge.sdk.routes.streaming.channels import vnc as vnc_channel_module+from skyvern.forge.sdk.routes.streaming.channels import vnc as vnc_channelfrom skyvern.forge.sdk.routes.streaming.channels.vnc import (_build_vnc_url_from_browser_address,loop_stream_vnc,@@ -89,7 +89,7 @@ async def test_a_session_with_no_routable_address_fails_instead_of_streaming(dialed.append(url)raise AssertionError("live view must not dial when no routed address exists")- monkeypatch.setattr(vnc_channel_module.websockets, "connect", _record_connect)+ monkeypatch.setattr(vnc_channel.websockets, "connect", _record_connect)with pytest.raises(MissingRoutedVncAddressError):await loop_stream_vnc(_channel(POD_ADDRESS)) # type: ignore[arg-type]diff --git a/tests/unit/google/test_google_oauth.py b/tests/unit/google/test_google_oauth.pyindex b8d3e740e..65a049a5a 100644--- a/tests/unit/google/test_google_oauth.py+++ b/tests/unit/google/test_google_oauth.py@@ -22,7 +22,7 @@ from skyvern.forge.sdk.schemas.google_oauth import (UpdateGoogleOAuthClientConfigRequest,UpdateGoogleOAuthCredentialRequest,)-from skyvern.forge.sdk.services import google_drive_service, google_oauth_service+from skyvern.forge.sdk.services import google_drive_service, google_oauth_service, oauth_consentfrom skyvern.schemas.workflows import FileStorageType, FileUploadDestination@@ -2040,10 +2040,12 @@ async def test_authorize_route_forwards_credential_id_for_reconnect(monkeypatch:response = await google_oauth_routes.google_oauth_authorize(request=request,current_org=SimpleNamespace(organization_id="org_1"),+ current_user_id="user_1",)assert response.authorize_url == "https://auth"assert start_mock.await_args.kwargs["credential_id"] == "goac_existing"+ assert start_mock.await_args.kwargs["initiator_id"] == "user_1"@pytest.mark.asyncio@@ -2061,6 +2063,7 @@ async def test_authorize_route_returns_404_when_credential_not_reauthorizable(await google_oauth_routes.google_oauth_authorize(request=request,current_org=SimpleNamespace(organization_id="org_1"),+ current_user_id="user_1",)assert exc_info.value.status_code == 404@@ -2197,6 +2200,7 @@ async def test_start_authorization_persists_verifier_and_returns_url(monkeypatchorganization_id="org_1",redirect_uri="https://x/cb",credential_name="my-cred",+ initiator_id="user_1",)assert result.authorize_url.startswith(google_oauth_service.GOOGLE_AUTHORIZE_ENDPOINT)@@ -2206,7 +2210,9 @@ async def test_start_authorization_persists_verifier_and_returns_url(monkeypatchassert insert_kwargs["organization_id"] == "org_1"assert insert_kwargs["credential_name"] == "my-cred"assert insert_kwargs["consent_redirect_uri"] == "https://x/cb"- assert insert_kwargs["consent_nonce"] == result.state+ assert insert_kwargs["consent_nonce"] == oauth_consent.consent_nonce(result.state, "user_1")+ # The value handed to Google must never be the value we look rows up by.+ assert insert_kwargs["consent_nonce"] != result.stateassert insert_kwargs["client_id"] == "cid"# The verifier must be in the same insert as everything else — no second# round-trip — so a crash mid-flow can't leave a verifier-less pending row.@@ -2260,6 +2266,7 @@ async def test_start_authorization_reconnect_reauthorizes_in_place(monkeypatch:organization_id="org_1",redirect_uri="https://x/cb",credential_id="goac_existing",+ initiator_id="user_1",)assert result.authorize_url.startswith(google_oauth_service.GOOGLE_AUTHORIZE_ENDPOINT)@@ -2269,7 +2276,8 @@ async def test_start_authorization_reconnect_reauthorizes_in_place(monkeypatch:reauth_mock.assert_awaited_once()kwargs = reauth_mock.await_args.kwargsassert kwargs["credential_id"] == "goac_existing"- assert kwargs["consent_nonce"] == result.state+ assert kwargs["consent_nonce"] == oauth_consent.consent_nonce(result.state, "user_1")+ assert kwargs["consent_nonce"] != result.stateassert kwargs["client_id"] == "cid"# The originally granted scopes are re-requested so the reconnected credential stays usable.assert "scope=" in result.authorize_url@@ -2423,7 +2431,8 @@ async def test_promote_pending_credential_encrypts_and_calls_repo(monkeypatch: presult = await google_oauth_service.promote_pending_credential(organization_id="org_1",- nonce="nonce-xyz",+ state="state-xyz",+ initiator_id="user_1",refresh_token="rt-plain",scopes_granted="https://a https://b",)@@ -2433,7 +2442,8 @@ async def test_promote_pending_credential_encrypts_and_calls_repo(monkeypatch: ppromote_mock.assert_awaited_once()kwargs = promote_mock.await_args.kwargsassert kwargs["organization_id"] == "org_1"- assert kwargs["nonce"] == "nonce-xyz"+ assert kwargs["nonce"] == oauth_consent.consent_nonce("state-xyz", "user_1")+ assert kwargs["nonce"] != "state-xyz"assert kwargs["encrypted_refresh_token"] == "ENC::rt"assert kwargs["encrypted_method"] == EncryptMethod.AESassert kwargs["scopes_granted"] == ["https://a", "https://b"]@@ -2457,10 +2467,14 @@ async def test_load_pending_consent_context_delegates_to_repo(monkeypatch: pytesresult = await google_oauth_service.load_pending_consent_context(organization_id="org_1",- nonce="nonce-xyz",+ state="state-xyz",+ initiator_id="user_1",)assert result is expected- fake_repo.load_pending_by_nonce.assert_awaited_once_with(organization_id="org_1", nonce="nonce-xyz")+ fake_repo.load_pending_by_nonce.assert_awaited_once_with(+ organization_id="org_1",+ nonce=oauth_consent.consent_nonce("state-xyz", "user_1"),+ )class _FakeOAuth2Session:@@ -3395,6 +3409,7 @@ async def test_google_oauth_callback_rejects_changed_client_before_exchange(await google_oauth_routes.google_oauth_callback(CreateGoogleOAuthCallbackRequest(code="code", state="nonce"),current_org=SimpleNamespace(organization_id="org_1"),+ current_user_id="user_1",)assert exc_info.value.status_code == 409@@ -3402,7 +3417,7 @@ async def test_google_oauth_callback_rejects_changed_client_before_exchange(exc_info.value.detail== "Google OAuth client configuration changed since consent started; restart the connection")- load_mock.assert_awaited_once_with(organization_id="org_1", nonce="nonce")+ load_mock.assert_awaited_once_with(organization_id="org_1", state="nonce", initiator_id="user_1")resolve_mock.assert_awaited_once_with("org_1")exchange_mock.assert_not_awaited()@@ -3472,6 +3487,7 @@ async def test_google_oauth_callback_allows_matching_or_legacy_client(response = await google_oauth_routes.google_oauth_callback(CreateGoogleOAuthCallbackRequest(code="code", state="nonce"),current_org=SimpleNamespace(organization_id="org_1"),+ current_user_id="user_1",)assert response.credential.id == "goac_1"@@ -3484,7 +3500,8 @@ async def test_google_oauth_callback_allows_matching_or_legacy_client()promote_mock.assert_awaited_once_with(organization_id="org_1",- nonce="nonce",+ state="nonce",+ initiator_id="user_1",refresh_token="refresh-token",scopes_granted=["https://www.googleapis.com/auth/spreadsheets"],)@@ -3567,6 +3584,7 @@ async def test_google_oauth_callback_email_capture_is_authoritative(response = await google_oauth_routes.google_oauth_callback(CreateGoogleOAuthCallbackRequest(code="code", state="nonce"),current_org=SimpleNamespace(organization_id="org_1"),+ current_user_id="user_1",)assert response.credential.email_address == "[email protected]"@@ -4094,3 +4112,165 @@ def test_google_oauth_credential_response_exposes_app_origin() -> None:resp_no_origin = GoogleOAuthCredentialResponse(credential=cred)assert resp_no_origin.app_origin is None+++class _ConsentRepoDouble:+ """In-memory stand-in for the consent-nonce lifecycle: insert, look up, consume once."""++ def __init__(self) -> None:+ self.rows: dict[str, dict[str, Any]] = {}++ async def insert_pending_credential(self, **kwargs: Any) -> SimpleNamespace:+ self.rows[kwargs["consent_nonce"]] = kwargs+ return SimpleNamespace(id=kwargs["credential_id"], organization_id=kwargs["organization_id"])++ async def load_pending_by_nonce(+ self,+ organization_id: str,+ nonce: str,+ now: datetime.datetime | None = None,+ ) -> Any:+ from skyvern.forge.sdk.db.repositories.google_oauth import PendingConsentContext++ row = self.rows.get(nonce)+ if row is None or row["organization_id"] != organization_id:+ return None+ return PendingConsentContext(+ credential_id=row["credential_id"],+ consent_redirect_uri=row["consent_redirect_uri"],+ consent_code_verifier=row["consent_code_verifier"],+ consent_app_origin=row.get("consent_app_origin"),+ client_id=row.get("client_id"),+ )++ async def promote_pending_to_active(+ self,+ organization_id: str,+ nonce: str,+ **kwargs: Any,+ ) -> GoogleOAuthCredentialBase:+ row = self.rows.pop(nonce, None)+ if row is None or row["organization_id"] != organization_id:+ raise google_oauth_service.InvalidConsentNonceError("Unknown or already consumed OAuth consent nonce")+ return GoogleOAuthCredentialBase(+ id=row["credential_id"],+ organization_id=organization_id,+ credential_name=row["credential_name"],+ provider="google",+ state=google_oauth_service.STATE_ACTIVE,+ scopes_requested=row["scopes_requested"],+ scopes_granted=list(kwargs["scopes_granted"]),+ created_at=datetime.datetime.utcnow(),+ modified_at=datetime.datetime.utcnow(),+ )+++def _install_consent_flow_doubles(monkeypatch: pytest.MonkeyPatch, repo: _ConsentRepoDouble) -> AsyncMock:+ monkeypatch.setattr(google_oauth_service.settings, "ENABLE_ENCRYPTION", True, raising=False)+ monkeypatch.setattr(google_oauth_service.settings, "GOOGLE_OAUTH_CLIENT_ID", "cid", raising=False)+ monkeypatch.setattr(google_oauth_service.settings, "GOOGLE_OAUTH_CLIENT_SECRET", "csecret", raising=False)+ monkeypatch.setattr(google_oauth_service.settings, "GOOGLE_OAUTH_REDIRECT_HOSTS", ["x"], raising=False)+ monkeypatch.setattr(+ google_oauth_service.SettingsManager,+ "get_settings",+ lambda: SimpleNamespace(ENABLE_ORGANIZATION_GOOGLE_OAUTH_CLIENT_CONFIG=False),+ )+ monkeypatch.setattr(+ google_oauth_service.app,+ "DATABASE",+ SimpleNamespace(google_oauth=repo, organizations=SimpleNamespace(get_valid_org_auth_token=AsyncMock())),+ raising=False,+ )+ monkeypatch.setattr(google_oauth_service, "encryptor", SimpleNamespace(encrypt=AsyncMock(return_value="ENC::rt")))+ monkeypatch.setattr(google_oauth_service.app, "CACHE", SimpleNamespace(set=AsyncMock()), raising=False)+ exchange_mock = AsyncMock(+ return_value={+ "access_token": "at",+ "refresh_token": "rt",+ "scope": "https://www.googleapis.com/auth/spreadsheets",+ }+ )+ monkeypatch.setattr(google_oauth_routes.google_oauth_service, "exchange_code_for_tokens", exchange_mock)+ return exchange_mock+++async def test_google_oauth_callback_rejects_state_redeemed_by_another_caller(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ """A consent challenge is redeemable only by the caller that started it."""+ repo = _ConsentRepoDouble()+ exchange_mock = _install_consent_flow_doubles(monkeypatch, repo)++ start = await google_oauth_service.start_authorization(+ organization_id="org_1",+ redirect_uri="https://x/cb",+ initiator_id="user_initiator",+ )++ with pytest.raises(HTTPException) as exc_info:+ await google_oauth_routes.google_oauth_callback(+ CreateGoogleOAuthCallbackRequest(code="code", state=start.state),+ current_org=SimpleNamespace(organization_id="org_1"),+ current_user_id="user_other",+ )++ assert exc_info.value.status_code == 400+ # Reject before spending the one-time authorization code.+ exchange_mock.assert_not_awaited()+ # The challenge stays redeemable by the caller that started it.+ assert len(repo.rows) == 1+++async def test_google_oauth_callback_consumes_state_and_rejects_replay(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ repo = _ConsentRepoDouble()+ _install_consent_flow_doubles(monkeypatch, repo)++ start = await google_oauth_service.start_authorization(+ organization_id="org_1",+ redirect_uri="https://x/cb",+ initiator_id="user_initiator",+ )++ response = await google_oauth_routes.google_oauth_callback(+ CreateGoogleOAuthCallbackRequest(code="code", state=start.state),+ current_org=SimpleNamespace(organization_id="org_1"),+ current_user_id="user_initiator",+ )+ assert response.credential.state == google_oauth_service.STATE_ACTIVE++ with pytest.raises(HTTPException) as exc_info:+ await google_oauth_routes.google_oauth_callback(+ CreateGoogleOAuthCallbackRequest(code="code", state=start.state),+ current_org=SimpleNamespace(organization_id="org_1"),+ current_user_id="user_initiator",+ )+ assert exc_info.value.status_code == 400++[email protected]("state", ["", "not-a-real-state"])+async def test_google_oauth_callback_rejects_unusable_state(+ monkeypatch: pytest.MonkeyPatch,+ state: str,+) -> None:+ repo = _ConsentRepoDouble()+ exchange_mock = _install_consent_flow_doubles(monkeypatch, repo)+ await google_oauth_service.start_authorization(+ organization_id="org_1",+ redirect_uri="https://x/cb",+ initiator_id="user_initiator",+ )++ with pytest.raises(HTTPException) as exc_info:+ await google_oauth_routes.google_oauth_callback(+ CreateGoogleOAuthCallbackRequest(code="code", state=state),+ current_org=SimpleNamespace(organization_id="org_1"),+ current_user_id="user_initiator",+ )++ assert exc_info.value.status_code == 400+ exchange_mock.assert_not_awaited()diff --git a/tests/unit/test_actions.py b/tests/unit/test_actions.pyindex 739dd494d..1d4525668 100644--- a/tests/unit/test_actions.py+++ b/tests/unit/test_actions.py@@ -1,9 +1,11 @@+from datetime import datetimefrom unittest.mock import MagicMockimport pytest-from pydantic import ValidationError+from pydantic import TypeAdapter, ValidationErrorfrom skyvern.config import settings+from skyvern.forge.sdk.db.models import ActionModelfrom skyvern.forge.sdk.db.repositories.workflow_parameters import WorkflowParametersRepositoryfrom skyvern.forge.sdk.db.utils import hydrate_actionfrom skyvern.forge.sdk.schemas import sdk_actions@@ -21,6 +23,7 @@ from skyvern.utils.action_redaction import (from skyvern.webeye.actions.action_types import ActionTypefrom skyvern.webeye.actions.actions import (Action,+ ActionStatus,ClickAction,ClosePageAction,ExtractAction,@@ -283,6 +286,8 @@ def test_action_log_payload_keeps_non_otp_input_debuggable() -> None:@pytest.mark.asyncioasync def test_create_action_redacts_response_but_preserves_action_json_for_hydration() -> None:secret_value = "OTP_SECRET_VALUE_SHOULD_NOT_APPEAR"+ started_at = datetime(2026, 7, 30, 12, 0, 0)+ finished_at = datetime(2026, 7, 30, 12, 0, 1)captured_models = []class FakeSession:@@ -315,6 +320,8 @@ async def test_create_action_redacts_response_but_preserves_action_json_for_hydrintention="Enter verification code",response=secret_value,totp_code_required=True,+ started_at=started_at,+ finished_at=finished_at,)await repo.create_action(action)@@ -323,11 +330,85 @@ async def test_create_action_redacts_response_but_preserves_action_json_for_hydrassert persisted_model.response == REDACTED_OTP_VALUEassert persisted_model.action_json["text"] == secret_valueassert persisted_model.action_json["response"] == secret_value+ assert persisted_model.started_at == started_at+ assert persisted_model.finished_at == finished_athydrated_action = hydrate_action(persisted_model)assert isinstance(hydrated_action, InputTextAction)assert hydrated_action.text == secret_valueassert hydrated_action.response == secret_value+ assert hydrated_action.model_dump(mode="json")["started_at"] == "2026-07-30T12:00:00"+ assert hydrated_action.model_dump(mode="json")["finished_at"] == "2026-07-30T12:00:01"+++def test_hydration_prefers_model_timestamps_over_action_json_snapshot() -> None:+ """action_json carries a serialized snapshot whose timestamps can lag the model columns+ (e.g. after the batch upsert refreshed them); the model columns must win."""+ model = ActionModel(+ action_id="a_ts_fence",+ action_type=ActionType.CLICK,+ status=ActionStatus.completed,+ organization_id="o_1",+ task_id="tsk_1",+ step_id="stp_1",+ step_order=0,+ action_order=0,+ started_at=datetime(2026, 7, 30, 12, 0, 0),+ finished_at=datetime(2026, 7, 30, 12, 0, 5),+ created_at=datetime(2026, 7, 30, 11, 59, 0),+ modified_at=datetime(2026, 7, 30, 12, 0, 5),+ action_json={+ "action_type": "click",+ "started_at": "2026-07-30T00:00:00",+ "finished_at": "2026-07-30T00:00:01",+ "created_at": "2026-07-29T00:00:00",+ "modified_at": "2026-07-30T00:00:01",+ },+ )++ hydrated = hydrate_action(model)++ assert hydrated.started_at == datetime(2026, 7, 30, 12, 0, 0)+ assert hydrated.finished_at == datetime(2026, 7, 30, 12, 0, 5)+ assert hydrated.created_at == datetime(2026, 7, 30, 11, 59, 0)+++def test_malformed_action_fallback_keeps_execution_timestamps() -> None:+ """A row whose action_json fails base-Action validation hydrates through the minimal+ fallback; the execution timestamps must survive that path too."""+ model = ActionModel(+ action_id="a_fallback",+ action_type=ActionType.CLICK,+ status=ActionStatus.completed,+ organization_id="o_1",+ task_id="tsk_1",+ step_id="stp_1",+ step_order=0,+ action_order=0,+ started_at=datetime(2026, 7, 30, 12, 0, 0),+ finished_at=datetime(2026, 7, 30, 12, 0, 5),+ created_at=datetime(2026, 7, 30, 11, 59, 0),+ modified_at=datetime(2026, 7, 30, 12, 0, 5),+ action_json={"action_type": "click", "confidence_float": "not-a-float"},+ )++ hydrated = hydrate_action(model)++ assert hydrated.started_at == datetime(2026, 7, 30, 12, 0, 0)+ assert hydrated.finished_at == datetime(2026, 7, 30, 12, 0, 5)+++def test_action_api_response_serializes_execution_timestamps() -> None:+ action = Action(+ action_type=ActionType.CLICK,+ started_at=datetime(2026, 7, 30, 12, 0, 0),+ finished_at=datetime(2026, 7, 30, 12, 0, 1),+ )++ payload = TypeAdapter(list[Action]).dump_python([action], mode="json")++ assert payload[0]["started_at"] == "2026-07-30T12:00:00"+ assert payload[0]["finished_at"] == "2026-07-30T12:00:01"def test_web_action_parse__no_element_id() -> None:diff --git a/tests/unit/test_agent_step_characterization.py b/tests/unit/test_agent_step_characterization.pyindex 252e0bc80..2ad173358 100644--- a/tests/unit/test_agent_step_characterization.py+++ b/tests/unit/test_agent_step_characterization.py@@ -1,5 +1,6 @@from __future__ import annotations+import asyncioimport base64from dataclasses import dataclass, fieldfrom datetime import UTC, datetime@@ -359,6 +360,29 @@ async def test_refresh_working_page_signal_reloads_and_skips_batch(monkeypatch:assert rig.context.refresh_working_page is False+async def test_reload_action_window_encloses_the_reload(monkeypatch: pytest.MonkeyPatch) -> None:+ """started_at is captured BEFORE the reload, so the recorded window encloses it instead of+ collapsing to a zero-duration stamp taken after the reload already finished."""+ rig = make_agent_step_rig(monkeypatch)+ rig.context.refresh_working_page = True+ during_reload: list[datetime] = []++ async def observed_reload() -> None:+ await asyncio.sleep(0.01)+ during_reload.append(datetime.now(UTC).replace(tzinfo=None))++ rig.browser_state.reload_page = AsyncMock(side_effect=observed_reload)++ _step, output = await rig.run()++ assert during_reload, "reload side effect never ran; the test is not exercising the reload path"+ assert output.actions_and_results is not None+ reload_action = output.actions_and_results[0][0]+ assert reload_action.started_at is not None and reload_action.finished_at is not None+ assert reload_action.started_at <= during_reload[0] <= reload_action.finished_at++@pytest.mark.asyncioasync def test_unexpected_exception_returns_failed_step_instead_of_raising(monkeypatch: pytest.MonkeyPatch) -> None:handler = AsyncMock(side_effect=RuntimeError("browser exploded"))diff --git a/tests/unit/test_api_handler_factory.py b/tests/unit/test_api_handler_factory.pyindex b07817cc0..25efe44b0 100644--- a/tests/unit/test_api_handler_factory.py+++ b/tests/unit/test_api_handler_factory.py@@ -738,6 +738,69 @@ class TestGemini3ReasoningEffortExperiment:assert params["thinking_level"] == "minimal"+class TestThinkingBudgetOptimization:+ @pytest.mark.parametrize("reasoning_effort", ["medium", "high"])+ def test_xai_reasoning_model_preserves_configured_reasoning_effort(+ self, reasoning_effort: str, monkeypatch: pytest.MonkeyPatch+ ) -> None:+ monkeypatch.setattr(api_handler_factory.litellm, "supports_reasoning", lambda model: True)++ llm_config = LLMConfig(+ model_name="xai/grok-4.5",+ required_env_vars=[],+ supports_vision=True,+ add_assistant_prefix=False,+ reasoning_effort=reasoning_effort,+ )+ params = LLMAPIHandlerFactory.get_api_parameters(llm_config)++ LLMAPIHandlerFactory._apply_thinking_budget_optimization(+ params, new_budget=1024, llm_config=llm_config, prompt_name="extract-actions"+ )++ assert params["reasoning_effort"] == reasoning_effort++ @pytest.mark.parametrize("reasoning_effort", ["medium", "high"])+ def test_non_xai_reasoning_model_clamps_configured_reasoning_effort(+ self, reasoning_effort: str, monkeypatch: pytest.MonkeyPatch+ ) -> None:+ monkeypatch.setattr(api_handler_factory.litellm, "supports_reasoning", lambda model: True)++ llm_config = LLMConfig(+ model_name="gpt-5",+ required_env_vars=[],+ supports_vision=True,+ add_assistant_prefix=False,+ reasoning_effort=reasoning_effort,+ )+ params = LLMAPIHandlerFactory.get_api_parameters(llm_config)++ LLMAPIHandlerFactory._apply_thinking_budget_optimization(+ params, new_budget=1024, llm_config=llm_config, prompt_name="extract-actions"+ )++ assert params["reasoning_effort"] == "low"++ def test_other_reasoning_model_defaults_to_low_without_configured_reasoning_effort(+ self, monkeypatch: pytest.MonkeyPatch+ ) -> None:+ monkeypatch.setattr(api_handler_factory.litellm, "supports_reasoning", lambda model: True)++ llm_config = LLMConfig(+ model_name="deepseek/deepseek-reasoner",+ required_env_vars=[],+ supports_vision=True,+ add_assistant_prefix=False,+ )+ params = LLMAPIHandlerFactory.get_api_parameters(llm_config)++ LLMAPIHandlerFactory._apply_thinking_budget_optimization(+ params, new_budget=1024, llm_config=llm_config, prompt_name="extract-actions"+ )++ assert params["reasoning_effort"] == "low"++# SKY-10200 — runtime tests for the router timeout-precedence fix and per-hop# fallback chain expansion. These complement the config-shape tests in# tests/cloud/test_llm_router_fallback.py by pinning the api_handler_factorydiff --git a/tests/unit/test_browser_header_sanitization.py b/tests/unit/test_browser_header_sanitization.pyindex f9cbead78..7c880d620 100644--- a/tests/unit/test_browser_header_sanitization.py+++ b/tests/unit/test_browser_header_sanitization.py@@ -6,7 +6,125 @@ context creation outright (SKY-8929). sanitize_browser_headers drops the bad namlaunch survives with the valid headers intact."""-from skyvern.webeye.browser_factory import sanitize_browser_headers+from collections.abc import Awaitable, Callable+from typing import Any+from unittest.mock import AsyncMock++import pytest+import structlog++import skyvern.webeye.browser_factory as browser_factory+from skyvern.webeye.browser_artifacts import BrowserArtifacts+from skyvern.webeye.browser_factory import BrowserContextFactory, sanitize_browser_headers+++class _FakeRequest:+ def __init__(self, url: str, headers: dict[str, str]) -> None:+ self.url = url+ self._headers = headers++ async def all_headers(self) -> dict[str, str]:+ return dict(self._headers)+++class _FakeRoute:+ def __init__(self) -> None:+ self.headers: dict[str, str] | None = None++ async def fallback(self, *, headers: dict[str, str] | None = None) -> None:+ self.headers = headers+++class _FakeBrowserContext:+ def __init__(self, context_headers: dict[str, str] | None = None) -> None:+ self.context_headers = dict(context_headers or {})+ self._handler: Callable[[_FakeRoute, _FakeRequest], Awaitable[None]] | None = None+ self.route_calls = 0++ async def route(+ self,+ pattern: str,+ handler: Callable[[_FakeRoute, _FakeRequest], Awaitable[None]],+ ) -> None:+ assert pattern == "**/*"+ self.route_calls += 1+ self._handler = handler++ async def set_extra_http_headers(self, headers: dict[str, str]) -> None:+ self.context_headers = dict(headers)++ async def dispatch(self, url: str, headers: dict[str, str] | None = None) -> dict[str, str]:+ request_headers = {**self.context_headers, **(headers or {})}+ if self._handler is None:+ return request_headers++ route = _FakeRoute()+ await self._handler(route, _FakeRequest(url, request_headers))+ return route.headers if route.headers is not None else request_headers+++class _FakeAgentFunction:+ def __init__(self, *, route_handlers_allowed: bool) -> None:+ self.route_handlers_allowed = route_handlers_allowed+ self.route_permission_checks = 0+ self.extension_setup_calls = 0++ def strip_proxy_session_extra_http_headers(+ self,+ headers: dict[str, str] | None,+ ) -> dict[str, str] | None:+ return {name: value for name, value in (headers or {}).items() if name != "X-Automation"}++ async def browser_context_route_handlers_allowed(self, **kwargs: Any) -> bool:+ self.route_permission_checks += 1+ return self.route_handlers_allowed++ async def should_apply_banked_cookies(self, organization_id: str | None) -> bool:+ return False++ async def setup_browser_context_extensions(self, **kwargs: Any) -> None:+ self.extension_setup_calls += 1+++async def _factory_context(+ monkeypatch: pytest.MonkeyPatch,+ *,+ route_handlers_allowed: bool = True,+ target_url: str | None = "https://target.test/start",+) -> tuple[_FakeBrowserContext, dict[str, Any], _FakeAgentFunction]:+ captured_creator_kwargs: dict[str, Any] = {}+ contexts: list[_FakeBrowserContext] = []++ async def creator(playwright: Any, **kwargs: Any) -> tuple[_FakeBrowserContext, BrowserArtifacts, None]:+ captured_creator_kwargs.update(kwargs)+ context = _FakeBrowserContext(kwargs.get("extra_http_headers"))+ contexts.append(context)+ return context, BrowserArtifacts(), None++ agent_function = _FakeAgentFunction(route_handlers_allowed=route_handlers_allowed)++ class FakeApp:+ AGENT_FUNCTION = agent_function++ monkeypatch.setattr(browser_factory, "app", FakeApp())+ monkeypatch.setattr(browser_factory, "restore_session_cookies", AsyncMock())+ monkeypatch.setattr(browser_factory, "set_browser_console_log", lambda **kwargs: None)+ monkeypatch.setattr(browser_factory, "set_popup_video_listener", lambda **kwargs: None)+ monkeypatch.setattr(browser_factory, "set_download_file_listener", lambda **kwargs: None)+ monkeypatch.setattr(browser_factory, "set_dialog_handler", lambda **kwargs: None)+ BrowserContextFactory.register_type("test-header-scoping", creator)+ monkeypatch.setattr(browser_factory.settings, "BROWSER_TYPE", "test-header-scoping")++ await BrowserContextFactory.create_browser_context(+ playwright=object(), # type: ignore[arg-type]+ url=target_url,+ extra_http_headers={+ "X-Test-Credential": "fake-token",+ "X-Automation": "automation-value",+ },+ )++ return contexts[0], captured_creator_kwargs, agent_functionclass TestSanitizeBrowserHeaders:@@ -51,3 +169,94 @@ class TestSanitizeBrowserHeaders:def test_drops_value_with_newline_or_null(self) -> None:result = sanitize_browser_headers({"X-NL": "a\nb", "X-Null": "a\x00b", "X-Ok": "keep"})assert result == {"X-Ok": "keep"}+++async def test_intended_origin_carries_caller_header(monkeypatch: pytest.MonkeyPatch) -> None:+ context, creator_kwargs, agent_function = await _factory_context(monkeypatch)++ headers = await context.dispatch("https://target.test/api")++ assert headers["X-Test-Credential"] == "fake-token"+ assert creator_kwargs["extra_http_headers"] == {"X-Automation": "automation-value"}+ assert agent_function.route_permission_checks == 1+++async def test_cross_origin_subresource_omits_caller_header(monkeypatch: pytest.MonkeyPatch) -> None:+ context, creator_kwargs, _ = await _factory_context(monkeypatch)++ headers = await context.dispatch("https://assets.test/script.js")++ assert "X-Test-Credential" not in creator_kwargs["extra_http_headers"]+ assert "X-Test-Credential" not in headers+++async def test_cross_origin_redirect_omits_caller_header(monkeypatch: pytest.MonkeyPatch) -> None:+ context, _, _ = await _factory_context(monkeypatch)+ initial_headers = await context.dispatch("https://target.test/redirect")++ redirected_headers = await context.dispatch("https://redirect.test/final", headers=initial_headers)++ assert "X-Test-Credential" not in redirected_headers+++async def test_different_port_is_a_different_origin(monkeypatch: pytest.MonkeyPatch) -> None:+ context, _, _ = await _factory_context(monkeypatch)++ headers = await context.dispatch("https://target.test:8443/api")++ assert "X-Test-Credential" not in headers+++async def test_lookalike_hostname_is_a_different_origin(monkeypatch: pytest.MonkeyPatch) -> None:+ context, _, _ = await _factory_context(monkeypatch)++ headers = await context.dispatch("https://target.test.attacker.test/api")++ assert "X-Test-Credential" not in headers+++async def test_automation_headers_are_unaffected(monkeypatch: pytest.MonkeyPatch) -> None:+ context, creator_kwargs, _ = await _factory_context(monkeypatch)++ headers = await context.dispatch("https://assets.test/script.js")++ assert headers["X-Automation"] == "automation-value"+ assert creator_kwargs["extra_http_headers"] == {"X-Automation": "automation-value"}+++async def test_missing_target_origin_omits_caller_header(monkeypatch: pytest.MonkeyPatch) -> None:+ context, creator_kwargs, _ = await _factory_context(monkeypatch, target_url=None)++ headers = await context.dispatch("https://target.test/api")++ assert "X-Test-Credential" not in headers+ assert creator_kwargs["extra_http_headers"] == {"X-Automation": "automation-value"}+++async def test_routes_not_permitted_omits_caller_headers(monkeypatch: pytest.MonkeyPatch) -> None:+ with structlog.testing.capture_logs() as logs:+ context, creator_kwargs, agent_function = await _factory_context(+ monkeypatch,+ route_handlers_allowed=False,+ )++ headers = await context.dispatch("https://target.test/api")++ assert creator_kwargs["extra_http_headers"] == {"X-Automation": "automation-value"}+ assert "X-Test-Credential" not in headers+ assert headers["X-Automation"] == "automation-value"+ assert context.route_calls == 0+ assert agent_function.route_permission_checks == 1+ assert agent_function.extension_setup_calls == 1+ assert {+ "event": "Omitting caller HTTP headers because browser context route handlers are not permitted",+ "log_level": "warning",+ } in logsdiff --git a/tests/unit/test_config_registry.py b/tests/unit/test_config_registry.pynew file mode 100644index 000000000..91d7f693f--- /dev/null+++ b/tests/unit/test_config_registry.py@@ -0,0 +1,29 @@+from typing import Any++import pytest++from skyvern.forge.sdk.api.llm import config_registry+from skyvern.forge.sdk.api.llm.api_handler_factory import LLMAPIHandlerFactory+++def test_xai_grok_4_5_cost_override_uses_separate_output_cap(monkeypatch: pytest.MonkeyPatch) -> None:+ registered_models: dict[str, dict[str, Any]] = {}+ monkeypatch.setattr(config_registry.litellm, "register_model", registered_models.update)++ config_registry._register_model_cost_overrides()++ model_info = registered_models[config_registry.XAI_GROK_4_5_MODEL]+ assert model_info["max_input_tokens"] == config_registry.XAI_GROK_4_5_CONTEXT_WINDOW+ assert model_info["max_output_tokens"] == config_registry.XAI_GROK_4_5_MAX_OUTPUT_TOKENS+ assert model_info["max_tokens"] == config_registry.XAI_GROK_4_5_MAX_OUTPUT_TOKENS+++def test_xai_grok_4_5_config_uses_reasoning_completion_cap(monkeypatch: pytest.MonkeyPatch) -> None:+ monkeypatch.setattr(config_registry.settings, "XAI_REASONING_EFFORT", "high")++ llm_config = config_registry._build_xai_grok_4_5_config()+ parameters = LLMAPIHandlerFactory.get_api_parameters(llm_config)++ assert llm_config.reasoning_effort == "high"+ assert parameters["max_completion_tokens"] == config_registry.XAI_GROK_4_5_MAX_OUTPUT_TOKENS+ assert "max_tokens" not in parametersdiff --git a/tests/unit/test_copilot_code_block_persist_seam.py b/tests/unit/test_copilot_code_block_persist_seam.pyindex c80fed235..fd76a5148 100644--- a/tests/unit/test_copilot_code_block_persist_seam.py+++ b/tests/unit/test_copilot_code_block_persist_seam.py@@ -8609,7 +8609,10 @@ class TestWholeTrajectoryImposition:assert len(code_blocks) > 1block = _code_blocks(parsed)[label]browser_code = "\n".join(str(stage.get("code") or "") for stage in code_blocks[:-1])- assert all(stage.get("parameter_keys") == ["postal_code"] for stage in code_blocks[:-1])+ for stage in code_blocks[:-1]:+ expected_keys = ["postal_code"] if "postal_code" in str(stage.get("code") or "") else None+ assert stage.get("parameter_keys") == expected_keys+ assert any(stage.get("parameter_keys") == ["postal_code"] for stage in code_blocks[:-1])assert "postal_code" in browser_codeassert "zip_code" not in browser_codecode = str(block["code"])@@ -13786,3 +13789,268 @@ class TestScoutedSpineRepeatedOmissionSeam:naming = workflow_update_module._pre_persist_scouted_spine_result(draft, ctx)assert naming is not Noneassert "#search-submit" in naming.violations[0]+++def _no_goal_value_metadata(label: str, declared_goal: str) -> dict:+ metadata = _terminal_metadata(label, declared_goal)+ for outcome in metadata["claimed_outcomes"]:+ outcome["goal_value_paths"] = []+ for expectation in metadata["terminal_verifier_expectations"]:+ expectation["goal_value_paths"] = []+ return metadata+++class TestScoutCredentialSegments:+ _LOGIN_URL = "https://example.com/login"++ def _credential_trajectory(self) -> list[dict[str, Any]]:+ return [+ {+ "tool_name": "fill_credential_field",+ "selector": "#user",+ "source_url": self._LOGIN_URL,+ "credential_id": "cred_1",+ "credential_field": "username",+ },+ {+ "tool_name": "fill_credential_field",+ "selector": "#pass",+ "source_url": self._LOGIN_URL,+ "credential_id": "cred_1",+ "credential_field": "password",+ },+ {+ "tool_name": "click",+ "selector": "#sign-in",+ "role": "button",+ "accessible_name": "Sign in",+ "source_url": self._LOGIN_URL,+ },+ {+ "tool_name": "click",+ "selector": "#reports-nav",+ "role": "link",+ "accessible_name": "Reports",+ "source_url": "https://example.com/dashboard",+ },+ {+ "tool_name": "read_value",+ "read_expression": "document.querySelector('#total').textContent",+ "read_output_path": "output.total",+ "source_url": "https://example.com/dashboard/reports",+ },+ ]++ def test_segments_are_valid_self_contained_python(self) -> None:+ synthesized = workflow_update_module.synthesize_code_block(self._credential_trajectory(), strict_selectors=True)+ assert synthesized is not None+ assert len(synthesized.segments) == 3++ for segment in synthesized.segments:+ ast.parse(textwrap.dedent(segment.code).strip())++ def test_credential_reaches_only_the_login_segment(self) -> None:+ synthesized = workflow_update_module.synthesize_code_block(self._credential_trajectory(), strict_selectors=True)+ assert synthesized is not None++ keys_per_segment = [[str(param.get("key")) for param in segment.parameters] for segment in synthesized.segments]++ assert any(keys for keys in keys_per_segment[:1])+ assert all(not keys for keys in keys_per_segment[1:])+ assert ".password" not in "".join(segment.code for segment in synthesized.segments[1:])++ def test_each_scouted_action_appears_in_exactly_one_segment(self) -> None:+ synthesized = workflow_update_module.synthesize_code_block(self._credential_trajectory(), strict_selectors=True)+ assert synthesized is not None++ for selector in ("#pass", "#sign-in", "#reports-nav"):+ hits = sum(1 for segment in synthesized.segments if f'.locator("{selector}").' in segment.code)+ assert hits == 1, f"{selector} appeared in {hits} segments"++ def test_value_read_lands_in_the_last_segment(self) -> None:+ synthesized = workflow_update_module.synthesize_code_block(self._credential_trajectory(), strict_selectors=True)+ assert synthesized is not None++ assert "page.evaluate" in synthesized.segments[-1].code+ assert not any("page.evaluate" in segment.code for segment in synthesized.segments[:-1])++ def test_trajectory_without_credential_fill_is_not_segmented(self) -> None:+ trajectory = [+ {"tool_name": "click", "selector": "#a", "source_url": self._LOGIN_URL},+ {"tool_name": "click", "selector": "#b", "source_url": self._LOGIN_URL},+ ]++ synthesized = workflow_update_module.synthesize_code_block(trajectory, strict_selectors=True)++ assert synthesized is not None+ assert synthesized.segments == []++ def test_no_identifiable_login_submit_is_not_segmented(self) -> None:+ trajectory = [+ {+ "tool_name": "fill_credential_field",+ "selector": "#user",+ "source_url": self._LOGIN_URL,+ "credential_id": "cred_1",+ "credential_field": "username",+ },+ {+ "tool_name": "read_value",+ "read_expression": "document.querySelector('#total').textContent",+ "read_output_path": "output.total",+ "source_url": "https://other.example.com/dashboard",+ },+ ]++ synthesized = workflow_update_module.synthesize_code_block(trajectory, strict_selectors=True)++ assert synthesized is not None+ assert synthesized.segments == []++ def test_login_only_trajectory_is_not_segmented(self) -> None:+ synthesized = workflow_update_module.synthesize_code_block(+ self._credential_trajectory()[:3], strict_selectors=True+ )++ assert synthesized is not None+ assert synthesized.segments == []++ def test_superseded_reads_do_not_shift_the_boundary(self) -> None:+ trajectory: list[dict[str, Any]] = [+ {+ "tool_name": "read_value",+ "read_expression": "early",+ "read_output_path": "output.total",+ "source_url": self._LOGIN_URL,+ },+ *self._credential_trajectory(),+ ]++ synthesized = workflow_update_module.synthesize_code_block(trajectory, strict_selectors=True)++ assert synthesized is not None+ assert len(synthesized.segments) == 3+ assert "credential" in "".join(str(p.get("key")) for p in synthesized.segments[0].parameters)+ assert "page.evaluate" in synthesized.segments[-1].code++ def test_resolver_prefers_segments_over_the_per_interaction_derivation(self) -> None:+ synthesized = workflow_update_module.synthesize_code_block(self._credential_trajectory(), strict_selectors=True)+ assert synthesized is not None++ resolved = workflow_update_module._resolve_durable_stages(synthesized, source_code=synthesized.code)++ assert resolved.segmented is True+ assert len(resolved.codes) == 3+ for code in resolved.codes:+ ast.parse(code)++ def test_split_places_segments_and_scopes_keys(self) -> None:+ code_block: dict[str, Any] = {"block_type": "code", "label": "get_total", "code": "placeholder"}+ parsed: dict[str, Any] = {"workflow_definition": {"blocks": [code_block]}}+ stage_codes = [+ 'await page.locator("#user").fill(str(cred.username))',+ 'await page.locator("#reports-nav").click()',+ ]++ with capture_logs() as logs:+ violations = workflow_update_module._split_selected_output_owner_into_browser_stages(+ parsed=parsed,+ code_block=code_block,+ stage_codes=stage_codes,+ extraction_code='value = await page.locator("#t").inner_text()\nreturn {"output": {"total": value}}',+ parameter_keys=["cred"],+ segmented=True,+ )++ assert violations == []+ blocks = parsed["workflow_definition"]["blocks"]+ assert [block.get("label") for block in blocks] == [+ "get_total_browser_stage_1",+ "get_total_browser_stage_2",+ "get_total",+ ]+ assert blocks[0].get("parameter_keys") == ["cred"]+ assert "parameter_keys" not in blocks[1]+ emitted = [entry for entry in logs if entry.get("event") == "copilot_output_owner_split_into_browser_stages"]+ assert len(emitted) == 1+ assert emitted[0]["credential_grouped"] is True++ def test_split_declines_when_another_block_routes_to_the_output_owner(self) -> None:+ code_block: dict[str, Any] = {"block_type": "code", "label": "get_total", "code": "placeholder"}+ upstream = {"block_type": "code", "label": "prep", "code": "pass", "next_block_label": "get_total"}+ parsed: dict[str, Any] = {"workflow_definition": {"blocks": [upstream, code_block]}}++ violations = workflow_update_module._split_selected_output_owner_into_browser_stages(+ parsed=parsed,+ code_block=code_block,+ stage_codes=["await page.locator('#a').click()", "await page.locator('#b').click()"],+ extraction_code='return {"output": {"total": 1}}',+ parameter_keys=[],+ segmented=True,+ )++ assert violations+ assert [block.get("label") for block in parsed["workflow_definition"]["blocks"]] == ["prep", "get_total"]++ def test_synthesized_step_action_types_use_the_shared_action_vocabulary(self) -> None:+ from skyvern.forge.sdk.workflow.models.block import CodeBlockStep++ synthesized = workflow_update_module.synthesize_code_block(self._credential_trajectory(), strict_selectors=True)+ assert synthesized is not None+ assert any(str(step.get("description", "")).startswith("Fill ") for step in synthesized.steps)++ for step in synthesized.steps:+ CodeBlockStep(**step)++ @pytest.mark.asyncio+ async def test_fused_credential_draft_persists_as_separated_blocks(self, monkeypatch: pytest.MonkeyPatch) -> None:+ _stub_successful_update(monkeypatch)++ async def _no_credential_validation_error(_value: object, _ctx: object) -> None:+ return None++ monkeypatch.setattr(+ workflow_update_module, "_credential_reference_validation_error", _no_credential_validation_error+ )+ ctx = _code_only_ctx()+ _enable_imposition(ctx)+ ctx.scout_trajectory = self._credential_trajectory()[:4]+ ctx.scouted_credential_field_inventory_by_credential_id = {"cred_1": frozenset({"username", "password"})}+ synthesized = workflow_update_module.synthesize_code_block(ctx.scout_trajectory, strict_selectors=True)+ assert synthesized is not None+ submitted_code = (+ synthesized.code.rstrip()+ + '\nvalue = await page.locator("#total").inner_text()\nreturn {"output": {"total": value}}\n'+ )+ submitted = yaml.safe_dump(+ {+ "title": "Dashboard total",+ "workflow_definition": {+ "parameters": [],+ "blocks": [{"block_type": "code", "label": "get_total", "code": submitted_code}],+ },+ },+ sort_keys=False,+ )+ metadata = [_no_goal_value_metadata("get_total", "read the dashboard total")]++ result = await _update_workflow({"workflow_yaml": submitted, "code_artifact_metadata": metadata}, ctx)++ assert result["ok"] is True+ parsed = parse_workflow_yaml(ctx.workflow_yaml)+ assert isinstance(parsed, dict)+ code_blocks = [block for block in workflow_blocks(parsed) if block.get("block_type") == "code"]+ assert [str(block.get("label") or "") for block in code_blocks][-1] == "get_total"+ assert len(code_blocks) >= 3+ stage_codes = [str(block.get("code") or "") for block in code_blocks[:-1]]+ owner_code = str(code_blocks[-1].get("code") or "")+ login_positions = [index for index, code in enumerate(stage_codes) if ".password" in code]+ nav_positions = [+ index for index, code in enumerate(stage_codes) if 'page.locator("#reports-nav").click()' in code+ ]+ assert login_positions and nav_positions+ assert max(login_positions) < min(nav_positions)+ assert ".password" not in owner_code+ assert "inner_text" in owner_code+ for code in (*stage_codes, owner_code):+ ast.parse(textwrap.dedent(code).strip())diff --git a/tests/unit/test_credential_vault_type_override.py b/tests/unit/test_credential_vault_type_override.pyindex 7bac4c57d..09802402c 100644--- a/tests/unit/test_credential_vault_type_override.py+++ b/tests/unit/test_credential_vault_type_override.py@@ -27,6 +27,9 @@ from skyvern.forge.sdk.services.credential.credential_vault_service import Credeclass TestLocalCredentialVaultSettings:"""Verify the local filesystem vault is enabled only in local envs by default."""+ def test_oss_credential_vault_type_defaults_to_skyvern(self) -> None:+ assert Settings.model_fields["CREDENTIAL_VAULT_TYPE"].default == CredentialVaultType.SKYVERN+def test_local_credential_vault_defaults_enabled_for_local_env(self) -> None:settings = Settings(_env_file=None, ENV="local", ENABLE_LOCAL_CREDENTIAL_VAULT=None)assert settings.is_local_credential_vault_enabled()@@ -166,11 +169,11 @@ class TestGetCredentialVaultServiceRouting:@pytest.mark.asyncioasync def test_no_override_uses_global_bitwarden(self) -> None:mock_bw = MagicMock(spec=CredentialVaultService)+ mock_settings = MagicMock(CREDENTIAL_VAULT_TYPE=CredentialVaultType.BITWARDEN)with (- patch("skyvern.forge.sdk.routes.credentials.settings") as mock_settings,patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,+ patch("skyvern.forge.sdk.routes.credentials.SettingsManager.get_settings", return_value=mock_settings),):- mock_settings.CREDENTIAL_VAULT_TYPE = CredentialVaultType.BITWARDENmock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bwresult = await _get_credential_vault_service()assert result is mock_bw@@ -178,24 +181,24 @@ class TestGetCredentialVaultServiceRouting:@pytest.mark.asyncioasync def test_no_override_uses_global_skyvern(self) -> None:mock_skyvern = MagicMock(spec=CredentialVaultService)+ mock_settings = MagicMock(CREDENTIAL_VAULT_TYPE=CredentialVaultType.SKYVERN)+ mock_settings.is_local_credential_vault_enabled.return_value = Truewith (- patch("skyvern.forge.sdk.routes.credentials.settings") as mock_settings,patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,+ patch("skyvern.forge.sdk.routes.credentials.SettingsManager.get_settings", return_value=mock_settings),):- mock_settings.CREDENTIAL_VAULT_TYPE = CredentialVaultType.SKYVERN- mock_settings.is_local_credential_vault_enabled.return_value = Truemock_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = mock_skyvernresult = await _get_credential_vault_service()assert result is mock_skyvern@pytest.mark.asyncioasync def test_no_override_skyvern_raises_when_local_vault_disabled(self) -> None:+ mock_settings = MagicMock(CREDENTIAL_VAULT_TYPE=CredentialVaultType.SKYVERN)+ mock_settings.is_local_credential_vault_enabled.return_value = Falsewith (- patch("skyvern.forge.sdk.routes.credentials.settings") as mock_settings,patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,+ patch("skyvern.forge.sdk.routes.credentials.SettingsManager.get_settings", return_value=mock_settings),):- mock_settings.CREDENTIAL_VAULT_TYPE = CredentialVaultType.SKYVERN- mock_settings.is_local_credential_vault_enabled.return_value = Falsemock_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = MagicMock(spec=CredentialVaultService)with pytest.raises(HTTPException) as exc_info:await _get_credential_vault_service()@@ -206,12 +209,12 @@ class TestGetCredentialVaultServiceRouting:async def test_override_skyvern_ignores_global(self) -> None:mock_bw = MagicMock(spec=CredentialVaultService)mock_skyvern = MagicMock(spec=CredentialVaultService)+ mock_settings = MagicMock(CREDENTIAL_VAULT_TYPE=CredentialVaultType.BITWARDEN)+ mock_settings.is_local_credential_vault_enabled.return_value = Truewith (- patch("skyvern.forge.sdk.routes.credentials.settings") as mock_settings,patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,+ patch("skyvern.forge.sdk.routes.credentials.SettingsManager.get_settings", return_value=mock_settings),):- mock_settings.CREDENTIAL_VAULT_TYPE = CredentialVaultType.BITWARDEN- mock_settings.is_local_credential_vault_enabled.return_value = Truemock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bwmock_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = mock_skyvernresult = await _get_credential_vault_service(@@ -223,12 +226,12 @@ class TestGetCredentialVaultServiceRouting:async def test_override_skyvern_raises_when_local_vault_disabled(self) -> None:mock_bw = MagicMock(spec=CredentialVaultService)mock_skyvern = MagicMock(spec=CredentialVaultService)+ mock_settings = MagicMock(CREDENTIAL_VAULT_TYPE=CredentialVaultType.BITWARDEN)+ mock_settings.is_local_credential_vault_enabled.return_value = Falsewith (- patch("skyvern.forge.sdk.routes.credentials.settings") as mock_settings,patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,+ patch("skyvern.forge.sdk.routes.credentials.SettingsManager.get_settings", return_value=mock_settings),):- mock_settings.CREDENTIAL_VAULT_TYPE = CredentialVaultType.BITWARDEN- mock_settings.is_local_credential_vault_enabled.return_value = Falsemock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bwmock_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = mock_skyvernwith pytest.raises(HTTPException) as exc_info:@@ -242,11 +245,7 @@ class TestGetCredentialVaultServiceRouting:async def test_override_custom_ignores_global(self) -> None:mock_bw = MagicMock(spec=CredentialVaultService)mock_custom = MagicMock(spec=CredentialVaultService)- with (- patch("skyvern.forge.sdk.routes.credentials.settings") as mock_settings,- patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,- ):- mock_settings.CREDENTIAL_VAULT_TYPE = CredentialVaultType.BITWARDEN+ with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bwmock_app.CUSTOM_CREDENTIAL_VAULT_SERVICE = mock_customresult = await _get_credential_vault_service(@@ -258,11 +257,7 @@ class TestGetCredentialVaultServiceRouting:async def test_override_azure_ignores_global(self) -> None:mock_bw = MagicMock(spec=CredentialVaultService)mock_azure = MagicMock(spec=CredentialVaultService)- with (- patch("skyvern.forge.sdk.routes.credentials.settings") as mock_settings,- patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,- ):- mock_settings.CREDENTIAL_VAULT_TYPE = CredentialVaultType.BITWARDEN+ with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bwmock_app.AZURE_CREDENTIAL_VAULT_SERVICE = mock_azureresult = await _get_credential_vault_service(@@ -274,11 +269,7 @@ class TestGetCredentialVaultServiceRouting:async def test_override_gcp_ignores_global(self) -> None:mock_bw = MagicMock(spec=CredentialVaultService)mock_gcp = MagicMock(spec=CredentialVaultService)- with (- patch("skyvern.forge.sdk.routes.credentials.settings") as mock_settings,- patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,- ):- mock_settings.CREDENTIAL_VAULT_TYPE = CredentialVaultType.BITWARDEN+ with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bwmock_app.GCP_CREDENTIAL_VAULT_SERVICE = mock_gcpresult = await _get_credential_vault_service(@@ -288,11 +279,7 @@ class TestGetCredentialVaultServiceRouting:@pytest.mark.asyncioasync def test_override_gcp_raises_when_not_configured(self) -> None:- with (- patch("skyvern.forge.sdk.routes.credentials.settings") as mock_settings,- patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,- ):- mock_settings.CREDENTIAL_VAULT_TYPE = CredentialVaultType.BITWARDEN+ with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:mock_app.GCP_CREDENTIAL_VAULT_SERVICE = Nonewith pytest.raises(HTTPException) as exc_info:await _get_credential_vault_service(@@ -303,11 +290,7 @@ class TestGetCredentialVaultServiceRouting:@pytest.mark.asyncioasync def test_override_custom_raises_when_not_configured(self) -> None:- with (- patch("skyvern.forge.sdk.routes.credentials.settings") as mock_settings,- patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,- ):- mock_settings.CREDENTIAL_VAULT_TYPE = CredentialVaultType.BITWARDEN+ with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:mock_app.CUSTOM_CREDENTIAL_VAULT_SERVICE = Nonewith pytest.raises(HTTPException) as exc_info:await _get_credential_vault_service(@@ -319,11 +302,11 @@ class TestGetCredentialVaultServiceRouting:@pytest.mark.asyncioasync def test_override_none_falls_back_to_global(self) -> None:mock_custom = MagicMock(spec=CredentialVaultService)+ mock_settings = MagicMock(CREDENTIAL_VAULT_TYPE=CredentialVaultType.CUSTOM)with (- patch("skyvern.forge.sdk.routes.credentials.settings") as mock_settings,patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,+ patch("skyvern.forge.sdk.routes.credentials.SettingsManager.get_settings", return_value=mock_settings),):- mock_settings.CREDENTIAL_VAULT_TYPE = CredentialVaultType.CUSTOMmock_app.CUSTOM_CREDENTIAL_VAULT_SERVICE = mock_customresult = await _get_credential_vault_service(vault_type_override=None)assert result is mock_custom@@ -344,12 +327,13 @@ class TestTemporaryTestLoginCredentialCleanup:mock_repository.get_credential = AsyncMock(return_value=credential)mock_service = MagicMock(spec=CredentialVaultService)mock_service.delete_credential = AsyncMock()+ mock_settings = MagicMock()+ mock_settings.is_local_credential_vault_enabled.return_value = Truewith (- patch("skyvern.forge.sdk.routes.credentials.settings") as mock_settings,patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,+ patch("skyvern.forge.sdk.routes.credentials.SettingsManager.get_settings", return_value=mock_settings),):- mock_settings.is_local_credential_vault_enabled.return_value = Truemock_app.DATABASE.credentials = mock_repositorymock_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = mock_service@@ -374,10 +358,7 @@ class TestTemporaryTestLoginCredentialCleanup:mock_service = MagicMock(spec=CredentialVaultService)mock_service.delete_credential = AsyncMock()- with (- patch("skyvern.forge.sdk.routes.credentials.settings"),- patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,- ):+ with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:mock_app.DATABASE.credentials = mock_repositorymock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_servicediff --git a/tests/unit/test_download_file_action_handler.py b/tests/unit/test_download_file_action_handler.pyindex c39b2734d..3192e14b1 100644--- a/tests/unit/test_download_file_action_handler.py+++ b/tests/unit/test_download_file_action_handler.py@@ -13,7 +13,7 @@ from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanEfrom skyvern.constants import BROWSER_DOWNLOAD_TIMEOUTfrom skyvern.errors.errors import UserDefinedErrorfrom skyvern.forge.sdk.models import StepStatus-from skyvern.webeye.actions.actions import ClickAction, DownloadFileAction+from skyvern.webeye.actions.actions import ActionStatus, ClickAction, DownloadFileActionfrom skyvern.webeye.actions.handler import (_BLOCKED_INLINE_PDF_RECOVERY_TIMEOUT_SECONDS,_INLINE_IFRAME_SRC_JS,@@ -160,6 +160,62 @@ async def _run_false_click_observation(return results, action, context, page, storage+async def test_reused_action_with_stale_finished_at_gets_fresh_stamp_on_exception(+ span_exporter: InMemorySpanExporter,+) -> None:+ """A hydrated/cached action arrives with a prior finished_at; if this execution's inner+ action raises, the fallback must stamp THIS execution, never preserve the stale value+ (which would yield finished_at < started_at)."""+ now = datetime.now(UTC)+ organization = make_organization(now)+ task, step, page, browser_state, scraped_page, action = _make_download_click_context(+ now=now,+ organization=organization,+ page_url="https://example.com/download",+ )+ stale = datetime(2020, 1, 1, 0, 0, 0)+ action.finished_at = stale++ with tempfile.TemporaryDirectory() as temp_dir:+ mock_app = MagicMock()+ mock_app.BROWSER_MANAGER.get_for_task.return_value = browser_state+ mock_app.DATABASE.workflow_params.create_action = AsyncMock(return_value=action)+ mock_app.STORAGE = MagicMock()++ with (+ patch.object(ActionHandler, "_handle_action", side_effect=RuntimeError("boom")),+ patch("skyvern.webeye.actions.handler.get_download_dir", return_value=temp_dir),+ patch("skyvern.webeye.actions.handler.skyvern_context.current", return_value=None),+ patch("skyvern.webeye.actions.handler.app", mock_app),+ ):+ with pytest.raises(RuntimeError):+ await ActionHandler.handle_action(+ scraped_page=scraped_page,+ task=task,+ step=step,+ page=page,+ action=action,+ )++ assert action.started_at is not None+ assert action.finished_at is not None+ assert action.finished_at != stale+ assert action.started_at <= action.finished_at+++async def test_agent_action_persists_execution_window(tmp_path: Path) -> None:+ rig = _make_false_click_observation_context()+ rig[-1].status = ActionStatus.completed++ _, action, _, _, _ = await _run_false_click_observation(tmp_path, rig=rig)++ assert action.started_at is not None+ assert action.finished_at is not None+ assert action.started_at <= action.finished_at++@pytest.mark.asyncioasync def test_false_click_captured_download_is_finalized_after_action_failure(tmp_path: Path) -> None:downloaded_path = tmp_path / "captured-after-failure.pdf"@@ -713,6 +769,7 @@ def _make_download_click_context(step = make_step(now, task, step_id="step-1", status=StepStatus.created, order=0, output=None)page = MagicMock()page.url = page_url+ page.is_closed.return_value = Falsepage.context.browser = Nonebrowser_state = MagicMock()browser_state.list_valid_pages = AsyncMock(return_value=[page])@@ -734,6 +791,239 @@ def _make_download_click_context(return task, step, page, browser_state, scraped_page, action+async def test_handle_action_recovers_working_page_closed_by_download_click() -> None:+ now = datetime.now(UTC)+ organization = make_organization(now)+ task, step, page, browser_state, scraped_page, action = _make_download_click_context(+ now=now,+ organization=organization,+ page_url="https://example.com/downloads",+ task_overrides={+ "error_code_mapping": {+ "download_failed": "The requested download could not be prepared",+ },+ },+ )+ task = task.model_copy(update={"download_timeout": 0.01})+ transient_callbacks: dict[str, Callable] = {}+ unrelated_page = MagicMock()+ unrelated_page.url = "https://example.com/unrelated"+ recovered_page = MagicMock()+ recovered_page.url = page.url+ recovered_page.is_closed.return_value = False+ recovered_page.context = page.context+ page.context._skyvern_cdp_download_active = False++ async def expose_original_binding(_name: str, callback: Callable) -> None:+ transient_callbacks["original"] = callback++ page.expose_binding = AsyncMock(side_effect=expose_original_binding)+ page.evaluate = AsyncMock(return_value=[])+ recovered_page.expose_binding = AsyncMock()+ recovered_page.evaluate = AsyncMock(return_value=[])+ browser_state.list_valid_pages = AsyncMock(return_value=[page, unrelated_page])+ browser_state.new_page = AsyncMock(return_value=recovered_page)+ browser_state.navigate_to_url = AsyncMock()+ browser_state.set_active_page = AsyncMock()++ async def close_page_during_click(*args: object, **kwargs: object) -> list[ActionSuccess]:+ transient_callbacks["original"](+ {},+ {"text": "The requested download could not be prepared", "timestamp_ms": 1},+ )+ page.is_closed.return_value = True+ return [ActionSuccess()]++ with tempfile.TemporaryDirectory() as temp_dir:+ mock_app = MagicMock()+ mock_app.BROWSER_MANAGER.get_for_task.return_value = browser_state+ mock_app.DATABASE.workflow_params.create_action = AsyncMock(return_value=action)+ mock_app.STORAGE = MagicMock()++ with (+ patch.object(ActionHandler, "_handle_action", side_effect=close_page_during_click),+ patch("skyvern.webeye.actions.handler.get_download_dir", return_value=temp_dir),+ patch("skyvern.webeye.actions.handler.list_files_in_directory", return_value=[]),+ patch("skyvern.webeye.actions.handler.skyvern_context.current", return_value=None),+ patch("skyvern.webeye.actions.handler.app", mock_app),+ ):+ results = await ActionHandler.handle_action(+ scraped_page=scraped_page,+ task=task,+ step=step,+ page=page,+ action=action,+ )++ browser_state.new_page.assert_awaited_once_with()+ browser_state.navigate_to_url.assert_awaited_once_with(+ page=recovered_page,+ url="https://example.com/downloads",+ )+ browser_state.set_active_page.assert_awaited_once_with(recovered_page)+ assert unrelated_page is not recovered_page+ assert results[-1].download_triggered is False+ assert results[-1].skip_remaining_actions is True+ assert isinstance(results[-1], ActionFailure)+ assert [error.error_code for error in action.errors or []] == ["download_failed"]+++async def test_handle_action_does_not_close_recovered_page_when_download_finishes() -> None:+ now = datetime.now(UTC)+ organization = make_organization(now)+ task, step, page, browser_state, scraped_page, action = _make_download_click_context(+ now=now,+ organization=organization,+ page_url="https://example.com/downloads",+ )+ download_popup = MagicMock()+ download_popup.url = "https://example.com/download-popup"+ download_popup.close = AsyncMock()+ recovered_page = MagicMock()+ recovered_page.url = page.url+ recovered_page.is_closed.return_value = False+ recovered_page.context = page.context+ recovered_page.close = AsyncMock()+ page.context._skyvern_cdp_download_active = False+ page.expose_binding = AsyncMock()+ page.evaluate = AsyncMock(return_value=[])+ recovered_page.expose_binding = AsyncMock()+ recovered_page.evaluate = AsyncMock(return_value=[])+ browser_state.list_valid_pages = AsyncMock(side_effect=[[page], [download_popup, recovered_page]])+ browser_state.new_page = AsyncMock(return_value=recovered_page)+ browser_state.navigate_to_url = AsyncMock()+ browser_state.set_active_page = AsyncMock()+ observer_lifecycle: list[str] = []+ original_observer = MagicMock()+ original_observer.events = [{"text": "The report download is ready", "timestamp_ms": 1}]+ original_observer.start = AsyncMock(side_effect=lambda **_: observer_lifecycle.append("original:start"))++ async def stop_original_observer() -> None:+ observer_lifecycle.append("original:stop")+ original_observer.events.clear()++ original_observer.stop = AsyncMock(side_effect=stop_original_observer)+ recovered_observer = MagicMock()+ recovered_observer.events = []+ recovered_observer.start = AsyncMock(side_effect=lambda **_: observer_lifecycle.append("recovered:start"))+ recovered_observer.stop = AsyncMock(side_effect=lambda: observer_lifecycle.append("recovered:stop"))++ with tempfile.TemporaryDirectory() as temp_dir:+ downloaded_file = Path(temp_dir) / "report.pdf"++ async def close_page_during_click(*args: object, **kwargs: object) -> list[ActionSuccess]:+ page.is_closed.return_value = True+ downloaded_file.write_bytes(b"downloaded")+ return [ActionSuccess()]++ mock_app = MagicMock()+ mock_app.BROWSER_MANAGER.get_for_task.return_value = browser_state+ mock_app.DATABASE.workflow_params.create_action = AsyncMock(return_value=action)+ mock_app.STORAGE = MagicMock()++ with (+ patch.object(ActionHandler, "_handle_action", side_effect=close_page_during_click),+ patch("skyvern.webeye.actions.handler.get_download_dir", return_value=temp_dir),+ patch(+ "skyvern.webeye.actions.handler.list_files_in_directory",+ side_effect=lambda _path: [str(downloaded_file)] if downloaded_file.exists() else [],+ ),+ patch(+ "skyvern.webeye.actions.handler.check_downloading_files_and_wait_for_download_to_complete",+ new=AsyncMock(),+ ),+ patch(+ "skyvern.webeye.actions.handler.TransientPageTextObserver",+ side_effect=[original_observer, recovered_observer],+ ),+ patch("skyvern.webeye.actions.handler.skyvern_context.current", return_value=None),+ patch("skyvern.webeye.actions.handler.app", mock_app),+ ):+ results = await ActionHandler.handle_action(+ scraped_page=scraped_page,+ task=task,+ step=step,+ page=page,+ action=action,+ )++ assert results[-1].download_triggered is True+ assert results[-1].skip_remaining_actions is True+ assert recovered_observer.events == [{"text": "The report download is ready", "timestamp_ms": 1}]+ assert observer_lifecycle == ["original:start", "original:stop", "recovered:start", "recovered:stop"]+ recovered_page.close.assert_not_awaited()+ download_popup.close.assert_awaited_once_with()+++async def test_handle_action_closes_failed_recovery_page_and_bounds_navigation() -> None:+ now = datetime.now(UTC)+ organization = make_organization(now)+ task, step, page, browser_state, scraped_page, action = _make_download_click_context(+ now=now,+ organization=organization,+ page_url="https://example.com/downloads",+ )+ task.download_timeout = 0.01+ failed_recovery_page = MagicMock()+ failed_recovery_page.url = "about:blank"+ failed_recovery_page.context = page.context+ failed_recovery_page.close = AsyncMock()+ page.context._skyvern_cdp_download_active = False+ page.expose_binding = AsyncMock()+ page.evaluate = AsyncMock(return_value=[])+ browser_state.new_page = AsyncMock(return_value=failed_recovery_page)+ navigation_started = asyncio.Event()++ async def hang_during_recovery(*args: object, **kwargs: object) -> None:+ navigation_started.set()+ await asyncio.Event().wait()++ browser_state.navigate_to_url = AsyncMock(side_effect=hang_during_recovery)+ browser_state.set_active_page = AsyncMock()++ async def close_page_during_click(*args: object, **kwargs: object) -> list[ActionSuccess]:+ page.is_closed.return_value = True+ return [ActionSuccess()]++ with tempfile.TemporaryDirectory() as temp_dir:+ mock_app = MagicMock()+ mock_app.BROWSER_MANAGER.get_for_task.return_value = browser_state+ mock_app.DATABASE.workflow_params.create_action = AsyncMock(return_value=action)+ mock_app.STORAGE = MagicMock()++ with (+ patch.object(ActionHandler, "_handle_action", side_effect=close_page_during_click),+ patch("skyvern.webeye.actions.handler.get_download_dir", return_value=temp_dir),+ patch("skyvern.webeye.actions.handler.list_files_in_directory", return_value=[]),+ patch("skyvern.webeye.actions.handler.skyvern_context.current", return_value=None),+ patch("skyvern.webeye.actions.handler.LOG.warning"),+ patch("skyvern.webeye.actions.handler.app", mock_app),+ ):+ results = await asyncio.wait_for(+ ActionHandler.handle_action(+ scraped_page=scraped_page,+ task=task,+ step=step,+ page=page,+ action=action,+ ),+ timeout=0.5,+ )++ assert navigation_started.is_set()+ browser_state.navigate_to_url.assert_awaited_once_with(+ page=failed_recovery_page,+ url="https://example.com/downloads",+ )+ browser_state.set_active_page.assert_not_awaited()+ failed_recovery_page.close.assert_awaited_once_with()+ assert results[-1].download_triggered is False+ assert results[-1].skip_remaining_actions is not True++@pytest.mark.asyncioasync def test_handle_action_timeout_bounds_browser_download_handler_drain(span_exporter: InMemorySpanExporter,@@ -827,8 +1117,11 @@ async def test_handle_action_download_completion_may_exceed_signal_budget(file.write(b"ready")return [ActionSuccess()]+ during_completion_wait: list[datetime] = []+async def slow_download_completion(**kwargs: object) -> None:assert kwargs["timeout"] == 0.2+ during_completion_wait.append(datetime.now(UTC).replace(tzinfo=None))await asyncio.sleep(0.05)mock_app = MagicMock()@@ -866,6 +1159,14 @@ async def test_handle_action_download_completion_may_exceed_signal_budget(assert elapsed < CI_TEST_RUNAWAY_TIMEOUT_SECONDSassert results[-1].download_triggered is Trueassert results[-1].downloaded_files == ["report.pdf"]+ # The download-triggered persist path stamps the execution window too, and the+ # window excludes the download-completion wait: finished_at was taken when the+ # inner action returned, strictly before the completion mock ran.+ assert action.started_at is not None+ assert action.finished_at is not None+ assert action.started_at <= action.finished_at+ assert during_completion_wait+ assert action.finished_at <= during_completion_wait[0]@pytest.mark.asyncio@@ -2541,6 +2842,7 @@ async def test_handle_action_prefers_observed_file_over_download_event_copy(page = MagicMock()page.url = "https://example.com/download"+ page.is_closed.return_value = Falsepage.context.browser = Nonesettle_active = Falsesettle_count = 0@@ -2869,6 +3171,7 @@ async def test_handle_action_stops_after_download_event_fallback_failure(page = MagicMock()page.url = "https://example.com/download"+ page.is_closed.return_value = Falsepage.context.browser = Nonedownload_callbacks: dict[str, Callable[[object], None]] = {}page.on.side_effect = lambda event, callback: download_callbacks.__setitem__(event, callback)diff --git a/tests/unit/test_hydrate_action_resilience.py b/tests/unit/test_hydrate_action_resilience.pyindex 91d671ae3..5a910fb92 100644--- a/tests/unit/test_hydrate_action_resilience.py+++ b/tests/unit/test_hydrate_action_resilience.py@@ -70,6 +70,8 @@ def _action_row(**overrides: Any) -> SimpleNamespace:"skyvern_element_hash": None,"skyvern_element_data": None,"screenshot_artifact_id": None,+ "started_at": None,+ "finished_at": None,"created_at": datetime(2026, 5, 6, 0, 0, 0),"modified_at": datetime(2026, 5, 6, 0, 0, 0),"action_json": None,diff --git a/tests/unit/test_microsoft_oauth_service.py b/tests/unit/test_microsoft_oauth_service.pyindex 3b4a276f3..d32899d5a 100644--- a/tests/unit/test_microsoft_oauth_service.py+++ b/tests/unit/test_microsoft_oauth_service.py@@ -435,6 +435,7 @@ async def test_callback_rejects_missing_mail_read_before_promoting(monkeypatch:await microsoft_oauth_routes.microsoft_oauth_callback(CreateMicrosoftOAuthCallbackRequest(code="code", state="state"),SimpleNamespace(organization_id="org_1"),+ "user_1",)assert exc_info.value.status_code == 400@@ -521,6 +522,7 @@ async def test_microsoft_oauth_callback_prefers_graph_mail_then_falls_back_to_clresponse = await microsoft_oauth_routes.microsoft_oauth_callback(CreateMicrosoftOAuthCallbackRequest(code="code", state="state"),SimpleNamespace(organization_id="org_1"),+ "user_1",)assert response.credential.email_address == expected_email@@ -611,6 +613,7 @@ async def test_microsoft_oauth_callback_preserves_email_on_transient_graph_failuresponse = await microsoft_oauth_routes.microsoft_oauth_callback(CreateMicrosoftOAuthCallbackRequest(code="code", state="state"),SimpleNamespace(organization_id="org_1"),+ "user_1",)assert response.credential.email_address == "[email protected]"@@ -690,6 +693,7 @@ async def test_microsoft_oauth_callback_falls_back_to_claim_on_non_transient_graresponse = await microsoft_oauth_routes.microsoft_oauth_callback(CreateMicrosoftOAuthCallbackRequest(code="code", state="state"),SimpleNamespace(organization_id="org_1"),+ "user_1",)assert response.credential.email_address == "[email protected]"@@ -924,3 +928,63 @@ async def test_microsoft_email_backfill_caches_cancelled_resolution()load_secrets.assert_awaited_once()+++async def test_microsoft_oauth_callback_rejects_state_redeemed_by_another_caller(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ """A consent challenge is redeemable only by the caller that started it."""+ rows: dict[str, dict[str, Any]] = {}++ async def insert_pending_credential(**kwargs: Any) -> SimpleNamespace:+ rows[kwargs["consent_nonce"]] = kwargs+ return SimpleNamespace(id=kwargs["credential_id"])++ async def load_pending_by_nonce(organization_id: str, nonce: str, **_: Any) -> Any:+ row = rows.get(nonce)+ if row is None or row["organization_id"] != organization_id:+ return None+ return PendingConsentContext(+ credential_id=row["credential_id"],+ consent_redirect_uri=row["consent_redirect_uri"],+ consent_code_verifier=row["consent_code_verifier"],+ scopes_requested=row["scopes_requested"],+ )++ monkeypatch.setattr(microsoft_oauth_service.settings, "ENABLE_ENCRYPTION", True, raising=False)+ monkeypatch.setattr(microsoft_oauth_service.settings, "MICROSOFT_OAUTH_CLIENT_ID", "cid", raising=False)+ monkeypatch.setattr(microsoft_oauth_service.settings, "MICROSOFT_OAUTH_CLIENT_SECRET", "csecret", raising=False)+ monkeypatch.setattr(microsoft_oauth_service.settings, "MICROSOFT_OAUTH_REDIRECT_HOSTS", ["app"], raising=False)+ monkeypatch.setattr(+ microsoft_oauth_service.app,+ "DATABASE",+ SimpleNamespace(+ microsoft_oauth=SimpleNamespace(+ insert_pending_credential=insert_pending_credential,+ load_pending_by_nonce=load_pending_by_nonce,+ )+ ),+ raising=False,+ )+ exchange_mock = AsyncMock()+ monkeypatch.setattr(microsoft_oauth_routes.microsoft_oauth_service, "exchange_code_for_tokens", exchange_mock)++ start = await microsoft_oauth_service.start_authorization(+ organization_id="org_1",+ redirect_uri="https://app/cb",+ initiator_id="user_initiator",+ )++ with pytest.raises(HTTPException) as exc_info:+ await microsoft_oauth_routes.microsoft_oauth_callback(+ CreateMicrosoftOAuthCallbackRequest(code="code", state=start.state),+ SimpleNamespace(organization_id="org_1"),+ "user_other",+ )++ assert exc_info.value.status_code == 400+ # Reject before spending the one-time authorization code.+ exchange_mock.assert_not_awaited()+ # The challenge stays redeemable by the caller that started it.+ assert len(rows) == 1diff --git a/tests/unit/test_real_browser_manager.py b/tests/unit/test_real_browser_manager.pyindex dbdeee749..23d4868ca 100644--- a/tests/unit/test_real_browser_manager.py+++ b/tests/unit/test_real_browser_manager.py@@ -10,6 +10,7 @@ from unittest.mock import AsyncMock, MagicMock, patchimport pytest+from skyvern.forge.sdk.artifact.storage.recording_test_helpers import fake_prepared_recordingfrom skyvern.webeye import real_browser_managerfrom skyvern.webeye.browser_artifacts import BrowserArtifacts, VideoArtifactfrom skyvern.webeye.browser_engine import BrowserEngineMetadata, BrowserEngineSelection@@ -443,17 +444,22 @@ def _make_browser_state_with_video(video_path: str) -> MagicMock:@pytest.mark.asyncio-async def test_get_video_artifacts_finalize_true_invokes_ffmpeg(tmp_path) -> None:- """The default (finalize=True) path remuxes via ffmpeg so the final upload has Duration + Cues."""+async def test_get_video_artifacts_finalize_true_prepares_upload(tmp_path) -> None:+ """The default (finalize=True) path prepares finalized recording bytes and extension."""src = tmp_path / "recording.webm"src.write_bytes(b"raw-webm-bytes")+ prepared = tmp_path / "recording.mp4"+ prepared.write_bytes(b"compressed-mp4-bytes")browser_state = _make_browser_state_with_video(str(src))- with patch("skyvern.webeye.real_browser_manager.finalize_webm", new=AsyncMock(return_value=b"remuxed")) as m:+ with patch(+ "skyvern.webeye.real_browser_manager.prepare_recording_for_upload",+ lambda path: fake_prepared_recording(path, str(prepared)),+ ):artifacts = await RealBrowserManager().get_video_artifacts(browser_state=browser_state)- m.assert_awaited_once_with(str(src))- assert artifacts[0].video_data == b"remuxed"+ assert artifacts[0].video_data == b"compressed-mp4-bytes"+ assert artifacts[0].video_file_extension == "mp4"@pytest.mark.asyncio@@ -467,26 +473,26 @@ async def test_get_video_artifacts_finalize_false_skips_ffmpeg(tmp_path) -> Nonesrc.write_bytes(b"partial-webm-bytes")browser_state = _make_browser_state_with_video(str(src))- with patch("skyvern.webeye.real_browser_manager.finalize_webm", new=AsyncMock()) as m:+ with patch("skyvern.webeye.real_browser_manager.prepare_recording_for_upload") as m:artifacts = await RealBrowserManager().get_video_artifacts(browser_state=browser_state, finalize=False)- m.assert_not_awaited()+ m.assert_not_called()assert artifacts[0].video_data == b"partial-webm-bytes"+ assert artifacts[0].video_file_extension == "webm"@pytest.mark.asyncioasync def test_get_video_artifacts_non_webm_skips_ffmpeg(tmp_path) -> None:"""Non-WebM container files (e.g. fully-formed MP4 from a remote source)- are container-valid already; remuxing them through ``finalize_webm`` would- corrupt the file. The extension-based short-circuit reads them raw."""+ are container-valid already; the extension-based short-circuit reads them raw."""src = tmp_path / "recording.mp4"src.write_bytes(b"mp4-bytes")browser_state = _make_browser_state_with_video(str(src))- with patch("skyvern.webeye.real_browser_manager.finalize_webm", new=AsyncMock()) as m:+ with patch.object(real_browser_manager, "prepare_recording_for_upload", new=AsyncMock()) as m:artifacts = await RealBrowserManager().get_video_artifacts(browser_state=browser_state)- m.assert_not_awaited()+ m.assert_not_called()assert artifacts[0].video_data == b"mp4-bytes"diff --git a/tests/unit/test_recording_artifact_update.py b/tests/unit/test_recording_artifact_update.pynew file mode 100644index 000000000..ee4ba5249--- /dev/null+++ b/tests/unit/test_recording_artifact_update.py@@ -0,0 +1,150 @@+import asyncio+from datetime import UTC, datetime+from unittest.mock import AsyncMock, patch++import pytest++from skyvern.forge.sdk.artifact.manager import ArtifactManager+from skyvern.forge.sdk.artifact.models import Artifact, ArtifactType+++def _make_recording_artifact(uri: str) -> Artifact:+ now = datetime.now(UTC)+ return Artifact(+ artifact_id="a_recording",+ artifact_type=ArtifactType.RECORDING,+ uri=uri,+ organization_id="org_1",+ task_id="task_1",+ created_at=now,+ modified_at=now,+ )+++async def test_update_recording_artifact_data_rewrites_uri_for_prepared_extension() -> None:+ manager = ArtifactManager()+ original = _make_recording_artifact("s3://bucket/path/recording.webm")+ updated = original.model_copy(update={"uri": "s3://bucket/path/recording.mp4", "file_size": 9})++ with patch("skyvern.forge.sdk.artifact.manager.app") as mock_app:+ mock_app.DATABASE.artifacts.get_artifact_by_id = AsyncMock(return_value=original)+ mock_app.DATABASE.artifacts.update_artifact_uri = AsyncMock(return_value=updated)+ mock_app.STORAGE.store_artifact = AsyncMock()++ await manager.update_artifact_data(+ artifact_id=original.artifact_id,+ organization_id=original.organization_id,+ data=b"mp4-bytes",+ file_extension="mp4",+ )+ await asyncio.gather(*manager.upload_aiotasks_map["task_1"])++ mock_app.DATABASE.artifacts.update_artifact_uri.assert_awaited_once_with(+ artifact_id=original.artifact_id,+ organization_id=original.organization_id,+ uri="s3://bucket/path/recording.mp4",+ file_size=9,+ )+ mock_app.STORAGE.store_artifact.assert_awaited_once_with(updated, b"mp4-bytes")+++async def test_update_recording_artifact_data_same_extension_updates_file_size() -> None:+ manager = ArtifactManager()+ artifact = _make_recording_artifact("s3://bucket/path/recording.webm")+ updated = artifact.model_copy(update={"file_size": 10})++ with patch("skyvern.forge.sdk.artifact.manager.app") as mock_app:+ mock_app.DATABASE.artifacts.get_artifact_by_id = AsyncMock(return_value=artifact)+ mock_app.DATABASE.artifacts.update_artifact_uri = AsyncMock(return_value=updated)+ mock_app.STORAGE.store_artifact = AsyncMock()++ await manager.update_artifact_data(+ artifact_id=artifact.artifact_id,+ organization_id=artifact.organization_id,+ data=b"webm-bytes",+ file_extension="webm",+ )+ await asyncio.gather(*manager.upload_aiotasks_map["task_1"])++ mock_app.DATABASE.artifacts.update_artifact_uri.assert_awaited_once_with(+ artifact_id=artifact.artifact_id,+ organization_id=artifact.organization_id,+ uri=artifact.uri,+ file_size=10,+ )+ mock_app.STORAGE.store_artifact.assert_awaited_once_with(updated, b"webm-bytes")+++async def test_update_recording_artifact_data_skips_db_update_when_uri_and_size_unchanged() -> None:+ manager = ArtifactManager()+ artifact = _make_recording_artifact("s3://bucket/path/recording.webm").model_copy(update={"file_size": 10})++ with patch("skyvern.forge.sdk.artifact.manager.app") as mock_app:+ mock_app.DATABASE.artifacts.get_artifact_by_id = AsyncMock(return_value=artifact)+ mock_app.DATABASE.artifacts.update_artifact_uri = AsyncMock()+ mock_app.STORAGE.store_artifact = AsyncMock()++ await manager.update_artifact_data(+ artifact_id=artifact.artifact_id,+ organization_id=artifact.organization_id,+ data=b"webm-bytes",+ file_extension="webm",+ )+ await asyncio.gather(*manager.upload_aiotasks_map["task_1"])++ mock_app.DATABASE.artifacts.update_artifact_uri.assert_not_awaited()+ mock_app.STORAGE.store_artifact.assert_awaited_once_with(artifact, b"webm-bytes")+++async def test_update_recording_artifact_data_fails_when_metadata_update_returns_none() -> None:+ manager = ArtifactManager()+ artifact = _make_recording_artifact("s3://bucket/path/recording.webm")++ with patch("skyvern.forge.sdk.artifact.manager.app") as mock_app:+ mock_app.DATABASE.artifacts.get_artifact_by_id = AsyncMock(return_value=artifact)+ mock_app.DATABASE.artifacts.update_artifact_uri = AsyncMock(return_value=None)+ mock_app.STORAGE.store_artifact = AsyncMock()++ with pytest.raises(RuntimeError, match="Failed to update recording artifact metadata"):+ await manager.update_artifact_data(+ artifact_id=artifact.artifact_id,+ organization_id=artifact.organization_id,+ data=b"mp4-bytes",+ file_extension="mp4",+ )++ mock_app.STORAGE.store_artifact.assert_not_awaited()+++async def test_update_recording_artifact_data_logs_store_task_failure() -> None:+ manager = ArtifactManager()+ artifact = _make_recording_artifact("s3://bucket/path/recording.webm")+ updated = artifact.model_copy(update={"uri": "s3://bucket/path/recording.mp4", "file_size": 9})++ with (+ patch("skyvern.forge.sdk.artifact.manager.app") as mock_app,+ patch("skyvern.forge.sdk.artifact.manager.LOG") as mock_log,+ ):+ mock_app.DATABASE.artifacts.get_artifact_by_id = AsyncMock(return_value=artifact)+ mock_app.DATABASE.artifacts.update_artifact_uri = AsyncMock(return_value=updated)+ mock_app.STORAGE.store_artifact = AsyncMock(side_effect=RuntimeError("upload failed"))++ await manager.update_artifact_data(+ artifact_id=artifact.artifact_id,+ organization_id=artifact.organization_id,+ data=b"mp4-bytes",+ file_extension="mp4",+ )+ await asyncio.gather(*manager.upload_aiotasks_map["task_1"], return_exceptions=True)++ assert any(+ call.args == ("Artifact store task failed",)+ and call.kwargs["artifact_id"] == updated.artifact_id+ and call.kwargs["uri"] == updated.uri+ for call in mock_log.warning.call_args_list+ )diff --git a/tests/unit/test_script_skyvern_page.py b/tests/unit/test_script_skyvern_page.pyindex 391a02b01..8577f72fc 100644--- a/tests/unit/test_script_skyvern_page.py+++ b/tests/unit/test_script_skyvern_page.py@@ -7,6 +7,7 @@ terminate() (raises ScriptTerminationException for Code 2.0 cached execution),and wait() (accepts both seconds= and timeout_ms= parameter styles)."""+import asyncioimport inspectimport reimport time@@ -1552,6 +1553,115 @@ class TestActionSubclassPersistence:assert action.x == 100assert action.y == 200+ @pytest.mark.asyncio+ async def test_cached_script_action_persists_execution_window(self, mock_scraped_page, mock_ai):+ from skyvern.webeye.actions.action_types import ActionType++ script_page = self._build_script_page(mock_scraped_page, mock_ai)+ script_page._wait_for_page_ready_before_action = AsyncMock()+ script_page._create_screenshot_after_execution = AsyncMock()+ script_page._create_html_action_after_execution = AsyncMock()+ captured: list = []+ context = self._build_context()++ async def execute(_page, **_kwargs):+ await asyncio.sleep(0.01)++ async def fake_create_action(action):+ captured.append(action)+ action.action_id = "act_test"+ return action++ with (+ patch(+ "skyvern.core.script_generations.script_skyvern_page.skyvern_context.current",+ return_value=context,+ ),+ patch(+ "skyvern.core.script_generations.script_skyvern_page.app.DATABASE.workflow_params.create_action",+ new=AsyncMock(side_effect=fake_create_action),+ ),+ patch(+ "skyvern.core.script_generations.script_skyvern_page.app.DATABASE.workflow_params.update_action_reasoning",+ new=AsyncMock(),+ ),+ patch(+ "skyvern.core.script_generations.script_skyvern_page.script_run_context_manager.get_run_context",+ return_value=None,+ ),+ patch("skyvern.core.script_generations.script_skyvern_page.settings.CACHED_ACTION_DELAY_SECONDS", 0),+ ):+ await script_page._decorate_call(execute, ActionType.CLICK, selector="#go")++ assert len(captured) == 1+ action = captured[0]+ assert action.started_at is not None+ assert action.finished_at is not None+ assert action.started_at <= action.finished_at++ @pytest.mark.asyncio+ async def test_cached_script_window_excludes_download_detection_baseline(self, mock_scraped_page, mock_ai):+ import time as time_module+ from pathlib import Path++ from skyvern.forge.sdk.db.datetime_utils import naive_utc_now+ from skyvern.webeye.actions.action_types import ActionType++ script_page = self._build_script_page(mock_scraped_page, mock_ai)+ script_page._wait_for_page_ready_before_action = AsyncMock()+ script_page._create_screenshot_after_execution = AsyncMock()+ script_page._create_html_action_after_execution = AsyncMock()+ captured: list = []+ context = self._build_context()+ context.browser_session_id = None+ during_baseline: list = []++ def fake_download_dir(workflow_run_id):+ time_module.sleep(0.002)+ during_baseline.append(naive_utc_now())+ return Path("/nonexistent-download-dir")++ async def execute(_page, **_kwargs):+ await asyncio.sleep(0.01)++ async def fake_create_action(action):+ captured.append(action)+ action.action_id = "act_test"+ return action++ with (+ patch(+ "skyvern.core.script_generations.script_skyvern_page.skyvern_context.current",+ return_value=context,+ ),+ patch(+ "skyvern.core.script_generations.script_skyvern_page.app.DATABASE.workflow_params.create_action",+ new=AsyncMock(side_effect=fake_create_action),+ ),+ patch(+ "skyvern.core.script_generations.script_skyvern_page.app.DATABASE.workflow_params.update_action_reasoning",+ new=AsyncMock(),+ ),+ patch(+ "skyvern.core.script_generations.script_skyvern_page.script_run_context_manager.get_run_context",+ return_value=None,+ ),+ patch("skyvern.core.script_generations.script_skyvern_page.settings.CACHED_ACTION_DELAY_SECONDS", 0),+ patch(+ "skyvern.core.script_generations.script_skyvern_page.get_path_for_workflow_download_directory",+ side_effect=fake_download_dir,+ ),+ ):+ await script_page._decorate_call(execute, ActionType.CLICK, selector="#go")++ assert during_baseline, "download-detection baseline never ran"+ assert len(captured) == 1+ action = captured[0]+ # The window starts at the action itself: started_at is stamped after the+ # download-detection baseline I/O, never before it.+ assert action.started_at is not None+ assert action.started_at >= during_baseline[0]+@pytest.mark.asyncioasync def test_scroll_persists_scroll_x_and_scroll_y(self, mock_scraped_page, mock_ai):from skyvern.webeye.actions.action_types import ActionTypediff --git a/tests/unit/workflow/test_code_block_recorder.py b/tests/unit/workflow/test_code_block_recorder.pyindex 50896599b..52dd7966d 100644--- a/tests/unit/workflow/test_code_block_recorder.py+++ b/tests/unit/workflow/test_code_block_recorder.py@@ -6,7 +6,7 @@ import asyncioimport jsonfrom collections.abc import AsyncIteratorfrom contextlib import asynccontextmanager-from datetime import datetime, timezone+from datetime import datetime, timedelta, timezonefrom types import SimpleNamespacefrom unittest.mock import AsyncMock@@ -148,11 +148,13 @@ async def _record_timed_action() -> Action:async def test_recorded_action_has_wall_clock_timestamps_and_duration() -> None:action = await _record_timed_action()- assert action.created_at is not None- assert action.modified_at is not None- assert action.created_at < action.modified_at- assert action.created_at.tzinfo is None- assert action.modified_at.tzinfo is None+ assert action.started_at is not None+ assert action.finished_at is not None+ assert action.started_at < action.finished_at+ assert action.started_at.tzinfo is None+ assert action.finished_at.tzinfo is None+ assert action.created_at is None+ assert action.modified_at is Noneassert isinstance(action.output, dict)assert "duration_ms" in action.output@@ -940,7 +942,7 @@ async def test_streamed_write_precedes_screenshot_backfilled_by_batch(monkeypatcasync def test_reupsert_preserves_action_end_timestamp_and_backfills_screenshot() -> None:async with _recorded_action_db() as db:action = await _record_timed_action()- stamped_end = action.modified_at+ stamped_end = action.finished_atawait db.workflow_params.upsert_recorded_action(action)await asyncio.sleep(0.01)@@ -950,10 +952,66 @@ async def test_reupsert_preserves_action_end_timestamp_and_backfills_screenshot(async with db.Session() as session:row = (await session.scalars(select(ActionModel).where(ActionModel.action_id == action.action_id))).one()- assert row.modified_at == stamped_end+ assert row.finished_at == stamped_endassert row.screenshot_artifact_id == "artifact_timing"+async def test_unstamped_reupsert_does_not_null_execution_timestamps() -> None:+ """The synthetic non-executed error row upserts with no execution timestamps; it must not+ overwrite a previously stamped row's started_at/finished_at with NULL."""+ async with _recorded_action_db() as db:+ action = await _record_timed_action()+ stamped_start, stamped_end = action.started_at, action.finished_at+ await db.workflow_params.upsert_recorded_action(action)++ unstamped = action.model_copy(update={"started_at": None, "finished_at": None})+ await db.workflow_params.upsert_recorded_action(unstamped)++ async with db.Session() as session:+ row = (await session.scalars(select(ActionModel).where(ActionModel.action_id == action.action_id))).one()++ assert row.started_at == stamped_start+ assert row.finished_at == stamped_end+++async def test_restamped_reupsert_takes_the_new_execution_timestamps() -> None:+ """The batch refresh re-upserts with newer stamps; the incoming values must win over the+ stored ones (this is the case that discriminates the coalesce argument order)."""+ async with _recorded_action_db() as db:+ action = await _record_timed_action()+ await db.workflow_params.upsert_recorded_action(action)++ newer_start = action.started_at + timedelta(seconds=5)+ newer_end = action.finished_at + timedelta(seconds=9)+ restamped = action.model_copy(update={"started_at": newer_start, "finished_at": newer_end})+ await db.workflow_params.upsert_recorded_action(restamped)++ async with db.Session() as session:+ row = (await session.scalars(select(ActionModel).where(ActionModel.action_id == action.action_id))).one()++ assert row.started_at == newer_start+ assert row.finished_at == newer_end+++async def test_unstamped_row_backfills_from_a_later_stamped_upsert() -> None:+ async with _recorded_action_db() as db:+ action = await _record_timed_action()+ stamped_start, stamped_end = action.started_at, action.finished_at+ unstamped = action.model_copy(update={"started_at": None, "finished_at": None})+ await db.workflow_params.upsert_recorded_action(unstamped)++ await db.workflow_params.upsert_recorded_action(action)++ async with db.Session() as session:+ row = (await session.scalars(select(ActionModel).where(ActionModel.action_id == action.action_id))).one()++ assert row.started_at == stamped_start+ assert row.finished_at == stamped_end++@pytest.mark.asyncioasync def test_recorded_action_timestamps_round_trip_through_hydration() -> None:async with _recorded_action_db() as db:@@ -964,10 +1022,12 @@ async def test_recorded_action_timestamps_round_trip_through_hydration() -> Nonerow = (await session.scalars(select(ActionModel).where(ActionModel.action_id == action.action_id))).one()hydrated = hydrate_action(row)- assert row.created_at == action.created_at- assert row.modified_at == action.modified_at- assert hydrated.created_at == action.created_at- assert hydrated.modified_at == action.modified_at+ assert row.started_at == action.started_at+ assert row.finished_at == action.finished_at+ assert hydrated.started_at == action.started_at+ assert hydrated.finished_at == action.finished_at+ assert row.created_at >= action.finished_at+ assert row.modified_at >= action.finished_at@pytest.mark.asyncio