Skip to content

Automate browser based workflows with AI

Gate CUA and Opus models for enterprise (#6420)

Suchintanddf6f6cf4b48
diff --git a/skyvern-frontend/src/components/BadgeLabel.tsx b/skyvern-frontend/src/components/BadgeLabel.tsx
new file mode 100644
index 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.tsx
new file mode 100644
index 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.tsx
index 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.tsx
index 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.tsx
index 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.py
index 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.py
new file mode 100644
index 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_names
diff --git a/skyvern/forge/sdk/routes/agent_protocol.py b/skyvern/forge/sdk/routes/agent_protocol.py
index 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_version
from skyvern.config import settings
from skyvern.exceptions import (
+ DisabledBlockExecutionError,
MissingBrowserAddressError,
SkyvernHTTPException,
WorkflowNotFound,
+ get_user_facing_exception_message,
)
from skyvern.forge import app
from skyvern.forge.prompts import prompt_engine
@@ -53,6 +55,7 @@ from skyvern.forge.sdk.core.curl_converter import curl_to_http_request_block_par
from skyvern.forge.sdk.core.permissions.permission_checker_factory import PermissionCheckerFactory
from skyvern.forge.sdk.core.security import generate_skyvern_signature
from skyvern.forge.sdk.db.enums import OrganizationAuthTokenType
+from skyvern.forge.sdk.enterprise_features import collect_enterprise_gated_run_features
from skyvern.forge.sdk.executor.factory import AsyncExecutorFactory
from skyvern.forge.sdk.models import Step
from 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.py
index 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_signature
from skyvern.forge.sdk.core.skyvern_context import SkyvernContext
from skyvern.forge.sdk.db._sentinels import _UNSET
from skyvern.forge.sdk.db.enums import OrganizationAuthTokenType, WorkflowRunTriggerType
+from skyvern.forge.sdk.enterprise_features import collect_enterprise_gated_run_features
from skyvern.forge.sdk.experimentation.enrich_tree import resolve_enrich_tree_for_context
from skyvern.forge.sdk.experimentation.screenshot_downscale import resolve_screenshot_downscale_for_context
from 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 parameters
workflow_run = await self.mark_workflow_run_as_running(workflow_run_id=workflow_run_id)
# Short-circuit when the conditional transition was refused (cron beat us
diff --git a/tests/unit/test_workflow_elapsed_timeout.py b/tests/unit/test_workflow_elapsed_timeout.py
index 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(mo
title="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(monkeypat
title="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_timeou
title="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_po
title="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_exhauste
title="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_r
title="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.py
new file mode 100644
index 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,
+ )