Skip to content

Automate browser based workflows with AI

SKY-10673: add code-first Copilot authoring policy (#6407)

Andrew Neilson4f4dfcd6179a
diff --git a/skyvern/forge/sdk/copilot/agent.py b/skyvern/forge/sdk/copilot/agent.py
index d67021b4f..a2b2f776f 100644
--- a/skyvern/forge/sdk/copilot/agent.py
+++ b/skyvern/forge/sdk/copilot/agent.py
@@ -38,7 +38,7 @@ from skyvern.forge.sdk.copilot.blocker_signal import (
)
from skyvern.forge.sdk.copilot.blocker_signal import to_trace_data as blocker_signal_to_trace_data
from skyvern.forge.sdk.copilot.build_phase import initial_build_phase
-from skyvern.forge.sdk.copilot.config import CopilotConfig
+from skyvern.forge.sdk.copilot.config import BlockAuthoringPolicy, CopilotConfig
from skyvern.forge.sdk.copilot.context import (
COPILOT_RESPONSE_TYPES,
AgentResult,
@@ -129,6 +129,39 @@ WORKFLOW_KNOWLEDGE_BASE_PATH = (
_COPILOT_TURN_SPAN_NAME = "copilot.turn"
_USER_MESSAGE_PREVIEW_MAX_CHARS = 40
+_CODE_ONLY_BROWSER_AUTHORING_PROMPT = """
+ACTIVE BLOCK AUTHORING POLICY: CODE-ONLY BROWSER MODE
+
+Browser/page workflow block types are unavailable in this mode: `navigation`,
+`action`, `login`, `extraction`, `goto_url`, `validation`, `file_download`,
+`file_upload`, `print_page`, `task`, `task_v2`, and `browser_task`.
+
+If a durable step touches the browser page or browser session, author it as a
+focused `code` block. Allowed non-browser helper blocks remain available when
+they do not directly interact with the browser page, such as `conditional`,
+`for_loop`, `while_loop`, `send_email`, S3/Google Sheets helpers, and workflow
+triggers.
+
+Do not call `validate_block`, do not create dummy/probe code blocks, and do not
+call `get_run_results` before a real workflow run exists.
+
+Code block runtime facts:
+- `code` is async Python executed with a Playwright `page` object and workflow
+ parameters available by key.
+- Workflow parameter keys that are valid Python identifiers are available as
+ local variables. Normalize them with locals such as
+ `name = str(person_name).strip()` before using them in page inputs.
+- Use deterministic, bounded Playwright calls such as `await page.goto(...)`,
+ `await page.click(...)`, `await page.fill(...)`, `await page.press(...)`,
+ `await page.wait_for_load_state(...)`, and `await page.evaluate(...)`.
+- For extraction blocks, return precise JSON-safe structured data and the
+ visible evidence text used to confirm it. Do not return only booleans for
+ visible records, products, totals, confirmations, or identifiers.
+- For multi-line code in workflow YAML, always use a YAML block scalar
+ (`code: |`). Never include placeholder text such as `[... truncated ...]`;
+ pass complete workflow YAML to update tools.
+"""
+
@runtime_checkable
class _AgentInstructionsContext(Protocol):
@@ -414,13 +447,16 @@ def _build_system_prompt(
copilot_config = config or CopilotConfig(security_rules=security_rules or "")
template = copilot_config.prompt_template.removesuffix(".j2")
workflow_knowledge_base = WORKFLOW_KNOWLEDGE_BASE_PATH.read_text(encoding="utf-8")
- return prompt_engine.load_prompt(
+ prompt = prompt_engine.load_prompt(
template=template,
workflow_knowledge_base=workflow_knowledge_base,
current_datetime=datetime.now(timezone.utc).isoformat(),
tool_usage_guide=tool_usage_guide,
security_rules=copilot_config.security_rules,
)
+ if copilot_config.block_authoring_policy == BlockAuthoringPolicy.CODE_ONLY_BROWSER:
+ prompt = f"{prompt}\n\n{_CODE_ONLY_BROWSER_AUTHORING_PROMPT.strip()}"
+ return prompt
def _runtime_verification_evidence_prompt(ctx: CopilotContext | None) -> str:
@@ -2749,6 +2785,7 @@ async def _run_copilot_turn_impl(
turn_id=turn_id,
turn_index=turn_index,
prior_block_count=prior_block_count,
+ block_authoring_policy=copilot_config.block_authoring_policy,
)
# Fail loud if a future caller skips the kwarg and gets a fresh UUID from
# the default_factory — the envelope and terminal frames would then carry
diff --git a/skyvern/forge/sdk/copilot/build_phase.py b/skyvern/forge/sdk/copilot/build_phase.py
index be87c93ea..038758231 100644
--- a/skyvern/forge/sdk/copilot/build_phase.py
+++ b/skyvern/forge/sdk/copilot/build_phase.py
@@ -76,6 +76,7 @@ _MUTATION_TOOLS: frozenset[str] = frozenset(
{"update_workflow", "update_and_run_blocks", "run_blocks_and_collect_debug"}
)
_DISCOVERY_TOOLS: frozenset[str] = frozenset({"discover_workflow_entrypoint"})
+_COMPOSITION_CONTEXT_TOOLS: frozenset[str] = frozenset({"inspect_page_for_composition"})
_URL_IN_TEXT_RE = re.compile(r"https?://[^\s<>\"\)]+", re.IGNORECASE)
@@ -215,6 +216,21 @@ def _phase_blocker_signal(ctx: Any, tool_name: str) -> CopilotToolBlockerSignal
blocked_tool=tool_name,
)
+ if tool_name in _COMPOSITION_CONTEXT_TOOLS and in_discovery:
+ return CopilotToolBlockerSignal(
+ blocker_kind="phase_gated",
+ agent_steering_text=(
+ "Page inspection for composition is only available after an entrypoint URL is known. "
+ "Call discover_workflow_entrypoint to resolve the entrypoint URL, or ASK_QUESTION for a URL first. "
+ "safe_reason_code=build_phase_composition_inspection_blocked_pre_compose."
+ ),
+ user_facing_reason="I need to know what page to inspect before I can read its form controls.",
+ recovery_hint="ask_user_clarifying",
+ cleared_by_tools=frozenset({"discover_workflow_entrypoint"}),
+ internal_reason_code="build_phase_composition_inspection_blocked_pre_compose",
+ blocked_tool=tool_name,
+ )
+
if tool_name in _BROWSER_PRIMITIVE_TOOLS and in_discovery:
return CopilotToolBlockerSignal(
blocker_kind="phase_gated",
diff --git a/skyvern/forge/sdk/copilot/context.py b/skyvern/forge/sdk/copilot/context.py
index 3ded29029..244c35fbf 100644
--- a/skyvern/forge/sdk/copilot/context.py
+++ b/skyvern/forge/sdk/copilot/context.py
@@ -11,6 +11,7 @@ from pydantic import BaseModel, Field
from typing_extensions import NotRequired, TypedDict
from skyvern.forge.sdk.copilot.build_phase import BuildPhase
+from skyvern.forge.sdk.copilot.config import BlockAuthoringPolicy
from skyvern.forge.sdk.copilot.runtime import AgentContext
from skyvern.forge.sdk.copilot.verification_evidence import WorkflowVerificationEvidence
from skyvern.forge.sdk.workflow.models.workflow import Workflow
@@ -319,6 +320,7 @@ class CopilotContext(AgentContext):
block_goal_main_goal: str = ""
allow_untested_workflow_draft: bool = False
request_policy: RequestPolicy | None = None
+ block_authoring_policy: BlockAuthoringPolicy = BlockAuthoringPolicy.STANDARD
turn_intent: TurnIntent | None = None
turn_context_packet: TurnContextPacket | None = None
latest_diagnosis_repair_contract: DiagnosisRepairContract | None = None
@@ -346,6 +348,8 @@ class CopilotContext(AgentContext):
last_test_failure_reason: str | None = None
failed_test_nudge_count: int = 0
explore_without_workflow_nudge_count: int = 0
+ code_only_code_schema_seen: bool = False
+ code_only_target_page_evidence_seen: bool = False
last_failed_workflow_yaml: str | None = None
# Set when a block-running tool timed out and the run's true outcome
# could not be reconciled (post-drain row was ``canceled``, non-final, or
diff --git a/skyvern/forge/sdk/copilot/mcp_adapter.py b/skyvern/forge/sdk/copilot/mcp_adapter.py
index 4e9d9de1a..de2525c3d 100644
--- a/skyvern/forge/sdk/copilot/mcp_adapter.py
+++ b/skyvern/forge/sdk/copilot/mcp_adapter.py
@@ -5,7 +5,7 @@ from __future__ import annotations
import json
from contextlib import AsyncExitStack
from dataclasses import dataclass, field
-from typing import Any, Awaitable, Callable
+from typing import TYPE_CHECKING, Any, Awaitable, Callable
import structlog
from agents.agent import AgentBase
@@ -25,6 +25,7 @@ from skyvern.forge.sdk.copilot.blocker_signal import (
stash_blocker_signal,
)
from skyvern.forge.sdk.copilot.build_phase import _phase_blocker_signal
+from skyvern.forge.sdk.copilot.config import BlockAuthoringPolicy, normalize_block_authoring_policy
from skyvern.forge.sdk.copilot.loop_detection import (
detect_failed_tool_step_loop_for_ctx,
detect_tool_loop,
@@ -39,6 +40,9 @@ from skyvern.forge.sdk.copilot.runtime import (
)
from skyvern.forge.sdk.copilot.screenshot_utils import enqueue_screenshot_from_result
+if TYPE_CHECKING:
+ from skyvern.forge.sdk.copilot.context import CopilotContext
+
PreHook = Callable[[dict[str, Any], AgentContext], Awaitable[dict[str, Any] | None]]
PostHook = Callable[[dict[str, Any], dict[str, Any], AgentContext], Awaitable[dict[str, Any]]]
@@ -62,6 +66,13 @@ LOG = structlog.get_logger()
_INTERNAL_TOOL_ARG_KEYS = frozenset({"_summarized"})
+def _hide_code_only_tool(ctx: CopilotContext, tool_name: str) -> bool:
+ return (
+ normalize_block_authoring_policy(ctx.block_authoring_policy) == BlockAuthoringPolicy.CODE_ONLY_BROWSER
+ and tool_name == "validate_block"
+ )
+
+
def _stash_and_emit_loop_blocker(ctx: Any, loop_message: str, tool_name: str) -> str:
return stash_blocker_signal(ctx, build_loop_blocker_signal(loop_message, tool_name=tool_name))
@@ -140,7 +151,7 @@ class SkyvernOverlayMCPServer(MCPServer):
self._context_provider = context_provider
self._client: Client | None = None
self._exit_stack: AsyncExitStack | None = None
- self._cached_tools: list[MCPTool] | None = None
+ self._cached_raw_tools: list[MCPTool] | None = None
@property
def name(self) -> str:
@@ -159,27 +170,30 @@ class SkyvernOverlayMCPServer(MCPServer):
await self._exit_stack.__aexit__(None, None, None)
self._client = None
self._exit_stack = None
- self._cached_tools = None
+ self._cached_raw_tools = None
async def list_tools(
self,
run_context: RunContextWrapper[Any] | None = None,
agent: AgentBase | None = None,
) -> list[MCPTool]:
- if self._cached_tools is not None:
- return self._cached_tools
-
if not self._client:
raise RuntimeError("Not connected — call connect() first")
- raw_tools = await self._client.list_tools()
+ if self._cached_raw_tools is None:
+ self._cached_raw_tools = await self._client.list_tools()
+ raw_tools = self._cached_raw_tools
result: list[MCPTool] = []
+ copilot_ctx = self._context_provider()
for tool in raw_tools:
if tool.name not in self._allowlist:
continue
copilot_name = self._reverse_alias.get(tool.name, tool.name)
+ if _hide_code_only_tool(copilot_ctx, copilot_name):
+ continue
+
overlay = self._overlays.get(copilot_name, SchemaOverlay())
schema = _apply_schema_overlay(tool.inputSchema, overlay)
@@ -192,7 +206,6 @@ class SkyvernOverlayMCPServer(MCPServer):
inputSchema=schema,
)
)
- self._cached_tools = result
return result
async def call_tool(
diff --git a/skyvern/forge/sdk/copilot/runtime.py b/skyvern/forge/sdk/copilot/runtime.py
index 1b68ab171..3a0a48a57 100644
--- a/skyvern/forge/sdk/copilot/runtime.py
+++ b/skyvern/forge/sdk/copilot/runtime.py
@@ -156,6 +156,8 @@ class AgentContext:
last_failure_category_top: str | None = None
last_update_block_count: int | None = None
last_failed_workflow_yaml: str | None = None
+ code_only_code_schema_seen: bool = False
+ code_only_target_page_evidence_seen: bool = False
repeated_failure_streak_count: int = 0
repeated_failure_nudge_emitted_at_streak: int = 0
challenge_gated_proxy_retry_count: int = 0
@@ -170,6 +172,7 @@ class AgentContext:
canonical_was_persisted_due_to_param_change: bool = False
allow_untested_workflow_draft: bool = False
request_policy: RequestPolicy | None = None
+ block_authoring_policy: Any = "standard"
effective_workflow_proxy_location: Any | None = None
copilot_run_start_monotonic: float | None = None
diff --git a/skyvern/forge/sdk/copilot/tools.py b/skyvern/forge/sdk/copilot/tools.py
index be970d81b..de514965d 100644
--- a/skyvern/forge/sdk/copilot/tools.py
+++ b/skyvern/forge/sdk/copilot/tools.py
@@ -73,6 +73,7 @@ from skyvern.forge.sdk.copilot.composition_evidence import (
parse_composition_html,
workflow_target_url,
)
+from skyvern.forge.sdk.copilot.config import BlockAuthoringPolicy, normalize_block_authoring_policy
from skyvern.forge.sdk.copilot.context import CopilotContext
from skyvern.forge.sdk.copilot.diagnosis_repair_contract import (
DiagnosisRepairContract,
@@ -2278,10 +2279,14 @@ async def _update_workflow(
# block type. The schema pre_hook only fires when the LLM consults the
# schema; this safety net fires regardless of emission path. Label-based
# diff preserves legacy workflows — only NEW banned labels trip the reject.
- banned_items = _detect_new_banned_blocks(workflow_yaml, ctx.workflow_yaml)
+ banned_items = _detect_new_banned_blocks(
+ workflow_yaml,
+ ctx.workflow_yaml,
+ banned_types=_copilot_banned_block_types(ctx),
+ )
if banned_items:
_record_banned_block_reject_span("_update_workflow", banned_items)
- return {"ok": False, "error": _banned_block_reject_message(banned_items)}
+ return {"ok": False, "error": _banned_block_reject_message(banned_items, ctx)}
composition_evidence_error = composition_page_evidence_error(ctx, workflow_yaml)
if composition_evidence_error:
@@ -4942,6 +4947,23 @@ async def _maybe_run_completion_verification_from_page_observation(
# a separate agent, which bypasses copilot-level block decomposition and
# obfuscates issues the copilot should surface/handle directly.
_COPILOT_BANNED_BLOCK_TYPES: frozenset[str] = frozenset({"task", "task_v2"})
+# Code-only browser mode uses this temporary hard ban to force iteration on
+# code-first Copilot behavior. The GA policy is not settled: it may allow some
+# of these block types again, or make the allow/ban list configurable.
+_COPILOT_CODE_ONLY_BROWSER_BANNED_BLOCK_TYPES: frozenset[str] = _COPILOT_BANNED_BLOCK_TYPES | frozenset(
+ {
+ "action",
+ "browser_task",
+ "extraction",
+ "file_download",
+ "file_upload",
+ "goto_url",
+ "login",
+ "navigation",
+ "print_page",
+ "validation",
+ }
+)
# Shared suffix across every LLM-facing rejection message for banned
# block emission — the pre-hook (schema-lookup reject) and the post-
@@ -4951,9 +4973,49 @@ _COPILOT_BANNED_BLOCK_ALTERNATIVES = (
"`extraction` for data extraction, `validation` for completion checks, "
"`login` for authentication, or `goto_url` for pure URL navigation."
)
+_COPILOT_CODE_ONLY_BROWSER_ALTERNATIVES = (
+ "Browser/page workflow block types are unavailable in code-only browser mode. Use focused `code` "
+ "blocks for durable page or browser-session work."
+)
+_CODE_ONLY_TARGET_EVIDENCE_KEYS = frozenset(
+ {
+ "buttons",
+ "fields",
+ "forms",
+ "inputs",
+ "links",
+ "options",
+ "result",
+ "results",
+ "rows",
+ "selects",
+ "tables",
+ "textareas",
+ "url",
+ }
+)
+_CODE_ONLY_SELECTOR_ACTION_TOOLS = frozenset({"click", "type_text", "select_option", "press_key"})
+
+
+def _copilot_block_authoring_policy(ctx: AgentContext | None) -> BlockAuthoringPolicy:
+ if ctx is None:
+ return BlockAuthoringPolicy.STANDARD
+ return normalize_block_authoring_policy(getattr(ctx, "block_authoring_policy", None))
-def _banned_block_reject_message(items: list[tuple[str, str]]) -> str:
+def _copilot_banned_block_types(ctx: AgentContext | None) -> frozenset[str]:
+ if _copilot_block_authoring_policy(ctx) == BlockAuthoringPolicy.CODE_ONLY_BROWSER:
+ return _COPILOT_CODE_ONLY_BROWSER_BANNED_BLOCK_TYPES
+ return _COPILOT_BANNED_BLOCK_TYPES
+
+
+def _copilot_banned_block_alternatives(ctx: AgentContext | None) -> str:
+ if _copilot_block_authoring_policy(ctx) == BlockAuthoringPolicy.CODE_ONLY_BROWSER:
+ return _COPILOT_CODE_ONLY_BROWSER_ALTERNATIVES
+ return _COPILOT_BANNED_BLOCK_ALTERNATIVES
+
+
+def _banned_block_reject_message(items: list[tuple[str, str]], ctx: AgentContext | None = None) -> str:
"""Uniform error text for the post-emission reject, sharing the
alternatives suffix with the schema pre-hook."""
labels = ", ".join(sorted({label for label, _ in items}))
@@ -4962,7 +5024,7 @@ def _banned_block_reject_message(items: list[tuple[str, str]]) -> str:
return (
f"Block type {types_part} is not available in the workflow copilot. "
f"Offending labels: [{labels}]. "
- f"{_COPILOT_BANNED_BLOCK_ALTERNATIVES}"
+ f"{_copilot_banned_block_alternatives(ctx)}"
)
@@ -5015,13 +5077,17 @@ def _record_workflow_proxy_location_span(workflow_yaml: str, workflow: Workflow)
pass
-def _collect_banned_block_items(blocks: list[Any]) -> list[tuple[str, str]]:
+def _collect_banned_block_items(
+ blocks: list[Any],
+ banned_types: frozenset[str] | None = None,
+) -> list[tuple[str, str]]:
"""Recursively walk ``blocks`` (mirroring
:func:`skyvern.forge.sdk.copilot.block_goal_wrapping._wrap_blocks_in_place`)
and return ``(label, normalized_block_type)`` for every block whose type is
in :data:`_COPILOT_BANNED_BLOCK_TYPES`. Blocks missing ``label`` are
skipped — the downstream Pydantic validator surfaces those errors on its
own."""
+ active_banned_types = banned_types or _COPILOT_BANNED_BLOCK_TYPES
items: list[tuple[str, str]] = []
for block in blocks:
if not isinstance(block, dict):
@@ -5029,13 +5095,14 @@ def _collect_banned_block_items(blocks: list[Any]) -> list[tuple[str, str]]:
raw_type = block.get("block_type")
if isinstance(raw_type, str):
normalized = raw_type.strip().lower()
- if normalized in _COPILOT_BANNED_BLOCK_TYPES:
+ raw_normalized = normalize_copilot_block_type_alias(normalized)
+ if normalized in active_banned_types or raw_normalized in active_banned_types:
label = block.get("label")
if isinstance(label, str):
- items.append((label, normalized))
+ items.append((label, raw_normalized))
loop_blocks = block.get("loop_blocks")
if isinstance(loop_blocks, list):
- items.extend(_collect_banned_block_items(loop_blocks))
+ items.extend(_collect_banned_block_items(loop_blocks, active_banned_types))
return items
@@ -5067,6 +5134,8 @@ def _block_label_from_yaml(block: dict[str, Any]) -> str | None:
def _detect_new_banned_blocks(
submitted_yaml: str,
prior_workflow_yaml: str | None,
+ *,
+ banned_types: frozenset[str] | None = None,
) -> list[tuple[str, str]]:
"""Return ``[(label, block_type), ...]`` for every banned-type block in
``submitted_yaml`` whose label is NOT present as a banned-type block in
@@ -5085,11 +5154,12 @@ def _detect_new_banned_blocks(
submitted_blocks = _parse_workflow_blocks(submitted_yaml)
if submitted_blocks is None:
return []
- submitted_items = _collect_banned_block_items(submitted_blocks)
+ active_banned_types = banned_types or _COPILOT_BANNED_BLOCK_TYPES
+ submitted_items = _collect_banned_block_items(submitted_blocks, active_banned_types)
if not submitted_items:
return []
prior_blocks = _parse_workflow_blocks(prior_workflow_yaml)
- prior_labels = {label for label, _ in _collect_banned_block_items(prior_blocks or [])}
+ prior_labels = {label for label, _ in _collect_banned_block_items(prior_blocks or [], active_banned_types)}
return [(label, block_type) for label, block_type in submitted_items if label not in prior_labels]
@@ -5216,11 +5286,27 @@ async def _get_block_schema_pre_hook(
normalized = normalize_copilot_block_type_alias(block_type)
if normalized != block_type.strip().lower():
params["block_type"] = normalized
- if normalized not in _COPILOT_BANNED_BLOCK_TYPES:
+ if normalized not in _copilot_banned_block_types(ctx):
return None
return {
"ok": False,
- "error": f"Block type {block_type!r} is not available in the workflow copilot. {_COPILOT_BANNED_BLOCK_ALTERNATIVES}",
+ "error": f"Block type {block_type!r} is not available in the workflow copilot. {_copilot_banned_block_alternatives(ctx)}",
+ }
+
+
+async def _validate_block_pre_hook(
+ params: dict[str, Any],
+ ctx: AgentContext,
+) -> dict[str, Any] | None:
+ if _copilot_block_authoring_policy(ctx) != BlockAuthoringPolicy.CODE_ONLY_BROWSER:
+ return None
+ return {
+ "ok": False,
+ "error": (
+ "CODE-ONLY BLOCK VALIDATION DISABLED: do not use validate_block, dummy code blocks, or probe code "
+ "blocks in code-only browser mode. Use MCP browser tools to explore the page, then call "
+ "update_and_run_blocks with real focused code blocks that implement the workflow behavior."
+ ),
}
@@ -5235,11 +5321,45 @@ async def _get_block_schema_post_hook(
if isinstance(data, dict):
block_types = data.get("block_types")
if isinstance(block_types, dict):
- for banned in _COPILOT_BANNED_BLOCK_TYPES:
+ for banned in _copilot_banned_block_types(ctx):
block_types.pop(banned, None)
+ block_type = data.get("block_type")
+ if _copilot_block_authoring_policy(ctx) == BlockAuthoringPolicy.CODE_ONLY_BROWSER and block_type == "code":
+ ctx.code_only_code_schema_seen = True
+ data["code_only_note"] = _COPILOT_CODE_ONLY_BROWSER_ALTERNATIVES
+ data["code_only_guidance"] = [
+ "Use one focused code block per durable browser goal, such as open, search, submit, expand, or extract.",
+ "Do not persist navigation/action/login/extraction/validation blocks for browser page work.",
+ "Use concrete selectors and text anchors found during exploration. If only intent targeting is available, inspect the page again before mutating.",
+ "Call update_and_run_blocks with a connected runnable set of real code blocks instead of validating dummy or probe blocks.",
+ "Keep block outputs JSON-safe and include visible evidence text when extracting records, products, totals, confirmations, or identifiers.",
+ ]
return result
+def _code_only_pre_run_results_error(ctx: CopilotContext) -> dict[str, Any] | None:
+ if _copilot_block_authoring_policy(ctx) != BlockAuthoringPolicy.CODE_ONLY_BROWSER:
+ return None
+ if ctx.workflow_persisted or ctx.update_workflow_called:
+ return None
+ for value in (
+ ctx.pending_reconciliation_run_id,
+ ctx.last_run_blocks_workflow_run_id,
+ ctx.last_successful_run_blocks_workflow_run_id,
+ ):
+ if isinstance(value, str) and value:
+ return None
+ return {
+ "ok": False,
+ "error": (
+ "CODE-ONLY EXPLORATION PHASE: get_run_results is unavailable before a real workflow run exists. "
+ "Use MCP browser tools such as navigate_browser, evaluate, click, type_text, get_browser_screenshot, "
+ "console_messages, scroll, select_option, or press_key to understand the page, then call "
+ "update_and_run_blocks with real focused code blocks."
+ ),
+ }
+
+
async def _evaluate_pre_hook(
params: dict[str, Any],
ctx: AgentContext,
@@ -5253,15 +5373,66 @@ async def _evaluate_pre_hook(
return None
-_JQUERY_SELECTOR_RE = re.compile(
- r":(?:contains|eq|first|last|gt|lt|nth|has|visible|hidden|checked)\s*\(", re.IGNORECASE
-)
+def _code_only_deterministic_targeting_error(tool_name: str) -> str:
+ return (
+ f"In code-only browser mode, {tool_name} requires a CSS/XPath selector for page mutations "
+ "after the reusable workflow has been verified. Use evaluate, screenshots, or page inspection "
+ "to derive a selector, then retry with selector only."
+ )
+
+
+def _code_only_selector_action_requires_deterministic_target(ctx: AgentContext) -> bool:
+ if _copilot_block_authoring_policy(ctx) != BlockAuthoringPolicy.CODE_ONLY_BROWSER:
+ return False
+ if not getattr(ctx, "workflow_persisted", False):
+ return False
+ return bool(getattr(ctx, "last_full_workflow_test_ok", False))
+
+
+def _strip_intent_for_code_only_selector_action(
+ params: dict[str, Any],
+ ctx: AgentContext,
+ *,
+ tool_name: str,
+) -> dict[str, Any] | None:
+ if not _code_only_selector_action_requires_deterministic_target(ctx):
+ return None
+ if tool_name not in _CODE_ONLY_SELECTOR_ACTION_TOOLS:
+ return None
+ selector = params.get("selector")
+ if isinstance(selector, str) and selector.strip():
+ if "intent" in params:
+ params["intent"] = None
+ return None
+ if params.get("intent"):
+ return {"ok": False, "error": _code_only_deterministic_targeting_error(tool_name)}
+ return None
+
+
+def _code_only_has_target_page_evidence(data: object) -> bool:
+ if not isinstance(data, dict):
+ return False
+ for key, value in data.items():
+ normalized = str(key).strip().lower()
+ if normalized in _CODE_ONLY_TARGET_EVIDENCE_KEYS and bool(value):
+ return True
+ if isinstance(value, dict) and _code_only_has_target_page_evidence(value):
+ return True
+ if isinstance(value, list) and any(_code_only_has_target_page_evidence(item) for item in value):
+ return True
+ return False
+
+
+_JQUERY_SELECTOR_RE = re.compile(r":(?:contains|eq|first|last|gt|lt|nth|visible|hidden|checked)\s*\(", re.IGNORECASE)
async def _click_pre_hook(
params: dict[str, Any],
ctx: AgentContext,
) -> dict[str, Any] | None:
+ deterministic_result = _strip_intent_for_code_only_selector_action(params, ctx, tool_name="click")
+ if deterministic_result is not None:
+ return deterministic_result
selector = params.get("selector", "")
if not selector:
return None
@@ -5282,6 +5453,27 @@ async def _click_pre_hook(
return None
+async def _type_text_pre_hook(
+ params: dict[str, Any],
+ ctx: AgentContext,
+) -> dict[str, Any] | None:
+ return _strip_intent_for_code_only_selector_action(params, ctx, tool_name="type_text")
+
+
+async def _select_option_pre_hook(
+ params: dict[str, Any],
+ ctx: AgentContext,
+) -> dict[str, Any] | None:
+ return _strip_intent_for_code_only_selector_action(params, ctx, tool_name="select_option")
+
+
+async def _press_key_pre_hook(
+ params: dict[str, Any],
+ ctx: AgentContext,
+) -> dict[str, Any] | None:
+ return _strip_intent_for_code_only_selector_action(params, ctx, tool_name="press_key")
+
+
async def _navigate_post_hook(
result: dict[str, Any],
raw: dict[str, Any],
@@ -5296,6 +5488,12 @@ async def _navigate_post_hook(
"get_browser_screenshot, or click to inspect page content "
"before responding."
)
+ if (
+ _copilot_block_authoring_policy(ctx) == BlockAuthoringPolicy.CODE_ONLY_BROWSER
+ and isinstance(ctx, CopilotContext)
+ and ctx.build_phase in {BuildPhase.INITIAL, BuildPhase.DISCOVERING}
+ ):
+ advance_to_composing(ctx, reason="code_only_browser_navigation_succeeded")
return result
@@ -5445,6 +5643,10 @@ async def _evaluate_post_hook(
if observation_step is not None:
result["observation_step"] = observation_step
result["data"]["observation_step"] = observation_step
+ if _copilot_block_authoring_policy(
+ ctx
+ ) == BlockAuthoringPolicy.CODE_ONLY_BROWSER and _code_only_has_target_page_evidence(result["data"]):
+ ctx.code_only_target_page_evidence_seen = True
await _maybe_run_completion_verification_from_page_observation(
ctx,
url=url,
@@ -5528,7 +5730,7 @@ def _build_skyvern_mcp_overlays() -> dict[str, SchemaOverlay]:
pre_hook=_get_block_schema_pre_hook,
post_hook=_get_block_schema_post_hook,
),
- "validate_block": SchemaOverlay(),
+ "validate_block": SchemaOverlay(pre_hook=_validate_block_pre_hook),
"navigate_browser": SchemaOverlay(
description=(
"Navigate the debug browser to a URL. "
@@ -5601,6 +5803,7 @@ def _build_skyvern_mcp_overlays() -> dict[str, SchemaOverlay]:
arg_transforms={"clear_first": "clear"},
requires_browser=True,
timeout=15,
+ pre_hook=_type_text_pre_hook,
post_hook=_type_text_post_hook,
),
"scroll": SchemaOverlay(
@@ -5634,6 +5837,7 @@ def _build_skyvern_mcp_overlays() -> dict[str, SchemaOverlay]:
required_overrides=["value"],
requires_browser=True,
timeout=15,
+ pre_hook=_select_option_pre_hook,
post_hook=_select_option_post_hook,
),
"press_key": SchemaOverlay(
@@ -5645,6 +5849,7 @@ def _build_skyvern_mcp_overlays() -> dict[str, SchemaOverlay]:
hide_params=frozenset({"session_id", "cdp_url"}),
required_overrides=["key"],
requires_browser=True,
+ pre_hook=_press_key_pre_hook,
post_hook=_press_key_post_hook,
),
}
@@ -6807,6 +7012,11 @@ async def get_run_results_tool(
authority_error = _authority_tool_error(copilot_ctx, "get_run_results")
if authority_error:
return json.dumps({"ok": False, "error": authority_error})
+ if isinstance(copilot_ctx, CopilotContext):
+ code_only_pre_run_error = _code_only_pre_run_results_error(copilot_ctx)
+ if code_only_pre_run_error is not None:
+ record_tool_step_result_for_ctx(copilot_ctx, "get_run_results", params, code_only_pre_run_error)
+ return json.dumps(code_only_pre_run_error)
result = await _get_run_results(params, copilot_ctx)
_record_per_tool_budget_problem_blocks_from_results(copilot_ctx, result)