Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
Gate CUA and Opus models for enterprise (#6420)
Suchintanddf6f6cf4b48
diff --git a/skyvern-frontend/src/components/BadgeLabel.tsx b/skyvern-frontend/src/components/BadgeLabel.tsxnew file mode 100644index 000000000..34ba3a335--- /dev/null+++ b/skyvern-frontend/src/components/BadgeLabel.tsx@@ -0,0 +1,38 @@+import type { ReactNode } from "react";++import { cn } from "@/util/utils";++export type BadgeVariant = "default" | "success" | "warning";++type Props = {+ label: ReactNode;+ badge?: string;+ badgeVariant?: BadgeVariant;+ className?: string;+};++function BadgeLabel({+ label,+ badge,+ badgeVariant = "default",+ className,+}: Props) {+ return (+ <div className={cn("flex items-center gap-2", className)}>+ <span>{label}</span>+ {badge && (+ <span+ className={cn("rounded px-1.5 py-0.5 text-[10px] font-medium", {+ "bg-green-500/20 text-green-400": badgeVariant === "success",+ "bg-amber-500/20 text-amber-400": badgeVariant === "warning",+ "bg-slate-500/20 text-slate-400": badgeVariant === "default",+ })}+ >+ {badge}+ </span>+ )}+ </div>+ );+}++export { BadgeLabel };diff --git a/skyvern-frontend/src/components/EngineSelector.test.tsx b/skyvern-frontend/src/components/EngineSelector.test.tsxnew file mode 100644index 000000000..c7e07f54e--- /dev/null+++ b/skyvern-frontend/src/components/EngineSelector.test.tsx@@ -0,0 +1,61 @@+// @vitest-environment jsdom++import { render, screen } from "@testing-library/react";+import type { ReactNode } from "react";+import { describe, expect, test, vi } from "vitest";++import { RunEngine } from "@/api/types";++import { RunEngineSelector } from "./EngineSelector";++vi.mock("./ui/select", () => ({+ Select: ({ children }: { children?: ReactNode }) => <div>{children}</div>,+ SelectContent: ({ children }: { children?: ReactNode }) => (+ <div>{children}</div>+ ),+ SelectItem: ({ children }: { children?: ReactNode }) => <div>{children}</div>,+ SelectTrigger: ({ children }: { children?: ReactNode }) => (+ <button type="button">{children}</button>+ ),+ SelectValue: ({ children }: { children?: ReactNode }) => (+ <span>{children}</span>+ ),+}));++describe("RunEngineSelector", () => {+ test("hides Yutori Navigator by default", () => {+ render(+ <RunEngineSelector value={RunEngine.SkyvernV1} onChange={() => {}} />,+ );++ expect(screen.queryByText("Yutori Navigator")).toBeNull();+ });++ test("keeps selected Yutori Navigator visible as deprecated", () => {+ render(+ <RunEngineSelector+ value={RunEngine.YutoriNavigator}+ onChange={() => {}}+ />,+ );++ expect(screen.getAllByText("Yutori Navigator").length).toBeGreaterThan(0);+ expect(screen.getAllByText("Deprecated").length).toBeGreaterThan(0);+ });++ test.each([+ [RunEngine.OpenaiCua, "OpenAI CUA"],+ [RunEngine.AnthropicCua, "Anthropic CUA"],+ ])("marks %s as enterprise-only", (engine, label) => {+ render(+ <RunEngineSelector+ value={engine}+ onChange={() => {}}+ availableEngines={[engine]}+ />,+ );++ expect(screen.getAllByText(label).length).toBeGreaterThan(0);+ expect(screen.getAllByText("Enterprise").length).toBeGreaterThan(0);+ });+});diff --git a/skyvern-frontend/src/components/EngineSelector.tsx b/skyvern-frontend/src/components/EngineSelector.tsxindex 180e2352b..bb3fbc530 100644--- a/skyvern-frontend/src/components/EngineSelector.tsx+++ b/skyvern-frontend/src/components/EngineSelector.tsx@@ -6,13 +6,13 @@ import {SelectTrigger,SelectValue,} from "./ui/select";-import { cn } from "@/util/utils";+import { BadgeLabel, type BadgeVariant } from "./BadgeLabel";type EngineOption = {value: RunEngine;label: string;badge?: string;- badgeVariant?: "default" | "success" | "warning";+ badgeVariant?: BadgeVariant;};type Props = {@@ -38,14 +38,20 @@ const allEngineOptions: Array<EngineOption> = [{value: RunEngine.OpenaiCua,label: "OpenAI CUA",+ badge: "Enterprise",+ badgeVariant: "warning",},{value: RunEngine.AnthropicCua,label: "Anthropic CUA",+ badge: "Enterprise",+ badgeVariant: "warning",},{value: RunEngine.YutoriNavigator,label: "Yutori Navigator",+ badge: "Deprecated",+ badgeVariant: "default",},];@@ -54,29 +60,8 @@ const defaultEngines: Array<RunEngine> = [RunEngine.SkyvernV1,RunEngine.OpenaiCua,RunEngine.AnthropicCua,- RunEngine.YutoriNavigator,];-function BadgeLabel({ option }: { option: EngineOption }) {- return (- <div className="flex items-center gap-2">- <span>{option.label}</span>- {option.badge && (- <span- className={cn("rounded px-1.5 py-0.5 text-[10px] font-medium", {- "bg-green-500/20 text-green-400": option.badgeVariant === "success",- "bg-amber-500/20 text-amber-400": option.badgeVariant === "warning",- "bg-slate-500/20 text-slate-400":- option.badgeVariant === "default" || !option.badgeVariant,- })}- >- {option.badge}- </span>- )}- </div>- );-}-function RunEngineSelector({value,onChange,@@ -84,8 +69,10 @@ function RunEngineSelector({availableEngines,}: Props) {const engines = availableEngines ?? defaultEngines;+ const visibleEngines =+ value && !engines.includes(value) ? [...engines, value] : engines;const engineOptions = allEngineOptions.filter((opt) =>- engines.includes(opt.value),+ visibleEngines.includes(opt.value),);const selectedOption = engineOptions.find(@@ -96,13 +83,23 @@ function RunEngineSelector({<Select value={value ?? RunEngine.SkyvernV1} onValueChange={onChange}><SelectTrigger className={className}><SelectValue>- {selectedOption && <BadgeLabel option={selectedOption} />}+ {selectedOption && (+ <BadgeLabel+ label={selectedOption.label}+ badge={selectedOption.badge}+ badgeVariant={selectedOption.badgeVariant}+ />+ )}</SelectValue></SelectTrigger><SelectContent>{engineOptions.map((option) => (<SelectItem key={option.value} value={option.value}>- <BadgeLabel option={option} />+ <BadgeLabel+ label={option.label}+ badge={option.badge}+ badgeVariant={option.badgeVariant}+ /></SelectItem>))}</SelectContent>diff --git a/skyvern-frontend/src/components/ModelSelector.test.tsx b/skyvern-frontend/src/components/ModelSelector.test.tsxindex 6c06e9716..8ed2c9f84 100644--- a/skyvern-frontend/src/components/ModelSelector.test.tsx+++ b/skyvern-frontend/src/components/ModelSelector.test.tsx@@ -2,6 +2,7 @@import { QueryClient, QueryClientProvider } from "@tanstack/react-query";import { cleanup, render, screen } from "@testing-library/react";+import type { ReactNode } from "react";import { afterEach, describe, expect, test, vi } from "vitest";import { WorkflowScopeContext } from "@/routes/workflows/editor/WorkflowScopeContext";@@ -18,23 +19,42 @@ vi.mock("@/api/AxiosClient", () => ({vi.mock("@/hooks/useCredentialGetter", () => ({useCredentialGetter: () => null,}));+vi.mock("@/components/ui/select", () => ({+ Select: ({ children }: { children?: ReactNode }) => <div>{children}</div>,+ SelectContent: ({ children }: { children?: ReactNode }) => (+ <div>{children}</div>+ ),+ SelectItem: ({+ children,+ value,+ }: {+ children?: ReactNode;+ value: string;+ }) => <div data-testid={`select-item-${value}`}>{children}</div>,+ SelectTrigger: ({ children }: { children?: ReactNode }) => (+ <button type="button">{children}</button>+ ),+ SelectValue: ({ placeholder }: { placeholder?: string }) => (+ <span>{placeholder}</span>+ ),+}));afterEach(() => {cleanup();vi.clearAllMocks();});-function renderSelector(readOnly: boolean) {+function renderSelector(+ readOnly: boolean,+ value: { model_name: string } | null = { model_name: "removed-model-x" },+) {const client = new QueryClient({defaultOptions: { queries: { retry: false } },});return render(<QueryClientProvider client={client}><WorkflowScopeContext.Provider value={{ workflowId: "w", readOnly }}>- <ModelSelector- value={{ model_name: "removed-model-x" }}- onChange={() => {}}- />+ <ModelSelector value={value} onChange={() => {}} /></WorkflowScopeContext.Provider></QueryClientProvider>,);@@ -53,4 +73,79 @@ describe("ModelSelector in a read-only comparison scope", () => {renderSelector(false);expect(screen.queryByTestId("model-selector-readonly")).toBeNull();});++ test("marks Claude Opus models as enterprise-only", async () => {+ getMock.mockResolvedValueOnce({+ data: {+ models: {+ "us.anthropic.claude-opus-4-20250514-v1:0": "Anthropic Claude 4 Opus",+ "claude-opus-4-6": "Anthropic Claude 4.6 Opus",+ "claude-opus-4-7": "Anthropic Claude 4.7 Opus",+ "claude-opus-4-8": "Anthropic Claude 4.8 Opus",+ },+ },+ });++ renderSelector(false, null);++ expect(await screen.findByText("Anthropic Claude 4 Opus")).toBeTruthy();+ expect(await screen.findByText("Anthropic Claude 4.6 Opus")).toBeTruthy();+ expect(await screen.findByText("Anthropic Claude 4.7 Opus")).toBeTruthy();+ expect(await screen.findByText("Anthropic Claude 4.8 Opus")).toBeTruthy();+ expect(screen.getAllByText("Enterprise")).toHaveLength(4);+ });++ test("marks selected deprecated Claude Opus 4.5 as enterprise-only", async () => {+ getMock.mockResolvedValueOnce({+ data: {+ models: {+ "claude-opus-4-5-20251101": "Anthropic Claude 4.5 Opus",+ },+ },+ });++ renderSelector(false, { model_name: "claude-opus-4-5-20251101" });++ expect(+ await screen.findByText("Anthropic Claude 4.5 Opus (deprecated)"),+ ).toBeTruthy();+ expect(screen.getByText("Enterprise")).toBeTruthy();+ });++ test("hides newly deprecated models unless currently selected", async () => {+ getMock.mockResolvedValueOnce({+ data: {+ models: {+ "azure/gpt-5.2": "GPT 5.2",+ "claude-opus-4-5-20251101": "Anthropic Claude 4.5 Opus",+ "mercury-2": "Inception Mercury 2",+ "azure/gpt-5.4": "GPT 5.4",+ },+ },+ });++ renderSelector(false, null);++ expect(await screen.findByText("GPT 5.4")).toBeTruthy();+ expect(screen.queryByText("GPT 5.2 (deprecated)")).toBeNull();+ expect(+ screen.queryByText("Anthropic Claude 4.5 Opus (deprecated)"),+ ).toBeNull();+ expect(screen.queryByText("Inception Mercury 2 (deprecated)")).toBeNull();+ });++ test("keeps a selected deprecated model visible", async () => {+ getMock.mockResolvedValueOnce({+ data: {+ models: {+ "azure/gpt-5.2": "GPT 5.2",+ "azure/gpt-5.4": "GPT 5.4",+ },+ },+ });++ renderSelector(false, { model_name: "azure/gpt-5.2" });++ expect(await screen.findByText("GPT 5.2 (deprecated)")).toBeTruthy();+ });});diff --git a/skyvern-frontend/src/components/ModelSelector.tsx b/skyvern-frontend/src/components/ModelSelector.tsxindex 7eb88885a..f92a69e6a 100644--- a/skyvern-frontend/src/components/ModelSelector.tsx+++ b/skyvern-frontend/src/components/ModelSelector.tsx@@ -13,6 +13,7 @@ import { useCredentialGetter } from "@/hooks/useCredentialGetter";import { ModelsResponse } from "@/api/types";import { WorkflowModel } from "@/routes/workflows/types/workflowTypes";import { useWorkflowScopeReadOnly } from "@/routes/workflows/editor/WorkflowScopeContext";+import { BadgeLabel } from "@/components/BadgeLabel";type Props = {className?: string;@@ -30,8 +31,19 @@ const deprecatedModelNames = new Set<string>(["gemini-2.5-flash-lite","azure/gpt-4.1","azure/gpt-5",+ "azure/gpt-5.2","azure/o3","claude-haiku-4-5-20251001",+ "claude-opus-4-5-20251101",+ "mercury-2",+]);++const enterpriseModelNames = new Set<string>([+ "us.anthropic.claude-opus-4-20250514-v1:0",+ "claude-opus-4-5-20251101",+ "claude-opus-4-6",+ "claude-opus-4-7",+ "claude-opus-4-8",]);function ModelSelector({@@ -122,15 +134,26 @@ function ModelSelector({<SelectValue placeholder={constants.SkyvernOptimized} /></SelectTrigger><SelectContent>- {choices.map((m) => (- <SelectItem key={m} value={m}>- {m === constants.SkyvernOptimized ? (- <span>Skyvern Optimized ✨</span>- ) : (- m- )}- </SelectItem>- ))}+ {choices.map((m) => {+ const modelName = reverseMap[m];+ return (+ <SelectItem key={m} value={m}>+ {m === constants.SkyvernOptimized ? (+ <span>Skyvern Optimized ✨</span>+ ) : (+ <BadgeLabel+ label={m}+ badge={+ modelName && enterpriseModelNames.has(modelName)+ ? "Enterprise"+ : undefined+ }+ badgeVariant="warning"+ />+ )}+ </SelectItem>+ );+ })}</SelectContent></Select>{value && clearable && (diff --git a/skyvern/forge/agent_functions.py b/skyvern/forge/agent_functions.pyindex bcff6b10f..cdd79d753 100644--- a/skyvern/forge/agent_functions.py+++ b/skyvern/forge/agent_functions.py@@ -646,6 +646,13 @@ class AgentFunction:) -> None:return+ async def validate_enterprise_feature_access(+ self,+ organization_id: str | None = None,+ feature_names: set[str] | None = None,+ ) -> None:+ return+async def prepare_step_execution(self,organization: Organization | None,diff --git a/skyvern/forge/sdk/enterprise_features.py b/skyvern/forge/sdk/enterprise_features.pynew file mode 100644index 000000000..0b57ef719--- /dev/null+++ b/skyvern/forge/sdk/enterprise_features.py@@ -0,0 +1,39 @@+from typing import Any++from skyvern.schemas.runs import RunEngine++ENTERPRISE_GATED_RUN_ENGINES: dict[RunEngine, str] = {+ RunEngine.openai_cua: "OpenAI CUA",+ RunEngine.anthropic_cua: "Anthropic CUA",+}+ENTERPRISE_GATED_MODEL_NAMES: dict[str, str] = {+ "us.anthropic.claude-opus-4-20250514-v1:0": "Anthropic Claude 4 Opus",+ "claude-opus-4-5-20251101": "Anthropic Claude 4.5 Opus",+ "claude-opus-4-6": "Anthropic Claude 4.6 Opus",+ "claude-opus-4-7": "Anthropic Claude 4.7 Opus",+ "claude-opus-4-8": "Anthropic Claude 4.8 Opus",+}+++def _get_model_name(model: dict[str, Any] | None) -> str | None:+ if not isinstance(model, dict):+ return None+ model_name = model.get("model_name")+ return model_name if isinstance(model_name, str) else None+++def collect_enterprise_gated_run_features(+ *,+ engine: RunEngine | None = None,+ model: dict[str, Any] | None = None,+) -> set[str]:+ feature_names: set[str] = set()++ if engine in ENTERPRISE_GATED_RUN_ENGINES:+ feature_names.add(ENTERPRISE_GATED_RUN_ENGINES[engine])++ model_name = _get_model_name(model)+ if model_name in ENTERPRISE_GATED_MODEL_NAMES:+ feature_names.add(ENTERPRISE_GATED_MODEL_NAMES[model_name])++ return feature_namesdiff --git a/skyvern/forge/sdk/routes/agent_protocol.py b/skyvern/forge/sdk/routes/agent_protocol.pyindex 143a5797a..6d33ebcc1 100644--- a/skyvern/forge/sdk/routes/agent_protocol.py+++ b/skyvern/forge/sdk/routes/agent_protocol.py@@ -33,9 +33,11 @@ from skyvern._version import __version__from skyvern.analytics import get_oss_versionfrom skyvern.config import settingsfrom skyvern.exceptions import (+ DisabledBlockExecutionError,MissingBrowserAddressError,SkyvernHTTPException,WorkflowNotFound,+ get_user_facing_exception_message,)from skyvern.forge import appfrom skyvern.forge.prompts import prompt_engine@@ -53,6 +55,7 @@ from skyvern.forge.sdk.core.curl_converter import curl_to_http_request_block_parfrom skyvern.forge.sdk.core.permissions.permission_checker_factory import PermissionCheckerFactoryfrom skyvern.forge.sdk.core.security import generate_skyvern_signaturefrom skyvern.forge.sdk.db.enums import OrganizationAuthTokenType+from skyvern.forge.sdk.enterprise_features import collect_enterprise_gated_run_featuresfrom skyvern.forge.sdk.executor.factory import AsyncExecutorFactoryfrom skyvern.forge.sdk.models import Stepfrom skyvern.forge.sdk.routes.code_samples import (@@ -174,6 +177,28 @@ FORCE_TASK_V1_MAX_STEPS = 25_create_from_prompt_adapter: TypeAdapter[CreateFromPromptRequest] = TypeAdapter(CreateFromPromptRequest)+async def _validate_enterprise_gated_task_run_features(+ *,+ organization_id: str,+ engine: RunEngine | None = None,+ model: dict[str, Any] | None = None,+) -> None:+ feature_names = collect_enterprise_gated_run_features(engine=engine, model=model)+ if not feature_names:+ return++ try:+ await app.AGENT_FUNCTION.validate_enterprise_feature_access(+ organization_id=organization_id,+ feature_names=feature_names,+ )+ except DisabledBlockExecutionError as e:+ raise HTTPException(+ status_code=http_status.HTTP_403_FORBIDDEN,+ detail=get_user_facing_exception_message(e),+ ) from e++class AISuggestionType(str, Enum):DATA_SCHEMA = "data_schema"@@ -247,6 +272,12 @@ async def run_task(if not run_request.max_steps or run_request.max_steps > cap:run_request.max_steps = cap+ await _validate_enterprise_gated_task_run_features(+ organization_id=current_org.organization_id,+ engine=run_request.engine,+ model=run_request.model,+ )+if run_request.engine in CUA_ENGINES or run_request.engine == RunEngine.skyvern_v1:# create task v1# if there's no url, call task generation first to generate the url, data schema if any@@ -2680,6 +2711,11 @@ async def run_task_v1(analytics.capture("skyvern-oss-agent-task-create", data={"url": task.url})await PermissionCheckerFactory.get_instance().check(current_org, browser_session_id=task.browser_session_id)await app.RATE_LIMITER.rate_limit_submit_run(current_org.organization_id)+ # Legacy TaskRequest has no engine field; CUA engine selection goes through /run/tasks.+ await _validate_enterprise_gated_task_run_features(+ organization_id=current_org.organization_id,+ model=task.model,+ )created_task = await task_v1_service.run_task(task=task,diff --git a/skyvern/forge/sdk/workflow/service.py b/skyvern/forge/sdk/workflow/service.pyindex 92e4ee08f..12bd7d926 100644--- a/skyvern/forge/sdk/workflow/service.py+++ b/skyvern/forge/sdk/workflow/service.py@@ -38,6 +38,7 @@ from skyvern.exceptions import (BrowserProfileNotFound,BrowserSessionNotFound,BrowserSessionNotRenewable,+ DisabledBlockExecutionError,InvalidCredentialId,MissingValueForParameter,ScriptTerminationException,@@ -61,6 +62,7 @@ from skyvern.forge.sdk.core.security import generate_skyvern_webhook_signaturefrom skyvern.forge.sdk.core.skyvern_context import SkyvernContextfrom skyvern.forge.sdk.db._sentinels import _UNSETfrom skyvern.forge.sdk.db.enums import OrganizationAuthTokenType, WorkflowRunTriggerType+from skyvern.forge.sdk.enterprise_features import collect_enterprise_gated_run_featuresfrom skyvern.forge.sdk.experimentation.enrich_tree import resolve_enrich_tree_for_contextfrom skyvern.forge.sdk.experimentation.screenshot_downscale import resolve_screenshot_downscale_for_contextfrom skyvern.forge.sdk.models import Step, StepStatus@@ -75,13 +77,17 @@ from skyvern.forge.sdk.workflow.exceptions import (WorkflowVersionConflict,)from skyvern.forge.sdk.workflow.models.block import (+ BaseTaskBlock,Block,BlockTypeVar,ConditionalBlock,ExtractionBlock,+ FileParserBlock,ForLoopBlock,NavigationBlock,+ PDFParserBlock,TaskV2Block,+ TextPromptBlock,WhileLoopBlock,WorkflowTriggerBlock,compute_conditional_scopes,@@ -181,6 +187,42 @@ def _format_workflow_run_elapsed_timeout_failure_reason(effective_minutes: int)return f"Workflow run exceeded max elapsed runtime limit of {effective_minutes} {minute_label}."+def _collect_enterprise_gated_workflow_features(+ workflow: Workflow,+ *,+ block_labels: list[str] | None = None,+) -> set[str]:+ # workflow.model is editor metadata today; executable blocks read their own model fields.+ feature_names: set[str] = set()++ all_blocks = get_all_blocks(workflow.workflow_definition.blocks)+ if block_labels:+ blocks_by_label = {block.label: block for block in all_blocks}+ blocks_to_check = get_all_blocks([blocks_by_label[label] for label in block_labels if label in blocks_by_label])+ else:+ blocks_to_check = all_blocks++ for block in blocks_to_check:+ # TaskV2Block deliberately stays out of this set: its inherited model field is not consumed at runtime.+ task_block_uses_engine_and_model = (+ isinstance(block, BaseTaskBlock) and block.block_type != BlockType.HUMAN_INTERACTION+ )+ block_uses_model = task_block_uses_engine_and_model or isinstance(+ block,+ (TextPromptBlock, FileParserBlock, PDFParserBlock),+ )+ engine = block.engine if task_block_uses_engine_and_model else None+ model = block.model if block_uses_model else None+ feature_names.update(+ collect_enterprise_gated_run_features(+ engine=engine,+ model=model,+ )+ )++ return feature_names++def _select_recording_urls_in_window(recordings: Sequence[FileInfo],lower_bound: datetime,@@ -1503,6 +1545,36 @@ class WorkflowService:)return workflow_run+ enterprise_gated_features = _collect_enterprise_gated_workflow_features(workflow, block_labels=block_labels)+ if enterprise_gated_features:+ try:+ await app.AGENT_FUNCTION.validate_enterprise_feature_access(+ organization_id=organization_id,+ feature_names=enterprise_gated_features,+ )+ except DisabledBlockExecutionError as e:+ LOG.warning(+ "Workflow uses enterprise-gated features without access",+ workflow_run_id=workflow_run_id,+ organization_id=organization_id,+ workflow_permanent_id=workflow.workflow_permanent_id,+ enterprise_gated_features=sorted(enterprise_gated_features),+ exc_info=True,+ )+ workflow_run = await self.mark_workflow_run_as_failed(+ workflow_run_id=workflow_run_id,+ failure_reason=get_user_facing_exception_message(e),+ )+ await self.clean_up_workflow(+ workflow=workflow,+ workflow_run=workflow_run,+ api_key=api_key,+ browser_session_id=browser_session_id,+ close_browser_on_completion=close_browser_on_completion,+ need_call_webhook=need_call_webhook,+ )+ return workflow_run+# Set workflow run status to running, create workflow run parametersworkflow_run = await self.mark_workflow_run_as_running(workflow_run_id=workflow_run_id)# Short-circuit when the conditional transition was refused (cron beat usdiff --git a/tests/unit/test_workflow_elapsed_timeout.py b/tests/unit/test_workflow_elapsed_timeout.pyindex d680c8e82..283b9abe1 100644--- a/tests/unit/test_workflow_elapsed_timeout.py+++ b/tests/unit/test_workflow_elapsed_timeout.py@@ -141,6 +141,7 @@ async def test_execute_workflow_returns_after_elapsed_timeout_without_finally(motitle="Timeout workflow",organization_id="org_1",generate_script_on_terminal=False,+ model=None,workflow_definition=SimpleNamespace(parameters=[],finally_block_label="cleanup",@@ -215,6 +216,7 @@ async def test_execute_workflow_times_out_slow_pre_block_script_lookup(monkeypattitle="Timeout workflow",organization_id="org_1",generate_script_on_terminal=False,+ model=None,workflow_definition=SimpleNamespace(parameters=[],finally_block_label="cleanup",@@ -285,6 +287,7 @@ async def test_execute_workflow_preserves_completed_status_after_post_run_timeoutitle="Timeout workflow",organization_id="org_1",generate_script_on_terminal=False,+ model=None,workflow_definition=SimpleNamespace(parameters=[],finally_block_label="cleanup",@@ -373,6 +376,7 @@ async def test_execute_workflow_preserves_timed_out_status_after_non_terminal_potitle="Timeout workflow",organization_id="org_1",generate_script_on_terminal=False,+ model=None,workflow_definition=SimpleNamespace(parameters=[],finally_block_label="cleanup",@@ -467,6 +471,7 @@ async def test_execute_workflow_marks_timed_out_when_post_run_budget_is_exhaustetitle="Timeout workflow",organization_id="org_1",generate_script_on_terminal=False,+ model=None,workflow_definition=SimpleNamespace(parameters=[],finally_block_label="cleanup",@@ -638,6 +643,7 @@ async def test_execute_workflow_refreshes_terminal_status_after_immediate_post_rtitle="Timeout workflow",organization_id="org_1",generate_script_on_terminal=False,+ model=None,workflow_definition=SimpleNamespace(parameters=[],finally_block_label="cleanup",@@ -726,6 +732,7 @@ async def test_execute_workflow_returns_finalized_status_after_post_run_timeout(title="Timeout workflow",organization_id="org_1",generate_script_on_terminal=False,+ model=None,workflow_definition=SimpleNamespace(parameters=[],finally_block_label="cleanup",@@ -820,6 +827,7 @@ async def test_execute_workflow_runs_finally_for_existing_timed_out_status(title="Timeout workflow",organization_id="org_1",generate_script_on_terminal=False,+ model=None,workflow_definition=SimpleNamespace(parameters=[],finally_block_label="cleanup",diff --git a/tests/unit/workflow/test_enterprise_feature_gating.py b/tests/unit/workflow/test_enterprise_feature_gating.pynew file mode 100644index 000000000..28bef0eef--- /dev/null+++ b/tests/unit/workflow/test_enterprise_feature_gating.py@@ -0,0 +1,235 @@+from datetime import UTC, datetime+from types import SimpleNamespace+from unittest.mock import AsyncMock++import pytest++from skyvern.exceptions import DisabledBlockExecutionError+from skyvern.forge.sdk.enterprise_features import collect_enterprise_gated_run_features+from skyvern.forge.sdk.workflow import service as service_module+from skyvern.forge.sdk.workflow.models.block import (+ BlockTypeVar,+ BranchCondition,+ ConditionalBlock,+ ForLoopBlock,+ NavigationBlock,+ TaskV2Block,+)+from skyvern.forge.sdk.workflow.models.parameter import OutputParameter+from skyvern.forge.sdk.workflow.models.workflow import Workflow, WorkflowDefinition, WorkflowRunStatus+from skyvern.forge.sdk.workflow.service import WorkflowService, _collect_enterprise_gated_workflow_features+from skyvern.schemas.runs import RunEngine+++def _output_parameter(key: str) -> OutputParameter:+ now = datetime.now(UTC)+ return OutputParameter(+ output_parameter_id=f"{key}_id",+ key=key,+ workflow_id="wf",+ created_at=now,+ modified_at=now,+ )+++def _navigation_block(+ label: str,+ *,+ engine: RunEngine = RunEngine.skyvern_v1,+ model: dict[str, str] | None = None,+) -> NavigationBlock:+ return NavigationBlock(+ url="https://example.com",+ label=label,+ title=label,+ navigation_goal="goal",+ output_parameter=_output_parameter(f"{label}_output"),+ engine=engine,+ model=model,+ )+++def _workflow(blocks: list[BlockTypeVar], model: dict[str, str] | None = None) -> Workflow:+ now = datetime.now(UTC)+ return Workflow(+ workflow_id="wf",+ organization_id="org",+ title="workflow",+ workflow_permanent_id="wpid",+ version=1,+ is_saved_task=False,+ workflow_definition=WorkflowDefinition(parameters=[], blocks=blocks),+ model=model,+ created_at=now,+ modified_at=now,+ )+++def test_collects_cua_engines_and_opus_46_models() -> None:+ workflow = _workflow(+ [+ _navigation_block("openai", engine=RunEngine.openai_cua),+ _navigation_block("opus", model={"model_name": "claude-opus-4-6"}),+ ],+ )++ assert _collect_enterprise_gated_workflow_features(workflow) == {+ "Anthropic Claude 4.6 Opus",+ "OpenAI CUA",+ }+++def test_collects_nested_anthropic_cua_engine() -> None:+ loop = ForLoopBlock(+ label="loop",+ output_parameter=_output_parameter("loop_output"),+ loop_blocks=[_navigation_block("anthropic", engine=RunEngine.anthropic_cua)],+ )+ workflow = _workflow([loop])++ assert _collect_enterprise_gated_workflow_features(workflow) == {"Anthropic CUA"}+++def test_block_label_filter_ignores_unselected_gated_blocks() -> None:+ workflow = _workflow(+ [+ _navigation_block("standard"),+ _navigation_block("openai", engine=RunEngine.openai_cua),+ ],+ )++ assert _collect_enterprise_gated_workflow_features(workflow, block_labels=["standard"]) == set()+++def test_block_label_filter_includes_selected_nested_gated_blocks() -> None:+ loop = ForLoopBlock(+ label="loop",+ output_parameter=_output_parameter("loop_output"),+ loop_blocks=[_navigation_block("anthropic", engine=RunEngine.anthropic_cua)],+ )+ workflow = _workflow([_navigation_block("standard"), loop])++ assert _collect_enterprise_gated_workflow_features(workflow, block_labels=["loop"]) == {"Anthropic CUA"}+++def test_ignores_unused_workflow_level_gated_model() -> None:+ workflow = _workflow(+ [_navigation_block("standard")],+ model={"model_name": "claude-opus-4-6"},+ )++ assert _collect_enterprise_gated_workflow_features(workflow) == set()+ assert _collect_enterprise_gated_workflow_features(workflow, block_labels=["standard"]) == set()+++def test_collects_conditional_branch_target_gated_blocks() -> None:+ conditional = ConditionalBlock(+ label="choose",+ output_parameter=_output_parameter("choose_output"),+ branch_conditions=[BranchCondition(is_default=True, next_block_label="openai")],+ )+ workflow = _workflow([conditional, _navigation_block("openai", engine=RunEngine.openai_cua)])++ assert _collect_enterprise_gated_workflow_features(workflow) == {"OpenAI CUA"}+++def test_ignores_non_enterprise_models_and_engines() -> None:+ workflow = _workflow(+ [_navigation_block("standard", model={"model_name": "gpt-4o"})],+ model={"model_name": "gemini-2.5-flash"},+ )++ assert _collect_enterprise_gated_workflow_features(workflow) == set()+++def test_ignores_stale_model_on_task_v2_block() -> None:+ workflow = _workflow(+ [+ TaskV2Block(+ label="task-v2",+ prompt="goal",+ output_parameter=_output_parameter("task_v2_output"),+ model={"model_name": "claude-opus-4-6"},+ )+ ]+ )++ assert _collect_enterprise_gated_workflow_features(workflow) == set()+++ ("model_name", "feature_name"),+ [+ ("us.anthropic.claude-opus-4-20250514-v1:0", "Anthropic Claude 4 Opus"),+ ("claude-opus-4-5-20251101", "Anthropic Claude 4.5 Opus"),+ ("claude-opus-4-6", "Anthropic Claude 4.6 Opus"),+ ("claude-opus-4-7", "Anthropic Claude 4.7 Opus"),+ ("claude-opus-4-8", "Anthropic Claude 4.8 Opus"),+ ],+)+def test_collects_opus_model_alias_enterprise_features(model_name: str, feature_name: str) -> None:+ assert collect_enterprise_gated_run_features(model={"model_name": model_name}) == {feature_name}+++def test_collects_direct_run_enterprise_features() -> None:+ assert collect_enterprise_gated_run_features(+ engine=RunEngine.anthropic_cua,+ model={"model_name": "claude-opus-4-6"},+ ) == {+ "Anthropic CUA",+ "Anthropic Claude 4.6 Opus",+ }+++async def test_execute_workflow_cleans_up_after_enterprise_gate_failure(monkeypatch: pytest.MonkeyPatch) -> None:+ workflow = _workflow([_navigation_block("openai", engine=RunEngine.openai_cua)])+ workflow_run = SimpleNamespace(+ workflow_run_id="wr_1",+ workflow_permanent_id=workflow.workflow_permanent_id,+ browser_profile_id=None,+ browser_address=None,+ status=WorkflowRunStatus.created,+ )+ failed_workflow_run = SimpleNamespace(+ workflow_run_id="wr_1",+ workflow_permanent_id=workflow.workflow_permanent_id,+ status=WorkflowRunStatus.failed,+ )+ organization = SimpleNamespace(organization_id="org")+ agent_function = SimpleNamespace(+ validate_enterprise_feature_access=AsyncMock(+ side_effect=DisabledBlockExecutionError("Enterprise plan required for OpenAI CUA")+ )+ )+ monkeypatch.setattr(service_module.app, "AGENT_FUNCTION", agent_function)+ monkeypatch.setattr(service_module.workflow_script_service, "workflow_has_conditionals", lambda _workflow: False)++ svc = WorkflowService()+ monkeypatch.setattr(svc, "get_workflow_run", AsyncMock(return_value=workflow_run))+ monkeypatch.setattr(svc, "get_workflow_by_permanent_id", AsyncMock(return_value=workflow))+ mark_workflow_run_as_failed = AsyncMock(return_value=failed_workflow_run)+ clean_up_workflow = AsyncMock()+ monkeypatch.setattr(svc, "mark_workflow_run_as_failed", mark_workflow_run_as_failed)+ monkeypatch.setattr(svc, "clean_up_workflow", clean_up_workflow)++ result = await svc.execute_workflow(+ workflow_run_id="wr_1",+ api_key="api_key",+ organization=organization,+ )++ assert result is failed_workflow_run+ agent_function.validate_enterprise_feature_access.assert_awaited_once_with(+ organization_id="org",+ feature_names={"OpenAI CUA"},+ )+ mark_workflow_run_as_failed.assert_awaited_once()+ clean_up_workflow.assert_awaited_once_with(+ workflow=workflow,+ workflow_run=failed_workflow_run,+ api_key="api_key",+ browser_session_id=None,+ close_browser_on_completion=True,+ need_call_webhook=True,+ )