Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
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.pyindex 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 annotationsfrom dataclasses import dataclass+from enum import StrEnumfrom typing import Anyfrom skyvern.forge.sdk.copilot.context import CopilotContextBROWSER_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: dictbrowser."""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: dictworkflow_run_id = copilot_ctx.last_run_blocks_workflow_run_idif 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__.pyindex 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 ToolContextfrom skyvern.forge import app as appfrom 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_bindingfrom 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 thatfill fields, submit searches, filter results, or expand result rows. Itcan 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 donot 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 packetdescribes the page only as it is at that moment: a control that appears solely after aninteraction -- a Delete control after an Add click, a cart after add-to-cart, the secure areaafter 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; youremain 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.pyindex 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 CopilotContextfrom skyvern.forge.sdk.copilot.diagnosis_repair_contract import author_time_leversfrom skyvern.forge.sdk.copilot.enforcement import _RECENT_TOOL_OUTPUT_CHAR_CAP, _requested_output_labels_by_pathfrom skyvern.forge.sdk.copilot.llm_config import resolve_fast_copilot_handler-from skyvern.forge.sdk.copilot.loop_detection import record_tool_step_result_for_ctxfrom skyvern.forge.sdk.copilot.output_extraction_plan import _exact_path, _value_witness_bindingsfrom 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 Noneand (- 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_idobservation_error: str | None = Noneevidence: dict[str, Any] | None = Noneframe: 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 = Noneif 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.", Nonereturn (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: strkind: str- run_page_source_session_id: str | None = None- observed_run_session_id: str | None = Noneif 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 resultentry_url = resolved_entry_urlregression_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 resultfailure_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 resultevidence, visual_fallback_frame = failure_capturecurrent_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 Noneand (- 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 resultif 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 resultif 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_stepresult = _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.pyindex 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 = Noneself._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 = 0self._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 selfdiff --git a/tests/unit/forge/sdk/routes/streaming/test_exfiltration_channel.py b/tests/unit/forge/sdk/routes/streaming/test_exfiltration_channel.pyindex 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, MagicMockimport pytestfrom playwright._impl._errors import TargetClosedError+import skyvern.forge.sdk.routes.streaming.channels.exfiltration as exfiltration_modulefrom 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 ScopedAsynciodef _make_context() -> MagicMock:@@ -120,6 +122,8 @@ class TestExfiltrationChannelEvents:ExfiltrationChannel._active_binding_channels[page] = channelExfiltrationChannel._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_channelsassert not ExfiltrationChannel._binding_registered_pagesassert not channel._page_console_captures+ assert not channel._decoration_init_script_pages+ assert not channel._decoration_page_locks@pytest.mark.asyncioasync 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.pyindex 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.pynew file mode 100644index 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.pyindex 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.pyindex 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: pymonkeypatch.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_outmonkeypatch.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(monkeypatchmonkeypatch.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.pyindex 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 RequestPolicyfrom 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), Noneasync 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 Truestored = 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 Trueassert 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_isctx.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 Falseassert "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 Noneassert ctx.composition_page_evidence is clean- assert ctx.post_run_page_observation_workflow_run_id is Noneassert 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_evidenceassert ctx.post_run_page_observation_workflow_run_id is Noneassert 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 == 3stored = ctx.composition_page_evidence@@ -3150,9 +3196,17 @@ async def test_refused_post_run_capture_preserves_stored_evidence_but_returns_thctx.composition_page_evidence = cleanreplacement_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_thassert 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 cleanevidence = result["data"]diff --git a/tests/unit/test_copilot_discovery.py b/tests/unit/test_copilot_discovery.pyindex 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_listfrom 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.pyindex 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,