Skip to content

Automate browser based workflows with AI

Split login from data extraction when the scout demonstrated a credentialed flow (#7934)

Andrew Neilson16b2efab8b4b
diff --git a/.env.example b/.env.example
index 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.py
new file mode 100644
index 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.json
index 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.mdx
index 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 Configuration
subtitle: 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-configuration
keywords:
- 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
+```
+
+---
+
## Anthropic
Claude models from [anthropic.com](https://www.anthropic.com/).
diff --git a/skyvern/cli/doctor.py b/skyvern/cli/doctor.py
index 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.py
index 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.py
index ff68b90c4..51a39741a 100644
--- a/skyvern/config.py
+++ b/skyvern/config.py
@@ -424,10 +424,15 @@ class Settings(BaseSettings):
ENABLE_VERTEX_AI: bool = False
ENABLE_AZURE_CUA: bool = False
ENABLE_OPENAI_COMPATIBLE: bool = False
+ ENABLE_XAI: bool = False
# OPENAI
OPENAI_API_KEY: str | None = None
GPT5_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"
# ANTHROPIC
ANTHROPIC_API_KEY: str | None = None
ANTHROPIC_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 = None
LOCAL_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.py
index 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 asyncio
import inspect
import os
import re
+from datetime import datetime
from pathlib import Path
from typing import Any, Callable
@@ -39,6 +40,7 @@ from skyvern.forge.sdk.api.files import (
)
from skyvern.forge.sdk.artifact.models import ArtifactType
from skyvern.forge.sdk.core import skyvern_context
+from skyvern.forge.sdk.db.datetime_utils import naive_utc_now
from skyvern.forge.sdk.db.utils import ACTION_TYPE_TO_CLASS
from skyvern.forge.sdk.schemas.totp_codes import OTPType
from 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):
raise
finally:
+ finished_at = naive_utc_now()
# Add a small buffer between cached actions to give slow pages time to settle
if 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 = None
diff --git a/skyvern/forge/agent.py b/skyvern/forge/agent.py
index 09152f247..4314c71ca 100644
--- a/skyvern/forge/agent.py
+++ b/skyvern/forge/agent.py
@@ -110,6 +110,7 @@ from skyvern.forge.sdk.core import skyvern_context
from skyvern.forge.sdk.core.hashing import diagnostic_fingerprint
from skyvern.forge.sdk.core.security import generate_skyvern_webhook_signature
from skyvern.forge.sdk.core.skyvern_context import SkyvernContext
+from skyvern.forge.sdk.db.datetime_utils import naive_utc_now
from skyvern.forge.sdk.db.enums import TaskType
from skyvern.forge.sdk.experimentation.enrich_tree import resolve_enrich_tree_for_context
from 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 = False
action_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_id
artifact_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_path
if 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:
continue
diff --git a/skyvern/forge/agent_functions.py b/skyvern/forge/agent_functions.py
index 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_KEY
return 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.py
index 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[[Requ
try:
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 < 400
and http_method in _READ_METHODS
diff --git a/skyvern/forge/sdk/api/llm/api_handler_factory.py b/skyvern/forge/sdk/api/llm/api_handler_factory.py
index 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_effort
LOG.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.py
index 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 litellm
import structlog
from skyvern.config import settings
@@ -11,6 +12,53 @@ from skyvern.schemas.llm import LiteLLMParams, LLMConfig, LLMRouterConfig
LOG = 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=1
diff --git a/skyvern/forge/sdk/artifact/manager.py b/skyvern/forge/sdk/artifact/manager.py
index 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_extension
from skyvern.forge.sdk.core import skyvern_context
from skyvern.forge.sdk.db.id import generate_artifact_id
from 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 artifacts
self._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 None
artifact = 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 forget
aio_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_key
async 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.py
index 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_extension
from skyvern.forge.sdk.models import Step
from skyvern.forge.sdk.schemas.ai_suggestions import AISuggestion
from skyvern.forge.sdk.schemas.files import FileInfo
from skyvern.forge.sdk.schemas.task_v2 import TaskV2, Thought
from skyvern.forge.sdk.schemas.workflow_runs import WorkflowRunBlock
from skyvern.utils.script_file_paths import build_script_file_storage_uri
+from skyvern.webeye.video_utils import prepare_recording_for_upload
LOG = 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 uri
async def delete_browser_session_file(
diff --git a/skyvern/forge/sdk/artifact/storage/gcs.py b/skyvern/forge/sdk/artifact/storage/gcs.py
index 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_extension
from skyvern.forge.sdk.models import Step
from skyvern.forge.sdk.schemas.ai_suggestions import AISuggestion
from skyvern.forge.sdk.schemas.files import FileInfo
from skyvern.forge.sdk.schemas.task_v2 import TaskV2, Thought
from skyvern.forge.sdk.schemas.workflow_runs import WorkflowRunBlock
from skyvern.utils.script_file_paths import build_script_file_storage_uri
+from skyvern.webeye.video_utils import prepare_recording_for_upload
LOG = 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 uri
async 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.py
new file mode 100644
index 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.py
index 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_extension
from skyvern.forge.sdk.models import Step
from skyvern.forge.sdk.schemas.ai_suggestions import AISuggestion
from 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.py
new file mode 100644
index 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.py
index 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 += 1
continue
@@ -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 = emitted
code = "\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.py
index 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, Any
return 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: engaged
credentials (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 False
return _trajectory_reaches_generic_goal(
diff --git a/skyvern/forge/sdk/copilot/tools/workflow_update.py b/skyvern/forge/sdk/copilot/tools/workflow_update.py
index 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.codes
if 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, *, sourc
if not body:
continue
stage_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_keys
stage_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_eligible
and len(durable_stage_codes) >= 2
and (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.py
index 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.py
index 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 annotations
import datetime
-from typing import TYPE_CHECKING, Callable
+from typing import TYPE_CHECKING, Any, Callable
import structlog
from 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.py
index 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, timezone
from typing import Any
import structlog
-from sqlalchemy import select
+from sqlalchemy import func, select
from sqlalchemy.dialects.postgresql import insert as pg_insert
from 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_at
async 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.py
index 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_FIELDS
if 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.py
index 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 SettingsManager
from skyvern.forge.sdk.workflow.browser_session_persistence import retrieve_persisted_workflow_browser_state_dir
from skyvern.forge.sdk.workflow.models.parameter import WorkflowParameterType
from 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_TYPE
if 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.py
index 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.py
index 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.py
index 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_consent
from skyvern.forge.sdk.settings_manager import SettingsManager
LOG = 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.py
index 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: F401
from skyvern.forge.sdk.encrypt import encryptor
from skyvern.forge.sdk.encrypt.base import EncryptMethod
from skyvern.forge.sdk.schemas.microsoft_oauth import MicrosoftOAuthCredentialBase
+from skyvern.forge.sdk.services import oauth_consent
from skyvern.utils.email_validation import SAFE_EMAIL_ADDRESS_PATTERN
LOG = 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.py
new file mode 100644
index 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.py
index 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:
raise
finally:
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_ms
self.actions.append(action)
diff --git a/skyvern/forge/sdk/workflow/service.py b/skyvern/forge/sdk/workflow/service.py
index 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 = False
for 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,
+ )
+ continue
if 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_path
if not video_artifact.video_data and (not video_path or not os.path.exists(video_path)):
continue
@@ -9357,17 +9374,33 @@ class WorkflowService:
)
continue
if 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_id
upload_keys.add(last_step.task_id)
if upload_keys:
diff --git a/skyvern/webeye/actions/actions.py b/skyvern/webeye/actions/actions.py
index 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 = None
created_at: datetime | None = None
modified_at: datetime | None = None
created_by: str | None = None
diff --git a/skyvern/webeye/actions/handler.py b/skyvern/webeye/actions/handler.py
index 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_fields
from skyvern.forge.sdk.core import skyvern_context
from skyvern.forge.sdk.core.hashing import diagnostic_fingerprint
from skyvern.forge.sdk.core.skyvern_context import PendingFileChooserListener, ensure_context
+from skyvern.forge.sdk.db.datetime_utils import naive_utc_now
from skyvern.forge.sdk.event.factory import EventStrategyFactory
from 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 = None
browser_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_id
return results
@@ -2998,6 +3004,7 @@ class ActionHandler:
else BROWSER_DOWNLOAD_TIMEOUT,
)
download_triggered = False
+ working_page_replaced_after_close = False
xhr_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 = True
results[-1].followup_message = DOWNLOAD_NOT_TRIGGERED_FOLLOWUP_MESSAGE
+ if working_page_replaced_after_close:
+ results[-1].skip_remaining_actions = True
action.download_triggered = False
return results
results[-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 = True
return results
finally:
+ # 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 -= 1
blank_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.py
index 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 = None
video_artifact_id: str | None = None
+ video_file_extension: str | None = None
video_data: bytes = b""
diff --git a/skyvern/webeye/browser_factory.py b/skyvern/webeye/browser_factory.py
index 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 PlaywrightError
from 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_TYPE
browser_context: BrowserContext | None = None
cleanup_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.py
index 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 RealBrowserState
from 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_upload
LOG = 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_path
if 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_extension
else:
- # 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.py
index 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 RealAsyncAzureStorageClient
from skyvern.forge.sdk.artifact.models import Artifact, ArtifactType
from skyvern.forge.sdk.artifact.storage.azure import AzureStorage
from 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 constants
TEST_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: Path
diff --git a/tests/unit/forge/sdk/artifact/storage/test_gcs_storage.py b/tests/unit/forge/sdk/artifact/storage/test_gcs_storage.py
index 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 RealAsyncGcsStorageClient
from skyvern.forge.sdk.artifact.models import Artifact, ArtifactType
from skyvern.forge.sdk.artifact.storage.base import SENSITIVE_SHARE_URL_EXPIRY_HOURS
from skyvern.forge.sdk.artifact.storage.gcs import GcsStorage
+from skyvern.forge.sdk.artifact.storage.recording_test_helpers import fake_prepared_recording
TEST_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: Path
diff --git a/tests/unit/forge/sdk/routes/streaming/test_vnc_routed_url.py b/tests/unit/forge/sdk/routes/streaming/test_vnc_routed_url.py
index 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 SimpleNamespace
import pytest
from 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_channel
from 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.py
index 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_consent
from 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(monkeypatch
organization_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(monkeypatch
assert 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.state
assert 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.kwargs
assert 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.state
assert 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: p
result = 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: p
promote_mock.assert_awaited_once()
kwargs = promote_mock.await_args.kwargs
assert 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.AES
assert kwargs["scopes_granted"] == ["https://a", "https://b"]
@@ -2457,10 +2467,14 @@ async def test_load_pending_consent_context_delegates_to_repo(monkeypatch: pytes
result = 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.py
index 739dd494d..1d4525668 100644
--- a/tests/unit/test_actions.py
+++ b/tests/unit/test_actions.py
@@ -1,9 +1,11 @@
+from datetime import datetime
from unittest.mock import MagicMock
import pytest
-from pydantic import ValidationError
+from pydantic import TypeAdapter, ValidationError
from skyvern.config import settings
+from skyvern.forge.sdk.db.models import ActionModel
from skyvern.forge.sdk.db.repositories.workflow_parameters import WorkflowParametersRepository
from skyvern.forge.sdk.db.utils import hydrate_action
from skyvern.forge.sdk.schemas import sdk_actions
@@ -21,6 +23,7 @@ from skyvern.utils.action_redaction import (
from skyvern.webeye.actions.action_types import ActionType
from 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.asyncio
async 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_hydr
intention="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_hydr
assert persisted_model.response == REDACTED_OTP_VALUE
assert persisted_model.action_json["text"] == secret_value
assert persisted_model.action_json["response"] == secret_value
+ assert persisted_model.started_at == started_at
+ assert persisted_model.finished_at == finished_at
hydrated_action = hydrate_action(persisted_model)
assert isinstance(hydrated_action, InputTextAction)
assert hydrated_action.text == secret_value
assert 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.py
index 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 asyncio
import base64
from dataclasses import dataclass, field
from 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.asyncio
async 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.py
index 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_factory
diff --git a/tests/unit/test_browser_header_sanitization.py b/tests/unit/test_browser_header_sanitization.py
index 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 nam
launch 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_function
class 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 logs
diff --git a/tests/unit/test_config_registry.py b/tests/unit/test_config_registry.py
new file mode 100644
index 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 parameters
diff --git a/tests/unit/test_copilot_code_block_persist_seam.py b/tests/unit/test_copilot_code_block_persist_seam.py
index 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) > 1
block = _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_code
assert "zip_code" not in browser_code
code = str(block["code"])
@@ -13786,3 +13789,268 @@ class TestScoutedSpineRepeatedOmissionSeam:
naming = workflow_update_module._pre_persist_scouted_spine_result(draft, ctx)
assert naming is not None
assert "#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.py
index 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 Crede
class 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.asyncio
async 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.BITWARDEN
mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bw
result = await _get_credential_vault_service()
assert result is mock_bw
@@ -178,24 +181,24 @@ class TestGetCredentialVaultServiceRouting:
@pytest.mark.asyncio
async 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 = True
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.SKYVERN
- mock_settings.is_local_credential_vault_enabled.return_value = True
mock_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = mock_skyvern
result = await _get_credential_vault_service()
assert result is mock_skyvern
@pytest.mark.asyncio
async 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 = False
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.SKYVERN
- mock_settings.is_local_credential_vault_enabled.return_value = False
mock_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 = True
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.BITWARDEN
- mock_settings.is_local_credential_vault_enabled.return_value = True
mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bw
mock_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = mock_skyvern
result = 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 = False
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.BITWARDEN
- mock_settings.is_local_credential_vault_enabled.return_value = False
mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bw
mock_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = mock_skyvern
with 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_bw
mock_app.CUSTOM_CREDENTIAL_VAULT_SERVICE = mock_custom
result = 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_bw
mock_app.AZURE_CREDENTIAL_VAULT_SERVICE = mock_azure
result = 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_bw
mock_app.GCP_CREDENTIAL_VAULT_SERVICE = mock_gcp
result = await _get_credential_vault_service(
@@ -288,11 +279,7 @@ class TestGetCredentialVaultServiceRouting:
@pytest.mark.asyncio
async 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 = None
with pytest.raises(HTTPException) as exc_info:
await _get_credential_vault_service(
@@ -303,11 +290,7 @@ class TestGetCredentialVaultServiceRouting:
@pytest.mark.asyncio
async 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 = None
with pytest.raises(HTTPException) as exc_info:
await _get_credential_vault_service(
@@ -319,11 +302,11 @@ class TestGetCredentialVaultServiceRouting:
@pytest.mark.asyncio
async 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.CUSTOM
mock_app.CUSTOM_CREDENTIAL_VAULT_SERVICE = mock_custom
result = 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 = True
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.is_local_credential_vault_enabled.return_value = True
mock_app.DATABASE.credentials = mock_repository
mock_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_repository
mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_service
diff --git a/tests/unit/test_download_file_action_handler.py b/tests/unit/test_download_file_action_handler.py
index 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 InMemorySpanE
from skyvern.constants import BROWSER_DOWNLOAD_TIMEOUT
from skyvern.errors.errors import UserDefinedError
from skyvern.forge.sdk.models import StepStatus
-from skyvern.webeye.actions.actions import ClickAction, DownloadFileAction
+from skyvern.webeye.actions.actions import ActionStatus, ClickAction, DownloadFileAction
from 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.asyncio
async 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 = False
page.context.browser = None
browser_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.asyncio
async 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_SECONDS
assert results[-1].download_triggered is True
assert 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 = False
page.context.browser = None
settle_active = False
settle_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 = False
page.context.browser = None
download_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.py
index 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.py
index 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_cl
response = 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_failu
response = 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_gra
response = 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) == 1
diff --git a/tests/unit/test_real_browser_manager.py b/tests/unit/test_real_browser_manager.py
index 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, patch
import pytest
+from skyvern.forge.sdk.artifact.storage.recording_test_helpers import fake_prepared_recording
from skyvern.webeye import real_browser_manager
from skyvern.webeye.browser_artifacts import BrowserArtifacts, VideoArtifact
from 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) -> None
src.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.asyncio
async 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.py
new file mode 100644
index 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.py
index 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 asyncio
import inspect
import re
import time
@@ -1552,6 +1553,115 @@ class TestActionSubclassPersistence:
assert action.x == 100
assert 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.asyncio
async def test_scroll_persists_scroll_x_and_scroll_y(self, mock_scraped_page, mock_ai):
from skyvern.webeye.actions.action_types import ActionType
diff --git a/tests/unit/workflow/test_code_block_recorder.py b/tests/unit/workflow/test_code_block_recorder.py
index 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 asyncio
import json
from collections.abc import AsyncIterator
from contextlib import asynccontextmanager
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
from types import SimpleNamespace
from 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 None
assert isinstance(action.output, dict)
assert "duration_ms" in action.output
@@ -940,7 +942,7 @@ async def test_streamed_write_precedes_screenshot_backfilled_by_batch(monkeypatc
async 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_at
await 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_end
assert 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.asyncio
async 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() -> None
row = (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