Skip to content

Automate browser based workflows with AI

Keep the recording mouse follower visible through page changes (#8490)

Cindy Lifa66df6f3e15
diff --git a/skyvern/forge/sdk/copilot/browser_target.py b/skyvern/forge/sdk/copilot/browser_target.py
index aba78ada5..0ed5e9163 100644
--- a/skyvern/forge/sdk/copilot/browser_target.py
+++ b/skyvern/forge/sdk/copilot/browser_target.py
@@ -9,14 +9,22 @@ report from the other.
from __future__ import annotations
from dataclasses import dataclass
+from enum import StrEnum
from typing import Any
from skyvern.forge.sdk.copilot.context import CopilotContext
BROWSER_TARGET_PARAM_NAME = "target"
+
+
+class BrowserTarget(StrEnum):
+ DEBUG = "debug"
+ LAST_RUN = "last_run"
+
+
BROWSER_TARGET_PARAM: dict[str, Any] = {
"type": "string",
- "enum": ["debug", "last_run"],
+ "enum": [target.value for target in BrowserTarget],
"description": (
"Which browser to act in. 'debug' (default) is the scouting browser this chat drives. "
"'last_run' is the browser the most recent test run executed in, which is a different "
@@ -36,7 +44,7 @@ class BrowserSessionBinding:
that lived on ``ctx.browser_session_id`` could be read by the wrong call.
"""
- target: str
+ target: BrowserTarget
# Set only when the model pointed this call at a browser other than the chat's own. The debug
# target deliberately carries none, so a session re-established mid-dispatch still applies.
session_id_override: str | None
@@ -69,18 +77,19 @@ def resolve_browser_session_binding(copilot_ctx: CopilotContext, arguments: dict
browser.
"""
requested = arguments.get(BROWSER_TARGET_PARAM_NAME)
- if requested is not None and requested not in ("debug", "last_run"):
+ try:
+ target = BrowserTarget.DEBUG if requested is None else BrowserTarget(requested)
+ except ValueError:
return BrowserSessionBinding(
- target="debug",
+ target=BrowserTarget.DEBUG,
session_id_override=None,
workflow_run_id=None,
source_matches_target=False,
unavailable_reason=f"Unknown browser target {requested!r}. Name 'debug' or 'last_run'.",
)
- target = requested or "debug"
- if target == "debug":
+ if target is BrowserTarget.DEBUG:
return BrowserSessionBinding(
- target="debug",
+ target=BrowserTarget.DEBUG,
session_id_override=None,
workflow_run_id=None,
source_matches_target=True,
@@ -89,7 +98,7 @@ def resolve_browser_session_binding(copilot_ctx: CopilotContext, arguments: dict
workflow_run_id = copilot_ctx.last_run_blocks_workflow_run_id
if not run_session_id:
return BrowserSessionBinding(
- target="last_run",
+ target=BrowserTarget.LAST_RUN,
session_id_override=None,
workflow_run_id=workflow_run_id,
source_matches_target=False,
@@ -102,13 +111,13 @@ def resolve_browser_session_binding(copilot_ctx: CopilotContext, arguments: dict
# dispatch moves the call to the live successor, and the session that acted is recoverable
# from completion_browser_session_id and the continuity generation.
return BrowserSessionBinding(
- target="last_run",
+ target=BrowserTarget.LAST_RUN,
session_id_override=None,
workflow_run_id=workflow_run_id,
source_matches_target=True,
)
return BrowserSessionBinding(
- target="last_run",
+ target=BrowserTarget.LAST_RUN,
session_id_override=run_session_id,
workflow_run_id=workflow_run_id,
source_matches_target=True,
diff --git a/skyvern/forge/sdk/copilot/tools/__init__.py b/skyvern/forge/sdk/copilot/tools/__init__.py
index a971f9952..bf29f4f2b 100644
--- a/skyvern/forge/sdk/copilot/tools/__init__.py
+++ b/skyvern/forge/sdk/copilot/tools/__init__.py
@@ -14,7 +14,7 @@ from agents.tool_context import ToolContext
from skyvern.forge import app as app
from skyvern.forge.sdk.copilot.ask_user import AskUserArguments, QuestionInput
-from skyvern.forge.sdk.copilot.browser_target import resolve_browser_session_binding
+from skyvern.forge.sdk.copilot.browser_target import BrowserTarget, resolve_browser_session_binding
from skyvern.forge.sdk.copilot.composition_evidence import (
composition_page_evidence_error as composition_page_evidence_error,
)
@@ -1409,6 +1409,7 @@ async def inspect_page_for_composition_tool(
ctx: RunContextWrapper,
target_url: str,
requested_output_reads: list[RequestedOutputRead] | None = None,
+ target: BrowserTarget = BrowserTarget.DEBUG,
) -> str:
"""Inspect a known page before composing form/search workflow blocks.
@@ -1417,10 +1418,15 @@ async def inspect_page_for_composition_tool(
Use this after the entrypoint URL is known and before authoring blocks that
fill fields, submit searches, filter results, or expand result rows. It
can also inspect the current browser page after a run by passing
- target_url="current_page"; use that after partial/budgeted runs so you do
+ target_url="current_page". `target="debug"` (the default) keeps the read on
+ the browser this chat drives; `target="last_run"` reads the browser used by
+ the most recent test run. Use the latter after partial/budgeted runs so you do
not replay a search that already advanced the page. Passing any other
- `target_url` navigates the live browser there and reports the reached
- `current_url`, so a further `navigate_browser` to that same URL is redundant. The packet
+ `target_url` navigates the targeted browser there and reports the reached
+ `current_url`, so a further `navigate_browser` to that same URL is redundant. Navigating
+ `target="last_run"` leaves the page that run stopped on, losing the state you are diagnosing,
+ and anything it submits there is real; pass `target_url="current_page"` to observe that browser
+ without moving it. The packet
describes the page only as it is at that moment: a control that appears solely after an
interaction -- a Delete control after an Add click, a cart after add-to-cart, the secure area
after login -- is absent from it until that interaction has happened.
@@ -1448,39 +1454,87 @@ async def inspect_page_for_composition_tool(
and returns every observed selector candidate with its cardinality as facts; you
remain responsible for choosing a selector and authoring the workflow read.
"""
- authority_error = _authority_tool_error(ctx.context, "inspect_page_for_composition")
- if authority_error:
- return _diagnosis_repair_tool_error(ctx.context, "inspect_page_for_composition", authority_error)
- admitted, _ = admitted_requested_output_reads(requested_output_reads or [])
- result = await _inspect_page_for_composition_impl(ctx.context, target_url, admitted)
- if requested_output_reads and result.get("ok"):
- data = result.get("data")
- witnessed_paths = _witnessed_output_paths(data)
- verified, unverified = await _verify_requested_output_reads(
- ctx.context, requested_output_reads, witnessed_paths
+ copilot_ctx = ctx.context
+ target_value = target.value
+ arguments: dict[str, Any] = {"target_url": target_url, "target": target_value}
+ if requested_output_reads is not None:
+ arguments["requested_output_reads"] = requested_output_reads
+ binding = resolve_browser_session_binding(copilot_ctx, {"target": target_value})
+
+ def finish(result: dict[str, Any], source_browser_session_id: str | None) -> str:
+ result_data = result.get("data")
+ session_provenance = result_data.get("browser_session_provenance") if isinstance(result_data, dict) else None
+ mixed_session_provenance = isinstance(session_provenance, dict) and session_provenance.get("mixed") is True
+ source_matches_target = (
+ binding.source_matches_target
+ and not mixed_session_provenance
+ and source_browser_session_id is not None
+ and source_browser_session_id == binding.session_id_for(copilot_ctx)
)
- if isinstance(data, dict):
- data["requested_output_designations"] = verified
- if unverified:
- data["unverified_output_designations"] = unverified
- retry_paths = [
- item["output_path"]
- for item in unverified
- if item.get("output_path") and item.get("reason") != SUPERSEDED_BY_VALUE_WITNESS
- ]
- if retry_paths:
- data["requested_output_designation_capability"] = requested_output_designation_capability(
- retry_paths
- )
- elif result.get("ok"):
- requested_paths = requested_output_paths_for_derivation(ctx.context)
- data = result.get("data")
- if requested_paths and isinstance(data, dict):
- data["requested_output_designation_capability"] = requested_output_designation_capability(
- list(requested_paths)
+ stamped = {
+ **result,
+ **binding.provenance(),
+ "source_matches_target": source_matches_target,
+ "source_browser_session_id": source_browser_session_id,
+ }
+ scrubbed = scrub_secrets_from_structure(copilot_ctx, stamped)
+ model_result = _model_facing_inspect_result(scrubbed)
+ record_tool_step_result_for_ctx(copilot_ctx, "inspect_page_for_composition", arguments, model_result)
+ return json.dumps(model_result)
+
+ if binding.unavailable_reason:
+ return finish(
+ {"ok": False, "data": None, "error": binding.unavailable_reason},
+ None,
+ )
+
+ with bound_call_browser_session(binding.session_id_override):
+ authority_error = _authority_tool_error(copilot_ctx, "inspect_page_for_composition")
+ if authority_error:
+ authority_result = json.loads(
+ _diagnosis_repair_tool_error(copilot_ctx, "inspect_page_for_composition", authority_error)
+ )
+ return finish(
+ authority_result,
+ None,
+ )
+ admitted, _ = admitted_requested_output_reads(requested_output_reads or [])
+ result = await _inspect_page_for_composition_impl(copilot_ctx, target_url, admitted)
+ if requested_output_reads and result.get("ok"):
+ data = result.get("data")
+ witnessed_paths = _witnessed_output_paths(data)
+ verified, unverified = await _verify_requested_output_reads(
+ copilot_ctx, requested_output_reads, witnessed_paths
)
- scrubbed_result = scrub_secrets_from_structure(ctx.context, result)
- return json.dumps(_model_facing_inspect_result(scrubbed_result))
+ if isinstance(data, dict):
+ data["requested_output_designations"] = verified
+ if unverified:
+ data["unverified_output_designations"] = unverified
+ retry_paths = [
+ item["output_path"]
+ for item in unverified
+ if item.get("output_path") and item.get("reason") != SUPERSEDED_BY_VALUE_WITNESS
+ ]
+ if retry_paths:
+ data["requested_output_designation_capability"] = requested_output_designation_capability(
+ retry_paths
+ )
+ elif result.get("ok"):
+ requested_paths = requested_output_paths_for_derivation(copilot_ctx)
+ data = result.get("data")
+ if requested_paths and isinstance(data, dict):
+ data["requested_output_designation_capability"] = requested_output_designation_capability(
+ list(requested_paths)
+ )
+ data = result.get("data")
+ source_browser_session_id = (
+ data.get("source_browser_session_id")
+ if isinstance(data, dict) and "source_browser_session_id" in data
+ else None
+ )
+ if not isinstance(source_browser_session_id, str):
+ source_browser_session_id = None
+ return finish(result, source_browser_session_id)
@function_tool(name_override="fill_credential_field", strict_mode=False)
diff --git a/skyvern/forge/sdk/copilot/tools/composition_capture.py b/skyvern/forge/sdk/copilot/tools/composition_capture.py
index 818463bb3..e5533b985 100644
--- a/skyvern/forge/sdk/copilot/tools/composition_capture.py
+++ b/skyvern/forge/sdk/copilot/tools/composition_capture.py
@@ -37,15 +37,16 @@ from skyvern.forge.sdk.copilot.context import CopilotContext
from skyvern.forge.sdk.copilot.diagnosis_repair_contract import author_time_levers
from skyvern.forge.sdk.copilot.enforcement import _RECENT_TOOL_OUTPUT_CHAR_CAP, _requested_output_labels_by_path
from skyvern.forge.sdk.copilot.llm_config import resolve_fast_copilot_handler
-from skyvern.forge.sdk.copilot.loop_detection import record_tool_step_result_for_ctx
from skyvern.forge.sdk.copilot.output_extraction_plan import _exact_path, _value_witness_bindings
from skyvern.forge.sdk.copilot.runtime import (
SENSITIVE_ORIGIN_ACTIVE_RUN_PAGE_ERROR,
SENSITIVE_ORIGIN_PAGE_ERROR,
AgentContext,
+ bound_call_browser_session,
browser_evidence_commit_lock,
browser_page_custody_lock,
clear_sensitive_origin_page_taint,
+ effective_browser_session_id,
sensitive_origin_page_facts_withheld,
sensitive_origin_page_has_active_run,
)
@@ -358,7 +359,7 @@ async def _composition_capture_visual_summary(
) -> VisualSummaryCapture:
capture_started_at = time.monotonic()
capture_url = evidence.get("current_url") or evidence.get("inspected_url")
- capture_session_id = getattr(ctx, "browser_session_id", None)
+ capture_session_id = effective_browser_session_id(ctx)
screenshot_result = await _composition_get_screenshot(ctx, dispatch_session_id=capture_session_id)
if not screenshot_result.get("ok"):
return VisualSummaryCapture(
@@ -886,9 +887,12 @@ async def _capture_composition_evidence(
requested_reads: tuple[AdmittedOutputRead, ...] = (),
) -> CompositionEvidenceCapture:
"""Capture page evidence, using HTML only to enrich a valid but unsettled structured packet."""
- capture_session_id = copilot_ctx.browser_session_id if isinstance(copilot_ctx, AgentContext) else None
+ capture_session_id = effective_browser_session_id(copilot_ctx) if isinstance(copilot_ctx, AgentContext) else None
+ capture_tracks_debug_session = (
+ isinstance(copilot_ctx, AgentContext) and capture_session_id == copilot_ctx.browser_session_id
+ )
capture_session_generation = (
- copilot_ctx.browser_session_continuity_generation if isinstance(copilot_ctx, AgentContext) else None
+ copilot_ctx.browser_session_continuity_generation if capture_tracks_debug_session else None
)
requested_targets = _seeded_capture_targets(copilot_ctx, requested_reads)
owned_labels = _seeded_label_owners(copilot_ctx, requested_reads)
@@ -977,15 +981,18 @@ async def _capture_composition_evidence(
isinstance(copilot_ctx, AgentContext)
and evidence is not None
and (
- copilot_ctx.browser_session_id != capture_session_id
- or copilot_ctx.browser_session_continuity_generation != capture_session_generation
+ effective_browser_session_id(copilot_ctx) != capture_session_id
+ or (
+ capture_session_generation is not None
+ and copilot_ctx.browser_session_continuity_generation != capture_session_generation
+ )
)
):
evidence = _composition_add_inspection_warning(evidence, "mixed_browser_session_provenance")
evidence["browser_session_provenance"] = {
"mixed": True,
"start_browser_session_id": capture_session_id,
- "end_browser_session_id": copilot_ctx.browser_session_id,
+ "end_browser_session_id": effective_browser_session_id(copilot_ctx),
"start_generation": capture_session_generation,
"end_generation": copilot_ctx.browser_session_continuity_generation,
}
@@ -998,48 +1005,30 @@ async def _read_run_session_page_evidence(
run_session_id: str,
current_url: str,
) -> tuple[dict[str, Any] | None, str | None, str | None, CapturedFrame | None]:
- """The discovery extractor reads ctx.browser_session_id per call, so the rebind targets the run
- session and is restored in a finally. The browser layer can substitute a replacement session for a
- closed one, so the id the capture actually observed is read back before the restore."""
- prior_session_id = ctx.browser_session_id
- ctx.browser_session_id = run_session_id
+ """Capture automatic post-run evidence under the run's call-local browser binding."""
observed_session_id: str | None = run_session_id
observation_error: str | None = None
evidence: dict[str, Any] | None = None
frame: CapturedFrame | None = None
- try:
- capture = await asyncio.wait_for(
- _capture_composition_evidence(ctx, inspected_url=current_url, current_url=current_url),
- timeout=_POST_RUN_REPAIR_CAPTURE_TIMEOUT_SECONDS,
- )
- evidence, observation_error, frame = _capture_result_parts(capture)
- except Exception:
- LOG.debug("Post-run run-session page capture failed", exc_info=True)
- observation_error = observation_error or "Post-run page capture against the run session failed."
- evidence = None
- finally:
- # Read before the restore, which is the only point where the substituted id is still visible.
- observed_session_id = ctx.browser_session_id
- ctx.browser_session_id = prior_session_id
+ with bound_call_browser_session(run_session_id):
+ try:
+ capture = await asyncio.wait_for(
+ _capture_composition_evidence(ctx, inspected_url=current_url, current_url=current_url),
+ timeout=_POST_RUN_REPAIR_CAPTURE_TIMEOUT_SECONDS,
+ )
+ evidence, observation_error, frame = _capture_result_parts(capture)
+ except Exception:
+ LOG.debug("Post-run run-session page capture failed", exc_info=True)
+ observation_error = observation_error or "Post-run page capture against the run session failed."
+ evidence = None
if not observed_session_id:
- # A mid-capture session create that fails clears the id, and an unknown source id grants
- # post-run identity, so an unprovable source has to drop the packet rather than launder it.
+ # An unknown source id grants post-run identity, so an unprovable source drops the packet
+ # rather than laundering it.
return None, None, observation_error or "Post-run page capture lost its browser session.", None
return (evidence if isinstance(evidence, dict) else None), observed_session_id, observation_error, frame
-def _post_run_page_source_session_id(ctx: CopilotContext, run_id: str | None) -> str | None:
- """The run's own browser session, when a current-page look lands after a run that executed in a
- different browser than the scout one."""
- if not run_id:
- return None
- run_session_id = ctx.last_run_blocks_browser_session_id
- if not run_session_id or run_session_id == ctx.browser_session_id:
- return None
- return run_session_id
-
-
def _preserves_existing_post_run_page_evidence(
copilot_ctx: CopilotContext,
stamped: dict[str, Any],
@@ -1208,19 +1197,17 @@ async def _inspect_page_for_composition_under_custody(
from `discover_workflow_entrypoint`: discovery answers "which page?";
inspection answers "what fields and controls are actually on this page?".
"""
- arguments = {"target_url": target_url}
authority_error = _authority_tool_error(copilot_ctx, "inspect_page_for_composition")
if authority_error:
- result = {"ok": False, "error": authority_error}
- record_tool_step_result_for_ctx(copilot_ctx, "inspect_page_for_composition", arguments, result)
- return result
+ return {"ok": False, "error": authority_error}
if sensitive_origin_page_has_active_run(copilot_ctx):
- result = {"ok": False, "data": None, "error": SENSITIVE_ORIGIN_ACTIVE_RUN_PAGE_ERROR}
- record_tool_step_result_for_ctx(copilot_ctx, "inspect_page_for_composition", arguments, result)
- return result
- capture_session_id = copilot_ctx.browser_session_id if isinstance(copilot_ctx, AgentContext) else None
+ return {"ok": False, "data": None, "error": SENSITIVE_ORIGIN_ACTIVE_RUN_PAGE_ERROR}
+ capture_session_id = effective_browser_session_id(copilot_ctx) if isinstance(copilot_ctx, AgentContext) else None
+ capture_tracks_debug_session = (
+ isinstance(copilot_ctx, AgentContext) and capture_session_id == copilot_ctx.browser_session_id
+ )
capture_session_generation = (
- copilot_ctx.browser_session_continuity_generation if isinstance(copilot_ctx, AgentContext) else None
+ copilot_ctx.browser_session_continuity_generation if capture_tracks_debug_session else None
)
use_current_page = (target_url or "").strip().lower() in _CURRENT_PAGE_INSPECTION_TARGETS
@@ -1235,27 +1222,21 @@ async def _inspect_page_for_composition_under_custody(
entry_url: str
kind: str
- run_page_source_session_id: str | None = None
- observed_run_session_id: str | None = None
if use_current_page:
- run_page_source_session_id = _post_run_page_source_session_id(copilot_ctx, run_id)
- current_url, _ = await _fallback_page_info(copilot_ctx, run_page_source_session_id)
+ current_url, _ = await _fallback_page_info(copilot_ctx)
entry_url = current_url or "current_page"
kind = "current_page"
else:
resolved_entry_url, kind = _resolve_discovery_entry_url(target_url)
if resolved_entry_url is None:
- result = {
+ return {
"ok": False,
"data": None,
"error": "inspect_page_for_composition requires a URL, domain with an explicit path, or target_url='current_page'.",
}
- record_tool_step_result_for_ctx(copilot_ctx, "inspect_page_for_composition", arguments, result)
- return result
entry_url = resolved_entry_url
regression_error = _non_current_inspection_regression_error(copilot_ctx, entry_url=entry_url)
if regression_error is not None:
- record_tool_step_result_for_ctx(copilot_ctx, "inspect_page_for_composition", arguments, regression_error)
return regression_error
# Skip re-navigation when the inspect target is the page the browser is already on. A
@@ -1288,23 +1269,13 @@ async def _inspect_page_for_composition_under_custody(
if on_target_page:
# current_page, or a URL target the agent is already on — capture without navigating.
current_url = inspect_target_url or entry_url
- if run_page_source_session_id:
- (
- evidence,
- observed_run_session_id,
- observation_error,
- visual_fallback_frame,
- ) = await _read_run_session_page_evidence(
- copilot_ctx, run_session_id=run_page_source_session_id, current_url=current_url
- )
- else:
- capture = await _capture_composition_evidence(
- copilot_ctx,
- inspected_url=entry_url,
- current_url=current_url,
- requested_reads=requested_reads,
- )
- evidence, observation_error, visual_fallback_frame = _capture_result_parts(capture)
+ capture = await _capture_composition_evidence(
+ copilot_ctx,
+ inspected_url=entry_url,
+ current_url=current_url,
+ requested_reads=requested_reads,
+ )
+ evidence, observation_error, visual_fallback_frame = _capture_result_parts(capture)
else:
nav_result = await _discovery_navigate(
copilot_ctx,
@@ -1317,13 +1288,11 @@ async def _inspect_page_for_composition_under_custody(
if sensitive_same_turn_run:
# Navigation failure may leave the browser on the sensitive origin page.
# Do not inspect that page through the ordinary failure fallback.
- result = {
+ return {
"ok": False,
"data": None,
"error": f"inspect_page_for_composition could not navigate: {nav_error}",
}
- record_tool_step_result_for_ctx(copilot_ctx, "inspect_page_for_composition", arguments, result)
- return result
failure_capture = await _composition_evidence_after_navigation_failure(
copilot_ctx,
inspected_url=entry_url,
@@ -1331,13 +1300,11 @@ async def _inspect_page_for_composition_under_custody(
requested_reads=requested_reads,
)
if failure_capture is None:
- result = {
+ return {
"ok": False,
"data": None,
"error": f"inspect_page_for_composition could not navigate: {nav_error}",
}
- record_tool_step_result_for_ctx(copilot_ctx, "inspect_page_for_composition", arguments, result)
- return result
evidence, visual_fallback_frame = failure_capture
current_url = str(evidence.get("current_url") or entry_url)
else:
@@ -1352,44 +1319,41 @@ async def _inspect_page_for_composition_under_custody(
evidence, observation_error, visual_fallback_frame = _capture_result_parts(capture)
if sensitive_origin_page_facts_withheld(copilot_ctx, run_id):
- result = {"ok": False, "data": None, "error": SENSITIVE_ORIGIN_PAGE_ERROR}
- record_tool_step_result_for_ctx(copilot_ctx, "inspect_page_for_composition", arguments, result)
- return result
+ return {"ok": False, "data": None, "error": SENSITIVE_ORIGIN_PAGE_ERROR}
if (
isinstance(copilot_ctx, AgentContext)
and evidence is not None
and (
- copilot_ctx.browser_session_id != capture_session_id
- or copilot_ctx.browser_session_continuity_generation != capture_session_generation
+ effective_browser_session_id(copilot_ctx) != capture_session_id
+ or (
+ capture_session_generation is not None
+ and copilot_ctx.browser_session_continuity_generation != capture_session_generation
+ )
)
):
evidence = _composition_add_inspection_warning(evidence, "mixed_browser_session_provenance")
evidence["browser_session_provenance"] = {
"mixed": True,
"start_browser_session_id": capture_session_id,
- "end_browser_session_id": copilot_ctx.browser_session_id,
+ "end_browser_session_id": effective_browser_session_id(copilot_ctx),
"start_generation": capture_session_generation,
"end_generation": copilot_ctx.browser_session_continuity_generation,
}
if observation_error is not None:
- result = {
+ return {
"ok": False,
"data": None,
"error": f"inspect_page_for_composition could not capture page evidence: {observation_error}",
}
- record_tool_step_result_for_ctx(copilot_ctx, "inspect_page_for_composition", arguments, result)
- return result
if evidence is None:
- result = {
+ return {
"ok": False,
"data": None,
"error": "inspect_page_for_composition could not capture page evidence.",
}
- record_tool_step_result_for_ctx(copilot_ctx, "inspect_page_for_composition", arguments, result)
- return result
if sensitive_same_turn_run:
evidence = scrub_secrets_from_structure(copilot_ctx, evidence)
@@ -1399,10 +1363,13 @@ async def _inspect_page_for_composition_under_custody(
if isinstance(run_id, str) and run_id:
session_provenance = evidence.get("browser_session_provenance")
mixed_session_provenance = isinstance(session_provenance, dict) and session_provenance.get("mixed") is True
+ mixed_end_session_id = (
+ session_provenance.get("end_browser_session_id")
+ if isinstance(session_provenance, dict) and mixed_session_provenance
+ else None
+ )
source_browser_session_id = (
- None
- if mixed_session_provenance
- else (observed_run_session_id if run_page_source_session_id else copilot_ctx.browser_session_id)
+ mixed_end_session_id if isinstance(mixed_end_session_id, str) else effective_browser_session_id(copilot_ctx)
)
evidence, preserved_stored_evidence = store_post_run_page_evidence(
copilot_ctx,
@@ -1425,6 +1392,23 @@ async def _inspect_page_for_composition_under_custody(
source_browser_session_id=source_browser_session_id,
)
else:
+ session_provenance = evidence.get("browser_session_provenance")
+ mixed_session_provenance = isinstance(session_provenance, dict) and session_provenance.get("mixed") is True
+ mixed_end_session_id = (
+ session_provenance.get("end_browser_session_id")
+ if isinstance(session_provenance, dict) and mixed_session_provenance
+ else None
+ )
+ evidence = stamp_page_evidence_provenance(
+ evidence,
+ source_browser_session_id=(
+ mixed_end_session_id
+ if isinstance(mixed_end_session_id, str)
+ else effective_browser_session_id(copilot_ctx)
+ ),
+ run_id=None,
+ run_browser_session_id=None,
+ )
copilot_ctx.composition_page_evidence = evidence
_attach_author_time_levers(copilot_ctx, evidence)
@@ -1453,7 +1437,11 @@ async def _inspect_page_for_composition_under_custody(
evidence,
url=str(evidence.get("current_url") or current_url or ""),
capture_session_id=capture_session_id,
- run_page_source_session_id=run_page_source_session_id,
+ run_page_source_session_id=(
+ capture_session_id
+ if isinstance(copilot_ctx, AgentContext) and capture_session_id != copilot_ctx.browser_session_id
+ else None
+ ),
)
# Surface the reached page at the top level so the model registers that the
# inspection already navigated there and does not re-issue navigate_browser.
@@ -1468,7 +1456,6 @@ async def _inspect_page_for_composition_under_custody(
if observation_step is not None:
result["observation_step"] = observation_step
result = _model_facing_inspect_result(result)
- record_tool_step_result_for_ctx(copilot_ctx, "inspect_page_for_composition", arguments, result)
if visual_fallback_frame is not None:
workflow_run_id = evidence.get("workflow_run_id")
enqueue_screenshot(
diff --git a/skyvern/forge/sdk/routes/streaming/channels/exfiltration.py b/skyvern/forge/sdk/routes/streaming/channels/exfiltration.py
index 847021a8f..365a6d4d8 100644
--- a/skyvern/forge/sdk/routes/streaming/channels/exfiltration.py
+++ b/skyvern/forge/sdk/routes/streaming/channels/exfiltration.py
@@ -88,6 +88,7 @@ class ExfiltrationChannel(CdpChannel):
_DISCARD_QUEUE_JS: t.ClassVar[str] = (
"() => { const q = window.__skyvern_exfil_queue; if (Array.isArray(q)) q.length = 0; }"
)
+ _DECORATION_PRESENT_JS: t.ClassVar[str] = '() => document.getElementById("__skyvern_mouse_follower") !== null'
_active_binding_channels: t.ClassVar[weakref.WeakKeyDictionary[Page, "ExfiltrationChannel"]] = (
weakref.WeakKeyDictionary()
)
@@ -104,6 +105,8 @@ class ExfiltrationChannel(CdpChannel):
self._pending_event_tasks: set[asyncio.Task[None]] = set()
self._refresh_task: asyncio.Task | None = None
self._drain_task: asyncio.Task | None = None
+ self._decoration_init_script_pages: weakref.WeakSet[Page] = weakref.WeakSet()
+ self._decoration_page_locks: weakref.WeakKeyDictionary[Page, asyncio.Lock] = weakref.WeakKeyDictionary()
self._pending_nav_tasks: weakref.WeakKeyDictionary[Page, asyncio.Task] = weakref.WeakKeyDictionary()
self._network_activity_count = 0
self._last_network_activity_emit = 0.0
@@ -336,6 +339,14 @@ class ExfiltrationChannel(CdpChannel):
url=page.url,
exc_info=True,
)
+ try:
+ await self.decorate(page)
+ except Exception:
+ LOG.debug(
+ f"{self.class_name} failed to refresh decoration on page",
+ url=page.url,
+ exc_info=True,
+ )
async def _drain_page_queue(self, page: Page) -> None:
if page.url.startswith("devtools:"):
@@ -632,12 +643,21 @@ class ExfiltrationChannel(CdpChannel):
if page.url.startswith("devtools:"):
return self
- LOG.info(f"{self.class_name} adding decoration to page.", url=page.url, **self.identity)
-
- await page.add_init_script(self.js("decorate"))
- await page.evaluate(self.js("decorate"))
-
- LOG.info(f"{self.class_name} decoration setup complete on page.", url=page.url, **self.identity)
+ lock = self._decoration_page_locks.get(page)
+ if lock is None:
+ lock = asyncio.Lock()
+ self._decoration_page_locks[page] = lock
+
+ async with lock:
+ decorate_script = self.js("decorate")
+ if page not in self._decoration_init_script_pages:
+ LOG.info(f"{self.class_name} adding decoration to page.", url=page.url, **self.identity)
+ await page.add_init_script(decorate_script)
+ self._decoration_init_script_pages.add(page)
+ await page.evaluate(decorate_script)
+ LOG.info(f"{self.class_name} decoration setup complete on page.", url=page.url, **self.identity)
+ elif not await page.evaluate(self._DECORATION_PRESENT_JS):
+ await page.evaluate(decorate_script)
return self
diff --git a/tests/unit/forge/sdk/routes/streaming/test_exfiltration_channel.py b/tests/unit/forge/sdk/routes/streaming/test_exfiltration_channel.py
index b5c2610f2..6855f07cd 100644
--- a/tests/unit/forge/sdk/routes/streaming/test_exfiltration_channel.py
+++ b/tests/unit/forge/sdk/routes/streaming/test_exfiltration_channel.py
@@ -13,12 +13,14 @@ from unittest.mock import AsyncMock, MagicMock
import pytest
from playwright._impl._errors import TargetClosedError
+import skyvern.forge.sdk.routes.streaming.channels.exfiltration as exfiltration_module
from skyvern.forge.sdk.routes.streaming.channels.exfiltration import (
ExfiltratedEventSource,
ExfiltrationChannel,
PageConsoleCapture,
)
from skyvern.forge.sdk.routes.streaming.channels.message import MessageChannelContext
+from tests.unit.scoped_asyncio import ScopedAsyncio
def _make_context() -> MagicMock:
@@ -120,6 +122,8 @@ class TestExfiltrationChannelEvents:
ExfiltrationChannel._active_binding_channels[page] = channel
ExfiltrationChannel._binding_registered_pages.add(page)
channel._page_console_captures[page] = PageConsoleCapture(console_listener=MagicMock())
+ channel._decoration_init_script_pages.add(page)
+ channel._decoration_page_locks[page] = asyncio.Lock()
del page
@@ -127,6 +131,8 @@ class TestExfiltrationChannelEvents:
assert not ExfiltrationChannel._active_binding_channels
assert not ExfiltrationChannel._binding_registered_pages
assert not channel._page_console_captures
+ assert not channel._decoration_init_script_pages
+ assert not channel._decoration_page_locks
@pytest.mark.asyncio
async def test_playwright_console_text_payload_emits_user_interaction(self) -> None:
@@ -351,6 +357,94 @@ class TestExfiltrationChannelEvents:
assert on_event.call_count == 2
+class TestDecorationRefresh:
+ @pytest.mark.asyncio
+ async def test_decoration_refresh_is_quiet_when_follower_exists(self, monkeypatch: pytest.MonkeyPatch) -> None:
+ channel, _ = _make_channel()
+ page = _make_page()
+ log = MagicMock()
+ monkeypatch.setattr(exfiltration_module, "LOG", log)
+
+ await channel.decorate(page)
+ log.info.reset_mock()
+ page.evaluate.reset_mock()
+ page.evaluate.return_value = True
+ await channel.decorate(page)
+
+ page.add_init_script.assert_awaited_once_with(channel.js("decorate"))
+ page.evaluate.assert_awaited_once_with(channel._DECORATION_PRESENT_JS)
+ log.info.assert_not_called()
+
+ @pytest.mark.asyncio
+ async def test_decoration_refresh_repairs_missing_follower_without_duplicate_init_scripts(self) -> None:
+ channel, _ = _make_channel()
+ page = _make_page()
+ page.evaluate = AsyncMock(side_effect=[None, False, None])
+
+ await channel.decorate(page)
+ await channel.decorate(page)
+
+ page.add_init_script.assert_awaited_once_with(channel.js("decorate"))
+ evaluated = [await_call.args[0] for await_call in page.evaluate.await_args_list]
+ assert evaluated == [channel.js("decorate"), channel._DECORATION_PRESENT_JS, channel.js("decorate")]
+
+ @pytest.mark.asyncio
+ async def test_concurrent_decoration_setup_registers_one_init_script(self) -> None:
+ channel, _ = _make_channel()
+ page = _make_page()
+ add_started = asyncio.Event()
+ release_add = asyncio.Event()
+
+ async def add_init_script(_script: str) -> None:
+ add_started.set()
+ await release_add.wait()
+
+ page.add_init_script = AsyncMock(side_effect=add_init_script)
+ page.evaluate = AsyncMock(return_value=True)
+
+ first = asyncio.create_task(channel.decorate(page))
+ await add_started.wait()
+ second = asyncio.create_task(channel.decorate(page))
+ await asyncio.sleep(0)
+ release_add.set()
+ await asyncio.gather(first, second)
+
+ page.add_init_script.assert_awaited_once_with(channel.js("decorate"))
+
+ @pytest.mark.asyncio
+ async def test_decoration_setup_is_retried_after_navigation_race(self) -> None:
+ channel, _ = _make_channel()
+ page = _make_page()
+ page.add_init_script = AsyncMock(side_effect=[RuntimeError("navigation interrupted setup"), None])
+
+ with pytest.raises(RuntimeError, match="navigation interrupted setup"):
+ await channel.decorate(page)
+ await channel.decorate(page)
+
+ assert page.add_init_script.await_count == 2
+ page.evaluate.assert_awaited_once_with(channel.js("decorate"))
+
+ @pytest.mark.asyncio
+ async def test_refresh_repairs_decoration_when_exfiltration_refresh_fails(
+ self, monkeypatch: pytest.MonkeyPatch
+ ) -> None:
+ channel, _ = _make_channel()
+ page = _make_page()
+ browser_context = MagicMock()
+ browser_context.pages = [page]
+ channel.browser_context = browser_context
+ channel.exfiltrate = AsyncMock(side_effect=RuntimeError("navigation interrupted exfiltration"))
+ sleep = AsyncMock(side_effect=[None, asyncio.CancelledError])
+ monkeypatch.setattr(exfiltration_module, "asyncio", ScopedAsyncio(sleep=sleep))
+
+ with pytest.raises(asyncio.CancelledError):
+ await channel._refresh_exfiltration_loop()
+
+ channel.exfiltrate.assert_awaited_once_with(page)
+ page.add_init_script.assert_awaited_once_with(channel.js("decorate"))
+ page.evaluate.assert_awaited_once_with(channel.js("decorate"))
+
+
def _make_stamped_event_data(seq: int = 0, doc_id: str = "doc-a") -> dict[str, object]:
return {**_make_event_data(), "exfilDocId": doc_id, "exfilSeq": seq}
diff --git a/tests/unit/test_copilot_agent_helpers.py b/tests/unit/test_copilot_agent_helpers.py
index 8af566cb0..23525bf79 100644
--- a/tests/unit/test_copilot_agent_helpers.py
+++ b/tests/unit/test_copilot_agent_helpers.py
@@ -7314,7 +7314,7 @@ class TestToolFactOwnership:
("select_option", "For free-text inputs"),
("press_key", "Escape"),
("console_messages", "read-only"),
- ("inspect_page_for_composition", "navigates the live browser there"),
+ ("inspect_page_for_composition", "navigates the targeted browser there"),
("get_block_schema", "task_v2"),
("evaluate", "record a scouted interaction"),
("inspect_page_for_composition", "bounded read of known or current page state"),
diff --git a/tests/unit/test_copilot_composition_browser_target.py b/tests/unit/test_copilot_composition_browser_target.py
new file mode 100644
index 000000000..5c49d0af3
--- /dev/null
+++ b/tests/unit/test_copilot_composition_browser_target.py
@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from types import SimpleNamespace
+from unittest.mock import AsyncMock
+
+import pytest
+
+from skyvern.forge.sdk.copilot.runtime import effective_browser_session_id
+from skyvern.forge.sdk.copilot.tools import inspect_page_for_composition_tool
+from tests.unit.copilot_test_helpers import make_copilot_ctx
+
+
+def test_composition_inspection_schema_exposes_typed_browser_target_default() -> None:
+ schema = inspect_page_for_composition_tool.params_json_schema
+
+ target = schema["properties"]["target"]
+ if "$ref" in target:
+ target = schema["$defs"][target["$ref"].rsplit("/", 1)[-1]]
+ assert target["enum"] == ["debug", "last_run"]
+ assert schema["properties"]["target"]["default"] == "debug"
+
+
+async def test_composition_inspection_binds_default_and_last_run_through_final_recording(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ ctx = make_copilot_ctx(browser_session_id="pbs_debug")
+ ctx.last_run_blocks_browser_session_id = "pbs_run"
+ ctx.last_run_blocks_workflow_run_id = "wr_run"
+ ctx.recorded_build_test_outcome_history = [{"workflow_run_id": "wr_run", "status": "failed"}]
+ recorded_outcome_history = list(ctx.recorded_build_test_outcome_history)
+ observed: list[str | None] = []
+ recorded: list[tuple[dict[str, object], dict[str, object]]] = []
+
+ async def inspect(inner_ctx: object, _target_url: str, _reads: tuple[object, ...]) -> dict[str, object]:
+ observed.append(effective_browser_session_id(inner_ctx)) # type: ignore[arg-type]
+ return {"ok": True, "data": {"source_browser_session_id": observed[-1]}}
+
+ monkeypatch.setattr("skyvern.forge.sdk.copilot.tools._authority_tool_error", lambda *_args: None)
+ monkeypatch.setattr("skyvern.forge.sdk.copilot.tools._inspect_page_for_composition_impl", inspect)
+ monkeypatch.setattr(
+ "skyvern.forge.sdk.copilot.tools.record_tool_step_result_for_ctx",
+ lambda _ctx, _name, arguments, result: recorded.append((arguments, result)),
+ )
+
+ answers = []
+ for arguments in ({"target_url": "current_page"}, {"target_url": "current_page", "target": "last_run"}):
+ raw = await inspect_page_for_composition_tool.on_invoke_tool(
+ SimpleNamespace(context=ctx, tool_name="inspect_page_for_composition"), json.dumps(arguments)
+ )
+ answers.append(json.loads(raw))
+
+ assert observed == ["pbs_debug", "pbs_run"]
+ assert [answer["browser_target"] for answer in answers] == ["debug", "last_run"]
+ assert answers[1]["browser_target_workflow_run_id"] == "wr_run"
+ assert [entry[0]["target"] for entry in recorded] == ["debug", "last_run"]
+ assert [entry[1] for entry in recorded] == answers
+ assert ctx.browser_session_id == "pbs_debug"
+ assert ctx.recorded_build_test_outcome_history == recorded_outcome_history
+
+
+async def test_missing_last_run_is_recorded_unavailable_without_dispatch(monkeypatch: pytest.MonkeyPatch) -> None:
+ ctx = make_copilot_ctx(browser_session_id="pbs_debug")
+ ctx.last_run_blocks_browser_session_id = None
+ inspect = AsyncMock()
+ recorded: list[dict[str, object]] = []
+ monkeypatch.setattr("skyvern.forge.sdk.copilot.tools._authority_tool_error", lambda *_args: None)
+ monkeypatch.setattr("skyvern.forge.sdk.copilot.tools._inspect_page_for_composition_impl", inspect)
+ monkeypatch.setattr(
+ "skyvern.forge.sdk.copilot.tools.record_tool_step_result_for_ctx",
+ lambda _ctx, _name, _arguments, result: recorded.append(result),
+ )
+
+ raw = await inspect_page_for_composition_tool.on_invoke_tool(
+ SimpleNamespace(context=ctx, tool_name="inspect_page_for_composition"),
+ json.dumps({"target_url": "current_page", "target": "last_run"}),
+ )
+ result = json.loads(raw)
+
+ inspect.assert_not_awaited()
+ assert result["ok"] is False
+ assert result["browser_target"] == "last_run"
+ assert result["source_matches_target"] is False
+ assert result["source_browser_session_id"] is None
+ assert recorded == [result]
+
+
+async def test_pre_dispatch_refusal_has_no_claimed_browser_source(monkeypatch: pytest.MonkeyPatch) -> None:
+ ctx = make_copilot_ctx(browser_session_id="pbs_debug")
+ inspect = AsyncMock()
+ recorded: list[dict[str, object]] = []
+ monkeypatch.setattr("skyvern.forge.sdk.copilot.tools._authority_tool_error", lambda *_args: "blocked")
+ monkeypatch.setattr(
+ "skyvern.forge.sdk.copilot.tools._diagnosis_repair_tool_error",
+ lambda *_args: json.dumps({"ok": False, "error": "blocked"}),
+ )
+ monkeypatch.setattr("skyvern.forge.sdk.copilot.tools._inspect_page_for_composition_impl", inspect)
+ monkeypatch.setattr(
+ "skyvern.forge.sdk.copilot.tools.record_tool_step_result_for_ctx",
+ lambda _ctx, _name, _arguments, result: recorded.append(result),
+ )
+
+ raw = await inspect_page_for_composition_tool.on_invoke_tool(
+ SimpleNamespace(context=ctx, tool_name="inspect_page_for_composition"),
+ json.dumps({"target_url": "current_page"}),
+ )
+ result = json.loads(raw)
+
+ inspect.assert_not_awaited()
+ assert result["source_browser_session_id"] is None
+ assert result["source_matches_target"] is False
+ assert recorded == [result]
+
+
+async def test_mixed_inner_provenance_is_not_replaced_with_the_target_session(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ ctx = make_copilot_ctx(browser_session_id="pbs_debug")
+ monkeypatch.setattr("skyvern.forge.sdk.copilot.tools._authority_tool_error", lambda *_args: None)
+ monkeypatch.setattr(
+ "skyvern.forge.sdk.copilot.tools._inspect_page_for_composition_impl",
+ AsyncMock(
+ return_value={
+ "ok": True,
+ "data": {
+ "source_browser_session_id": "pbs_replacement",
+ "browser_session_provenance": {
+ "mixed": True,
+ "start_browser_session_id": "pbs_debug",
+ "end_browser_session_id": "pbs_replacement",
+ },
+ },
+ }
+ ),
+ )
+ monkeypatch.setattr("skyvern.forge.sdk.copilot.tools.record_tool_step_result_for_ctx", lambda *_args: None)
+
+ raw = await inspect_page_for_composition_tool.on_invoke_tool(
+ SimpleNamespace(context=ctx, tool_name="inspect_page_for_composition"),
+ json.dumps({"target_url": "current_page"}),
+ )
+ result = json.loads(raw)
+
+ assert result["source_browser_session_id"] == "pbs_replacement"
+ assert result["source_matches_target"] is False
+
+
+async def test_opposite_composition_targets_are_task_local(monkeypatch: pytest.MonkeyPatch) -> None:
+ ctx = make_copilot_ctx(browser_session_id="pbs_debug")
+ ctx.last_run_blocks_browser_session_id = "pbs_run"
+ ctx.last_run_blocks_workflow_run_id = "wr_run"
+ both_entered = asyncio.Event()
+ entrants = 0
+
+ async def inspect(inner_ctx: object, _target_url: str, _reads: tuple[object, ...]) -> dict[str, object]:
+ nonlocal entrants
+ entrants += 1
+ if entrants == 2:
+ both_entered.set()
+ await asyncio.wait_for(both_entered.wait(), timeout=1)
+ source = effective_browser_session_id(inner_ctx) # type: ignore[arg-type]
+ await asyncio.sleep(0)
+ assert effective_browser_session_id(inner_ctx) == source # type: ignore[arg-type]
+ return {"ok": True, "data": {"source_browser_session_id": source}}
+
+ monkeypatch.setattr("skyvern.forge.sdk.copilot.tools._authority_tool_error", lambda *_args: None)
+ monkeypatch.setattr("skyvern.forge.sdk.copilot.tools._inspect_page_for_composition_impl", inspect)
+ monkeypatch.setattr("skyvern.forge.sdk.copilot.tools.record_tool_step_result_for_ctx", lambda *_args: None)
+
+ async def invoke(target: str) -> dict[str, object]:
+ raw = await inspect_page_for_composition_tool.on_invoke_tool(
+ SimpleNamespace(context=ctx, tool_name="inspect_page_for_composition"),
+ json.dumps({"target_url": "current_page", "target": target}),
+ )
+ return json.loads(raw)
+
+ debug, last_run = await asyncio.gather(invoke("debug"), invoke("last_run"))
+
+ assert debug["data"]["source_browser_session_id"] == "pbs_debug"
+ assert last_run["data"]["source_browser_session_id"] == "pbs_run"
+ assert ctx.browser_session_id == "pbs_debug"
+
+
+async def test_requested_output_probe_remains_inside_target_binding(monkeypatch: pytest.MonkeyPatch) -> None:
+ ctx = make_copilot_ctx(browser_session_id="pbs_debug")
+ ctx.last_run_blocks_browser_session_id = "pbs_run"
+ ctx.last_run_blocks_workflow_run_id = "wr_run"
+ observed: list[str | None] = []
+
+ async def verify(inner_ctx: object, *_args: object) -> tuple[list[dict[str, object]], list[dict[str, object]]]:
+ observed.append(effective_browser_session_id(inner_ctx)) # type: ignore[arg-type]
+ return [], []
+
+ monkeypatch.setattr("skyvern.forge.sdk.copilot.tools._authority_tool_error", lambda *_args: None)
+ monkeypatch.setattr(
+ "skyvern.forge.sdk.copilot.tools._inspect_page_for_composition_impl",
+ AsyncMock(return_value={"ok": True, "data": {}}),
+ )
+ monkeypatch.setattr("skyvern.forge.sdk.copilot.tools._verify_requested_output_reads", verify)
+ monkeypatch.setattr("skyvern.forge.sdk.copilot.tools.record_tool_step_result_for_ctx", lambda *_args: None)
+
+ await inspect_page_for_composition_tool.on_invoke_tool(
+ SimpleNamespace(context=ctx, tool_name="inspect_page_for_composition"),
+ json.dumps(
+ {
+ "target_url": "current_page",
+ "target": "last_run",
+ "requested_output_reads": [{"output_path": "value", "value_text": "7", "label": "Value"}],
+ }
+ ),
+ )
+
+ assert observed == ["pbs_run"]
diff --git a/tests/unit/test_copilot_composition_evidence.py b/tests/unit/test_copilot_composition_evidence.py
index c8c406cad..bfe0aa26c 100644
--- a/tests/unit/test_copilot_composition_evidence.py
+++ b/tests/unit/test_copilot_composition_evidence.py
@@ -5171,7 +5171,7 @@ async def test_capture_retains_rendered_disclosure_facts_on_a_standalone_control
</body></html>
"""
server = _RecordingCompositionServer(structured_json=rendered, html=html, reject_html=True)
- ctx = SimpleNamespace(discovery_mcp_server=server)
+ ctx = SimpleNamespace(discovery_mcp_server=server, browser_session_id=None)
evidence, error = await tools_module._capture_composition_evidence(
ctx,
@@ -5253,7 +5253,7 @@ async def test_capture_prefers_html_parse_over_hollow_structured_on_fallback(mon
)
html = "<html><head><title>Notice</title></head><body><p>Welcome notice text</p></body></html>"
server = _RecordingCompositionServer(structured_json=hollow, html=html)
- ctx = SimpleNamespace(discovery_mcp_server=server)
+ ctx = SimpleNamespace(discovery_mcp_server=server, browser_session_id=None)
evidence, error = await tools_module._capture_composition_evidence(
ctx, inspected_url="https://example.com/p", current_url="https://example.com/p"
diff --git a/tests/unit/test_copilot_composition_scrape.py b/tests/unit/test_copilot_composition_scrape.py
index b811f9eea..02d294b97 100644
--- a/tests/unit/test_copilot_composition_scrape.py
+++ b/tests/unit/test_copilot_composition_scrape.py
@@ -202,7 +202,7 @@ async def test_late_structured_error_retains_valid_hollow_packet(monkeypatch: py
monkeypatch.setattr(tools.composition_capture, "asyncio", ScopedAsyncio(sleep=AsyncMock()))
evidence, error = await tools._capture_composition_evidence(
- SimpleNamespace(),
+ SimpleNamespace(browser_session_id=None),
inspected_url="https://example.com/loading",
current_url="https://example.com/loading",
)
@@ -268,7 +268,9 @@ async def test_unrendered_challenge_keeps_structured_packet_when_relooks_run_out
monkeypatch.setattr(tools.composition_capture, "asyncio", _AsyncioSleepProxy(settle_sleep))
evidence, html_error = await tools._capture_composition_evidence(
- SimpleNamespace(), inspected_url="https://example.com/login", current_url="https://example.com/login"
+ SimpleNamespace(browser_session_id=None),
+ inspected_url="https://example.com/login",
+ current_url="https://example.com/login",
)
assert html_error is None
@@ -355,7 +357,9 @@ async def test_signalled_packet_survives_extractor_blinking_mid_loop(monkeypatch
monkeypatch.setattr(tools.composition_capture, "asyncio", _AsyncioSleepProxy(AsyncMock()))
evidence, html_error = await tools._capture_composition_evidence(
- SimpleNamespace(), inspected_url="https://example.com/login", current_url="https://example.com/login"
+ SimpleNamespace(browser_session_id=None),
+ inspected_url="https://example.com/login",
+ current_url="https://example.com/login",
)
assert html_error is None
@@ -1085,6 +1089,30 @@ def test_witness_the_capture_cannot_record_leaves_no_witness_in_the_packet(
assert tools._witnessed_output_paths(packet) == frozenset()
+def test_last_run_browser_witness_never_becomes_a_scouted_read(monkeypatch: pytest.MonkeyPatch) -> None:
+ recorded: list[str] = []
+ monkeypatch.setattr(
+ tools.composition_capture,
+ "_record_scouted_read",
+ lambda ctx, *, expression, data, url, declared_output_path=None: recorded.append(expression),
+ )
+ ctx = _requested_tile_ctx()
+ packet = _witness_packet()
+
+ tools.composition_capture._record_value_witnesses(
+ ctx,
+ packet,
+ url="https://example.com/metrics",
+ capture_session_id="pbs_run",
+ run_page_source_session_id="pbs_run",
+ )
+
+ assert recorded == []
+ assert "value_witnesses" not in packet
+ assert "requested_values" not in packet
+ assert tools._witnessed_output_paths(packet) == frozenset()
+
+
def test_a_read_bound_to_another_path_leaves_its_path_to_the_designation_probe(
monkeypatch: pytest.MonkeyPatch,
) -> None:
diff --git a/tests/unit/test_copilot_diagnosis_repair_contract.py b/tests/unit/test_copilot_diagnosis_repair_contract.py
index ede8a1792..4211cb0fa 100644
--- a/tests/unit/test_copilot_diagnosis_repair_contract.py
+++ b/tests/unit/test_copilot_diagnosis_repair_contract.py
@@ -54,7 +54,11 @@ from skyvern.forge.sdk.copilot.request_policy import RequestPolicy
from skyvern.forge.sdk.copilot.run_outcome import (
RecordedRunOutcome,
)
-from skyvern.forge.sdk.copilot.runtime import OriginRunRedactionRegistry
+from skyvern.forge.sdk.copilot.runtime import (
+ OriginRunRedactionRegistry,
+ bound_call_browser_session,
+ effective_browser_session_id,
+)
from skyvern.forge.sdk.copilot.runtime_authoring_repair import (
OBSTRUCTION_SUMMARY_MAX_CHARS,
finalize_runtime_authoring_repair_context_from_page_observation,
@@ -2917,19 +2921,11 @@ async def _drive_inspect_page(
*,
captured: dict[str, object] | None,
target_url: str = "current_page",
- capture_lands_on_session: str | None = None,
- capture_clears_session: bool = False,
- capture_raises: bool = False,
+ browser_session_id: str | None = None,
) -> dict[str, object]:
async def fake_capture(
inner_ctx: CopilotContext, *, inspected_url: str, current_url: str, **_kwargs: object
) -> tuple[dict[str, object] | None, None]:
- if capture_clears_session:
- inner_ctx.browser_session_id = None
- elif capture_lands_on_session is not None:
- inner_ctx.browser_session_id = capture_lands_on_session
- if capture_raises:
- raise TimeoutError("capture timed out after the session was substituted")
return (dict(captured) if captured is not None else None), None
async def fake_page_info(inner_ctx: CopilotContext, session_id_override: str | None = None) -> tuple[str, str]:
@@ -2937,7 +2933,29 @@ async def _drive_inspect_page(
monkeypatch.setattr(composition_capture_module, "_capture_composition_evidence", fake_capture)
monkeypatch.setattr(composition_capture_module, "_fallback_page_info", fake_page_info)
- return await composition_capture_module._inspect_page_for_composition_impl(ctx, target_url)
+ with bound_call_browser_session(browser_session_id):
+ return await composition_capture_module._inspect_page_for_composition_impl(ctx, target_url)
+
+
+async def test_post_run_current_page_inspect_without_a_target_stays_on_the_scout_browser(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """A current-page look after a run reads the browser this chat drives, not the run's.
+
+ Nothing binds this call, so only the tool's own default decides. Reading the run's browser
+ here is the SKY-15909 defect: the user is shown another browser's page as their own.
+ """
+ ctx = _post_run_inspect_ctx()
+
+ result = await _drive_inspect_page(monkeypatch, ctx, captured=_bounded_failure_page_evidence())
+
+ assert result["ok"] is True
+ stored = ctx.composition_page_evidence
+ assert isinstance(stored, dict)
+ assert stored["source_browser_session_id"] == "scout_session"
+ assert stored["observed_after_workflow_run"] is False
+ assert "workflow_run_id" not in stored
@pytest.mark.asyncio
@@ -2947,7 +2965,12 @@ async def test_post_run_current_page_inspect_is_sourced_from_the_run_session(
ctx = _post_run_inspect_ctx()
with capture_logs() as logs:
- result = await _drive_inspect_page(monkeypatch, ctx, captured=_bounded_failure_page_evidence())
+ result = await _drive_inspect_page(
+ monkeypatch,
+ ctx,
+ captured=_bounded_failure_page_evidence(),
+ browser_session_id="run_session",
+ )
assert result["ok"] is True
stored = ctx.composition_page_evidence
@@ -2981,7 +3004,7 @@ async def test_sensitive_current_page_inspect_redacts_registry_values_and_keeps_
evidence = _bounded_failure_page_evidence()
evidence["forms"] = [{"fields": [{"label": "Verification code", "selector": "#totp", "value": "654321"}]}]
- result = await _drive_inspect_page(monkeypatch, ctx, captured=evidence)
+ result = await _drive_inspect_page(monkeypatch, ctx, captured=evidence, browser_session_id="run_session")
assert result["ok"] is True
assert result["data"]["forms"][0]["fields"][0]["label"] == "Verification code"
@@ -3007,63 +3030,74 @@ async def test_sensitive_current_page_inspect_stays_withheld_while_origin_run_is
ctx.sensitive_origin_browser_session_ids = {"run_session"}
ctx.active_sensitive_origin_browser_session_ids = {"run_session"}
- result = await _drive_inspect_page(monkeypatch, ctx, captured=_bounded_failure_page_evidence())
+ result = await _drive_inspect_page(
+ monkeypatch,
+ ctx,
+ captured=_bounded_failure_page_evidence(),
+ browser_session_id="run_session",
+ )
assert result["ok"] is False
assert "specific named URL" in result["error"]
@pytest.mark.asyncio
-async def test_post_run_inspect_drops_a_packet_whose_source_session_is_unprovable(
+async def test_automatic_post_run_capture_uses_a_call_local_run_binding(
monkeypatch: pytest.MonkeyPatch,
) -> None:
- """A failed mid-capture session create clears the id, and an unknown source id grants post-run
- identity, so the packet has to be dropped rather than laundered into the run's own evidence."""
ctx = _post_run_inspect_ctx()
+ observed: list[str | None] = []
- result = await _drive_inspect_page(
- monkeypatch,
+ async def fake_capture(
+ inner_ctx: CopilotContext, *, inspected_url: str, current_url: str
+ ) -> tuple[dict[str, object], None]:
+ observed.append(effective_browser_session_id(inner_ctx))
+ return _bounded_failure_page_evidence(), None
+
+ monkeypatch.setattr(composition_capture_module, "_capture_composition_evidence", fake_capture)
+ evidence, source_session_id, error, _ = await composition_capture_module._read_run_session_page_evidence(
ctx,
- captured=_bounded_failure_page_evidence(),
- capture_clears_session=True,
+ run_session_id="run_session",
+ current_url="https://example.test/app/results",
)
- assert result["ok"] is False
- assert ctx.composition_page_evidence is None
- assert ctx.post_run_page_observation_workflow_run_id is None
+ assert evidence is not None
+ assert source_session_id == "run_session"
+ assert error is None
+ assert observed == ["run_session"]
assert ctx.browser_session_id == "scout_session"
@pytest.mark.asyncio
-async def test_failed_post_run_capture_on_a_substituted_session_is_inert(
+async def test_failed_automatic_post_run_capture_is_inert(
monkeypatch: pytest.MonkeyPatch,
) -> None:
- """Substitution racing a capture failure is the trickiest path here: it must neither grant post-run
- identity nor disturb the packet already stored for the run."""
ctx = _post_run_inspect_ctx()
clean = _clean_same_run_page_evidence()
ctx.composition_page_evidence = clean
- result = await _drive_inspect_page(
- monkeypatch,
+ async def failed_capture(inner_ctx: CopilotContext, *, inspected_url: str, current_url: str) -> tuple[None, None]:
+ assert effective_browser_session_id(inner_ctx) == "run_session"
+ raise TimeoutError("capture timed out")
+
+ monkeypatch.setattr(composition_capture_module, "_capture_composition_evidence", failed_capture)
+ evidence, source_session_id, error, _ = await composition_capture_module._read_run_session_page_evidence(
ctx,
- captured=_bounded_failure_page_evidence(),
- capture_lands_on_session="replacement_session",
- capture_raises=True,
+ run_session_id="run_session",
+ current_url="https://example.test/app/results",
)
- assert result["ok"] is False
+ assert evidence is None
+ assert source_session_id == "run_session"
+ assert error is not None
assert ctx.composition_page_evidence is clean
- assert ctx.post_run_page_observation_workflow_run_id is None
assert ctx.browser_session_id == "scout_session"
@pytest.mark.asyncio
-async def test_post_run_inspect_does_not_close_the_session_it_landed_on(
+async def test_automatic_post_run_capture_does_not_close_its_target_session(
monkeypatch: pytest.MonkeyPatch,
) -> None:
- """Tool calls in one batch run concurrently, so a session read back off the shared context may be
- a sibling's rather than this capture's substitute; closing it would kill a live browser."""
ctx = _post_run_inspect_ctx()
closed: list[str] = []
@@ -3073,11 +3107,17 @@ async def test_post_run_inspect_does_not_close_the_session_it_landed_on(
monkeypatch.setattr("skyvern.forge.app.PERSISTENT_SESSIONS_MANAGER", _Sessions(), raising=False)
- await _drive_inspect_page(
- monkeypatch,
+ async def fake_capture(
+ inner_ctx: CopilotContext, *, inspected_url: str, current_url: str
+ ) -> tuple[dict[str, object], None]:
+ assert effective_browser_session_id(inner_ctx) == "run_session"
+ return _bounded_failure_page_evidence(), None
+
+ monkeypatch.setattr(composition_capture_module, "_capture_composition_evidence", fake_capture)
+ await composition_capture_module._read_run_session_page_evidence(
ctx,
- captured=_bounded_failure_page_evidence(),
- capture_lands_on_session="replacement_session",
+ run_session_id="run_session",
+ current_url="https://example.test/app/results",
)
assert closed == []
@@ -3085,23 +3125,29 @@ async def test_post_run_inspect_does_not_close_the_session_it_landed_on(
@pytest.mark.asyncio
-async def test_post_run_inspect_stamps_the_session_the_capture_landed_on(
+async def test_mixed_target_capture_does_not_claim_a_browser_source(
monkeypatch: pytest.MonkeyPatch,
) -> None:
ctx = _post_run_inspect_ctx()
+ evidence = _bounded_failure_page_evidence()
+ evidence["browser_session_provenance"] = {
+ "mixed": True,
+ "start_browser_session_id": "run_session",
+ "end_browser_session_id": "replacement_session",
+ }
result = await _drive_inspect_page(
monkeypatch,
ctx,
- captured=_bounded_failure_page_evidence(),
- capture_lands_on_session="replacement_session",
+ captured=evidence,
+ browser_session_id="run_session",
)
- evidence = result["data"]
- assert isinstance(evidence, dict)
- assert evidence["source_browser_session_id"] == "replacement_session"
- assert evidence["observed_after_workflow_run"] is False
- assert "workflow_run_id" not in evidence
+ result_evidence = result["data"]
+ assert isinstance(result_evidence, dict)
+ assert result_evidence["source_browser_session_id"] == "replacement_session"
+ assert result_evidence["observed_after_workflow_run"] is False
+ assert "workflow_run_id" not in result_evidence
assert ctx.post_run_page_observation_workflow_run_id is None
assert result["reached_via"] == "current_page"
@@ -3133,7 +3179,7 @@ async def test_preserved_post_run_capture_does_not_move_the_observation_marker(
"challenge_controls": [],
}
- await _drive_inspect_page(monkeypatch, ctx, captured=hollow)
+ await _drive_inspect_page(monkeypatch, ctx, captured=hollow, browser_session_id="run_session")
assert ctx.post_run_page_observation_generation == 3
stored = ctx.composition_page_evidence
@@ -3150,9 +3196,17 @@ async def test_refused_post_run_capture_preserves_stored_evidence_but_returns_th
ctx.composition_page_evidence = clean
replacement_page = _bounded_failure_page_evidence()
replacement_page["page_title"] = "Replacement session page"
+ replacement_page["browser_session_provenance"] = {
+ "mixed": True,
+ "start_browser_session_id": "run_session",
+ "end_browser_session_id": "replacement_session",
+ }
result = await _drive_inspect_page(
- monkeypatch, ctx, captured=replacement_page, capture_lands_on_session="replacement_session"
+ monkeypatch,
+ ctx,
+ captured=replacement_page,
+ browser_session_id="run_session",
)
assert ctx.composition_page_evidence is clean
@@ -3160,6 +3214,7 @@ async def test_refused_post_run_capture_preserves_stored_evidence_but_returns_th
assert isinstance(evidence, dict)
assert evidence["page_title"] == "Replacement session page"
assert evidence["observed_after_workflow_run"] is False
+ assert evidence["source_browser_session_id"] == "replacement_session"
@pytest.mark.asyncio
@@ -3179,7 +3234,7 @@ async def test_hollow_post_run_capture_preserves_stored_evidence_but_returns_the
"challenge_controls": [],
}
- result = await _drive_inspect_page(monkeypatch, ctx, captured=hollow)
+ result = await _drive_inspect_page(monkeypatch, ctx, captured=hollow, browser_session_id="run_session")
assert ctx.composition_page_evidence is clean
evidence = result["data"]
diff --git a/tests/unit/test_copilot_discovery.py b/tests/unit/test_copilot_discovery.py
index 4e1d7b4c8..aeaa4f6ed 100644
--- a/tests/unit/test_copilot_discovery.py
+++ b/tests/unit/test_copilot_discovery.py
@@ -21,7 +21,11 @@ from skyvern.forge.sdk.copilot.composition_browser_expressions import (
)
from skyvern.forge.sdk.copilot.enforcement import _RECENT_TOOL_OUTPUT_CHAR_CAP, _prune_input_list
from skyvern.forge.sdk.copilot.request_policy import RequestPolicy, _ground_user_provided_sites
-from skyvern.forge.sdk.copilot.runtime import PendingBrowserInteractionObservation
+from skyvern.forge.sdk.copilot.runtime import (
+ PendingBrowserInteractionObservation,
+ bound_call_browser_session,
+ current_call_browser_session_override,
+)
from skyvern.forge.sdk.copilot.tools import (
_discovery_walk,
_inspect_page_for_composition_impl,
@@ -872,7 +876,8 @@ async def test_post_run_visual_fallback_binds_the_observed_run_session(
ctx.last_run_blocks_workflow_run_id = "wr_123" # type: ignore[attr-defined]
async def fake_page_info(_ctx: object, session_id: str | None = None) -> tuple[str, str]:
- assert session_id == "pbs_run"
+ assert session_id is None
+ assert current_call_browser_session_override() == "pbs_run"
return "https://www.example.com/search", "Search"
async def fake_visual_summary(
@@ -903,7 +908,8 @@ async def test_post_run_visual_fallback_binds_the_observed_run_session(
monkeypatch.setattr(tools_module.composition_capture, "_fallback_page_info", fake_page_info)
monkeypatch.setattr(tools_module.composition_capture, "_composition_summarize_screenshot", fake_visual_summary)
- result = await _inspect_page_for_composition_impl(ctx, "current_page")
+ with bound_call_browser_session("pbs_run"):
+ result = await _inspect_page_for_composition_impl(ctx, "current_page")
assert result["data"]["source_browser_session_id"] == "pbs_run"
assert result["data"]["workflow_run_id"] == "wr_123"
diff --git a/tests/unit/test_copilot_requested_output_designation.py b/tests/unit/test_copilot_requested_output_designation.py
index 9ebef85b7..37190a76d 100644
--- a/tests/unit/test_copilot_requested_output_designation.py
+++ b/tests/unit/test_copilot_requested_output_designation.py
@@ -47,6 +47,9 @@ class _DesignationServer:
def _ctx(server: _DesignationServer) -> SimpleNamespace:
return SimpleNamespace(
+ browser_session_id="pbs-debug",
+ last_run_blocks_browser_session_id=None,
+ last_run_blocks_workflow_run_id=None,
discovery_mcp_server=server,
completion_criteria_turn_state=None,
request_policy=None,