Skip to content

Automate browser based workflows with AI

Allow browser_profile_id + browser_session_id together and inject browser_session_id into Jinja templates (#4967)

Marc Kelechava438bee958858
diff --git a/docs/integrations/mcp.mdx b/docs/integrations/mcp.mdx
index 58bd7d869..14097cff7 100644
--- a/docs/integrations/mcp.mdx
+++ b/docs/integrations/mcp.mdx
@@ -46,22 +46,30 @@ claude mcp add-json skyvern '{"type":"http","url":"https://api.skyvern.com/mcp/"
</Tab>
<Tab title="Claude Desktop">
-Add to your Claude Desktop config file (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS, `~/.config/Claude/claude_desktop_config.json` on Linux):
+Add to your Claude Desktop config file:
+
+- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Linux**: `~/.config/Claude/claude_desktop_config.json`
+- **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
```json
{
"mcpServers": {
"Skyvern": {
- "type": "streamable-http",
- "url": "https://api.skyvern.com/mcp/",
- "headers": {
- "x-api-key": "YOUR_SKYVERN_API_KEY"
- }
+ "command": "npx",
+ "args": [
+ "mcp-remote",
+ "https://api.skyvern.com/mcp/",
+ "--header",
+ "x-api-key:YOUR_SKYVERN_API_KEY"
+ ]
}
}
}
```
+This uses [mcp-remote](https://www.npmjs.com/package/mcp-remote) to bridge the remote MCP server to stdio. Requires Node.js >= 20.
+
</Tab>
<Tab title="Cursor">
@@ -123,7 +131,7 @@ x-api-key = "SKYVERN_API_KEY"
</Tab>
</Tabs>
-That's it — no Python, no `pip install`, no local server. Your AI assistant connects directly to Skyvern Cloud over HTTPS.
+That's it — no Python, no `pip install`, no local server. Your AI assistant connects directly to Skyvern Cloud over HTTPS. Claude Desktop uses [mcp-remote](https://www.npmjs.com/package/mcp-remote) to bridge the connection (requires Node.js >= 20).
## Alternative: Local mode (self-hosted)
diff --git a/fern/integrations/mcp.mdx b/fern/integrations/mcp.mdx
index 8d3438af7..b4a99cd7d 100644
--- a/fern/integrations/mcp.mdx
+++ b/fern/integrations/mcp.mdx
@@ -46,22 +46,30 @@ claude mcp add-json skyvern '{"type":"http","url":"https://api.skyvern.com/mcp/"
</Tab>
<Tab title="Claude Desktop">
-Add to your Claude Desktop config file (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS, `~/.config/Claude/claude_desktop_config.json` on Linux):
+Add to your Claude Desktop config file:
+
+- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Linux**: `~/.config/Claude/claude_desktop_config.json`
+- **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
```json
{
"mcpServers": {
"Skyvern": {
- "type": "streamable-http",
- "url": "https://api.skyvern.com/mcp/",
- "headers": {
- "x-api-key": "YOUR_SKYVERN_API_KEY"
- }
+ "command": "npx",
+ "args": [
+ "mcp-remote",
+ "https://api.skyvern.com/mcp/",
+ "--header",
+ "x-api-key:YOUR_SKYVERN_API_KEY"
+ ]
}
}
}
```
+This uses [mcp-remote](https://www.npmjs.com/package/mcp-remote) to bridge the remote MCP server to stdio. Requires Node.js >= 20.
+
</Tab>
<Tab title="Cursor">
@@ -123,7 +131,7 @@ x-api-key = "SKYVERN_API_KEY"
</Tab>
</Tabs>
-That's it — no Python, no `pip install`, no local server. Your AI assistant connects directly to Skyvern Cloud over HTTPS.
+That's it — no Python, no `pip install`, no local server. Your AI assistant connects directly to Skyvern Cloud over HTTPS. Claude Desktop uses [mcp-remote](https://www.npmjs.com/package/mcp-remote) to bridge the connection (requires Node.js >= 20).
## Alternative: Local mode (self-hosted)
diff --git a/skyvern/cli/setup_commands.py b/skyvern/cli/setup_commands.py
index d0a766b0b..c239ad88d 100644
--- a/skyvern/cli/setup_commands.py
+++ b/skyvern/cli/setup_commands.py
@@ -52,6 +52,17 @@ def _build_remote_mcp_entry(api_key: str, url: str = _DEFAULT_REMOTE_URL) -> dic
return entry
+def _build_mcp_remote_bridge_entry(api_key: str, url: str = _DEFAULT_REMOTE_URL) -> dict:
+ """Build an npx mcp-remote entry for clients that only support stdio (e.g. Claude Desktop)."""
+ args = ["mcp-remote", url]
+ if api_key:
+ args.extend(["--header", f"x-api-key:{api_key}"])
+ return {
+ "command": "npx",
+ "args": args,
+ }
+
+
def _build_local_mcp_entry(
api_key: str,
base_url: str,
@@ -78,14 +89,16 @@ def _build_local_mcp_entry(
def _has_api_key(entry: dict | None) -> bool:
- """Check whether an MCP config entry carries an API key (remote or local format)."""
+ """Check whether an MCP config entry carries an API key (remote, local, or mcp-remote bridge format)."""
if not entry:
return False
if entry.get("headers", {}).get("x-api-key"):
return True
if entry.get("env", {}).get("SKYVERN_API_KEY"):
return True
- return False
+ # mcp-remote bridge: API key is in args as "--header", "x-api-key:..."
+ args = entry.get("args", [])
+ return any(isinstance(a, str) and a.startswith("x-api-key:") for a in args)
def _upsert_mcp_config(
@@ -152,6 +165,7 @@ def _build_entry(
local: bool,
use_python_path: bool,
url: str | None,
+ use_mcp_remote_bridge: bool = False,
) -> dict:
if local:
return _build_local_mcp_entry(api_key, base_url, use_python_path=use_python_path)
@@ -160,6 +174,8 @@ def _build_entry(
if parsed.scheme not in ("http", "https"):
console.print(f"[red]Invalid URL: {remote_url} (must start with http:// or https://)[/red]")
raise typer.Exit(code=1)
+ if use_mcp_remote_bridge:
+ return _build_mcp_remote_bridge_entry(api_key, url=remote_url)
return _build_remote_mcp_entry(api_key, url=remote_url)
@@ -224,10 +240,14 @@ def _run_setup(
local: bool,
use_python_path: bool,
url: str | None,
+ *,
+ use_mcp_remote_bridge: bool = False,
) -> None:
env_key, env_url = _get_env_credentials()
key = api_key or env_key
- entry = _build_entry(key, env_url, local=local, use_python_path=use_python_path, url=url)
+ entry = _build_entry(
+ key, env_url, local=local, use_python_path=use_python_path, url=url, use_mcp_remote_bridge=use_mcp_remote_bridge
+ )
_upsert_mcp_config(config_path, tool_name, entry, dry_run=dry_run, yes=yes)
@@ -245,8 +265,18 @@ def setup_claude(
use_python_path: bool = _python_path_opt,
url: str | None = _url_opt,
) -> None:
- """Register Skyvern MCP with Claude Desktop (remote by default)."""
- _run_setup("Claude Desktop", _claude_desktop_config_path(), api_key, dry_run, yes, local, use_python_path, url)
+ """Register Skyvern MCP with Claude Desktop (uses mcp-remote bridge for remote mode)."""
+ _run_setup(
+ "Claude Desktop",
+ _claude_desktop_config_path(),
+ api_key,
+ dry_run,
+ yes,
+ local,
+ use_python_path,
+ url,
+ use_mcp_remote_bridge=not local,
+ )
@setup_app.command("claude-code")
diff --git a/skyvern/forge/sdk/workflow/context_manager.py b/skyvern/forge/sdk/workflow/context_manager.py
index f81ce8e19..6698f1139 100644
--- a/skyvern/forge/sdk/workflow/context_manager.py
+++ b/skyvern/forge/sdk/workflow/context_manager.py
@@ -181,6 +181,7 @@ class WorkflowRunContext:
self.workflow_run_outputs: dict[str, Any] = {}
self._aws_client = aws_client
self.organization_id: str | None = None
+ self.browser_session_id: str | None = None
self.include_secrets_in_templates: bool = False
self.credential_totp_identifiers: dict[str, str] = {}
diff --git a/skyvern/forge/sdk/workflow/models/block.py b/skyvern/forge/sdk/workflow/models/block.py
index 92e2ab970..a590024fe 100644
--- a/skyvern/forge/sdk/workflow/models/block.py
+++ b/skyvern/forge/sdk/workflow/models/block.py
@@ -409,6 +409,8 @@ class Block(BaseModel, abc.ABC):
template_data["workflow_run_id"] = workflow_run_context.workflow_run_id
if "current_date" not in template_data:
template_data["current_date"] = datetime.now(timezone.utc).strftime(CURRENT_DATE_FORMAT)
+ if "browser_session_id" not in template_data:
+ template_data["browser_session_id"] = workflow_run_context.browser_session_id or ""
template_data["workflow_run_outputs"] = workflow_run_context.workflow_run_outputs
template_data["workflow_run_summary"] = workflow_run_context.build_workflow_run_summary()
diff --git a/skyvern/forge/sdk/workflow/models/workflow.py b/skyvern/forge/sdk/workflow/models/workflow.py
index e3d3f7fc9..34edc796c 100644
--- a/skyvern/forge/sdk/workflow/models/workflow.py
+++ b/skyvern/forge/sdk/workflow/models/workflow.py
@@ -2,7 +2,7 @@ from datetime import datetime
from enum import StrEnum
from typing import Any, List
-from pydantic import BaseModel, field_validator, model_validator
+from pydantic import BaseModel, field_validator
from typing_extensions import deprecated
from skyvern.forge.sdk.schemas.files import FileInfo
@@ -41,12 +41,6 @@ class WorkflowRequestBody(BaseModel):
return url
return validate_url(url)
- @model_validator(mode="after")
- def validate_browser_reference(cls, values: "WorkflowRequestBody") -> "WorkflowRequestBody":
- if values.browser_session_id and values.browser_profile_id:
- raise ValueError("Cannot specify both browser_session_id and browser_profile_id")
- return values
-
@deprecated("Use WorkflowRunResponse instead")
class RunWorkflowResponse(BaseModel):
diff --git a/skyvern/forge/sdk/workflow/service.py b/skyvern/forge/sdk/workflow/service.py
index b3207d563..f448b71b9 100644
--- a/skyvern/forge/sdk/workflow/service.py
+++ b/skyvern/forge/sdk/workflow/service.py
@@ -918,6 +918,13 @@ class WorkflowService:
browser_session_id=browser_session_id,
)
+ # Make browser_session_id available in Jinja templates via {{ browser_session_id }}.
+ # IMPORTANT: This must happen before _execute_workflow_blocks, which is where
+ # template rendering occurs. If this assignment moves after block execution,
+ # browser_session_id will silently resolve to empty string in templates.
+ workflow_run_context = app.WORKFLOW_CONTEXT_MANAGER.get_workflow_run_context(workflow_run_id)
+ workflow_run_context.browser_session_id = browser_session_id
+
renewal_task: asyncio.Task[None] | None = None
if browser_session_id:
try:
@@ -3050,6 +3057,7 @@ class WorkflowService:
code_gen: bool | None = None,
) -> WorkflowRun:
# validate the browser session or profile id
+ browser_profile_id = workflow_request.browser_profile_id
if workflow_request.browser_session_id:
browser_session = await app.DATABASE.get_persistent_browser_session(
session_id=workflow_request.browser_session_id,
@@ -3057,17 +3065,34 @@ class WorkflowService:
)
if not browser_session:
raise BrowserSessionNotFound(browser_session_id=workflow_request.browser_session_id)
+ # Auto-propagate profile from session when not explicitly provided
+ if not browser_profile_id and browser_session.browser_profile_id:
+ browser_profile_id = browser_session.browser_profile_id
+ LOG.info(
+ "Auto-propagated browser_profile_id from browser session",
+ browser_session_id=workflow_request.browser_session_id,
+ browser_profile_id=browser_profile_id,
+ )
- if workflow_request.browser_profile_id:
+ if browser_profile_id:
browser_profile = await app.DATABASE.get_browser_profile(
- workflow_request.browser_profile_id,
+ browser_profile_id,
organization_id=organization_id,
)
if not browser_profile:
- raise BrowserProfileNotFound(
- profile_id=workflow_request.browser_profile_id,
- organization_id=organization_id,
- )
+ # If the profile was auto-propagated from session but has been deleted, skip it
+ if browser_profile_id != workflow_request.browser_profile_id:
+ LOG.warning(
+ "Browser session has browser_profile_id but profile not found, ignoring",
+ browser_session_id=workflow_request.browser_session_id,
+ browser_profile_id=browser_profile_id,
+ )
+ browser_profile_id = None
+ else:
+ raise BrowserProfileNotFound(
+ profile_id=browser_profile_id,
+ organization_id=organization_id,
+ )
# Check if this workflow/org should use browser sessions (anti-bot detection mitigation)
browser_session_id = workflow_request.browser_session_id
@@ -3103,7 +3128,7 @@ class WorkflowService:
workflow_id=workflow_id,
organization_id=organization_id,
browser_session_id=browser_session_id,
- browser_profile_id=workflow_request.browser_profile_id,
+ browser_profile_id=browser_profile_id,
proxy_location=workflow_request.proxy_location,
webhook_callback_url=workflow_request.webhook_callback_url,
totp_verification_url=workflow_request.totp_verification_url,
diff --git a/skyvern/schemas/runs.py b/skyvern/schemas/runs.py
index 3bdc7f0a1..f1888c85a 100644
--- a/skyvern/schemas/runs.py
+++ b/skyvern/schemas/runs.py
@@ -5,7 +5,7 @@ from enum import StrEnum
from typing import Annotated, Any, Literal, Union
from zoneinfo import ZoneInfo
-from pydantic import BaseModel, Field, field_validator, model_validator
+from pydantic import BaseModel, Field, field_validator
from skyvern.forge.sdk.schemas.files import FileInfo
from skyvern.schemas.docs.doc_examples import (
@@ -531,12 +531,6 @@ class WorkflowRunRequest(BaseModel):
return url
return validate_url(url)
- @model_validator(mode="after")
- def validate_browser_reference(cls, values: WorkflowRunRequest) -> WorkflowRunRequest:
- if values.browser_session_id and values.browser_profile_id:
- raise ValueError("Cannot specify both browser_session_id and browser_profile_id")
- return values
-
class BlockRunRequest(WorkflowRunRequest):
block_labels: list[str] = Field(
diff --git a/skyvern/webeye/real_browser_manager.py b/skyvern/webeye/real_browser_manager.py
index 3ba5ddc02..e15b9bfe3 100644
--- a/skyvern/webeye/real_browser_manager.py
+++ b/skyvern/webeye/real_browser_manager.py
@@ -391,19 +391,45 @@ class RealBrowserManager(BrowserManager):
LOG.info("Cleaning up for workflow run")
browser_state_to_close = self.pages.pop(workflow_run_id, None)
if browser_state_to_close:
- # Stop tracing before closing the browser if tracing is enabled
- if browser_state_to_close.browser_context and browser_state_to_close.browser_artifacts.traces_dir:
+ # If another workflow run still references this browser state (e.g. a
+ # parent whose in-memory browser was shared via use_parent_browser_session),
+ # skip closing the browser so the parent can continue using it.
+ shared = any(bs is browser_state_to_close for bs in self.pages.values())
+ effective_close = close_browser_on_completion and not shared
+ if shared:
+ LOG.info(
+ "Browser state is shared with another workflow run, skipping browser close",
+ workflow_run_id=workflow_run_id,
+ )
+
+ # Stop tracing before closing the browser if tracing is enabled.
+ # Skip when the browser is shared — Playwright supports only one active
+ # tracing session per context, so stopping here would kill the parent's trace.
+ if (
+ browser_state_to_close.browser_context
+ and browser_state_to_close.browser_artifacts.traces_dir
+ and not shared
+ ):
trace_path = f"{browser_state_to_close.browser_artifacts.traces_dir}/{workflow_run_id}.zip"
await browser_state_to_close.browser_context.tracing.stop(path=trace_path)
LOG.info("Stopped tracing", trace_path=trace_path)
- await browser_state_to_close.close(close_browser_on_completion=close_browser_on_completion)
+ await browser_state_to_close.close(close_browser_on_completion=effective_close)
for task_id in task_ids:
task_browser_state = self.pages.pop(task_id, None)
if task_browser_state is None:
continue
+ # Same shared-state check for task-level entries
+ shared = any(bs is task_browser_state for bs in self.pages.values())
+ effective_close = close_browser_on_completion and not shared
+ if shared:
+ LOG.info(
+ "Browser state is shared with another workflow run, skipping browser close",
+ task_id=task_id,
+ workflow_run_id=workflow_run_id,
+ )
try:
- await task_browser_state.close(close_browser_on_completion=close_browser_on_completion)
+ await task_browser_state.close(close_browser_on_completion=effective_close)
except Exception:
LOG.info(
"Failed to close the browser state from the task block, might because it's already closed.",
diff --git a/tests/unit/test_branch_criteria.py b/tests/unit/test_branch_criteria.py
index d6818a087..e20393aad 100644
--- a/tests/unit/test_branch_criteria.py
+++ b/tests/unit/test_branch_criteria.py
@@ -26,6 +26,7 @@ class FakeWorkflowRunContext:
self.workflow_id = "wf-id"
self.workflow_permanent_id = "wf-perm-id"
self.workflow_run_id = "wf-run-id"
+ self.browser_session_id: str | None = None
def get_block_metadata(self, label: str) -> dict:
return dict(self._block_metadata.get(label, {}))
diff --git a/tests/unit/workflow/test_browser_session_id_template.py b/tests/unit/workflow/test_browser_session_id_template.py
new file mode 100644
index 000000000..80ccab6a8
--- /dev/null
+++ b/tests/unit/workflow/test_browser_session_id_template.py
@@ -0,0 +1,292 @@
+"""Unit tests for {{ browser_session_id }} template variable injection from WorkflowRunContext.
+
+Tests both the low-level template rendering AND the full customer flow:
+ 1. WorkflowRunContext is created (like initialize_workflow_run_context)
+ 2. browser_session_id is set on the context (like execute_workflow does)
+ 3. Multiple block types render templates that reference {{ browser_session_id }}
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from unittest.mock import MagicMock
+
+from skyvern.forge.sdk.workflow.context_manager import WorkflowRunContext
+from skyvern.forge.sdk.workflow.models.block import HttpRequestBlock, NavigationBlock
+from skyvern.forge.sdk.workflow.models.parameter import OutputParameter
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+class FakeWorkflowRunContext:
+ """Lightweight stand-in for tests that don't need the real WorkflowRunContext."""
+
+ def __init__(
+ self,
+ *,
+ values: dict | None = None,
+ browser_session_id: str | None = None,
+ ) -> None:
+ self.values = dict(values or {})
+ self.secrets = {}
+ self.include_secrets_in_templates = False
+ self.workflow_title = "wf-title"
+ self.workflow_id = "wf-id"
+ self.workflow_permanent_id = "wf-perm-id"
+ self.workflow_run_id = "wr_test123"
+ self.workflow_run_outputs = {}
+ self.browser_session_id = browser_session_id
+
+ def get_block_metadata(self, label: str) -> dict:
+ return {}
+
+ def build_workflow_run_summary(self) -> str:
+ return ""
+
+
+def _make_output_parameter() -> OutputParameter:
+ now = datetime.now(timezone.utc)
+ return OutputParameter(
+ key="__output__",
+ output_parameter_id="op_test",
+ workflow_id="w_test",
+ created_at=now,
+ modified_at=now,
+ )
+
+
+def _make_http_block() -> HttpRequestBlock:
+ return HttpRequestBlock(
+ label="test_http",
+ url="https://api.example.com/v1/run/workflows",
+ method="POST",
+ output_parameter=_make_output_parameter(),
+ )
+
+
+def _make_navigation_block() -> NavigationBlock:
+ return NavigationBlock(
+ label="test_nav",
+ url="https://example.com",
+ navigation_goal="Navigate to the page",
+ output_parameter=_make_output_parameter(),
+ )
+
+
+def _make_real_workflow_run_context(*, browser_session_id: str | None = None) -> WorkflowRunContext:
+ """Create a real WorkflowRunContext (as execute_workflow would) with a mock AWS client."""
+ ctx = WorkflowRunContext(
+ workflow_title="E2E Test Workflow",
+ workflow_id="wf_e2e_test",
+ workflow_permanent_id="wpid_e2e_test",
+ workflow_run_id="wr_e2e_test",
+ aws_client=MagicMock(),
+ )
+ ctx.browser_session_id = browser_session_id
+ return ctx
+
+
+# ---------------------------------------------------------------------------
+# 1. Basic template injection (FakeWorkflowRunContext)
+# ---------------------------------------------------------------------------
+
+
+class TestBrowserSessionIdTemplateInjection:
+ """Verify {{ browser_session_id }} resolves from WorkflowRunContext."""
+
+ def test_resolves_from_workflow_run_context(self) -> None:
+ block = _make_http_block()
+ ctx = FakeWorkflowRunContext(browser_session_id="pbs_abc123")
+ result = block.format_block_parameter_template_from_workflow_run_context("{{ browser_session_id }}", ctx)
+ assert result == "pbs_abc123"
+
+ def test_renders_empty_when_no_session(self) -> None:
+ block = _make_http_block()
+ ctx = FakeWorkflowRunContext(browser_session_id=None)
+ result = block.format_block_parameter_template_from_workflow_run_context("{{ browser_session_id }}", ctx)
+ assert result == ""
+
+ def test_workflow_parameter_takes_precedence(self) -> None:
+ """If a workflow parameter named browser_session_id exists, it should win over the context attribute."""
+ block = _make_http_block()
+ ctx = FakeWorkflowRunContext(values={"browser_session_id": "pbs_from_param"}, browser_session_id="pbs_from_ctx")
+ result = block.format_block_parameter_template_from_workflow_run_context("{{ browser_session_id }}", ctx)
+ assert result == "pbs_from_param"
+
+ def test_embedded_in_json_body(self) -> None:
+ """Test the customer's actual pattern: browser_session_id embedded in a JSON body template."""
+ block = _make_http_block()
+ ctx = FakeWorkflowRunContext(browser_session_id="pbs_xyz789")
+ template = '{"workflow_id": "wpid_test", "browser_session_id": "{{ browser_session_id }}"}'
+ result = block.format_block_parameter_template_from_workflow_run_context(template, ctx)
+ assert result == '{"workflow_id": "wpid_test", "browser_session_id": "pbs_xyz789"}'
+
+
+# ---------------------------------------------------------------------------
+# 2. Full customer flow e2e (real WorkflowRunContext, multiple block types)
+# ---------------------------------------------------------------------------
+
+
+class TestCustomerFlowE2E:
+ """Simulate the real customer flow end-to-end:
+ 1. Create browser profile (bp_...)
+ 2. Create browser session with that profile (pbs_...)
+ 3. Run workflow → execute_workflow sets browser_session_id on WorkflowRunContext
+ 4. Workflow blocks render {{ browser_session_id }} in their templates
+ """
+
+ def test_http_block_json_body_with_real_context(self) -> None:
+ """Customer pattern: HTTP request block POSTs to /v1/run/workflows with
+ browser_session_id in the JSON body."""
+ ctx = _make_real_workflow_run_context(browser_session_id="pbs_customer_abc")
+ block = _make_http_block()
+
+ body_template = (
+ '{"workflow_id": "wpid_abc", '
+ '"browser_session_id": "{{ browser_session_id }}", '
+ '"parameters": {"key": "value"}}'
+ )
+ result = block.format_block_parameter_template_from_workflow_run_context(body_template, ctx)
+
+ assert '"browser_session_id": "pbs_customer_abc"' in result
+ assert "{{ browser_session_id }}" not in result
+
+ def test_navigation_block_url_with_real_context(self) -> None:
+ """Navigation block that includes browser_session_id in the URL template."""
+ ctx = _make_real_workflow_run_context(browser_session_id="pbs_nav_test")
+ block = _make_navigation_block()
+
+ url_template = "https://api.example.com/sessions/{{ browser_session_id }}/status"
+ result = block.format_block_parameter_template_from_workflow_run_context(url_template, ctx)
+
+ assert result == "https://api.example.com/sessions/pbs_nav_test/status"
+
+ def test_multiple_template_variables_together(self) -> None:
+ """Templates can use browser_session_id alongside other workflow-level variables."""
+ ctx = _make_real_workflow_run_context(browser_session_id="pbs_multi_var")
+ block = _make_http_block()
+
+ template = (
+ '{"workflow_run_id": "{{ workflow_run_id }}", '
+ '"browser_session_id": "{{ browser_session_id }}", '
+ '"workflow_id": "{{ workflow_id }}"}'
+ )
+ result = block.format_block_parameter_template_from_workflow_run_context(template, ctx)
+
+ assert '"workflow_run_id": "wr_e2e_test"' in result
+ assert '"browser_session_id": "pbs_multi_var"' in result
+ assert '"workflow_id": "wf_e2e_test"' in result
+
+ def test_no_session_renders_empty_string_in_json(self) -> None:
+ """When no browser session is used, {{ browser_session_id }} renders as empty string."""
+ ctx = _make_real_workflow_run_context(browser_session_id=None)
+ block = _make_http_block()
+
+ template = '{"browser_session_id": "{{ browser_session_id }}"}'
+ result = block.format_block_parameter_template_from_workflow_run_context(template, ctx)
+
+ assert result == '{"browser_session_id": ""}'
+
+ def test_context_attribute_matches_execute_workflow_assignment(self) -> None:
+ """Verify that the WorkflowRunContext.browser_session_id attribute works
+ exactly as execute_workflow assigns it (line 921-923 of service.py)."""
+ ctx = WorkflowRunContext(
+ workflow_title="Real Workflow",
+ workflow_id="wf_real",
+ workflow_permanent_id="wpid_real",
+ workflow_run_id="wr_real",
+ aws_client=MagicMock(),
+ )
+ # This mirrors: workflow_run_context.browser_session_id = browser_session_id
+ ctx.browser_session_id = "pbs_from_execute_workflow"
+
+ block = _make_http_block()
+ result = block.format_block_parameter_template_from_workflow_run_context("{{ browser_session_id }}", ctx)
+ assert result == "pbs_from_execute_workflow"
+
+ def test_auto_created_session_id_propagates(self) -> None:
+ """Simulate auto-creation flow: browser_session_id starts None, then gets set
+ after auto_create_browser_session_if_needed returns a session."""
+ ctx = _make_real_workflow_run_context(browser_session_id=None)
+
+ # Before auto-creation: should render empty
+ block = _make_http_block()
+ result_before = block.format_block_parameter_template_from_workflow_run_context("{{ browser_session_id }}", ctx)
+ assert result_before == ""
+
+ # Simulate auto-creation setting the session ID (like service.py does)
+ ctx.browser_session_id = "pbs_auto_created"
+
+ result_after = block.format_block_parameter_template_from_workflow_run_context("{{ browser_session_id }}", ctx)
+ assert result_after == "pbs_auto_created"
+
+
+# ---------------------------------------------------------------------------
+# 3. WorkflowContextManager → context injection → template rendering chain
+# ---------------------------------------------------------------------------
+
+
+class TestAutoCreateSessionContextInjection:
+ """Simulate the full execute_workflow path when auto_create_browser_session_if_needed
+ creates a session: WorkflowContextManager registers the context, execute_workflow
+ mutates browser_session_id on it, then blocks render templates from the same context."""
+
+ def test_context_manager_register_then_mutate_then_render(self) -> None:
+ """Exercise the real WorkflowContextManager.get_workflow_run_context path
+ that execute_workflow uses to inject browser_session_id."""
+ from skyvern.forge.sdk.workflow.context_manager import WorkflowContextManager
+
+ mgr = WorkflowContextManager()
+ workflow_run_id = "wr_auto_test"
+
+ # Step 1: Register context (like initialize_workflow_run_context does)
+ ctx = WorkflowRunContext(
+ workflow_title="Auto-Create Test",
+ workflow_id="wf_auto",
+ workflow_permanent_id="wpid_auto",
+ workflow_run_id=workflow_run_id,
+ aws_client=MagicMock(),
+ )
+ mgr.workflow_run_contexts[workflow_run_id] = ctx
+
+ # Step 2: Simulate auto_create_browser_session_if_needed returning a session,
+ # then execute_workflow setting browser_session_id via get_workflow_run_context
+ auto_created_session_id = "pbs_auto_created_999"
+ retrieved_ctx = mgr.get_workflow_run_context(workflow_run_id)
+ retrieved_ctx.browser_session_id = auto_created_session_id
+
+ # Step 3: Verify template rendering (as _execute_workflow_blocks would)
+ block = _make_http_block()
+ body_template = '{"browser_session_id": "{{ browser_session_id }}", "workflow_run_id": "{{ workflow_run_id }}"}'
+ result = block.format_block_parameter_template_from_workflow_run_context(body_template, retrieved_ctx)
+
+ assert f'"browser_session_id": "{auto_created_session_id}"' in result
+ assert f'"workflow_run_id": "{workflow_run_id}"' in result
+
+ def test_context_manager_without_auto_create(self) -> None:
+ """When no auto-creation happens, browser_session_id stays None and renders empty."""
+ from skyvern.forge.sdk.workflow.context_manager import WorkflowContextManager
+
+ mgr = WorkflowContextManager()
+ workflow_run_id = "wr_no_auto"
+
+ ctx = WorkflowRunContext(
+ workflow_title="No Auto-Create",
+ workflow_id="wf_no_auto",
+ workflow_permanent_id="wpid_no_auto",
+ workflow_run_id=workflow_run_id,
+ aws_client=MagicMock(),
+ )
+ mgr.workflow_run_contexts[workflow_run_id] = ctx
+
+ # execute_workflow sets browser_session_id = None (no auto-creation)
+ retrieved_ctx = mgr.get_workflow_run_context(workflow_run_id)
+ retrieved_ctx.browser_session_id = None
+
+ block = _make_http_block()
+ result = block.format_block_parameter_template_from_workflow_run_context(
+ "{{ browser_session_id }}", retrieved_ctx
+ )
+ assert result == ""
diff --git a/tests/unit/workflow/test_dag_engine.py b/tests/unit/workflow/test_dag_engine.py
index a78eb03f0..bcc6af640 100644
--- a/tests/unit/workflow/test_dag_engine.py
+++ b/tests/unit/workflow/test_dag_engine.py
@@ -74,6 +74,7 @@ class DummyContext:
self.workflow_id = "wf"
self.workflow_permanent_id = "wf-perm"
self.workflow_run_id = workflow_run_id
+ self.browser_session_id: str | None = None
def update_block_metadata(self, label: str, metadata: dict) -> None:
self.blocks_metadata[label] = metadata