Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
Restrict access to credential folders (#8950)
Aaron Perez1ae950bb9d83
diff --git a/docs/api-reference/openapi.json b/docs/api-reference/openapi.jsonindex 6ba474d8d..40c5cad8f 100644--- a/docs/api-reference/openapi.json+++ b/docs/api-reference/openapi.json@@ -11222,6 +11222,17 @@],"title": "Last Verified Login At"},+ "linked_credential_id": {+ "anyOf": [+ {+ "type": "string"+ },+ {+ "type": "null"+ }+ ],+ "title": "Linked Credential Id"+ },"linked_credential_name": {"anyOf": [{diff --git a/fern/openapi/skyvern_openapi.json b/fern/openapi/skyvern_openapi.jsonindex 9c549fe7f..f1a65e388 100644--- a/fern/openapi/skyvern_openapi.json+++ b/fern/openapi/skyvern_openapi.json@@ -11102,6 +11102,17 @@],"title": "Last Verified Login At"},+ "linked_credential_id": {+ "anyOf": [+ {+ "type": "string"+ },+ {+ "type": "null"+ }+ ],+ "title": "Linked Credential Id"+ },"linked_credential_name": {"anyOf": [{@@ -34515,4 +34526,4 @@"x-fern-server-name": "Local"}]-}\ No newline at end of file+}diff --git a/skyvern/forge/agent_functions.py b/skyvern/forge/agent_functions.pyindex 6c34a724f..505ef7a7a 100644--- a/skyvern/forge/agent_functions.py+++ b/skyvern/forge/agent_functions.py@@ -989,6 +989,40 @@ class AgentFunction:"""Return visible folder IDs for Cloud request lists; OSS keeps organization-wide visibility."""return None+ async def workflow_folders_restricted(self, organization_id: str) -> bool:+ """Cloud reports folder restrictions; OSS has no workflow-folder ACLs."""+ return False++ async def accessible_workflow_reference_ids(+ self, principal: RequestPrincipal | None, action: str, references: set[tuple[str, str]]+ ) -> set[tuple[str, str]]:+ """Return references visible to this principal; OSS has no workflow-folder ACLs."""+ return references++ async def accessible_credential_folder_ids(self, principal: RequestPrincipal | None) -> set[str] | None:+ """Return visible credential-folder IDs for Cloud request lists; OSS keeps organization-wide visibility."""+ return None++ async def credential_folders_restricted(self, organization_id: str) -> bool:+ """Cloud reports folder restrictions; OSS has no credential-folder ACLs."""+ return False++ async def credential_folder_admin_bypass(self, principal: RequestPrincipal | None) -> bool:+ """Cloud reports the credential-folder Admin bypass; OSS has no credential-folder ACLs."""+ return False++ async def accessible_credential_ids(+ self, principal: RequestPrincipal | None, action: str, credential_ids: set[str]+ ) -> set[str]:+ """Return credentials visible for an action; OSS has no credential-folder ACLs."""+ return credential_ids++ async def accessible_browser_session_ids(+ self, principal: RequestPrincipal | None, organization_id: str, browser_session_ids: set[str]+ ) -> set[str]:+ """Return sessions whose associated workflow credentials are usable; OSS has no credential-folder ACLs."""+ return browser_session_ids+async def enforce_folder_access(self, principal: RequestPrincipal | None, action: str, resource: Mapping[str, object]) -> None:@@ -1017,6 +1051,48 @@ class AgentFunction:"""Cloud raises 403 when a folder denies the action on any of the runs, checked in one pass; OSS allows."""return None+ async def enforce_credential_folder_access_for_ids(+ self,+ principal: RequestPrincipal | None,+ action: str,+ references: set[tuple[str, str]],+ *,+ session: AsyncSession | None = None,+ ) -> None:+ """Cloud raises 403 when a credential folder denies the action on any referenced credential or folder."""+ return None++ async def enforce_credential_use(+ self,+ organization_id: str,+ credential_id: str,+ *,+ principal: RequestPrincipal | None = None,+ workflow_run_id: str | None = None,+ ) -> None:+ """Cloud checks folder use before releasing a credential secret; OSS has no credential-folder ACLs."""++ async def enforce_totp_identifier_credential_use(+ self, organization_id: str, totp_identifier: str, *, workflow_run_id: str | None = None+ ) -> None:+ """Cloud checks credentials bound to a TOTP identifier; OSS has no credential-folder ACLs."""++ async def enforce_browser_session_credential_use(+ self, principal: RequestPrincipal | None, browser_session_id: str+ ) -> None:+ """Cloud checks the credential linked to a saved profile before session access; OSS has no folder ACLs."""++ async def enforce_workflow_run_credential_use(+ self,+ principal: RequestPrincipal | None,+ workflow_run_id: str,+ *,+ organization_id: str | None = None,+ browser_profile_id: str | None = None,+ browser_session_id: str | None = None,+ ) -> None:+ """Cloud checks credentials attached to run browser state; OSS has no credential-folder ACLs."""+async def hidden_workflow_permanent_ids(self, principal: RequestPrincipal | None, organization_id: str) -> frozenset[str] | None:diff --git a/skyvern/forge/sdk/copilot/credential_pause.py b/skyvern/forge/sdk/copilot/credential_pause.pyindex faca23cc4..c35931d4c 100644--- a/skyvern/forge/sdk/copilot/credential_pause.py+++ b/skyvern/forge/sdk/copilot/credential_pause.py@@ -40,7 +40,12 @@ from skyvern.forge import appfrom skyvern.forge.sdk.browser_action_policy import canonicalize_originfrom skyvern.forge.sdk.cache.base import BaseCachefrom skyvern.forge.sdk.copilot.config import CopilotConfig-from skyvern.forge.sdk.copilot.credential_resolution import loggable_origin, safe_admitted_url, url_parts+from skyvern.forge.sdk.copilot.credential_resolution import (+ load_credentials,+ loggable_origin,+ safe_admitted_url,+ url_parts,+)from skyvern.forge.sdk.copilot.diagnosis_repair_contract import DiagnosisFailureType, RepairNextActionfrom skyvern.forge.sdk.copilot.human_input_wait import pause_human_inputfrom skyvern.forge.sdk.copilot.request_policy import RequestPolicy@@ -914,7 +919,7 @@ async def _try_resolve_credential_response(return CredentialPauseResolution(action="signed_in", signed_in=signed_in) if signed_in else Noneif not credential_id:return None- existing = await app.DATABASE.credentials.get_credentials_by_ids([credential_id], organization_id=organization_id)+ existing = await load_credentials(organization_id, credential_ids=[credential_id])if not existing:return Nonereturn CredentialPauseResolution(action="connected", credential=existing[0])@@ -1063,7 +1068,10 @@ async def _run_credential_pause(from skyvern.forge.sdk.copilot.tools.credential_fill import _read_vault_named_sites # circular import# The vault entry's sites grant whole-site, so they are compared by site; an unreadable entry offers nothing.- vault_sites = await _read_vault_named_sites(ctx, named_credential_id)+ try:+ vault_sites = await _read_vault_named_sites(ctx, named_credential_id)+ except PermissionError:+ vault_sites = Noneif vault_sites is None or (vault_sites and not any(same_site(login_page_urls[0], uri) for uri in vault_sites)):named_credential_id = Nonetimeout_seconds = copilot_config.credential_pause_timeout_secondsdiff --git a/skyvern/forge/sdk/copilot/credential_resolution.py b/skyvern/forge/sdk/copilot/credential_resolution.pyindex 6b2b028ab..59ac3ab24 100644--- a/skyvern/forge/sdk/copilot/credential_resolution.py+++ b/skyvern/forge/sdk/copilot/credential_resolution.py@@ -14,6 +14,7 @@ from urllib.parse import ParseResult, parse_qsl, urlencode, urlparsefrom skyvern.forge import appfrom skyvern.forge.sdk.schemas.credentials import Credential, CredentialType+from skyvern.forge.sdk.services.request_principal import get_request_principalCredentialUrlTier = Literal["url_exact", "url_path", "url_host"]CredentialResolutionTier = Literal["url_exact", "url_path", "url_host", "urlless_sole"]@@ -32,17 +33,56 @@ class CredentialResolution:return any(candidate.credential_id == credential_id for candidate in self.candidates)-async def load_credentials(organization_id: str) -> list[Credential]:+async def credential_folder_ids_for_current_request() -> set[str] | None:+ principal = get_request_principal()+ return await app.AGENT_FUNCTION.accessible_credential_folder_ids(principal) if principal is not None else None+++async def load_credentials(+ organization_id: str,+ *,+ credential_ids: Sequence[str] | None = None,+ page: int | None = None,+ page_size: int = 50,+ include_deleted: bool = False,+) -> list[Credential]:+ allowed_folder_ids = await credential_folder_ids_for_current_request()+ if credential_ids is not None:+ return await app.DATABASE.credentials.get_credentials_by_ids(+ list(credential_ids),+ organization_id=organization_id,+ allowed_folder_ids=allowed_folder_ids,+ include_deleted=include_deleted,+ )+ if page is not None:+ return await app.DATABASE.credentials.get_credentials(+ organization_id=organization_id,+ page=page,+ page_size=page_size,+ allowed_folder_ids=allowed_folder_ids,+ )+page = 1credentials: list[Credential] = []while True:- items = await app.DATABASE.credentials.get_credentials(organization_id=organization_id, page=page, page_size=50)+ items = await app.DATABASE.credentials.get_credentials(+ organization_id=organization_id,+ page=page,+ page_size=50,+ allowed_folder_ids=allowed_folder_ids,+ )credentials.extend(items)if len(items) < 50:return sorted(credentials, key=lambda c: getattr(c, "created_at", None) or "", reverse=True)page += 1+async def count_visible_credentials(organization_id: str) -> int:+ return await app.DATABASE.credentials.count_credentials(+ organization_id, allowed_folder_ids=await credential_folder_ids_for_current_request()+ )++def _parse_url(url: str) -> ParseResult | None:"""`urlparse` that declines a malformed authority instead of raising.diff --git a/skyvern/forge/sdk/copilot/demonstration_recorder.py b/skyvern/forge/sdk/copilot/demonstration_recorder.pyindex a0c726bcb..8b729196c 100644--- a/skyvern/forge/sdk/copilot/demonstration_recorder.py+++ b/skyvern/forge/sdk/copilot/demonstration_recorder.py@@ -19,12 +19,11 @@ from playwright.async_api import Pagefrom skyvern.cli.mcp_tools._localhost import is_localhost_urlfrom skyvern.config import settingsfrom skyvern.exceptions import BlockedHost, SkyvernHTTPException-from skyvern.forge import appfrom skyvern.forge.sdk.cache.base import BaseCachefrom skyvern.forge.sdk.copilot.config import ALL_BLOCK_FAMILIES, AuthoringCapabilityfrom skyvern.forge.sdk.copilot.context import CopilotContextfrom skyvern.forge.sdk.copilot.credential_pause import apply_connected_credential_to_policy-from skyvern.forge.sdk.copilot.credential_resolution import safe_admitted_url+from skyvern.forge.sdk.copilot.credential_resolution import load_credentials, safe_admitted_urlfrom skyvern.forge.sdk.copilot.demonstration_tap import DEMONSTRATION_MAX_EVENTS, PageTap, TapEventfrom skyvern.forge.sdk.copilot.request_policy import RequestPolicyfrom skyvern.forge.sdk.copilot.runtime import (@@ -870,9 +869,7 @@ class DemonstrationRecorder:or self.page is None):return- credentials = await app.DATABASE.credentials.get_credentials_by_ids(- [credential_id], organization_id=self.organization_id- )+ credentials = await load_credentials(self.organization_id, credential_ids=[credential_id])if not credentials:await self._notice("The saved credential is no longer available.", level="error")returndiff --git a/skyvern/forge/sdk/copilot/demonstration_replay.py b/skyvern/forge/sdk/copilot/demonstration_replay.pyindex f9cd7e5d2..03ea9f240 100644--- a/skyvern/forge/sdk/copilot/demonstration_replay.py+++ b/skyvern/forge/sdk/copilot/demonstration_replay.py@@ -11,12 +11,11 @@ from typing import Any, castimport structlogfrom mcp.types import CallToolResult, TextContent-from skyvern.forge import appfrom skyvern.forge.sdk.api.llm.api_handler import LLMAPIHandlerfrom skyvern.forge.sdk.cache.base import BaseCachefrom skyvern.forge.sdk.copilot.context import CopilotContextfrom skyvern.forge.sdk.copilot.credential_pause import apply_connected_credential_to_policy-from skyvern.forge.sdk.copilot.credential_resolution import safe_admitted_url+from skyvern.forge.sdk.copilot.credential_resolution import load_credentials, safe_admitted_urlfrom skyvern.forge.sdk.copilot.demonstration_recorder import (DEMONSTRATION_CANCELLED_TTL,DEMONSTRATION_TTL,@@ -213,9 +212,7 @@ async def _replay_events(source_url = _safe_model_visible_url(_event_source_url(event))credentials = []if isinstance(credential_id, str):- credentials = await app.DATABASE.credentials.get_credentials_by_ids(- [credential_id], organization_id=ctx.organization_id- )+ credentials = await load_credentials(ctx.organization_id, credential_ids=[credential_id])policy = ctx.request_policyif credentials and isinstance(policy, RequestPolicy):policy.credential_ask_login_page_urls = [source_url]diff --git a/skyvern/forge/sdk/copilot/request_policy.py b/skyvern/forge/sdk/copilot/request_policy.pyindex d573d4f5d..ea8bcc49b 100644--- a/skyvern/forge/sdk/copilot/request_policy.py+++ b/skyvern/forge/sdk/copilot/request_policy.py@@ -14,7 +14,6 @@ import structlogfrom pydantic import BaseModel, ConfigDict, ValidationErrorfrom skyvern.config import settings-from skyvern.forge import appfrom skyvern.forge.log_redaction import redact_sensitive_fieldsfrom skyvern.forge.prompts import prompt_enginefrom skyvern.forge.sdk.api.llm.api_handler import LLMAPIHandler@@ -214,10 +213,7 @@ async def _saved_credential_ids(citations: list[str], organization_id: str) -> sconnection_ids = {citation for citation in citations if citation.startswith("goac_")}verified_ids: set[str] = set()if credential_ids:- credentials = await app.DATABASE.credentials.get_credentials_by_ids(- credential_ids,- organization_id=organization_id,- )+ credentials = await _load_credentials(organization_id, credential_ids=credential_ids)verified_ids.update(credential.credential_id for credential in credentials)if connection_ids:connections = await google_oauth_service.get_visible_credentials_for_org(organization_id)@@ -4363,10 +4359,7 @@ async def _seed_prior_approved_credentials(missing_ids = sorted(approved_ids - {credential.credential_id for credential in policy.resolved_credentials})if not missing_ids:return- credentials = await app.DATABASE.credentials.get_credentials_by_ids(- missing_ids,- organization_id=organization_id,- )+ credentials = await _load_credentials(organization_id, credential_ids=missing_ids)policy.resolved_credentials = _deduplicate_credentials([*policy.resolved_credentials,@@ -4391,10 +4384,7 @@ async def _seed_proposed_credential(seed = _proposed_credential_seed(global_llm_context)if seed is None:return- credentials = await app.DATABASE.credentials.get_credentials_by_ids(- [seed.credential_id],- organization_id=organization_id,- )+ credentials = await _load_credentials(organization_id, credential_ids=[seed.credential_id])credential = next((item for item in credentials if item.credential_id == seed.credential_id), None)if credential is None:returndiff --git a/skyvern/forge/sdk/copilot/tools/account_groups.py b/skyvern/forge/sdk/copilot/tools/account_groups.pyindex 8460c767b..417783303 100644--- a/skyvern/forge/sdk/copilot/tools/account_groups.py+++ b/skyvern/forge/sdk/copilot/tools/account_groups.py@@ -26,6 +26,7 @@ from skyvern.forge.sdk.copilot.ask_user import (wait_for_interaction,)from skyvern.forge.sdk.copilot.context import CopilotContext+from skyvern.forge.sdk.copilot.credential_resolution import load_credentialsfrom skyvern.forge.sdk.copilot.secret_redaction import redact_raw_secrets_for_promptfrom skyvern.forge.sdk.copilot.secret_scrub import scrub_secrets_from_structure, scrub_secrets_from_textfrom skyvern.forge.sdk.copilot.tools.credentials import (@@ -308,9 +309,7 @@ async def _latest_outcomes(async def _resolve_credentials(ctx: CopilotContext, credential_ids: list[str]) -> dict[str, Credential]:found = {credential.credential_id: credential- for credential in await app.DATABASE.credentials.get_credentials_by_ids(- credential_ids, organization_id=ctx.organization_id- )+ for credential in await load_credentials(ctx.organization_id, credential_ids=credential_ids)}missing = [credential_id for credential_id in credential_ids if credential_id not in found]if missing:@@ -453,6 +452,7 @@ def _rows(group: WorkflowRunGroupResponse, labels: dict[str, str]) -> list[Accououtcome=item.outcome,)for item in group.items+ if item.key in labels]@@ -558,8 +558,8 @@ async def _group_for_this_workflow(ctx: CopilotContext, workflow_run_group_id: sasync def _labels(ctx: CopilotContext, group: WorkflowRunGroupResponse) -> dict[str, str]:- credentials = await app.DATABASE.credentials.get_credentials_by_ids(- [item.key for item in group.items], organization_id=ctx.organization_id+ credentials = await load_credentials(+ ctx.organization_id, credential_ids=[item.key for item in group.items], include_deleted=True)return {credential.credential_id: _label(credential) for credential in credentials}diff --git a/skyvern/forge/sdk/copilot/tools/credential_deletion.py b/skyvern/forge/sdk/copilot/tools/credential_deletion.pyindex e894b32bf..6a251a27d 100644--- a/skyvern/forge/sdk/copilot/tools/credential_deletion.py+++ b/skyvern/forge/sdk/copilot/tools/credential_deletion.py@@ -4,6 +4,7 @@ from collections import Counterfrom typing import Any, Literalfrom uuid import uuid4+from fastapi import HTTPExceptionfrom pydantic import BaseModelfrom skyvern.config import settings@@ -17,6 +18,8 @@ from skyvern.forge.sdk.copilot.ask_user import (wait_for_interaction,)from skyvern.forge.sdk.copilot.context import CopilotContext+from skyvern.forge.sdk.copilot.credential_resolution import count_visible_credentials, load_credentials+from skyvern.forge.sdk.services.request_principal import get_request_principalDELETE_TOOL_DESCRIPTION = ("Delete saved credentials (passwords, cards, secrets) from this organization's Skyvern vault, after the "@@ -47,6 +50,12 @@ def credential_delete_enabled() -> bool:return settings.COPILOT_CREDENTIAL_DELETE_ENABLED+async def enforce_credential_delete_access(credential_id: str) -> None:+ await app.AGENT_FUNCTION.enforce_credential_folder_access_for_ids(+ get_request_principal(), "credential.delete", {("credential_id", credential_id)}+ )++async def build_delete_review(ctx: CopilotContext, credential_ids: list[str]) -> CredentialDeleteReview | str:if not credential_ids:return "Select at least one credential id."@@ -60,23 +69,32 @@ async def build_delete_review(ctx: CopilotContext, credential_ids: list[str]) ->return f"These credential ids are listed more than once: {duplicates}. Nothing was deleted."found = {credential.credential_id: credential- for credential in await app.DATABASE.credentials.get_credentials_by_ids(- credential_ids, organization_id=ctx.organization_id- )+ for credential in await load_credentials(ctx.organization_id, credential_ids=credential_ids)}missing = [credential_id for credential_id in credential_ids if credential_id not in found]if missing:return f"These ids are not saved credentials in this organization: {missing}. Nothing was deleted."- return CredentialDeleteReview(- rows=[+ rows: list[CredentialDeleteRow] = []+ for credential_id in credential_ids:+ try:+ await enforce_credential_delete_access(credential_id)+ except HTTPException as exc:+ if exc.status_code != 403:+ raise+ continue+ credential = found[credential_id]+ rows.append(CredentialDeleteRow(credential_id=credential_id,- name=found[credential_id].name,- credential_type=found[credential_id].credential_type,+ name=credential.name,+ credential_type=credential.credential_type,)- for credential_id in credential_ids- ],- total_credential_count=await app.DATABASE.credentials.count_credentials(ctx.organization_id),+ )+ if not rows:+ return "None of the selected credentials can be deleted. Nothing was deleted."+ return CredentialDeleteReview(+ rows=rows,+ total_credential_count=await count_visible_credentials(ctx.organization_id),)diff --git a/skyvern/forge/sdk/copilot/tools/credential_fill.py b/skyvern/forge/sdk/copilot/tools/credential_fill.pyindex c88a09d1e..732f98ac8 100644--- a/skyvern/forge/sdk/copilot/tools/credential_fill.py+++ b/skyvern/forge/sdk/copilot/tools/credential_fill.py@@ -83,6 +83,7 @@ from skyvern.forge.sdk.schemas.credentials import ()from skyvern.forge.sdk.schemas.workflow_copilot import CredentialRegistration, WorkflowCopilotCredentialRegistrationfrom skyvern.forge.sdk.services.credentials import generate_totp_code, normalize_totp_config+from skyvern.forge.sdk.services.request_principal import get_request_principalfrom skyvern.webeye.utils.dom import is_post_dispatch_click_timeoutfrom ._shared import _emit_tool_blocker_signal@@ -285,7 +286,10 @@ async def _credential_evidence_admits_origin("""Whether the credential itself places it on the recovery origin, and nowhere else."""if credential.credential_id == recovery.refused_credential_id:return False- vault_sites = await _read_vault_named_sites(copilot_ctx, credential.credential_id)+ try:+ vault_sites = await _read_vault_named_sites(copilot_ctx, credential.credential_id)+ except PermissionError:+ return Falseif vault_sites is None:return Falseevidence = ([credential.tested_url] if credential.tested_url else []) + vault_sites@@ -399,6 +403,11 @@ async def _vault_named_sites(copilot_ctx: AgentContext, credential_id: str) -> lasync def _read_vault_named_sites(copilot_ctx: AgentContext, credential_id: str) -> list[str] | None:"""Sites the credential's own vault entry names (only Bitwarden items carry any), or None when the read failed."""+ await app.AGENT_FUNCTION.enforce_credential_use(+ copilot_ctx.organization_id,+ credential_id,+ principal=get_request_principal(),+ )cached = copilot_ctx.vault_login_uris_by_credential_id.get(credential_id)if cached is not None:return cached@@ -1040,6 +1049,14 @@ async def _credential_fill_origin_grant(async def _load_vault_credential_item(copilot_ctx: AgentContext, credential_id: str) -> tuple[CredentialItem | None, str]:+ try:+ await app.AGENT_FUNCTION.enforce_credential_use(+ copilot_ctx.organization_id,+ credential_id,+ principal=get_request_principal(),+ )+ except PermissionError:+ return None, "Credential not accessible."try:db_credential = await app.DATABASE.credentials.get_credential(credential_id, organization_id=copilot_ctx.organization_id@@ -1378,7 +1395,10 @@ async def _fill_credential_field_impl_serial("error": f"fill_credential_field `field` must be one of: {', '.join(CREDENTIAL_FILL_FIELD_NAMES)}.",})- origin_grant, policy_error = await _credential_fill_origin_grant(copilot_ctx, credential_id)+ try:+ origin_grant, policy_error = await _credential_fill_origin_grant(copilot_ctx, credential_id)+ except PermissionError:+ return finish({"ok": False, "error": "Credential not accessible."})if policy_error or origin_grant is None:LOG.info("copilot fill_credential_field rejected tool-side",diff --git a/skyvern/forge/sdk/copilot/tools/credentials.py b/skyvern/forge/sdk/copilot/tools/credentials.pyindex 2da423a90..6653918f1 100644--- a/skyvern/forge/sdk/copilot/tools/credentials.py+++ b/skyvern/forge/sdk/copilot/tools/credentials.py@@ -880,10 +880,7 @@ async def _credential_ids_validation_error(credential_ids: list[str], ctx: Agent]try:existing_credentials = (- await app.DATABASE.credentials.get_credentials_by_ids(- password_credential_ids,- organization_id=ctx.organization_id,- )+ await load_credentials(ctx.organization_id, credential_ids=password_credential_ids)if password_credential_idselse [])@@ -1107,11 +1104,7 @@ async def _list_credentials(params: dict[str, Any], ctx: AgentContext) -> dict[spage = max(1, params.get("page", 1))page_size = min(max(1, params.get("page_size") or 10), LIST_CREDENTIALS_MAX_PAGE_SIZE)- credentials = await app.DATABASE.credentials.get_credentials(- organization_id=ctx.organization_id,- page=page,- page_size=page_size,- )+ credentials = await load_credentials(ctx.organization_id, page=page, page_size=page_size)serialized = [_serialize_credential(credential) for credential in credentials]_record_discovered_credentials_on_policy(ctx, credentials)return {diff --git a/skyvern/forge/sdk/copilot/tools/run_execution.py b/skyvern/forge/sdk/copilot/tools/run_execution.pyindex 37f5245a3..a53ccdd52 100644--- a/skyvern/forge/sdk/copilot/tools/run_execution.py+++ b/skyvern/forge/sdk/copilot/tools/run_execution.py@@ -3181,6 +3181,11 @@ async def _bind_origin_run_redaction_registry(awaiting_runtime_secret_values = Falsecredential_parameters: dict[str, Any] = {}for index, credential_id in enumerate(credential_ids):+ await app.AGENT_FUNCTION.enforce_credential_use(+ ctx.organization_id,+ credential_id,+ workflow_run_id=workflow_run_id,+ )try:db_credential = await app.DATABASE.credentials.get_credential(credential_id,diff --git a/skyvern/forge/sdk/db/repositories/browser_sessions.py b/skyvern/forge/sdk/db/repositories/browser_sessions.pyindex 6e51861d5..a775d8268 100644--- a/skyvern/forge/sdk/db/repositories/browser_sessions.py+++ b/skyvern/forge/sdk/db/repositories/browser_sessions.py@@ -355,6 +355,7 @@ class BrowserSessionsRepository(BaseRepository):page_size: int = 10,search_key: str | None = None,managed: bool | None = None,+ exclude_search_profile_ids: set[str] | None = None,) -> list[BrowserProfile]:if page < 1:raise ValueError(f"Page must be greater than 0, got {page}")@@ -377,6 +378,8 @@ class BrowserSessionsRepository(BaseRepository):BrowserProfileModel.description.ilike(search_like),))+ if exclude_search_profile_ids:+ query = query.filter(BrowserProfileModel.browser_profile_id.notin_(exclude_search_profile_ids))# The id tie-break only needs to be deterministic so pagination stays# stable when created_at collides; it isn't meant to encode recency.query = (@@ -391,17 +394,23 @@ class BrowserSessionsRepository(BaseRepository):# without a per-row usage fetch (which fanned out one 3-table join per row on every list load).if profiles:credential_rows = await session.execute(- select(CredentialModel.browser_profile_id, CredentialModel.name).where(+ select(+ CredentialModel.browser_profile_id,+ CredentialModel.credential_id,+ CredentialModel.name,+ ).where(CredentialModel.browser_profile_id.in_([p.browser_profile_id for p in profiles]),CredentialModel.organization_id == organization_id,CredentialModel.deleted_at.is_(None),))- name_by_profile: dict[str, str] = {}- for browser_profile_id, name in credential_rows.all():- name_by_profile.setdefault(browser_profile_id, name)+ credential_by_profile: dict[str, tuple[str, str]] = {}+ for browser_profile_id, credential_id, name in credential_rows.all():+ credential_by_profile.setdefault(browser_profile_id, (credential_id, name))for profile in profiles:- profile.linked_credential_name = name_by_profile.get(profile.browser_profile_id)+ linked_credential = credential_by_profile.get(profile.browser_profile_id)+ if linked_credential is not None:+ profile.linked_credential_id, profile.linked_credential_name = linked_credentialreturn profiles@@ -536,9 +545,7 @@ class BrowserSessionsRepository(BaseRepository):linked_credentials = (await session.scalars(- select(CredentialModel)- .filter_by(browser_profile_id=profile_id, organization_id=organization_id)- .filter(CredentialModel.deleted_at.is_(None))+ select(CredentialModel).filter_by(browser_profile_id=profile_id, organization_id=organization_id))).all()cleared_credential_ids = [credential.credential_id for credential in linked_credentials]diff --git a/skyvern/forge/sdk/db/repositories/credential_folders.py b/skyvern/forge/sdk/db/repositories/credential_folders.pyindex 3ef3f60a5..583632420 100644--- a/skyvern/forge/sdk/db/repositories/credential_folders.py+++ b/skyvern/forge/sdk/db/repositories/credential_folders.py@@ -1,8 +1,10 @@from __future__ import annotations+from collections.abc import Awaitable, Callablefrom datetime import datetime, timezonefrom sqlalchemy import func, or_, select, update+from sqlalchemy.ext.asyncio import AsyncSessionfrom skyvern.forge.sdk.db._error_handling import db_operationfrom skyvern.forge.sdk.db.base_repository import BaseRepository@@ -38,6 +40,7 @@ class CredentialFoldersRepository(BaseRepository):page: int = 1,page_size: int = 10,search_query: str | None = None,+ allowed_folder_ids: set[str] | None = None,) -> list[CredentialFolderModel]:async with self.Session() as session:stmt = (@@ -56,6 +59,9 @@ class CredentialFoldersRepository(BaseRepository):))+ if allowed_folder_ids is not None:+ stmt = stmt.filter(CredentialFolderModel.folder_id.in_(allowed_folder_ids))+stmt = stmt.order_by(CredentialFolderModel.modified_at.desc())stmt = stmt.offset((page - 1) * page_size).limit(page_size)@@ -186,24 +192,34 @@ class CredentialFoldersRepository(BaseRepository):credential_id: str,organization_id: str,folder_id: str | None,+ authorize_move: Callable[[AsyncSession], Awaitable[None]] | None = None,) -> Credential | None:# Treat an empty folder_id as "remove from folder" (None) so it isn't# written as a non-existent "" id and trip the folder foreign key.folder_id = folder_id or Noneasync with self.Session() as session:- credential = await session.get(CredentialModel, credential_id)+ credential = await session.scalar(+ select(CredentialModel).where(CredentialModel.credential_id == credential_id).with_for_update()+ )if credential is None or credential.organization_id != organization_id or credential.deleted_at is not None:return None# Validate the target folder in-org and bump its modified_at in a single fetchif folder_id:- folder_model = await session.get(CredentialFolderModel, folder_id)+ folder_model = await session.scalar(+ select(CredentialFolderModel).where(CredentialFolderModel.folder_id == folder_id).with_for_update()+ )if (folder_model is Noneor folder_model.organization_id != organization_idor folder_model.deleted_at is not None):raise ValueError(f"Credential folder {folder_id} not found")++ if authorize_move is not None:+ await authorize_move(session)++ if folder_id:folder_model.modified_at = datetime.now(timezone.utc)credential.folder_id = folder_iddiff --git a/skyvern/forge/sdk/db/repositories/credentials.py b/skyvern/forge/sdk/db/repositories/credentials.pyindex c9aea4ace..e247d6833 100644--- a/skyvern/forge/sdk/db/repositories/credentials.py+++ b/skyvern/forge/sdk/db/repositories/credentials.py@@ -3,12 +3,12 @@ from __future__ import annotationsfrom datetime import datetime, timezonefrom typing import cast-from sqlalchemy import func, or_, select, update+from sqlalchemy import delete, func, or_, select, updatefrom skyvern.forge.sdk.db._error_handling import db_operationfrom skyvern.forge.sdk.db.base_repository import BaseRepositoryfrom skyvern.forge.sdk.db.exceptions import NotFoundError-from skyvern.forge.sdk.db.models import CredentialModel, OrganizationBitwardenCollectionModel+from skyvern.forge.sdk.db.models import CredentialModel, OrganizationBitwardenCollectionModel, TOTPCodeModelfrom skyvern.forge.sdk.db.repositories.proxy_pin_update import apply_proxy_pin_to_model, normalize_proxy_pin_for_createfrom skyvern.forge.sdk.db.utils import serialize_proxy_locationfrom skyvern.forge.sdk.schemas.credentials import (@@ -19,10 +19,41 @@ from skyvern.forge.sdk.schemas.credentials import (from skyvern.forge.sdk.schemas.organization_bitwarden_collections import OrganizationBitwardenCollectionfrom skyvern.schemas.proxy_pinning import generate_proxy_session_id, should_generate_proxy_session_idfrom skyvern.schemas.runs import ProxyLocation, ProxyLocationInput+from skyvern.utils.email_validation import (+ EMAIL_IDENTIFIER_TRIM_CHARS,+ SAFE_EMAIL_ADDRESS_PATTERN,+ normalize_identifier_if_email,+)+from skyvern.utils.phone_validation import (+ looks_like_phone_identifier,+ normalize_identifier,+ phone_identifier_candidates,+)_UNSET = object()+def _phone_identifier_aliases(identifier: str) -> set[str]:+ aliases = set(phone_identifier_candidates(identifier))+ normalized = normalize_identifier(identifier)+ if normalized.startswith("+1") and len(normalized) == 12:+ aliases.add(normalized[2:])+ digits = "".join(character for character in identifier if character.isdigit())+ if len(digits) == 10:+ aliases.add(f"+1{digits}")+ return aliases+++def _totp_identifiers_match(left: str, right: str) -> bool:+ if normalize_identifier(left) == normalize_identifier(right):+ return True+ return (+ looks_like_phone_identifier(left)+ and looks_like_phone_identifier(right)+ and bool(_phone_identifier_aliases(left) & _phone_identifier_aliases(right))+ )++class CredentialRepository(BaseRepository):"""Database operations for credential and Bitwarden collection management."""@@ -95,6 +126,104 @@ class CredentialRepository(BaseRepository):).all()return [Credential.model_validate(c) for c in credentials]+ @db_operation("get_credential_ids_by_browser_profile_ids")+ async def get_credential_ids_by_browser_profile_ids(+ self, browser_profile_ids: set[str] | None, organization_id: str+ ) -> dict[str, set[str]]:+ links_by_profile = await self.get_browser_profile_credential_links(browser_profile_ids, organization_id)+ return {+ profile_id: {credential_id for credential_id, _ in links} for profile_id, links in links_by_profile.items()+ }++ @db_operation("get_browser_profile_credential_links")+ async def get_browser_profile_credential_links(+ self, browser_profile_ids: set[str] | None, organization_id: str+ ) -> dict[str, list[tuple[str, str | None]]]:+ if browser_profile_ids == set():+ return {}+ async with self.Session() as session:+ query = select(+ CredentialModel.browser_profile_id,+ CredentialModel.credential_id,+ CredentialModel.folder_id,+ ).where(+ CredentialModel.browser_profile_id.is_not(None),+ CredentialModel.organization_id == organization_id,+ )+ if browser_profile_ids is not None:+ query = query.where(CredentialModel.browser_profile_id.in_(browser_profile_ids))+ rows = (await session.execute(query)).all()+ links_by_profile: dict[str, list[tuple[str, str | None]]] = {}+ for browser_profile_id, credential_id, folder_id in rows:+ if browser_profile_id is not None:+ links_by_profile.setdefault(browser_profile_id, []).append((credential_id, folder_id))+ return links_by_profile++ @db_operation("get_credential_ids_by_totp_identifiers")+ async def get_credential_ids_by_totp_identifiers(+ self, totp_identifiers: set[str], organization_id: str+ ) -> dict[str, set[str]]:+ if not totp_identifiers:+ return {}+ normalized_identifiers = {normalize_identifier(value) for value in totp_identifiers}+ phone_identifiers = {+ normalize_identifier(value) for value in totp_identifiers if looks_like_phone_identifier(value)+ }+ phone_identifiers_by_candidate: dict[str, set[str]] = {}+ for identifier in phone_identifiers:+ candidates = phone_identifier_candidates(identifier)+ # Keep the national alias authorization-only; OTP retrieval must not match ambiguous bare rows.+ if identifier.startswith("+1") and len(identifier) == 12:+ candidates.append(identifier[2:])+ for candidate in candidates:+ phone_identifiers_by_candidate.setdefault(candidate, set()).add(identifier)+ email_identifiers = {+ identifier+ for value in totp_identifiers+ if SAFE_EMAIL_ADDRESS_PATTERN.fullmatch(identifier := normalize_identifier_if_email(value))+ }+ async with self.Session() as session:+ identifier_filters = [CredentialModel.totp_identifier.in_(totp_identifiers)]+ if email_identifiers:+ trim = func.btrim if session.bind.dialect.name == "postgresql" else func.trim+ identifier_filters.append(+ func.lower(trim(CredentialModel.totp_identifier, EMAIL_IDENTIFIER_TRIM_CHARS)).in_(+ email_identifiers+ )+ )+ rows = (+ await session.execute(+ select(CredentialModel.totp_identifier, CredentialModel.credential_id).where(+ or_(*identifier_filters),+ CredentialModel.organization_id == organization_id,+ )+ )+ ).all()+ if phone_identifiers:+ # Legacy credentials may use punctuation that the OTP ingestion normalizer removes.+ rows.extend(+ (+ await session.execute(+ select(CredentialModel.totp_identifier, CredentialModel.credential_id).where(+ CredentialModel.organization_id == organization_id,+ CredentialModel.totp_identifier.is_not(None),+ )+ )+ ).all()+ )+ credential_ids_by_identifier: dict[str, set[str]] = {}+ for totp_identifier, credential_id in rows:+ if totp_identifier is None:+ continue+ normalized = normalize_identifier(totp_identifier)+ matches = {normalized} if normalized in normalized_identifiers else set()+ if looks_like_phone_identifier(totp_identifier):+ for candidate in phone_identifier_candidates(totp_identifier):+ matches.update(phone_identifiers_by_candidate.get(candidate, set()))+ for identifier in matches:+ credential_ids_by_identifier.setdefault(identifier, set()).add(credential_id)+ return credential_ids_by_identifier+@db_operation("link_browser_profile_if_unset")async def link_browser_profile_if_unset(self, credential_id: str, organization_id: str, browser_profile_id: str@@ -141,22 +270,32 @@ class CredentialRepository(BaseRepository):return None@db_operation("get_credentials_by_ids")- async def get_credentials_by_ids(self, credential_ids: list[str], organization_id: str) -> list[Credential]:+ async def get_credentials_by_ids(+ self,+ credential_ids: list[str],+ organization_id: str,+ allowed_folder_ids: set[str] | None = None,+ include_deleted: bool = False,+ ) -> list[Credential]:if not credential_ids:return []async with self.Session() as session:- credentials = (- await session.scalars(- select(CredentialModel)- .filter(CredentialModel.credential_id.in_(credential_ids))- .filter_by(organization_id=organization_id)- .filter(CredentialModel.deleted_at.is_(None))+ query = (+ select(CredentialModel)+ .filter(CredentialModel.credential_id.in_(credential_ids))+ .filter_by(organization_id=organization_id)+ )+ if not include_deleted:+ query = query.filter(CredentialModel.deleted_at.is_(None))+ if allowed_folder_ids is not None:+ query = query.filter(+ or_(CredentialModel.folder_id.is_(None), CredentialModel.folder_id.in_(allowed_folder_ids)))- ).all()+ credentials = (await session.scalars(query)).all()return [Credential.model_validate(credential) for credential in credentials]@db_operation("count_credentials")- async def count_credentials(self, organization_id: str) -> int:+ async def count_credentials(self, organization_id: str, allowed_folder_ids: set[str] | None = None) -> int:async with self.Session() as session:query = (select(func.count())@@ -164,6 +303,10 @@ class CredentialRepository(BaseRepository):.filter_by(organization_id=organization_id).filter(CredentialModel.deleted_at.is_(None)))+ if allowed_folder_ids is not None:+ query = query.filter(+ or_(CredentialModel.folder_id.is_(None), CredentialModel.folder_id.in_(allowed_folder_ids))+ )return int(await session.scalar(query) or 0)@db_operation("get_credentials")@@ -176,6 +319,7 @@ class CredentialRepository(BaseRepository):credential_type: str | None = None,search: str | None = None,folder_id: str | None = None,+ allowed_folder_ids: set[str] | None = None,) -> list[Credential]:async with self.Session() as session:query = (@@ -189,6 +333,10 @@ class CredentialRepository(BaseRepository):query = query.filter(CredentialModel.credential_type == credential_type)if folder_id is not None:query = query.filter(CredentialModel.folder_id == folder_id)+ if allowed_folder_ids is not None:+ query = query.filter(+ or_(CredentialModel.folder_id.is_(None), CredentialModel.folder_id.in_(allowed_folder_ids))+ )if search:# Escape LIKE wildcards so a literal % or _ in the query narrows rather than broadens.escaped = search.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")@@ -306,6 +454,43 @@ class CredentialRepository(BaseRepository):).first()if not credential:raise NotFoundError(f"Credential {credential_id} not found")+ old_totp_identifier = credential.totp_identifier+ if isinstance(old_totp_identifier, str) and (+ totp_identifier is None or not _totp_identifiers_match(old_totp_identifier, totp_identifier)+ ):+ other_identifiers = (+ await session.scalars(+ select(CredentialModel.totp_identifier).where(+ CredentialModel.organization_id == organization_id,+ CredentialModel.credential_id != credential_id,+ CredentialModel.totp_identifier.is_not(None),+ )+ )+ ).all()+ if not any(_totp_identifiers_match(old_totp_identifier, other) for other in other_identifiers):+ if SAFE_EMAIL_ADDRESS_PATTERN.fullmatch(old_totp_identifier.strip()):+ trim = func.btrim if session.bind.dialect.name == "postgresql" else func.trim+ identifier_filter = func.lower(+ trim(TOTPCodeModel.totp_identifier, EMAIL_IDENTIFIER_TRIM_CHARS)+ ) == normalize_identifier(old_totp_identifier)+ elif looks_like_phone_identifier(old_totp_identifier):+ identifier_filter = TOTPCodeModel.totp_identifier.in_(+ {old_totp_identifier, *_phone_identifier_aliases(old_totp_identifier)}+ )+ else:+ identifier_filter = TOTPCodeModel.totp_identifier == old_totp_identifier+ # Remove cached codes before their workflow context can make them appear unlinked.+ await session.execute(+ delete(TOTPCodeModel).where(+ TOTPCodeModel.organization_id == organization_id,+ identifier_filter,+ or_(+ TOTPCodeModel.task_id.is_not(None),+ TOTPCodeModel.workflow_id.is_not(None),+ TOTPCodeModel.workflow_run_id.is_not(None),+ ),+ )+ )credential.item_id = item_idcredential.name = namecredential.credential_type = credential_typediff --git a/skyvern/forge/sdk/db/repositories/otp.py b/skyvern/forge/sdk/db/repositories/otp.pyindex 8ad60a215..b0b085852 100644--- a/skyvern/forge/sdk/db/repositories/otp.py+++ b/skyvern/forge/sdk/db/repositories/otp.py@@ -132,6 +132,7 @@ class OTPRepository(BaseRepository):self,organization_id: str,limit: int = 50,+ offset: int = 0,valid_lifespan_minutes: int | None = None,otp_type: OTPType | None = None,workflow_run_id: str | None = None,@@ -155,7 +156,8 @@ class OTPRepository(BaseRepository):query = query.filter(TOTPCodeModel.workflow_run_id == workflow_run_id)if totp_identifier:query = query.filter(_identifier_filter(totp_identifier))- query = query.order_by(TOTPCodeModel.created_at.desc()).limit(limit)+ query = query.order_by(TOTPCodeModel.created_at.desc(), TOTPCodeModel.totp_code_id.desc())+ query = query.offset(offset).limit(limit)totp_codes = (await session.scalars(query)).all()return [TOTPCode.model_validate(totp_code) for totp_code in totp_codes]diff --git a/skyvern/forge/sdk/db/repositories/workflow_runs.py b/skyvern/forge/sdk/db/repositories/workflow_runs.pyindex 21d1b375b..ff2f2dc78 100644--- a/skyvern/forge/sdk/db/repositories/workflow_runs.py+++ b/skyvern/forge/sdk/db/repositories/workflow_runs.py@@ -3377,6 +3377,51 @@ class WorkflowRunsRepository(BaseRepository):for run, title in workflow_runs_and_titles_tuples]+ @db_operation("get_workflow_run_ids_by_browser_session_ids")+ async def get_workflow_run_ids_by_browser_session_ids(+ self, browser_session_ids: Collection[str], organization_id: str+ ) -> dict[str, set[str]]:+ """Return every run associated with each session, without applying caller visibility filters."""+ if not browser_session_ids:+ return {}++ associations = union_all(+ select(WorkflowRunModel.browser_session_id, WorkflowRunModel.workflow_run_id).where(+ WorkflowRunModel.organization_id == organization_id,+ WorkflowRunModel.browser_session_id.in_(browser_session_ids),+ ),+ select(TaskModel.browser_session_id, TaskModel.workflow_run_id).where(+ TaskModel.organization_id == organization_id,+ TaskModel.browser_session_id.in_(browser_session_ids),+ TaskModel.workflow_run_id.is_not(None),+ ),+ select(TaskV2Model.browser_session_id, TaskV2Model.workflow_run_id).where(+ TaskV2Model.organization_id == organization_id,+ TaskV2Model.browser_session_id.in_(browser_session_ids),+ TaskV2Model.workflow_run_id.is_not(None),+ ),+ select(WorkflowRunAttemptModel.pinned_browser_session_id, WorkflowRunAttemptModel.workflow_run_id).where(+ WorkflowRunAttemptModel.organization_id == organization_id,+ WorkflowRunAttemptModel.pinned_browser_session_id.in_(browser_session_ids),+ ),+ select(+ PersistentBrowserSessionModel.persistent_browser_session_id,+ PersistentBrowserSessionModel.created_for_workflow_run_id,+ ).where(+ PersistentBrowserSessionModel.organization_id == organization_id,+ PersistentBrowserSessionModel.persistent_browser_session_id.in_(browser_session_ids),+ PersistentBrowserSessionModel.created_for_workflow_run_id.is_not(None),+ ),+ )+ async with self.Session() as session:+ rows = (await session.execute(associations)).all()++ runs_by_session: dict[str, set[str]] = {}+ for browser_session_id, workflow_run_id in rows:+ if browser_session_id and workflow_run_id:+ runs_by_session.setdefault(browser_session_id, set()).add(workflow_run_id)+ return runs_by_session+@db_operation("get_workflow_metadata_for_browser_session")async def get_workflow_metadata_for_browser_session(self, browser_session_id: str, organization_id: strdiff --git a/skyvern/forge/sdk/routes/agent_protocol.py b/skyvern/forge/sdk/routes/agent_protocol.pyindex 9b3d025cb..25880c021 100644--- a/skyvern/forge/sdk/routes/agent_protocol.py+++ b/skyvern/forge/sdk/routes/agent_protocol.py@@ -168,6 +168,7 @@ from skyvern.forge.sdk.workflow.exceptions import (InvalidTemplateWorkflowPermanentId,WorkflowDefinitionValidationException,)+from skyvern.forge.sdk.workflow.models.parameter import CredentialParameter, WorkflowParameter, WorkflowParameterTypefrom skyvern.forge.sdk.workflow.models.tags import CallerType, TagSource, TagWriteContextfrom skyvern.forge.sdk.workflow.models.validators import is_reserved_tag_keyfrom skyvern.forge.sdk.workflow.models.workflow import (@@ -1573,6 +1574,7 @@ async def update_workflow_legacy(changed_fields=changed_fields,),)+ await _redact_inaccessible_workflow_credential_ids([workflow])return workflow@@ -1673,6 +1675,7 @@ async def update_workflow(changed_fields=changed_fields,),)+ await _redact_inaccessible_workflow_credential_ids([workflow])return workflow@@ -2064,6 +2067,7 @@ async def update_workflow_folder(changed_fields=("folder_id",),related_resource_ids=(workflow.folder_id,) if workflow.folder_id else (),)+ await _redact_inaccessible_workflow_credential_ids([workflow])return workflowexcept ValueError as e:raise HTTPException(status_code=http_status.HTTP_400_BAD_REQUEST, detail=str(e)) from e@@ -5810,12 +5814,15 @@ async def get_workflow_and_run_from_workflow_run_id(x_user_agent: Annotated[str | None, Header(include_in_schema=False)] = None,) -> WorkflowRunWithWorkflowResponse:analytics.capture("skyvern-oss-agent-workflow-run-get")- return await run_service.coalesce_in_flight(+ response = await run_service.coalesce_in_flight(_build_workflow_and_run_from_workflow_run_id,current_org.organization_id,workflow_run_id,caps_run_response_values(x_user_agent),)+ response = response.model_copy(update={"workflow": response.workflow.model_copy(deep=True)})+ await _redact_inaccessible_workflow_credential_ids([response.workflow])+ return responseasync def _build_workflow_and_run_from_workflow_run_id(@@ -6024,6 +6031,7 @@ async def get_workflows(search_key=effective_search or "",statuses=effective_statuses,)+ await _redact_inaccessible_workflow_credential_ids(workflows)return workflowsif only_saved_tasks and only_workflows:@@ -6032,7 +6040,7 @@ async def get_workflows(detail="only_saved_tasks and only_workflows cannot be used together",)- return await app.WORKFLOW_SERVICE.get_workflows_by_organization_id(+ workflows = await app.WORKFLOW_SERVICE.get_workflows_by_organization_id(organization_id=current_org.organization_id,page=page,page_size=page_size,@@ -6044,6 +6052,81 @@ async def get_workflows(statuses=effective_statuses,workflow_tags=workflow_tags or None,)+ await _redact_inaccessible_workflow_credential_ids(workflows)+ return workflows+++async def _redact_inaccessible_workflow_credential_ids(workflows: Sequence[Workflow]) -> None:+ workflow_parameters = [+ (+ workflow.workflow_definition.parameters,+ {+ parameter.key+ for parameter in workflow.workflow_definition.parameters+ if isinstance(parameter, WorkflowParameter)+ and parameter.workflow_parameter_type == WorkflowParameterType.CREDENTIAL_ID+ },+ )+ for workflow in workflows+ ]+ credential_ids: set[str] = set()+ for parameters, parameter_keys in workflow_parameters:+ for parameter in parameters:+ if isinstance(parameter, CredentialParameter):+ credential_ids.update(+ credential_id+ for credential_id in (+ parameter.credential_id if parameter.credential_id not in parameter_keys else None,+ *(parameter.credential_ids or []),+ *(parameter.fallback_credential_ids or []),+ )+ if credential_id+ )+ elif (+ isinstance(parameter, WorkflowParameter)+ and parameter.workflow_parameter_type == WorkflowParameterType.CREDENTIAL_ID+ and isinstance(parameter.default_value, str)+ and parameter.default_value+ ):+ credential_ids.add(parameter.default_value)+ if not credential_ids:+ return++ principal = get_request_principal()+ try:+ accessible_ids = await app.AGENT_FUNCTION.accessible_credential_ids(+ principal, "credential.read", credential_ids+ )+ except Exception:+ LOG.warning(+ "Workflow credential visibility check failed; redacting credential references",+ organization_id=principal.organization_id if principal else None,+ exc_info=True,+ )+ accessible_ids = set()++ for parameters, parameter_keys in workflow_parameters:+ for parameter in parameters:+ if isinstance(parameter, CredentialParameter):+ if parameter.credential_id not in accessible_ids and parameter.credential_id not in parameter_keys:+ parameter.credential_id = ""+ if parameter.credential_ids is not None:+ parameter.credential_ids = [+ credential_id for credential_id in parameter.credential_ids if credential_id in accessible_ids+ ]+ if parameter.fallback_credential_ids is not None:+ parameter.fallback_credential_ids = [+ credential_id+ for credential_id in parameter.fallback_credential_ids+ if credential_id in accessible_ids+ ]+ elif (+ isinstance(parameter, WorkflowParameter)+ and parameter.workflow_parameter_type == WorkflowParameterType.CREDENTIAL_ID+ and isinstance(parameter.default_value, str)+ and parameter.default_value not in accessible_ids+ ):+ parameter.default_value = None@base_router.put(@@ -6101,6 +6184,7 @@ async def get_workflow_templates() -> list[Workflow]:statuses=[WorkflowStatus.published, WorkflowStatus.draft],)+ await _redact_inaccessible_workflow_credential_ids(workflows)return workflows@@ -6151,6 +6235,7 @@ async def get_workflow(workflow.set_effective_default_engine(await effective_default_engine(workflow_permanent_id, current_org.organization_id))+ await _redact_inaccessible_workflow_credential_ids([workflow])return workflow@@ -6185,10 +6270,12 @@ async def get_workflow_versions(if workflow_permanent_id not in await app.STORAGE.retrieve_global_workflows():raise InvalidTemplateWorkflowPermanentId(workflow_permanent_id=workflow_permanent_id)- return await app.WORKFLOW_SERVICE.get_workflow_versions_by_permanent_id(+ workflows = await app.WORKFLOW_SERVICE.get_workflow_versions_by_permanent_id(workflow_permanent_id=workflow_permanent_id,organization_id=None if template else current_org.organization_id,)+ await _redact_inaccessible_workflow_credential_ids(workflows)+ return workflows@base_router.post(diff --git a/skyvern/forge/sdk/routes/browser_profiles.py b/skyvern/forge/sdk/routes/browser_profiles.pyindex 09e322515..7df5b31d0 100644--- a/skyvern/forge/sdk/routes/browser_profiles.py+++ b/skyvern/forge/sdk/routes/browser_profiles.py@@ -49,6 +49,7 @@ from skyvern.forge.sdk.schemas.persistent_browser_sessions import (is_external_cdp_session,)from skyvern.forge.sdk.services import org_auth_service+from skyvern.forge.sdk.services.request_principal import get_request_principalfrom skyvern.forge.sdk.workflow.browser_session_persistence import retrieve_persisted_workflow_browser_state_dirfrom skyvern.schemas.proxy_pinning import apply_proxy_pin_update as _apply_proxy_pin_updatefrom skyvern.schemas.proxy_pinning import should_generate_proxy_session_id@@ -80,6 +81,11 @@ _SESSION_PROFILE_SAVE_LOCK_WAIT_SECONDS = 30_SESSION_PROFILE_SAVED_MARKER_TTL = timedelta(days=1)+def _redact_credential_profile_labels(profile: BrowserProfile) -> None:+ profile.name = "Browser profile"+ profile.description = None++def _normalize_proxy_pin_fields(*,proxy_location: ProxyLocationInput,@@ -252,6 +258,29 @@ async def list_browser_profiles(managed=managed,)+ principal = get_request_principal()+ hidden_profile_ids: set[str] = set()+ credential_links_by_profile: dict[str, list[tuple[str, str | None]]] | None = None+ if (+ search_key+ and await app.AGENT_FUNCTION.credential_folders_restricted(organization_id)+ and not await app.AGENT_FUNCTION.credential_folder_admin_bypass(principal)+ ):+ credential_links_by_profile = await app.DATABASE.credentials.get_browser_profile_credential_links(+ None, organization_id+ )+ all_credential_ids = {+ credential_id for links in credential_links_by_profile.values() for credential_id, _folder_id in links+ }+ allowed_credential_ids = await app.AGENT_FUNCTION.accessible_credential_ids(+ principal, "credential.read", all_credential_ids+ )+ hidden_profile_ids = {+ profile_id+ for profile_id, links in credential_links_by_profile.items()+ if not {credential_id for credential_id, _folder_id in links} <= allowed_credential_ids+ }+profiles = await app.DATABASE.browser_sessions.list_browser_profiles(organization_id=organization_id,include_deleted=include_deleted,@@ -259,8 +288,34 @@ async def list_browser_profiles(page_size=page_size,search_key=search_key,managed=managed,+ exclude_search_profile_ids=hidden_profile_ids,)+ if (+ profiles+ and await app.AGENT_FUNCTION.credential_folders_restricted(organization_id)+ and not await app.AGENT_FUNCTION.credential_folder_admin_bypass(principal)+ ):+ if credential_links_by_profile is None:+ credential_links_by_profile = await app.DATABASE.credentials.get_browser_profile_credential_links(+ {profile.browser_profile_id for profile in profiles}, organization_id+ )+ credential_ids = {+ credential_id for links in credential_links_by_profile.values() for credential_id, _folder_id in links+ }+ allowed_credential_ids = await app.AGENT_FUNCTION.accessible_credential_ids(+ principal, "credential.read", credential_ids+ )+ for profile in profiles:+ linked_ids = {+ credential_id+ for credential_id, _folder_id in credential_links_by_profile.get(profile.browser_profile_id, [])+ }+ if linked_ids and not linked_ids <= allowed_credential_ids:+ profile.linked_credential_id = None+ profile.linked_credential_name = None+ _redact_credential_profile_labels(profile)+LOG.info("Listed browser profiles",organization_id=organization_id,@@ -325,6 +380,34 @@ async def get_browser_profile()raise BrowserProfileNotFound(profile_id=profile_id, organization_id=organization_id)+ linked_credentials = await app.DATABASE.credentials.get_credentials_by_browser_profile_id(+ profile_id, organization_id+ )+ principal = get_request_principal()+ redact_labels = False+ if await app.AGENT_FUNCTION.credential_folders_restricted(+ organization_id+ ) and not await app.AGENT_FUNCTION.credential_folder_admin_bypass(principal):+ linked_credential_links_by_profile = await app.DATABASE.credentials.get_browser_profile_credential_links(+ {profile_id}, organization_id+ )+ linked_credential_ids = {+ credential_id for credential_id, _folder_id in linked_credential_links_by_profile.get(profile_id, [])+ }+ allowed_credential_ids = await app.AGENT_FUNCTION.accessible_credential_ids(+ principal, "credential.read", linked_credential_ids+ )+ if linked_credential_ids and not linked_credential_ids <= allowed_credential_ids:+ linked_credentials = []+ profile.linked_credential_id = None+ profile.linked_credential_name = None+ redact_labels = True+ if linked_credentials:+ profile.linked_credential_id = linked_credentials[0].credential_id+ profile.linked_credential_name = linked_credentials[0].name+ if redact_labels:+ _redact_credential_profile_labels(profile)+LOG.info("Retrieved browser profile",organization_id=organization_id,@@ -373,6 +456,18 @@ async def get_browser_profile_usage(profile_id=profile_id,organization_id=organization_id,)+ principal = get_request_principal()+ if (+ usage.credentials+ and await app.AGENT_FUNCTION.credential_folders_restricted(organization_id)+ and not await app.AGENT_FUNCTION.credential_folder_admin_bypass(principal)+ ):+ allowed_credential_ids = await app.AGENT_FUNCTION.accessible_credential_ids(+ principal, "credential.read", {credential.credential_id for credential in usage.credentials}+ )+ usage.credentials = [+ credential for credential in usage.credentials if credential.credential_id in allowed_credential_ids+ ]LOG.info("Retrieved browser profile usage",organization_id=organization_id,diff --git a/skyvern/forge/sdk/routes/browser_sessions.py b/skyvern/forge/sdk/routes/browser_sessions.pyindex 9756086e1..65cc098a7 100644--- a/skyvern/forge/sdk/routes/browser_sessions.py+++ b/skyvern/forge/sdk/routes/browser_sessions.py@@ -37,11 +37,13 @@ from skyvern.forge.sdk.routes.routers import base_routerfrom skyvern.forge.sdk.schemas.organizations import Organizationfrom skyvern.forge.sdk.schemas.persistent_browser_sessions import (API_BROWSER_SESSION_CREATED_BY,+ PersistentBrowserSession,PersistentBrowserSessionStatus,is_external_cdp_session,is_final_status,)from skyvern.forge.sdk.services import org_auth_service+from skyvern.forge.sdk.services.request_principal import get_request_principalfrom skyvern.forge.sdk.workflow.models.workflow import WorkflowRunfrom skyvern.schemas.action_log import (ACTION_LOG_DEFAULT_PAGE_SIZE,@@ -96,6 +98,54 @@ def _browser_session_not_found() -> HTTPException:return HTTPException(status_code=404, detail={"code": "browser_session_not_found"})+async def _filter_credential_inaccessible_sessions(+ sessions: list[PersistentBrowserSession], organization_id: str+) -> list[PersistentBrowserSession]:+ if not sessions:+ return []+ principal = get_request_principal()+ profile_ids = {session.browser_profile_id for session in sessions if session.browser_profile_id}+ try:+ profile_accessible_ids = {session.persistent_browser_session_id for session in sessions}+ if principal is None:+ profile_accessible_ids = {+ session.persistent_browser_session_id for session in sessions if not session.browser_profile_id+ }+ elif profile_ids and await app.AGENT_FUNCTION.credential_folders_restricted(organization_id):+ links_by_profile = await app.DATABASE.credentials.get_browser_profile_credential_links(+ profile_ids, organization_id+ )+ credential_ids = {credential_id for links in links_by_profile.values() for credential_id, _ in links}+ accessible_credential_ids = await app.AGENT_FUNCTION.accessible_credential_ids(+ principal, "credential.use", credential_ids+ )+ profile_accessible_ids = {+ session.persistent_browser_session_id+ for session in sessions+ if not session.browser_profile_id+ or {credential_id for credential_id, _ in links_by_profile.get(session.browser_profile_id, [])}+ <= accessible_credential_ids+ }+ run_credential_accessible_ids = await app.AGENT_FUNCTION.accessible_browser_session_ids(+ principal,+ organization_id,+ {session.persistent_browser_session_id for session in sessions},+ )+ except Exception:+ LOG.warning(+ "Browser session credential authorization failed; denying",+ organization_id=organization_id,+ exc_info=True,+ )+ return []+ return [+ session+ for session in sessions+ if session.persistent_browser_session_id in profile_accessible_ids+ and session.persistent_browser_session_id in run_credential_accessible_ids+ ]++async def _read_action_log_body(request: Request) -> bytes:content_length = request.headers.get("content-length")if content_length is not None:@@ -166,6 +216,7 @@ async def get_browser_sessions_all(page=page,page_size=page_size,)+ browser_sessions = await _filter_credential_inaccessible_sessions(browser_sessions, current_org.organization_id)responses = await asyncio.gather(*[@@ -731,6 +782,7 @@ async def get_browser_sessions(for browser_session in browser_sessionsif browser_session.persistent_browser_session_id in visible_ids]+ visible_sessions = await _filter_credential_inaccessible_sessions(visible_sessions, current_org.organization_id)return await asyncio.gather(*[BrowserSessionResponse.from_browser_session(browser_session, app.STORAGE)diff --git a/skyvern/forge/sdk/routes/credentials.py b/skyvern/forge/sdk/routes/credentials.pyindex cee6f0949..b050f8fdb 100644--- a/skyvern/forge/sdk/routes/credentials.py+++ b/skyvern/forge/sdk/routes/credentials.py@@ -44,6 +44,7 @@ from fastapi import BackgroundTasks, Body, Depends, Header, HTTPException, Path,from onepassword.client import Client as OnePasswordClientfrom onepassword.errors import DesktopSessionExpiredException, RateLimitExceededExceptionfrom sqlalchemy.exc import IntegrityError+from sqlalchemy.ext.asyncio import AsyncSessionfrom skyvern.config import settingsfrom skyvern.exceptions import (@@ -178,6 +179,7 @@ from skyvern.services.otp_service import ()from skyvern.services.run_service import cancel_workflow_runfrom skyvern.utils.email_validation import normalize_identifier_if_email+from skyvern.utils.phone_validation import normalize_identifierfrom skyvern.utils.url_validators import validate_urlLOG = structlog.get_logger()@@ -540,6 +542,34 @@ async def send_totp_code(workflow_run = await app.DATABASE.workflow_runs.get_workflow_run(data.workflow_run_id, curr_org.organization_id)if not workflow_run:raise HTTPException(status_code=400, detail=f"Invalid workflow run id: {data.workflow_run_id}")+ workflow_references = {+ (kind, value)+ for kind, value in (+ ("task_id", data.task_id),+ ("workflow_id", data.workflow_id),+ ("workflow_run_id", data.workflow_run_id),+ )+ if value is not None+ }+ if await app.AGENT_FUNCTION.workflow_folders_restricted(curr_org.organization_id) and workflow_references:+ accessible_references = await app.AGENT_FUNCTION.accessible_workflow_reference_ids(+ get_request_principal(), "workflow_run.update", workflow_references+ )+ if workflow_references - accessible_references:+ raise HTTPException(status_code=403, detail="Workflow folder access denied.")+ if await app.AGENT_FUNCTION.credential_folders_restricted(curr_org.organization_id):+ credential_ids_by_identifier = await app.DATABASE.credentials.get_credential_ids_by_totp_identifiers(+ {totp_identifier}, curr_org.organization_id+ )+ await app.AGENT_FUNCTION.enforce_credential_folder_access_for_ids(+ get_request_principal(),+ "credential.use",+ {+ ("credential_id", credential_id)+ for credential_ids in credential_ids_by_identifier.values()+ for credential_id in credential_ids+ },+ )content = data.content.strip()otp_value: OTPValue | None = OTPValue(value=content)otp_parse_skipped_for_insufficient_credits = False@@ -660,16 +690,81 @@ async def get_totp_codes(description="Maximum number of codes to return.",),) -> list[TOTPCode]:- codes = await app.DATABASE.otp.get_recent_otp_codes(- organization_id=curr_org.organization_id,- limit=limit,- valid_lifespan_minutes=None,- otp_type=otp_type,- workflow_run_id=workflow_run_id,- totp_identifier=totp_identifier,- )+ principal = get_request_principal()+ workflow_restricted = await app.AGENT_FUNCTION.workflow_folders_restricted(curr_org.organization_id)+ credential_restricted = await app.AGENT_FUNCTION.credential_folders_restricted(curr_org.organization_id)+ if (workflow_restricted or credential_restricted) and principal is None:+ return []++ restricted = workflow_restricted or credential_restricted+ page_size = max(limit, 50) if restricted else limit+ # shortcut: scan at most 1,000 OTPs; return 503 for incomplete results, use SQL ACL filtering to search older codes.+ scan_limit = min(page_size * 10, 1_000) if restricted else limit+ codes: list[TOTPCode] = []+ offset = 0+ while len(codes) < limit and offset < scan_limit:+ page_limit = min(page_size, scan_limit - offset)+ page = await app.DATABASE.otp.get_recent_otp_codes(+ organization_id=curr_org.organization_id,+ limit=page_limit,+ offset=offset,+ valid_lifespan_minutes=None,+ otp_type=otp_type,+ workflow_run_id=workflow_run_id,+ totp_identifier=totp_identifier,+ )+ if not page:+ break+ page_length = len(page)+ offset += page_length++ if workflow_restricted:+ references_by_code = {+ code.totp_code_id: {+ (kind, value)+ for kind, value in (+ ("workflow_id", code.workflow_id),+ ("workflow_run_id", code.workflow_run_id),+ ("task_id", code.task_id),+ )+ if value is not None+ }+ for code in page+ }+ accessible_references = await app.AGENT_FUNCTION.accessible_workflow_reference_ids(+ principal, "workflow_run.read", set().union(*references_by_code.values())+ )+ page = [code for code in page if references_by_code[code.totp_code_id] <= accessible_references]++ if credential_restricted and page and not await app.AGENT_FUNCTION.credential_folder_admin_bypass(principal):+ credential_ids_by_identifier = await app.DATABASE.credentials.get_credential_ids_by_totp_identifiers(+ {normalize_identifier(code.totp_identifier) for code in page}, curr_org.organization_id+ )+ credential_ids = set().union(*credential_ids_by_identifier.values())+ allowed_credential_ids = await app.AGENT_FUNCTION.accessible_credential_ids(+ principal, "credential.use", credential_ids+ )+ page = [+ code+ for code in page+ if (+ (linked_ids := credential_ids_by_identifier.get(normalize_identifier(code.totp_identifier))) is None+ and (code.workflow_id or code.workflow_run_id or code.task_id)+ )+ or (linked_ids is not None and linked_ids <= allowed_credential_ids)+ ]++ codes.extend(page)+ if page_length < page_limit:+ break++ if offset >= scan_limit and len(codes) < limit:+ raise HTTPException(+ status_code=status.HTTP_503_SERVICE_UNAVAILABLE,+ detail="OTP search reached its access scan limit; add a filter and retry.",+ )- return codes+ return codes[:limit]async def _validate_credential_browser_profile_id(@@ -692,10 +787,13 @@ async def _validate_credential_browser_profile_id(status_code=400,detail="A credential can only link a plain browser profile, not a workflow-managed one.",)- owners = await app.DATABASE.credentials.get_credentials_by_browser_profile_id(- browser_profile_id=browser_profile_id, organization_id=organization_id+ links_by_profile = await app.DATABASE.credentials.get_browser_profile_credential_links(+ {browser_profile_id}, organization_id)- if any(owner.credential_id != current_credential_id for owner in owners):+ if any(+ credential_id != current_credential_id+ for credential_id, _folder_id in links_by_profile.get(browser_profile_id, [])+ ):raise HTTPException(status_code=400,detail="This browser profile is already linked to another credential.",@@ -1481,6 +1579,22 @@ def _humanize_test_failure(raw_reason: str | None) -> str:return "The login test was unsuccessful. Please verify your credentials and the login URL, then try again."+async def _get_credential_test_run(credential_id: str, workflow_run_id: str, organization_id: str) -> Any:+ workflow_run = await app.DATABASE.workflow_runs.get_workflow_run(+ workflow_run_id=workflow_run_id, organization_id=organization_id+ )+ if workflow_run is None:+ raise HTTPException(status_code=404, detail=f"Workflow run {workflow_run_id} not found")+ parameters = await app.DATABASE.workflow_runs.get_workflow_run_parameters(workflow_run_id)+ if not any(+ workflow_parameter.workflow_parameter_type == WorkflowParameterType.CREDENTIAL_ID+ and run_parameter.value == credential_id+ for workflow_parameter, run_parameter in parameters+ ):+ raise HTTPException(status_code=404, detail=f"Workflow run {workflow_run_id} not found")+ return workflow_run++@base_router.get("/credentials/{credential_id}/test/{workflow_run_id}",response_model=TestCredentialStatusResponse,@@ -1512,12 +1626,7 @@ async def get_test_credential_status(current_org: Organization = Depends(org_auth_service.get_current_org_for_credential_routes),) -> TestCredentialStatusResponse:organization_id = current_org.organization_id-- workflow_run = await app.DATABASE.workflow_runs.get_workflow_run(- workflow_run_id=workflow_run_id, organization_id=organization_id- )- if not workflow_run:- raise HTTPException(status_code=404, detail=f"Workflow run {workflow_run_id} not found")+ workflow_run = await _get_credential_test_run(credential_id, workflow_run_id, organization_id)credential = await app.DATABASE.credentials.get_credential(credential_id=credential_id, organization_id=organization_id@@ -1623,6 +1732,7 @@ async def cancel_credential_test(current_org: Organization = Depends(org_auth_service.get_current_org_for_credential_routes),) -> CancelTestResponse:organization_id = current_org.organization_id+ await _get_credential_test_run(credential_id, workflow_run_id, organization_id)LOG.info("Canceling credential test",@@ -2615,6 +2725,10 @@ async def get_credentials(SECURITY: Like ``get_credential``, this endpoint never returns raw secretmaterial. See the module docstring for the full security invariant."""+ principal = get_request_principal()+ allowed_folder_ids = (+ await app.AGENT_FUNCTION.accessible_credential_folder_ids(principal) if principal is not None else None+ )credentials = await app.DATABASE.credentials.get_credentials(current_org.organization_id,page=page,@@ -2623,6 +2737,7 @@ async def get_credentials(credential_type=credential_type.value if isinstance(credential_type, CredentialType) else None,search=search if isinstance(search, str) else None,folder_id=folder_id if isinstance(folder_id, str) else None,+ allowed_folder_ids=allowed_folder_ids,)return [_convert_to_response(credential) for credential in credentials]@@ -2719,11 +2834,16 @@ async def get_credential_folders(search: str | None = Query(None, description="Search folders by title or description"),current_org: Organization = Depends(org_auth_service.get_current_org_for_credential_routes),) -> list[CredentialFolder]:+ principal = get_request_principal()+ allowed_folder_ids = (+ await app.AGENT_FUNCTION.accessible_credential_folder_ids(principal) if principal is not None else None+ )folders = await app.DATABASE.credential_folders.get_credential_folders(organization_id=current_org.organization_id,page=page,page_size=page_size,search_query=search,+ allowed_folder_ids=allowed_folder_ids,)if folders:@@ -2800,10 +2920,13 @@ async def delete_credential_folder(folder_id: str = Path(..., description="Credential folder ID", examples=["cfld_123"]),current_org: Organization = Depends(org_auth_service.get_current_org_for_credential_routes),) -> dict:- success = await app.DATABASE.credential_folders.soft_delete_credential_folder(- folder_id=folder_id,- organization_id=current_org.organization_id,- )+ try:+ success = await app.DATABASE.credential_folders.soft_delete_credential_folder(+ folder_id=folder_id,+ organization_id=current_org.organization_id,+ )+ except ValueError as exc:+ raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=str(exc)) from excif not success:raise HTTPException(status_code=404, detail=f"Credential folder {folder_id} not found")@@ -2833,11 +2956,24 @@ async def update_credential_folder_assignment(data: UpdateCredentialFolderRequest = Body(...),current_org: Organization = Depends(org_auth_service.get_current_org_for_credential_routes),) -> CredentialResponse:+ principal = get_request_principal()++ async def reauthorize_move(session: AsyncSession) -> None:+ if principal is None:+ return+ references = {("credential_id", credential_id)}+ if data.folder_id:+ references.add(("folder_id", data.folder_id))+ await app.AGENT_FUNCTION.enforce_credential_folder_access_for_ids(+ principal, "credential.move", references, session=session+ )+try:credential = await app.DATABASE.credential_folders.set_credential_folder(credential_id=credential_id,organization_id=current_org.organization_id,folder_id=data.folder_id,+ authorize_move=reauthorize_move,)except ValueError as e:raise HTTPException(status_code=400, detail=str(e)) from ediff --git a/skyvern/forge/sdk/routes/streaming/auth.py b/skyvern/forge/sdk/routes/streaming/auth.pyindex 295355dd1..302876d68 100644--- a/skyvern/forge/sdk/routes/streaming/auth.py+++ b/skyvern/forge/sdk/routes/streaming/auth.py@@ -56,12 +56,43 @@ async def _close_unauthenticated(websocket: WebSocket, **log_kwargs: t.Any) -> Nasync def folder_access_denied(websocket: WebSocket, action: str, resource: t.Mapping[str, str | None]) -> bool:"""Close the stream when the caller's workflow folders do not cover the run behind it."""+ principal = get_request_principal()try:# The evaluator judges one identifier per call, so each id behind the stream is checked on its own.for key, value in resource.items():if value:- await app.AGENT_FUNCTION.enforce_folder_access(get_request_principal(), action, {key: value})- except HTTPException:+ await app.AGENT_FUNCTION.enforce_folder_access(principal, action, {key: value})+ if key == "browser_session_id":+ await app.AGENT_FUNCTION.enforce_browser_session_credential_use(principal, value)+ elif key == "workflow_run_id":+ await app.AGENT_FUNCTION.enforce_workflow_run_credential_use(principal, value)+ elif key == "task_id":+ try:+ organization_id = principal.organization_id if principal else None+ task = await app.DATABASE.tasks.get_task(value, organization_id=organization_id)+ if task is None:+ continue+ if task.workflow_run_id:+ await app.AGENT_FUNCTION.enforce_workflow_run_credential_use(+ principal, task.workflow_run_id+ )+ session = await app.DATABASE.browser_sessions.get_persistent_browser_session_by_runnable_id(+ value, organization_id=task.organization_id+ )+ if session:+ await app.AGENT_FUNCTION.enforce_browser_session_credential_use(+ principal, session.persistent_browser_session_id+ )+ except (HTTPException, PermissionError):+ raise+ except Exception as exc:+ LOG.warning(+ "Task stream credential authorization failed; denying",+ task_id=value,+ exc_info=True,+ )+ raise PermissionError("credential not accessible") from exc+ except (HTTPException, PermissionError):LOG.info("Rejecting streaming connection outside the caller's workflow folders.", action=action)try:await websocket.close(code=4403)diff --git a/skyvern/forge/sdk/routes/twilio_integration.py b/skyvern/forge/sdk/routes/twilio_integration.pyindex c53b3cfd1..9104d1163 100644--- a/skyvern/forge/sdk/routes/twilio_integration.py+++ b/skyvern/forge/sdk/routes/twilio_integration.py@@ -34,6 +34,7 @@ from skyvern.forge.sdk.schemas.sms import (TwilioPhoneNumberInfo,)from skyvern.forge.sdk.services import org_auth_service+from skyvern.forge.sdk.services.request_principal import get_request_principalfrom skyvern.forge.sdk.services.route_authorization import require_request_actionsfrom skyvern.forge.sdk.services.twilio_service import (TwilioApiError,@@ -423,6 +424,9 @@ async def _enable_twilio_phone_number_locked(organization_id: str,) -> OrganizationPhoneNumber:if request.credential_id is not None:+ await app.AGENT_FUNCTION.enforce_credential_folder_access_for_ids(+ get_request_principal(), "credential.use", {("credential_id", request.credential_id)}+ )bound_credential = await app.DATABASE.credentials.get_credential(request.credential_id, organization_id=organization_id)@@ -446,6 +450,14 @@ async def _enable_twilio_phone_number_locked(raise HTTPException(status_code=409, detail="Phone number changed during lifecycle operation")registered = await _get_registered_phone_number(phone_number, organization_id)_require_twilio_provider(registered)+ if (+ registered is not None+ and registered.credential_id is not None+ and registered.credential_id != request.credential_id+ ):+ await app.AGENT_FUNCTION.enforce_credential_folder_access_for_ids(+ get_request_principal(), "credential.use", {("credential_id", registered.credential_id)}+ )connected_config = await app.DATABASE.sms.get_connected_sms_config(organization_id)if connected_config is None:connected_config = await app.DATABASE.sms.create_sms_config(@@ -704,7 +716,16 @@ async def list_registered_phone_numbers(current_org: Annotated[Organization, Depends(org_auth_service.get_current_org_for_credential_routes)],) -> list[OrganizationPhoneNumber]:_require_twilio_sms_enabled()- return await app.DATABASE.sms.list_phone_numbers(current_org.organization_id)+ phone_numbers = await app.DATABASE.sms.list_phone_numbers(current_org.organization_id)+ credential_ids = {phone.credential_id for phone in phone_numbers if phone.credential_id is not None}+ if credential_ids and await app.AGENT_FUNCTION.credential_folders_restricted(current_org.organization_id):+ accessible_credential_ids = await app.AGENT_FUNCTION.accessible_credential_ids(+ get_request_principal(), "credential.read", credential_ids+ )+ for phone in phone_numbers:+ if phone.credential_id not in accessible_credential_ids:+ phone.credential_id = None+ return phone_numbers@twilio_integration_router.get(@@ -793,6 +814,10 @@ async def _disable_twilio_phone_number_locked(if registered is None:raise HTTPException(status_code=404, detail="Phone number not found")_require_twilio_provider(registered)+ if registered.credential_id is not None:+ await app.AGENT_FUNCTION.enforce_credential_folder_access_for_ids(+ get_request_principal(), "credential.use", {("credential_id", registered.credential_id)}+ )was_quarantined = registered.status == "quarantined"client: Any | None = Noneif registered.provider_number_sid:@@ -883,6 +908,15 @@ async def _disable_twilio_phone_number_locked(phone_number.phone_number_id,changed_fields=("status",),)+ if (+ phone_number.credential_id is not None+ and await app.AGENT_FUNCTION.credential_folders_restricted(organization_id)+ and phone_number.credential_id+ not in await app.AGENT_FUNCTION.accessible_credential_ids(+ get_request_principal(), "credential.read", {phone_number.credential_id}+ )+ ):+ phone_number.credential_id = Nonereturn phone_numberdiff --git a/skyvern/forge/sdk/routes/workflow_copilot.py b/skyvern/forge/sdk/routes/workflow_copilot.pyindex babd0efff..74daaa786 100644--- a/skyvern/forge/sdk/routes/workflow_copilot.py+++ b/skyvern/forge/sdk/routes/workflow_copilot.py@@ -75,7 +75,7 @@ from skyvern.forge.sdk.copilot.credential_pause import (sign_in_site,start_manual_sign_in,)-from skyvern.forge.sdk.copilot.credential_resolution import safe_admitted_url+from skyvern.forge.sdk.copilot.credential_resolution import load_credentials, safe_admitted_urlfrom skyvern.forge.sdk.copilot.demonstration_recorder import (DemonstrationRecorder,DemonstrationRejection,@@ -111,7 +111,10 @@ from skyvern.forge.sdk.copilot.review_gate import parse_execution_receipts, serifrom skyvern.forge.sdk.copilot.runtime import close_browser_session_quietlyfrom skyvern.forge.sdk.copilot.steer import STEER_DOORBELL_TTL, copilot_steer_keyfrom skyvern.forge.sdk.copilot.tools.account_groups import recover_account_group_links-from skyvern.forge.sdk.copilot.tools.credential_deletion import credential_delete_enabled+from skyvern.forge.sdk.copilot.tools.credential_deletion import (+ credential_delete_enabled,+ enforce_credential_delete_access,+)from skyvern.forge.sdk.copilot.tools.workflow_update import (_validated_pending_workflow_proposal,private_workflow_settings_from_proposal,@@ -2188,6 +2191,7 @@ async def _commit_staged_workflow(build_source=WorkflowBuildSource.copilot,preserve_completion_contract=not clear_persisted_completion_contract,validate_code_block_templates=False,+ preserve_redacted_credential_references_from=canonical,)@@ -2272,6 +2276,7 @@ async def _restore_workflow_definition(original_workflow: Workflow | None, organbuild_source=original_workflow.build_source,preserve_completion_contract=False,validate_code_block_templates=False,+ preserve_redacted_credential_references_from=original_workflow,)# A shielded finalizer runs in a child task with a copied context, so the marker has to be a# mutable object shared by reference rather than a value set through the ContextVar.@@ -4362,7 +4367,12 @@ async def _delete_one_credential(organization_id: str, credential_id: str) -> Cr# A timeout stops the wait but never cancels the delete, so a late vault delete still gets its audit, profile# reap, TOTP clear and item cleanup.hooks = BackgroundTasks()- deletion = _detach_credential_delete_task(delete_organization_credential(organization_id, credential_id, hooks))++ async def delete() -> None:+ await enforce_credential_delete_access(credential_id)+ await delete_organization_credential(organization_id, credential_id, hooks)++ deletion = _detach_credential_delete_task(delete())deletion.add_done_callback(lambda _: _detach_credential_delete_task(_run_post_delete_hooks(hooks)))try:await asyncio.wait_for(asyncio.shield(deletion), CREDENTIAL_DELETE_TIMEOUT.total_seconds())@@ -4717,8 +4727,9 @@ async def workflow_copilot_credential_response(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,detail="credential_id is required when action is 'connected'",)- existing = await app.DATABASE.credentials.get_credentials_by_ids(- [credential_id], organization_id=organization.organization_id+ existing = await load_credentials(+ organization_id=organization.organization_id,+ credential_ids=[credential_id],)if not existing:raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Credential {credential_id} not found")diff --git a/skyvern/forge/sdk/schemas/browser_profiles.py b/skyvern/forge/sdk/schemas/browser_profiles.pyindex 3ae09b707..cc0f59176 100644--- a/skyvern/forge/sdk/schemas/browser_profiles.py+++ b/skyvern/forge/sdk/schemas/browser_profiles.py@@ -23,8 +23,8 @@ class BrowserProfile(BaseModel):modified_at: datetimedeleted_at: datetime | None = Nonelast_verified_login_at: datetime | None = None- # Populated by the list endpoint (batched) so the UI can show the credential-login role + freshness on- # rows without a per-row usage fetch. None on single-get and for profiles no credential links.+ # Populated on list and single-get responses so the UI can show the linked credential when visible.+ linked_credential_id: str | None = Nonelinked_credential_name: str | None = None@field_validator("proxy_location", mode="before")diff --git a/skyvern/forge/sdk/services/route_authorization.py b/skyvern/forge/sdk/services/route_authorization.pyindex 8af502323..cf62336fc 100644--- a/skyvern/forge/sdk/services/route_authorization.py+++ b/skyvern/forge/sdk/services/route_authorization.py@@ -137,7 +137,7 @@ ROUTE_ACTIONS: Mapping[str, str] = {"skyvern.forge.sdk.routes.credentials.get_credential": "credential.read","skyvern.forge.sdk.routes.credentials.get_credential_folder": "credential_folder.read","skyvern.forge.sdk.routes.credentials.get_credential_folders": "credential_folder.list",- "skyvern.forge.sdk.routes.credentials.get_credential_totp_code": "credential.read",+ "skyvern.forge.sdk.routes.credentials.get_credential_totp_code": "credential.use","skyvern.forge.sdk.routes.credentials.get_credentials": "credential.list","skyvern.forge.sdk.routes.credentials.get_custom_credential_service_config": "vault_provider.read","skyvern.forge.sdk.routes.credentials.get_custom_credential_service_status": "vault_provider.status",@@ -156,7 +156,7 @@ ROUTE_ACTIONS: Mapping[str, str] = {"skyvern.forge.sdk.routes.credentials.update_bitwarden_credential": "vault_provider.update","skyvern.forge.sdk.routes.credentials.update_credential": "credential.update","skyvern.forge.sdk.routes.credentials.update_credential_folder": "credential_folder.update",- "skyvern.forge.sdk.routes.credentials.update_credential_folder_assignment": "credential_folder.update",+ "skyvern.forge.sdk.routes.credentials.update_credential_folder_assignment": "credential.move","skyvern.forge.sdk.routes.credentials.update_custom_credential_service_config": "vault_provider.update","skyvern.forge.sdk.routes.credentials.update_onepassword_token": "vault_provider.update","skyvern.forge.sdk.routes.custom_llms.create_custom_llm": "custom_model.create",diff --git a/skyvern/forge/sdk/workflow/context_manager.py b/skyvern/forge/sdk/workflow/context_manager.pyindex e194536fe..0e6b21169 100644--- a/skyvern/forge/sdk/workflow/context_manager.py+++ b/skyvern/forge/sdk/workflow/context_manager.py@@ -1291,6 +1291,11 @@ class WorkflowRunContext:organization: Organization,fetch: CredentialFetch,) -> None:+ await app.AGENT_FUNCTION.enforce_credential_use(+ organization.organization_id,+ credential_id,+ workflow_run_id=self.workflow_run_id,+ )db_credential = await app.DATABASE.credentials.get_credential(credential_id, organization_id=organization.organization_id)diff --git a/skyvern/forge/sdk/workflow/service.py b/skyvern/forge/sdk/workflow/service.pyindex 1b11a3d6e..1b8c03600 100644--- a/skyvern/forge/sdk/workflow/service.py+++ b/skyvern/forge/sdk/workflow/service.py@@ -168,6 +168,7 @@ from skyvern.forge.sdk.schemas.persistent_browser_sessions import (from skyvern.forge.sdk.schemas.tasks import Task, TaskStatusfrom skyvern.forge.sdk.schemas.workflow_runs import WorkflowRunBlock, WorkflowRunTimeline, WorkflowRunTimelineTypefrom skyvern.forge.sdk.schemas.workflow_schedules import OneTimeDispatchStatus+from skyvern.forge.sdk.services.request_principal import RequestPrincipal, get_request_principalfrom skyvern.forge.sdk.streaming.registries import mark_stream_closingfrom skyvern.forge.sdk.submission import shadow as submission_shadowfrom skyvern.forge.sdk.trace import traced@@ -356,8 +357,10 @@ from skyvern.schemas.workflows import (BlockResult,BlockStatus,BlockType,+ CredentialParameterYAML,WorkflowCreateYAMLRequest,WorkflowDefinitionYAML,+ WorkflowParameterYAML,WorkflowStatus,)from skyvern.services import script_service, uploaded_file_service, workflow_script_service@@ -2821,10 +2824,33 @@ class WorkflowService:)return value- async def _validate_credential_ids(self, credential_ids: list[str], organization: Organization) -> list[Credential]:+ async def _validate_credential_ids(+ self,+ credential_ids: list[str],+ organization: Organization,+ *,+ principal: RequestPrincipal | None = None,+ workflow_run_id: str | None = None,+ skip_credential_use_ids: set[str] | None = None,+ ) -> list[Credential]:if not credential_ids:return []unique_ids = list(dict.fromkeys(credential_ids))+ principal = principal or get_request_principal()+ for credential_id in unique_ids:+ if skip_credential_use_ids and credential_id in skip_credential_use_ids:+ continue+ try:+ await app.AGENT_FUNCTION.enforce_credential_use(+ organization.organization_id,+ credential_id,+ principal=principal,+ workflow_run_id=workflow_run_id,+ )+ except PermissionError as exc:+ raise SkyvernHTTPException(+ message="Credential not accessible", status_code=HTTPStatus.FORBIDDEN+ ) from excexisting = await app.DATABASE.credentials.get_credentials_by_ids(unique_ids, organization_id=organization.organization_id)@@ -2899,7 +2925,9 @@ class WorkflowService:continueif isinstance(credential_id, str) and credential_id:bound_credential_ids.append(credential_id)- validated_bound_credentials = await self._validate_credential_ids(bound_credential_ids, organization)+ validated_bound_credentials = await self._validate_credential_ids(+ bound_credential_ids, organization, workflow_run_id=workflow_run.workflow_run_id+ )sequential_ids = sorted({credential.credential_id for credential in validated_bound_credentials if credential.run_sequentially})@@ -2918,8 +2946,12 @@ class WorkflowService:self,parameters: list[Any],organization: Organization,+ *,+ preserved_credential_references: set[tuple[str, str, str]] | None = None,) -> None:credential_ids_to_validate: list[str] = []+ credential_ids_requiring_use: set[str] = set()+ preserved_credential_references = preserved_credential_references or set()for parameter in parameters:key = getattr(parameter, "key", None) or "<unknown>"credential_ids = getattr(parameter, "credential_ids", None)@@ -2942,6 +2974,11 @@ class WorkflowService:)parameter.credential_id = credential_ids[0]credential_ids_to_validate.extend(credential_ids)+ credential_ids_requiring_use.update(+ credential_id+ for credential_id in credential_ids+ if (key, "credential_ids", credential_id) not in preserved_credential_references+ )fallback_credential_ids = getattr(parameter, "fallback_credential_ids", None)if fallback_credential_ids is not None:@@ -2955,6 +2992,11 @@ class WorkflowService:]parameter.fallback_credential_ids = fallback_credential_ids or Nonecredential_ids_to_validate.extend(fallback_credential_ids)+ credential_ids_requiring_use.update(+ credential_id+ for credential_id in fallback_credential_ids+ if (key, "fallback_credential_ids", credential_id) not in preserved_credential_references+ )if (getattr(parameter, "credential_ids", None) is not None@@ -2983,7 +3025,17 @@ class WorkflowService:status_code=400,)- await self._validate_credential_ids(credential_ids_to_validate, organization)+ if credential_id := getattr(parameter, "credential_id", None):+ credential_ids_to_validate.append(credential_id)+ if (key, "credential_id", credential_id) not in preserved_credential_references:+ credential_ids_requiring_use.add(credential_id)++ # A hidden id reused in a different field is a new reference and still needs use access.+ await self._validate_credential_ids(+ credential_ids_to_validate,+ organization,+ skip_credential_use_ids=set(credential_ids_to_validate) - credential_ids_requiring_use,+ )@staticmethoddef _get_rotating_credential_parameters(workflow: Workflow) -> list[CredentialParameter]:@@ -3132,7 +3184,9 @@ class WorkflowService:return overrides- async def _rotation_candidates_may_require_serialization(self, workflow: Workflow, organization_id: str) -> bool:+ async def _rotation_candidates_may_require_serialization(+ self, workflow: Workflow, organization_id: str, *, workflow_run_id: str | None = None+ ) -> bool:"""Conservatively decide whether a failed rotating-credential selection could still haveresolved to a credential opted into sequential execution. Any candidate flaggedrun_sequentially — or any candidate we cannot verify — fails closed so a serialized lane is@@ -3148,7 +3202,9 @@ class WorkflowService:if organization is None:return Truetry:- credentials = await self._validate_credential_ids(sorted(candidate_ids), organization)+ credentials = await self._validate_credential_ids(+ sorted(candidate_ids), organization, workflow_run_id=workflow_run_id+ )except Exception:# Cannot verify the candidate pool (missing/invalid id or lookup error) — fail closed.return True@@ -3223,7 +3279,7 @@ class WorkflowService:# candidate. A keyless workflow whose pool is provably non-sequential keeps the legacy# best-effort partial selection — the pre-feature behavior for runs outside serialization.if workflow.browser_profile_key or await self._rotation_candidates_may_require_serialization(- workflow, organization_id+ workflow, organization_id, workflow_run_id=workflow_run.workflow_run_id):raisereturn selections@@ -3233,6 +3289,7 @@ class WorkflowService:workflow: Workflow,organization: Organization,request_data: dict[str, Any] | None,+ credential_use_principal: RequestPrincipal | None = None,) -> None:all_workflow_parameters = await self.get_workflow_parameters(workflow_id=workflow.workflow_id)schedule_parameters = [@@ -3290,7 +3347,9 @@ class WorkflowService:))- await self._validate_credential_ids(credential_ids_to_validate, organization)+ await self._validate_credential_ids(+ credential_ids_to_validate, organization, principal=credential_use_principal+ )async def resolve_workflow_for_run(self,@@ -3676,7 +3735,9 @@ class WorkflowService:parameter_values = {param.key: value for param, value in workflow_parameter_values}if prevalidated_workflow_parameters is None:await self._validate_credential_ids(- self._credential_id_values(workflow_parameter_values), organization+ self._credential_id_values(workflow_parameter_values),+ organization,+ workflow_run_id=workflow_run.workflow_run_id,)await self._validate_bitwarden_item_ids(workflow=workflow, parameter_values=parameter_values)run_credential_parameter_overrides = await self._apply_run_credential_parameter_overrides(@@ -11422,6 +11483,102 @@ class WorkflowService:exc_info=True,)+ async def _preserve_redacted_credential_references(+ self,+ workflow_definition: WorkflowDefinition | WorkflowDefinitionYAML,+ previous_workflow: Workflow | None,+ ) -> set[tuple[str, str, str]]:+ if previous_workflow is None:+ return set()++ previous_parameters = {+ parameter.key: parameter+ for parameter in previous_workflow.workflow_definition.parameters+ if isinstance(parameter, CredentialParameter)+ }+ previous_workflow_parameters = {+ parameter.key: parameter+ for parameter in previous_workflow.workflow_definition.parameters+ if isinstance(parameter, WorkflowParameter)+ and parameter.workflow_parameter_type == WorkflowParameterType.CREDENTIAL_ID+ }+ credential_parameter_keys = set(previous_workflow_parameters)+ credential_ids = {+ credential_id+ for parameter in previous_parameters.values()+ for credential_id in (+ parameter.credential_id if parameter.credential_id not in credential_parameter_keys else None,+ *(parameter.credential_ids or []),+ *(parameter.fallback_credential_ids or []),+ )+ if credential_id+ }+ credential_ids.update(+ parameter.default_value+ for parameter in previous_workflow_parameters.values()+ if isinstance(parameter.default_value, str) and parameter.default_value+ )+ if not credential_ids:+ return set()++ visible_ids = await app.AGENT_FUNCTION.accessible_credential_ids(+ get_request_principal(), "credential.read", credential_ids+ )+ preserved_references: set[tuple[str, str, str]] = set()+ for parameter in workflow_definition.parameters:+ if isinstance(parameter, (WorkflowParameter, WorkflowParameterYAML)):+ previous_workflow_parameter = previous_workflow_parameters.get(parameter.key)+ if (+ previous_workflow_parameter is not None+ and isinstance(previous_workflow_parameter.default_value, str)+ and previous_workflow_parameter.default_value not in visible_ids+ ):+ if not parameter.default_value:+ parameter.default_value = previous_workflow_parameter.default_value+ if parameter.default_value == previous_workflow_parameter.default_value:+ preserved_references.add(+ (parameter.key, "default_value", previous_workflow_parameter.default_value)+ )+ continue+ if not isinstance(parameter, (CredentialParameter, CredentialParameterYAML)):+ continue+ previous = previous_parameters.get(parameter.key)+ if previous is None:+ continue++ if (+ previous.credential_id+ and previous.credential_id not in credential_parameter_keys+ and previous.credential_id not in visible_ids+ ):+ if not parameter.credential_id:+ parameter.credential_id = previous.credential_id+ if parameter.credential_id == previous.credential_id:+ preserved_references.add((parameter.key, "credential_id", previous.credential_id))++ for field_name in ("credential_ids", "fallback_credential_ids"):+ previous_values = getattr(previous, field_name) or []+ hidden_values = [value for value in previous_values if value not in visible_ids]+ if not hidden_values:+ continue++ # The workflow read serializer filters hidden ids; restore them in their prior positions.+ values = list(getattr(parameter, field_name) or [])+ hidden_after: dict[str | None, list[str]] = {}+ preceding_visible: str | None = None+ for value in previous_values:+ if value in visible_ids and value in values:+ preceding_visible = value+ elif value in hidden_values and value not in values:+ hidden_after.setdefault(preceding_visible, []).append(value)+ for visible_value, hidden in hidden_after.items():+ insert_at = values.index(visible_value) + 1 if visible_value in values else 0+ values[insert_at:insert_at] = hidden+ setattr(parameter, field_name, list(dict.fromkeys(values)))+ preserved_references.update((parameter.key, field_name, value) for value in hidden_values)++ return preserved_references+async def update_workflow_definition(self,workflow_id: str,@@ -11460,17 +11617,24 @@ class WorkflowService:preserve_completion_contract: bool = True,created_via: str | None = None,validate_code_block_templates: bool = True,+ preserve_redacted_credential_references_from: Workflow | None = None,+ preserved_credential_references: set[tuple[str, str, str]] | None = None,) -> Workflow:if workflow_definition is not None:if validate_code_block_templates:self._validate_code_block_templates(workflow_definition)self._validate_block_engines(workflow_definition)+ if preserved_credential_references is None:+ preserved_credential_references = await self._preserve_redacted_credential_references(+ workflow_definition, preserve_redacted_credential_references_from+ )if organization_id is not None:organization = await app.DATABASE.organizations.get_organization(organization_id=organization_id)if organization is not None:await self._validate_and_normalize_credential_rotation_parameters(workflow_definition.parameters,organization,+ preserved_credential_references=preserved_credential_references,)await encrypt_workflow_definition_secrets(workflow_definition, organization_id)updated_workflow = await app.DATABASE.workflows.update_workflow_and_reconcile_definition_params(@@ -17219,10 +17383,6 @@ class WorkflowService:return (workflow, ()) if return_write_result else workflowrecording_id_to_attach = None- await self._validate_and_normalize_credential_rotation_parameters(- request.workflow_definition.parameters,- organization,- )new_workflow_id: str | None = Noneattached_recording_to_new_version = Falserefresh_schedule_runtime_limits = False@@ -17246,6 +17406,14 @@ class WorkflowService:else:existing_latest_workflow = None+ preserved_credential_references = await self._preserve_redacted_credential_references(+ request.workflow_definition, existing_latest_workflow+ )+ await self._validate_and_normalize_credential_rotation_parameters(+ request.workflow_definition.parameters,+ organization,+ preserved_credential_references=preserved_credential_references,+ )if request.webhook_callback_url and (existing_latest_workflow is Noneor request.webhook_callback_url != existing_latest_workflow.webhook_callback_url@@ -17294,6 +17462,7 @@ class WorkflowService:created_via=created_via,notify_workflow_saved=False,validate_code_block_templates=validate_code_block_templates,+ preserved_credential_references=preserved_credential_references,)self._schedule_workflow_saved_hook_best_effort(diff --git a/skyvern/services/otp_service.py b/skyvern/services/otp_service.pyindex 0208085e9..04bcd2fa2 100644--- a/skyvern/services/otp_service.py+++ b/skyvern/services/otp_service.py@@ -1004,6 +1004,11 @@ async def poll_otp_value(cancels this early (``asyncio.wait_for``) can pass its own contexts and then read``observed_otp_types`` off them to report which kind of OTP did arrive."""+ if totp_identifier:+ await app.AGENT_FUNCTION.enforce_totp_identifier_credential_use(+ organization_id, totp_identifier, workflow_run_id=workflow_run_id+ )+timeout = timedelta(minutes=settings.VERIFICATION_CODE_POLLING_TIMEOUT_MINS)if max_wait_seconds is not None:timeout = min(timeout, timedelta(seconds=max_wait_seconds))diff --git a/skyvern/utils/email_validation.py b/skyvern/utils/email_validation.pyindex 1536f3d04..be3d834cf 100644--- a/skyvern/utils/email_validation.py+++ b/skyvern/utils/email_validation.py@@ -1,14 +1,20 @@import reSAFE_EMAIL_ADDRESS_PATTERN = re.compile(r"^[A-Za-z0-9.!#$%&'*+/=?^_`{|}~-]+@[A-Za-z0-9.-]+$")+# Keep SQL identifier matching aligned with Python's str.strip().+EMAIL_IDENTIFIER_TRIM_CHARS = (+ " \t\n\r\v\f\x1c\x1d\x1e\x1f\x85\xa0\u1680"+ "\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a"+ "\u2028\u2029\u202f\u205f\u3000"+)def normalize_email_address(value: str) -> str:- return value.strip().casefold()+ return value.strip(EMAIL_IDENTIFIER_TRIM_CHARS).casefold()def normalize_identifier_if_email(value: str) -> str:- stripped_identifier = value.strip()+ stripped_identifier = value.strip(EMAIL_IDENTIFIER_TRIM_CHARS)if SAFE_EMAIL_ADDRESS_PATTERN.fullmatch(stripped_identifier):return normalize_email_address(value)return valuediff --git a/skyvern/webeye/real_browser_manager.py b/skyvern/webeye/real_browser_manager.pyindex 2079ff9b9..7973fb520 100644--- a/skyvern/webeye/real_browser_manager.py+++ b/skyvern/webeye/real_browser_manager.py@@ -1037,6 +1037,14 @@ class RealBrowserManager(BrowserManager):task: Task,browser_session_id: str | None = None,) -> BrowserState:+ if task.workflow_run_id:+ await app.AGENT_FUNCTION.enforce_workflow_run_credential_use(+ None,+ task.workflow_run_id,+ organization_id=task.organization_id,+ browser_session_id=browser_session_id,+ )+browser_state = self.get_for_task(task_id=task.task_id, workflow_run_id=task.workflow_run_id)lost_external_browser = Falseif browser_state is not None:@@ -1260,6 +1268,15 @@ class RealBrowserManager(BrowserManager):if browser_profile_id is None:browser_profile_id = workflow_run.browser_profile_id+ # Shared run/task/SDK attachment boundary; route guards remain early 403s.+ await app.AGENT_FUNCTION.enforce_workflow_run_credential_use(+ None,+ workflow_run_id,+ organization_id=workflow_run.organization_id,+ browser_profile_id=browser_profile_id,+ browser_session_id=browser_session_id,+ )+context = skyvern_context.current()# A synthetic run never begins the session; only an explicit runnable can acquire it.owner_fallback_id = None if context is not None and context.workflow_run_is_synthetic else workflow_run_iddiff --git a/tests/unit/forge/sdk/routes/streaming/test_screenshot_stream_disconnect.py b/tests/unit/forge/sdk/routes/streaming/test_screenshot_stream_disconnect.pyindex 77719f1e9..49a2353f4 100644--- a/tests/unit/forge/sdk/routes/streaming/test_screenshot_stream_disconnect.py+++ b/tests/unit/forge/sdk/routes/streaming/test_screenshot_stream_disconnect.py@@ -43,6 +43,9 @@ class _DisconnectedWebSocket:async def send_json(self, data: dict) -> None:self.sent.append(data)+ async def close(self, *, code: int = 1000) -> None:+ return None+async def receive(self) -> dict:if not self._disconnect_delivered:self._disconnect_delivered = True@@ -74,7 +77,12 @@ async def test_workflow_run_streaming_stops_sending_once_the_client_is_gone(monkeypatch.setattr(app,"AGENT_FUNCTION",- SimpleNamespace(mark_streaming_viewer_active=AsyncMock(), enforce_folder_access=AsyncMock()),+ SimpleNamespace(+ mark_streaming_viewer_active=AsyncMock(),+ enforce_folder_access=AsyncMock(),+ enforce_browser_session_credential_use=AsyncMock(),+ enforce_workflow_run_credential_use=AsyncMock(),+ ),)with capture_logs() as logs:@@ -108,6 +116,9 @@ class _WatchingWebSocket:raise self._send_errorself.sent.append(data)+ async def close(self, *, code: int = 1000) -> None:+ return None+async def receive(self) -> dict:await asyncio.Event().wait()raise AssertionError("unreachable")@@ -169,7 +180,12 @@ def run_stream(monkeypatch: pytest.MonkeyPatch) -> Callable[..., Awaitable[_Watcmonkeypatch.setattr(app,"AGENT_FUNCTION",- SimpleNamespace(mark_streaming_viewer_active=AsyncMock(), enforce_folder_access=AsyncMock()),+ SimpleNamespace(+ mark_streaming_viewer_active=AsyncMock(),+ enforce_folder_access=AsyncMock(),+ enforce_browser_session_credential_use=AsyncMock(),+ enforce_workflow_run_credential_use=AsyncMock(),+ ),)async def _connect(@@ -181,7 +197,17 @@ def run_stream(monkeypatch: pytest.MonkeyPatch) -> Callable[..., Awaitable[_Watctask_id: str = "",send_error: Exception | None = None,) -> _WatchingWebSocket:- monkeypatch.setattr(app, "DATABASE", SimpleNamespace(workflow_runs=runs, tasks=runs))+ monkeypatch.setattr(+ app,+ "DATABASE",+ SimpleNamespace(+ workflow_runs=runs,+ tasks=runs,+ browser_sessions=SimpleNamespace(+ get_persistent_browser_session_by_runnable_id=AsyncMock(return_value=None)+ ),+ ),+ )monkeypatch.setattr(app, "STORAGE", SimpleNamespace(get_streaming_file=AsyncMock(return_value=frame)))monkeypatch.setattr(screenshot, "STREAMING_TIMEOUT", timeout_seconds)websocket = _WatchingWebSocket(send_error)@@ -204,7 +230,13 @@ async def test_run_stream_tile_counts_a_run_once_and_only_while_its_failure_is_upool_timeout = TimeoutError("QueuePool limit reached")runs = _ScriptedRuns({- "wr_blank": [WorkflowRunStatus.running, pool_timeout, WorkflowRunStatus.running, WorkflowRunStatus.running],+ "wr_blank": [+ WorkflowRunStatus.running,+ pool_timeout,+ WorkflowRunStatus.running,+ WorkflowRunStatus.running,+ WorkflowRunStatus.running,+ ],"wr_recovered": [WorkflowRunStatus.running,pool_timeout,@@ -286,7 +318,9 @@ async def test_task_page_stream_error_counts_as_unrecovered_because_the_task_pagrun_stream: Callable[..., Awaitable[_WatchingWebSocket]],) -> None:pool_timeout = TimeoutError("QueuePool limit reached")- runs = _ScriptedRuns({"wr_task": [WorkflowRunStatus.running, pool_timeout], "wr_run": [pool_timeout]})+ runs = _ScriptedRuns(+ {"wr_task": [WorkflowRunStatus.running, WorkflowRunStatus.running, pool_timeout], "wr_run": [pool_timeout]}+ )with capture_logs() as logs:await run_stream(runs, frame=b"png", timeout_seconds=10_000, task_id="tsk_task")await run_stream(runs, frame=b"png", timeout_seconds=10_000, workflow_run_id="wr_run")diff --git a/tests/unit/forge/sdk/routes/test_browser_sessions.py b/tests/unit/forge/sdk/routes/test_browser_sessions.pyindex e85114959..aaef03271 100644--- a/tests/unit/forge/sdk/routes/test_browser_sessions.py+++ b/tests/unit/forge/sdk/routes/test_browser_sessions.py@@ -356,8 +356,12 @@ async def test_get_browser_session_enables_strict_download_lookup() -> None:async def test_fan_out_listings_keep_each_sessions_storage_listings_sequential(endpoint: str) -> None:"""These endpoints already gather across sessions, so overlapping a session's two listings wouldonly raise the request's peak pool checkouts from N to 2N."""- sessions = [MagicMock(), MagicMock()]+ sessions = [MagicMock(browser_profile_id=None, persistent_browser_session_id=f"pbs_{index}") for index in range(2)]app_mock = MagicMock()+ app_mock.AGENT_FUNCTION.enforce_browser_session_credential_use = AsyncMock()+ app_mock.AGENT_FUNCTION.accessible_browser_session_ids = AsyncMock(+ return_value={session.persistent_browser_session_id for session in sessions}+ )app_mock.DATABASE.browser_sessions.get_persistent_browser_sessions_history = AsyncMock(return_value=sessions)app_mock.PERSISTENT_SESSIONS_MANAGER.get_active_sessions = AsyncMock(return_value=sessions)app_mock.DATABASE.browser_sessions.get_folder_visible_browser_session_ids = AsyncMock(diff --git a/tests/unit/forge/sdk/test_list_browser_profiles_route.py b/tests/unit/forge/sdk/test_list_browser_profiles_route.pyindex a44d7f28e..e56b9c8e7 100644--- a/tests/unit/forge/sdk/test_list_browser_profiles_route.py+++ b/tests/unit/forge/sdk/test_list_browser_profiles_route.py@@ -38,6 +38,7 @@ def _build_client(monkeypatch: pytest.MonkeyPatch) -> tuple[TestClient, AsyncMocasync def _fake_org() -> SimpleNamespace:return SimpleNamespace(organization_id=ORG_ID)+ monkeypatch.setattr(forge_app.AGENT_FUNCTION, "credential_folders_restricted", AsyncMock(return_value=False))list_browser_profiles = AsyncMock()monkeypatch.setattr(forge_app.DATABASE.browser_sessions,@@ -72,6 +73,7 @@ def test_list_browser_profiles_default_pagination(monkeypatch: pytest.MonkeyPatcpage_size=10,search_key=None,managed=None,+ exclude_search_profile_ids=set(),)@@ -89,6 +91,7 @@ def test_list_browser_profiles_explicit_pagination(monkeypatch: pytest.MonkeyPatpage_size=10,search_key=None,managed=None,+ exclude_search_profile_ids=set(),)@@ -124,6 +127,7 @@ def test_list_browser_profiles_alias_trailing_slash(monkeypatch: pytest.MonkeyPapage_size=5,search_key=None,managed=None,+ exclude_search_profile_ids=set(),)@@ -143,6 +147,7 @@ def test_list_browser_profiles_search_key_hit_on_name(monkeypatch: pytest.Monkeypage_size=10,search_key="production",managed=None,+ exclude_search_profile_ids=set(),)@@ -162,6 +167,7 @@ def test_list_browser_profiles_search_key_hit_on_description(monkeypatch: pytestpage_size=10,search_key="staging_login",managed=None,+ exclude_search_profile_ids=set(),)@@ -180,6 +186,7 @@ def test_list_browser_profiles_search_key_miss(monkeypatch: pytest.MonkeyPatch)page_size=10,search_key="no_such_profile",managed=None,+ exclude_search_profile_ids=set(),)@@ -197,6 +204,7 @@ def test_list_browser_profiles_search_key_with_pagination(monkeypatch: pytest.Mopage_size=5,search_key="prod",managed=None,+ exclude_search_profile_ids=set(),)@@ -214,4 +222,5 @@ def test_list_browser_profiles_search_key_with_include_deleted(monkeypatch: pytepage_size=10,search_key="archived",managed=None,+ exclude_search_profile_ids=set(),)diff --git a/tests/unit/test_context_manager.py b/tests/unit/test_context_manager.pyindex 33a5cf0fe..e71b3446d 100644--- a/tests/unit/test_context_manager.py+++ b/tests/unit/test_context_manager.py@@ -341,6 +341,7 @@ def _install_credential_app(),CREDENTIAL_VAULT_SERVICES={CredentialVaultType.AZURE_VAULT: vault_service},AGENT_FUNCTION=SimpleNamespace(+ enforce_credential_use=AsyncMock(),process_registered_credential_item=AsyncMock(side_effect=lambda **kwargs: kwargs["credential_item"]),parse_enterprise_totp_secret=AsyncMock(return_value=None),),diff --git a/tests/unit/test_copilot_agent_helpers.py b/tests/unit/test_copilot_agent_helpers.pyindex 8a667a0a3..374ccb082 100644--- a/tests/unit/test_copilot_agent_helpers.py+++ b/tests/unit/test_copilot_agent_helpers.py@@ -5767,7 +5767,12 @@ workflow_definition:assert "cred_missing" in errorassert "not found in this organization" in errorassert "Stop before creating, updating, or running the workflow" in error- get_credentials_by_ids.assert_awaited_once_with(["cred_valid", "cred_missing"], organization_id="org-1")+ get_credentials_by_ids.assert_awaited_once_with(+ ["cred_valid", "cred_missing"],+ organization_id="org-1",+ allowed_folder_ids=None,+ include_deleted=False,+ )@pytest.mark.asyncioasync def test_valid_tool_credential_reference_allows_tool_path(self, monkeypatch) -> None:@@ -5783,7 +5788,9 @@ workflow_definition:error = await _credential_reference_validation_error({"credential_id": "cred_valid"}, _ctx())assert error is None- get_credentials_by_ids.assert_awaited_once_with(["cred_valid"], organization_id="org-1")+ get_credentials_by_ids.assert_awaited_once_with(+ ["cred_valid"], organization_id="org-1", allowed_folder_ids=None, include_deleted=False+ )@pytest.mark.asyncioasync def test_update_workflow_allows_missing_credentials_for_explicit_untested_draft(self, monkeypatch) -> None:@@ -6432,7 +6439,9 @@ class TestRunBlocksCredentialApproval:assert result["ok"] is Falseassert result["error"] == "Organization not found"- database.credentials.get_credentials_by_ids.assert_awaited_once_with(["cred_resolved"], organization_id="org-1")+ database.credentials.get_credentials_by_ids.assert_awaited_once_with(+ ["cred_resolved"], organization_id="org-1", allowed_folder_ids=None, include_deleted=False+ )database.organizations.get_organization.assert_awaited_once_with(organization_id="org-1")@pytest.mark.asyncio@@ -7025,7 +7034,7 @@ class TestRunBlocksCredentialApprovalFrontierScope:assert "unapproved_credential_reference" not in (result.get("error") or "")assert result["error"] == "Organization not found"database.credentials.get_credentials_by_ids.assert_awaited_once_with(- [self.CREDENTIAL_ID], organization_id="org-1"+ [self.CREDENTIAL_ID], organization_id="org-1", allowed_folder_ids=None, include_deleted=False)@pytest.mark.asyncio@@ -7167,7 +7176,7 @@ class TestRunBlocksCredentialApprovalFrontierScope:assert "not found in this organization" in result["error"]assert self.CREDENTIAL_ID in result["error"]database.credentials.get_credentials_by_ids.assert_awaited_once_with(- [self.CREDENTIAL_ID], organization_id="org-1"+ [self.CREDENTIAL_ID], organization_id="org-1", allowed_folder_ids=None, include_deleted=False)diff --git a/tests/unit/test_copilot_credential_deletion.py b/tests/unit/test_copilot_credential_deletion.pyindex f61c673e6..49084f8f9 100644--- a/tests/unit/test_copilot_credential_deletion.py+++ b/tests/unit/test_copilot_credential_deletion.py@@ -9,7 +9,7 @@ from unittest.mock import AsyncMockimport pytestimport pytest_asyncio-from fastapi import FastAPI+from fastapi import FastAPI, HTTPExceptionfrom httpx import ASGITransport, AsyncClient, Responsefrom pydantic_core import to_jsonfrom sqlalchemy import event, select, update@@ -29,7 +29,7 @@ from skyvern.forge.sdk.copilot.ask_user import ()from skyvern.forge.sdk.copilot.browser_ablation import resolve_copilot_tool_surfacefrom skyvern.forge.sdk.copilot.context import CopilotContext-from skyvern.forge.sdk.copilot.tools import copilot_native_tools+from skyvern.forge.sdk.copilot.tools import copilot_native_tools, credential_deletionfrom skyvern.forge.sdk.copilot.tools.credential_deletion import delete_saved_credentialsfrom skyvern.forge.sdk.db.models import CredentialModel, WorkflowCopilotChatMessageModel, WorkflowCopilotChatModelfrom skyvern.forge.sdk.routes import credentials as credential_routes@@ -37,6 +37,7 @@ from skyvern.forge.sdk.routes import workflow_copilot as routesfrom skyvern.forge.sdk.schemas.credentials import Credential, CredentialVaultTypefrom skyvern.forge.sdk.schemas.workflow_copilot import CopilotPendingTurnfrom skyvern.forge.sdk.schemas.workflow_copilot import WorkflowCopilotChatSender as Sender+from skyvern.forge.sdk.services.request_principal import AuthKind, RequestPrincipalfrom tests.unit.conftest import RUN_GROUP_ORG, RUN_GROUP_WPID, GroupEnvSECRET = "vault-secret-fixture-55190"@@ -222,6 +223,31 @@ async def test_confirm_deletes_only_the_checked_entries_and_reports_each_outcomeassert SECRET not in to_json(surface).decode()+async def test_confirmation_rechecks_delete_access_before_deleting_a_card_entry(+ chat: Chat, monkeypatch: pytest.MonkeyPatch+) -> None:+ task = _start(chat, ["cred_1"])+ card = await _card(chat)+ viewer = RequestPrincipal(RUN_GROUP_ORG, AuthKind.bearer, "viewer", "org:member")+ monkeypatch.setattr(credential_deletion, "get_request_principal", lambda: viewer)++ async def deny_viewer(principal: RequestPrincipal | None, action: str, references: set[tuple[str, str]]) -> None:+ assert principal == viewer+ assert action == "credential.delete"+ assert references == {("credential_id", "cred_1")}+ raise HTTPException(status_code=403, detail="credential_folder_access_denied")++ monkeypatch.setattr(app.AGENT_FUNCTION, "enforce_credential_folder_access_for_ids", deny_viewer)+ confirmed = await _confirm(chat, card, ["cred_1"])+ result = await asyncio.wait_for(task, 5)++ assert confirmed.status_code == 200+ assert [(item["credential_id"], item["outcome"]) for item in result["outcomes"]] == [("cred_1", "failed")]+ assert chat.vault.deleted == []+ assert not chat.vault.entered.is_set()++@pytest.mark.asyncio@pytest.mark.parametrize("answer", ["skip", "approve_via_reply", "stop", "client_gone"])async def test_an_unconfirmed_card_deletes_nothing(chat: Chat, answer: str) -> None:diff --git a/tests/unit/test_copilot_credential_pause.py b/tests/unit/test_copilot_credential_pause.pyindex 5d95f251b..cb959cd0d 100644--- a/tests/unit/test_copilot_credential_pause.py+++ b/tests/unit/test_copilot_credential_pause.py@@ -44,6 +44,7 @@ from skyvern.exceptions import HttpException as VaultHttpExceptionfrom skyvern.forge import appfrom skyvern.forge.sdk.cache.base import NoopLockfrom skyvern.forge.sdk.copilot import credential_pause as credential_pause_module+from skyvern.forge.sdk.copilot import credential_resolutionfrom skyvern.forge.sdk.copilot import tools as tools_modulefrom skyvern.forge.sdk.copilot.agent import _finalize_result_with_blocker_override, _turn_credential_prompt_reasonfrom skyvern.forge.sdk.copilot.blocker_signal import (@@ -1212,6 +1213,36 @@ async def test_route_404_when_credential_unknown_or_foreign_org(monkeypatch: pytassert cache.set_calls == []+async def test_route_404_when_connected_credential_is_in_a_hidden_folder(monkeypatch: pytest.MonkeyPatch) -> None:+ cache = _FakeCache()+ _seed_active_pause(cache, "org-1", "chat-1", "turn-1", "tok-1")+ monkeypatch.setattr(app, "CACHE", cache, raising=False)+ credential_lookup = AsyncMock(return_value=[])+ monkeypatch.setattr(+ app, "DATABASE", SimpleNamespace(credentials=SimpleNamespace(get_credentials_by_ids=credential_lookup))+ )+ monkeypatch.setattr(+ credential_resolution, "credential_folder_ids_for_current_request", AsyncMock(return_value={"folder_visible"})+ )+ organization = SimpleNamespace(organization_id="org-1")++ with pytest.raises(HTTPException) as excinfo:+ await workflow_copilot_credential_response(+ _response_request(action="connected", credential_id="cred_hidden"),+ organization=organization,+ )++ assert excinfo.value.status_code == status.HTTP_404_NOT_FOUND+ credential_lookup.assert_awaited_once_with(+ ["cred_hidden"],+ organization_id="org-1",+ allowed_folder_ids={"folder_visible"},+ include_deleted=False,+ )+ assert cache.set_calls == []++@pytest.mark.asyncioasync def test_route_writes_flag_for_connected_with_valid_credential(monkeypatch: pytest.MonkeyPatch) -> None:cache = _FakeCache()@@ -2508,6 +2539,21 @@ async def test_a_named_login_known_for_another_site_is_left_to_the_picker(assert [card.named_credential_id for card in _sent_cards(ctx)] == [offered]+async def test_denied_vault_site_read_leaves_a_named_login_to_the_picker(monkeypatch: pytest.MonkeyPatch) -> None:+ ctx = _tool_ctx(monkeypatch, _answered_cache("skip"))+ ctx.request_policy.current_turn_named_credential_ids = {"cred_1"}+ monkeypatch.setattr(+ credential_fill_module,+ "_read_vault_named_sites",+ AsyncMock(side_effect=PermissionError("credential not accessible")),+ )++ await _ask(ctx, "https://portal.example.com/login")++ assert [card.named_credential_id for card in _sent_cards(ctx)] == [None]++@pytest.mark.asyncio@pytest.mark.parametrize("carried_as", ["approval", "proposal"])async def test_a_login_carried_in_for_another_site_is_left_to_the_picker_when_named_again(@@ -2763,6 +2809,28 @@ async def test_origin_recovery_admits_no_credential_it_cannot_place_on_the_provi_assert_declined(ctx, result, "connected_other_site")+async def test_denied_vault_site_read_does_not_abort_origin_recovery(monkeypatch: pytest.MonkeyPatch) -> None:+ ctx = _recovery_ctx(monkeypatch, _answered_cache("connected", "cred_idp"))+ monkeypatch.setattr(+ credential_fill_module,+ "_read_vault_named_sites",+ AsyncMock(side_effect=PermissionError("credential not accessible")),+ )+ _stub_credential_lookup(monkeypatch, _idp_credential())+ monkeypatch.setattr(+ credential_pause_module.app.DATABASE,+ "workflow_params",+ SimpleNamespace(record_pending_copilot_turn_credential_resume=AsyncMock()),+ raising=False,+ )++ result = await _ask(ctx, f"{_IDP_ORIGIN}/login")++ assert ctx.credential_pause_outcome == "not_admitted"+ _assert_declined(ctx, result, "connected_other_site")++@pytest.mark.asyncioasync def test_a_recovery_connect_keeps_the_named_service_login_approved_beside_the_provider_login(monkeypatch: pytest.MonkeyPatch,diff --git a/tests/unit/test_copilot_fill_credential_field.py b/tests/unit/test_copilot_fill_credential_field.pyindex b3aaa9820..b85c539d7 100644--- a/tests/unit/test_copilot_fill_credential_field.py+++ b/tests/unit/test_copilot_fill_credential_field.py@@ -206,7 +206,10 @@ class TestResolveCredentialFillValue:monkeypatch.setattr(object.__getattribute__(app, "_inst"),"AGENT_FUNCTION",- SimpleNamespace(parse_enterprise_totp_secret=AsyncMock(return_value=None)),+ SimpleNamespace(+ enforce_credential_use=AsyncMock(),+ parse_enterprise_totp_secret=AsyncMock(return_value=None),+ ),raising=False,)@@ -2727,7 +2730,7 @@ workflow_definition:policy.current_turn_named_credential_ids = {"cred_123"}if origin_arm == "saved_other_approved":with patch(- "skyvern.forge.sdk.copilot.request_policy.app.DATABASE.credentials.get_credentials_by_ids",+ "skyvern.forge.sdk.copilot.credential_resolution.app.DATABASE.credentials.get_credentials_by_ids",AsyncMock(return_value=[credential]),):await _seed_prior_approved_credentials(diff --git a/tests/unit/test_copilot_positive_evidence_carriers.py b/tests/unit/test_copilot_positive_evidence_carriers.pyindex 9d746c625..7e29d2e9c 100644--- a/tests/unit/test_copilot_positive_evidence_carriers.py+++ b/tests/unit/test_copilot_positive_evidence_carriers.py@@ -673,7 +673,7 @@ async def test_track_a_registry_refuses_credential_run_even_when_scout_values_arrun_execution_module,"app",SimpleNamespace(- AGENT_FUNCTION=SimpleNamespace(serialize_codeblock_parameters=dict),+ AGENT_FUNCTION=SimpleNamespace(enforce_credential_use=AsyncMock(), serialize_codeblock_parameters=dict),DATABASE=SimpleNamespace(credentials=SimpleNamespace(get_credential=AsyncMock(return_value=None))),),)@@ -722,6 +722,7 @@ async def test_track_a_registry_admits_complete_run_bound_static_credential_valu"app",SimpleNamespace(AGENT_FUNCTION=SimpleNamespace(+ enforce_credential_use=AsyncMock(),serialize_codeblock_parameters=lambda values: values,process_registered_credential_item=process,),@@ -768,6 +769,7 @@ async def test_track_a_registry_keeps_static_credential_values_when_totp_is_dyna"app",SimpleNamespace(AGENT_FUNCTION=SimpleNamespace(+ enforce_credential_use=AsyncMock(),serialize_codeblock_parameters=lambda values: values,process_registered_credential_item=AsyncMock(return_value=credential_item),),diff --git a/tests/unit/test_copilot_request_policy_workflow_credentials.py b/tests/unit/test_copilot_request_policy_workflow_credentials.pyindex 11d70dc59..92f81fbb8 100644--- a/tests/unit/test_copilot_request_policy_workflow_credentials.py+++ b/tests/unit/test_copilot_request_policy_workflow_credentials.py@@ -422,6 +422,7 @@ async def test_list_credentials_normalizes_pagination(organization_id="org-1",page=expected_page,page_size=expected_page_size,+ allowed_folder_ids=None,)assert result["data"]["page"] == expected_pageassert result["data"]["page_size"] == expected_page_sizediff --git a/tests/unit/test_credential_fallback.py b/tests/unit/test_credential_fallback.pyindex 2b16f4d29..bc43ff03f 100644--- a/tests/unit/test_credential_fallback.py+++ b/tests/unit/test_credential_fallback.py@@ -109,6 +109,7 @@ async def _validate_parameter(parameter: CredentialParameter, existing_ids: listorganization = SimpleNamespace(organization_id="org_test")existing = [SimpleNamespace(credential_id=credential_id) for credential_id in existing_ids or []]with patch("skyvern.forge.sdk.workflow.service.app") as mock_app:+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()mock_app.DATABASE.credentials.get_credentials_by_ids = AsyncMock(return_value=existing)await service._validate_and_normalize_credential_rotation_parameters([parameter], organization)@@ -119,7 +120,7 @@ async def test_workflow_save_validation_dedupes_fallback_credentials_preserving_fallback_credential_ids=["cred_b", "cred_c", "cred_b", "cred_d", "cred_c"],)- await _validate_parameter(parameter, ["cred_b", "cred_c", "cred_d"])+ await _validate_parameter(parameter, ["cred_primary", "cred_b", "cred_c", "cred_d"])assert parameter.fallback_credential_ids == ["cred_b", "cred_c", "cred_d"]assert parameter.credential_id == "cred_primary"@@ -130,7 +131,7 @@ async def test_workflow_save_validation_rejects_unknown_fallback_credential_id()parameter = _credential_parameter(fallback_credential_ids=["cred_missing"])with pytest.raises(InvalidCredentialId):- await _validate_parameter(parameter, [])+ await _validate_parameter(parameter, ["cred_primary"])@pytest.mark.asyncio@@ -138,7 +139,7 @@ async def test_workflow_save_validation_rejects_bad_fallback_trigger() -> None:parameter = _credential_parameter(fallback_credential_ids=["cred_b"], fallback_trigger="later")with pytest.raises(SkyvernHTTPException, match="fallback_trigger"):- await _validate_parameter(parameter, ["cred_b"])+ await _validate_parameter(parameter, ["cred_primary", "cred_b"])@pytest.mark.asyncio@@ -153,7 +154,7 @@ async def test_workflow_save_validation_rejects_trigger_without_fallback_list()async def test_workflow_save_validation_normalizes_empty_fallback_list_to_none() -> None:parameter = _credential_parameter(fallback_credential_ids=[])- await _validate_parameter(parameter)+ await _validate_parameter(parameter, ["cred_primary"])assert parameter.fallback_credential_ids is None@@ -162,7 +163,7 @@ async def test_workflow_save_validation_normalizes_empty_fallback_list_to_none()async def test_workflow_save_validation_drops_primary_credential_from_fallbacks() -> None:parameter = _credential_parameter(fallback_credential_ids=["cred_primary", "cred_b"])- await _validate_parameter(parameter, ["cred_b"])+ await _validate_parameter(parameter, ["cred_primary", "cred_b"])assert parameter.fallback_credential_ids == ["cred_b"]@@ -206,7 +207,7 @@ async def test_workflow_save_validation_allows_rotation_without_fallback_credentasync def test_workflow_save_validation_allows_fallback_credentials_without_rotation() -> None:parameter = _credential_parameter(fallback_credential_ids=["cred_b", "cred_c"])- await _validate_parameter(parameter, ["cred_b", "cred_c"])+ await _validate_parameter(parameter, ["cred_primary", "cred_b", "cred_c"])assert parameter.credential_ids is Noneassert parameter.fallback_credential_ids == ["cred_b", "cred_c"]diff --git a/tests/unit/test_credential_rotation.py b/tests/unit/test_credential_rotation.pyindex edd48ae02..38b1bef88 100644--- a/tests/unit/test_credential_rotation.py+++ b/tests/unit/test_credential_rotation.py@@ -571,6 +571,7 @@ async def test_workflow_save_validation_rejects_unknown_credential_id() -> None:with patch("skyvern.forge.sdk.workflow.service.app") as mock_app:mock_app.DATABASE.workflows.get_browser_action_policy = AsyncMock(return_value=None)mock_app.DATABASE.credentials.get_credentials_by_ids = AsyncMock(return_value=[])+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()with pytest.raises(InvalidCredentialId):await service._validate_and_normalize_credential_rotation_parameters([parameter], org)@@ -595,6 +596,7 @@ async def test_workflow_save_validation_normalizes_credential_id_to_first_rotatiwith patch("skyvern.forge.sdk.workflow.service.app") as mock_app:mock_app.DATABASE.workflows.get_browser_action_policy = AsyncMock(return_value=None)mock_app.DATABASE.credentials.get_credentials_by_ids = AsyncMock(return_value=existing)+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()await service._validate_and_normalize_credential_rotation_parameters([parameter], org)assert parameter.credential_id == "cred_a"@@ -617,6 +619,7 @@ async def test_workflow_save_validation_dedupes_credential_ids_preserving_order(with patch("skyvern.forge.sdk.workflow.service.app") as mock_app:mock_app.DATABASE.workflows.get_browser_action_policy = AsyncMock(return_value=None)mock_get_credentials = AsyncMock(return_value=existing)+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()mock_app.DATABASE.credentials.get_credentials_by_ids = mock_get_credentialsawait service._validate_and_normalize_credential_rotation_parameters([parameter], org)@@ -790,6 +793,7 @@ async def _attempt_setup_rotation_profile_run():mock_app.DATABASE.workflows.get_browser_action_policy = AsyncMock(return_value=None)mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)mock_app.AGENT_FUNCTION.is_browser_memory_engine_enabled = AsyncMock(return_value=False)mock_app.DATABASE.browser_sessions.get_or_create_managed_browser_profile = AsyncMock(@@ -873,6 +877,7 @@ async def _setup_bound_credentials(patch("skyvern.forge.sdk.workflow.credential_selection.app") as selection_app,):mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)mock_app.DATABASE.workflows.get_browser_action_policy = AsyncMock(return_value=None)mock_app.DATABASE.workflow_runs.update_workflow_run = AsyncMock(side_effect=update_workflow_run)@@ -911,6 +916,7 @@ async def test_direct_bindings_snapshot_only_opted_in_credentials_and_runtime_reassert workflow_run.sequential_credential_id == "cred_serial"with patch("skyvern.forge.sdk.workflow.context_manager.app") as context_app:+ context_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()context_app.DATABASE.workflow_run_credential_selections = _SelectionRepo()assert await sequential_context.resolve_credential_parameter_id(sequential, "org_test") == "cred_serial"assert await parallel_context.resolve_credential_parameter_id(parallel, "org_test") == "cred_parallel"@@ -943,6 +949,7 @@ async def test_plain_indirect_binding_snapshots_and_runtime_resolves_bound_paramassert workflow_run.sequential_credential_id == "cred_runtime"with patch("skyvern.forge.sdk.workflow.context_manager.app") as context_app:+ context_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()context_app.DATABASE.workflow_run_credential_selections = _SelectionRepo()assert await context.resolve_credential_parameter_id(login, "org_test") == "cred_runtime"assert context.get_resolved_credential_parameter_id(login.key) == "cred_runtime"@@ -1001,6 +1008,7 @@ async def test_runtime_only_indirect_binding_fails_closed_if_resolved_credentialorganization = SimpleNamespace(organization_id="org_test")with patch("skyvern.forge.sdk.workflow.context_manager.app") as mock_app:+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()mock_app.DATABASE.workflow_run_credential_selections = _SelectionRepo()mock_app.DATABASE.credentials.get_credential = AsyncMock(return_value=SimpleNamespace(credential_id="cred_runtime", run_sequentially=True)@@ -1047,6 +1055,7 @@ async def test_runtime_credential_registration_proceeds_when_lane_is_safe(credential_service.get_credential_item = AsyncMock(return_value=SimpleNamespace(credential=credential))with patch("skyvern.forge.sdk.workflow.context_manager.app") as mock_app:+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()mock_app.DATABASE.workflow_run_credential_selections = _SelectionRepo()mock_app.DATABASE.credentials.get_credential = AsyncMock(return_value=db_credential)mock_app.DATABASE.workflow_runs.get_workflow_run = AsyncMock(@@ -1084,6 +1093,7 @@ async def test_keyed_rotation_snapshot_and_runtime_reuse_one_persisted_selectionpatch("skyvern.forge.sdk.workflow.context_manager.app") as context_app,):selection_app.DATABASE.workflow_run_credential_selections = repo+ context_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()context_app.DATABASE.workflow_run_credential_selections = reporuntime_credential_id = await context.resolve_credential_parameter_id(login, "org_test")@@ -1209,6 +1219,7 @@ async def _select_render_with_failed_rotation(patch("skyvern.forge.sdk.workflow.service.app") as mock_app,patch("skyvern.forge.sdk.workflow.service.select_credential_for_run", select_mock),):+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()mock_app.DATABASE.organizations.get_organization = AsyncMock(return_value=SimpleNamespace(organization_id="org_test"))@@ -1645,6 +1656,7 @@ async def test_retry_retains_credential_pool_binding_when_new_lane_cannot_be_admcredential_service.get_credential_item = AsyncMock(return_value=SimpleNamespace(credential=credential))with patch("skyvern.forge.sdk.workflow.context_manager.app") as context_app:context_app.DATABASE = sqlite_db+ context_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()context_app.CREDENTIAL_VAULT_SERVICES.get.return_value = credential_servicecontext_app.AGENT_FUNCTION.process_registered_credential_item = AsyncMock(side_effect=lambda *, workflow_run_id, db_credential, credential_item: credential_item@@ -1766,6 +1778,7 @@ async def test_retry_registers_prepared_binding_after_definition_edit(retry_rotacredential_service.get_credential_item = AsyncMock(return_value=SimpleNamespace(credential=credential))with patch("skyvern.forge.sdk.workflow.context_manager.app") as context_app:context_app.DATABASE = database+ context_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()context_app.CREDENTIAL_VAULT_SERVICES.get.return_value = credential_servicecontext_app.AGENT_FUNCTION.process_registered_credential_item = AsyncMock(side_effect=lambda *, workflow_run_id, db_credential, credential_item: credential_item@@ -2043,11 +2056,13 @@ async def test_retry_runtime_registration_with_single_credential_definition(patch("skyvern.forge.sdk.workflow.service.app") as service_app,):context_app.DATABASE = database+ context_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()context_app.CREDENTIAL_VAULT_SERVICES.get.return_value = credential_servicecontext_app.AGENT_FUNCTION.process_registered_credential_item = AsyncMock(side_effect=lambda *, workflow_run_id, db_credential, credential_item: credential_item)service_app.DATABASE = database+ service_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()service_app.WORKFLOW_CONTEXT_MANAGER.workflow_run_contexts = {}context = _runtime_context()context.attempt_number = 2diff --git a/tests/unit/test_credential_update_params.py b/tests/unit/test_credential_update_params.pyindex bf51cf798..2f74609c5 100644--- a/tests/unit/test_credential_update_params.py+++ b/tests/unit/test_credential_update_params.py@@ -1086,8 +1086,8 @@ async def test_validate_browser_profile_id_rejects_other_credential_owned(monkey)monkeypatch.setattr(forge_app.DATABASE.credentials,- "get_credentials_by_browser_profile_id",- AsyncMock(return_value=[SimpleNamespace(credential_id="cred_other")]),+ "get_browser_profile_credential_links",+ AsyncMock(return_value={"bp_x": [("cred_other", None)]}),)with pytest.raises(HTTPException) as exc:await credentials_routes._validate_credential_browser_profile_id("bp_x", "org_123")@@ -1103,8 +1103,8 @@ async def test_validate_browser_profile_id_accepts_plain_unowned(monkeypatch: py)monkeypatch.setattr(forge_app.DATABASE.credentials,- "get_credentials_by_browser_profile_id",- AsyncMock(return_value=[]),+ "get_browser_profile_credential_links",+ AsyncMock(return_value={}),)# No raise.await credentials_routes._validate_credential_browser_profile_id("bp_x", "org_123")@@ -1119,8 +1119,8 @@ async def test_validate_browser_profile_id_allows_relink_to_same_credential(monk)monkeypatch.setattr(forge_app.DATABASE.credentials,- "get_credentials_by_browser_profile_id",- AsyncMock(return_value=[SimpleNamespace(credential_id="cred_self")]),+ "get_browser_profile_credential_links",+ AsyncMock(return_value={"bp_x": [("cred_self", None)]}),)# Re-linking the profile a credential already owns is a no-op, not a conflict.await credentials_routes._validate_credential_browser_profile_id(@@ -1163,8 +1163,8 @@ async def test_create_credential_links_validated_browser_profile_id(monkeypatch:)monkeypatch.setattr(forge_app.DATABASE.credentials,- "get_credentials_by_browser_profile_id",- AsyncMock(return_value=[]),+ "get_browser_profile_credential_links",+ AsyncMock(return_value={}),)update_credential = AsyncMock(return_value=_stored_credential(browser_profile_id="bp_plain", pin=True))monkeypatch.setattr(forge_app.DATABASE.credentials, "update_credential", update_credential)@@ -1261,8 +1261,8 @@ async def test_rename_credential_sets_pin_and_validated_browser_profile_id(monke)monkeypatch.setattr(forge_app.DATABASE.credentials,- "get_credentials_by_browser_profile_id",- AsyncMock(return_value=[]),+ "get_browser_profile_credential_links",+ AsyncMock(return_value={}),)update_credential = AsyncMock(return_value=_stored_credential(browser_profile_id="bp_plain", pin=True))monkeypatch.setattr(forge_app.DATABASE.credentials, "update_credential", update_credential)@@ -1395,8 +1395,8 @@ async def test_update_credential_route_applies_validated_browser_profile_and_pin)monkeypatch.setattr(forge_app.DATABASE.credentials,- "get_credentials_by_browser_profile_id",- AsyncMock(return_value=[]),+ "get_browser_profile_credential_links",+ AsyncMock(return_value={}),)vault_service = SimpleNamespace(update_credential=AsyncMock(return_value=_stored_credential()),@@ -1533,10 +1533,7 @@ async def test_update_credential_conflict_reraises_unrelated_integrity_error(mon@pytest.mark.asyncio-async def test_validate_browser_profile_id_relinks_when_owner_soft_deleted(monkeypatch: pytest.MonkeyPatch) -> None:- # G amendment 1: a soft-deleted owner must NOT reserve the profile. The read-check queries live- # credentials only (get_credentials_by_browser_profile_id filters deleted_at), and the partial-unique- # index predicate matches (deleted_at IS NULL), so relinking is allowed.+async def test_validate_browser_profile_id_rejects_soft_deleted_owner(monkeypatch: pytest.MonkeyPatch) -> None:monkeypatch.setattr(forge_app.DATABASE.browser_sessions,"get_browser_profile",@@ -1544,10 +1541,11 @@ async def test_validate_browser_profile_id_relinks_when_owner_soft_deleted(monke)monkeypatch.setattr(forge_app.DATABASE.credentials,- "get_credentials_by_browser_profile_id",- AsyncMock(return_value=[]), # the soft-deleted owner is filtered out by the repo+ "get_browser_profile_credential_links",+ AsyncMock(return_value={"bp_x": [("cred_deleted", "folder_restricted")]}),)- await credentials_routes._validate_credential_browser_profile_id("bp_x", "org_123")+ with pytest.raises(HTTPException, match="already linked to another credential"):+ await credentials_routes._validate_credential_browser_profile_id("bp_x", "org_123")@pytest.mark.asyncio@@ -1563,8 +1561,8 @@ async def test_create_credential_profile_alone_does_not_reset_pin(monkeypatch: p)monkeypatch.setattr(forge_app.DATABASE.credentials,- "get_credentials_by_browser_profile_id",- AsyncMock(return_value=[]),+ "get_browser_profile_credential_links",+ AsyncMock(return_value={}),)update_credential = AsyncMock(return_value=_stored_credential(browser_profile_id="bp_plain"))monkeypatch.setattr(forge_app.DATABASE.credentials, "update_credential", update_credential)diff --git a/tests/unit/test_credentials_totp_route_logging.py b/tests/unit/test_credentials_totp_route_logging.pyindex 14d334888..1364a1110 100644--- a/tests/unit/test_credentials_totp_route_logging.py+++ b/tests/unit/test_credentials_totp_route_logging.py@@ -7,6 +7,7 @@ import pytestimport structlog.testingfrom fastapi import FastAPI, HTTPException, Response+from skyvern.forge.agent_functions import AgentFunctionfrom skyvern.forge.sdk.routes import credentialsfrom skyvern.forge.sdk.routes.routers import base_router, legacy_base_routerfrom skyvern.forge.sdk.schemas.credentials import Credential, CredentialType, CredentialVaultType, TotpType@@ -15,6 +16,11 @@ from skyvern.forge.sdk.services.credential.custom_credential_vault_service imporfrom skyvern.services.otp_service import OTPValue[email protected](autouse=True)+def _oss_agent_function(monkeypatch: pytest.MonkeyPatch) -> None:+ monkeypatch.setattr(credentials.app, "AGENT_FUNCTION", AgentFunction())++def _raw_row(totp_code_id: str = "otp_raw") -> RawTOTPCode:return RawTOTPCode(totp_code_id=totp_code_id,@@ -193,6 +199,8 @@ async def test_send_totp_code_insufficient_credits_returns_402_when_raw_content_credentials.app,"AGENT_FUNCTION",SimpleNamespace(+ workflow_folders_restricted=AsyncMock(return_value=False),+ credential_folders_restricted=AsyncMock(return_value=False),has_sufficient_credit_for_otp_parse=AsyncMock(return_value=False),charge_for_otp_parse=charge,),@@ -239,6 +247,8 @@ async def test_send_totp_code_insufficient_credits_persists_raw_within_cap(credentials.app,"AGENT_FUNCTION",SimpleNamespace(+ workflow_folders_restricted=AsyncMock(return_value=False),+ credential_folders_restricted=AsyncMock(return_value=False),has_sufficient_credit_for_otp_parse=AsyncMock(return_value=False),charge_for_otp_parse=charge,),diff --git a/tests/unit/test_download_dir_rebind.py b/tests/unit/test_download_dir_rebind.pyindex e6c923db6..0ab423f8f 100644--- a/tests/unit/test_download_dir_rebind.py+++ b/tests/unit/test_download_dir_rebind.py@@ -615,6 +615,7 @@ async def test_browser_manager_adoption_rebinds_to_run_dir(browser_manager: Real):mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=browser_state)mock_app.AGENT_FUNCTION.on_browser_context_acquired = AsyncMock()+ mock_app.AGENT_FUNCTION.enforce_workflow_run_credential_use = AsyncMock()result = await manager.get_or_create_for_workflow_run(_workflow_attach_run(),browser_session_id="bs_block",@@ -645,6 +646,7 @@ async def test_browser_manager_adoption_skips_rebind_when_session_dir_binding():mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=browser_state)mock_app.AGENT_FUNCTION.on_browser_context_acquired = AsyncMock()+ mock_app.AGENT_FUNCTION.enforce_workflow_run_credential_use = AsyncMock()result = await manager.get_or_create_for_workflow_run(_workflow_attach_run(),browser_session_id="bs_block",@@ -674,6 +676,7 @@ async def test_browser_manager_adoption_rebinds_via_context_page_without_owning_):mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=browser_state)mock_app.AGENT_FUNCTION.on_browser_context_acquired = AsyncMock()+ mock_app.AGENT_FUNCTION.enforce_workflow_run_credential_use = AsyncMock()result = await manager.get_or_create_for_workflow_run(_workflow_attach_run(),browser_session_id="bs_block",@@ -700,6 +703,7 @@ async def test_browser_manager_adoption_no_browser_no_page_returns_state(browser):mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=browser_state)mock_app.AGENT_FUNCTION.on_browser_context_acquired = AsyncMock()+ mock_app.AGENT_FUNCTION.enforce_workflow_run_credential_use = AsyncMock()result = await manager.get_or_create_for_workflow_run(_workflow_attach_run(),browser_session_id="bs_block",@@ -892,6 +896,7 @@ async def test_browser_manager_adoption_rebind_error_is_fail_open(browser_manage):mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=browser_state)mock_app.AGENT_FUNCTION.on_browser_context_acquired = AsyncMock()+ mock_app.AGENT_FUNCTION.enforce_workflow_run_credential_use = AsyncMock()result = await manager.get_or_create_for_workflow_run(_workflow_attach_run(),browser_session_id="bs_block",@@ -1543,6 +1548,7 @@ async def test_real_browser_manager_adoption_resolves_context_run_id(browser_manpatch("skyvern.webeye.real_browser_manager.skyvern_context.current", return_value=ctx),):mock_app.AGENT_FUNCTION.on_browser_context_acquired = AsyncMock()+ mock_app.AGENT_FUNCTION.enforce_workflow_run_credential_use = AsyncMock()mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=browser_state)mock_app.DATABASE.browser_sessions.touch_last_activity = AsyncMock()result = await manager.get_or_create_for_workflow_run(workflow_run, browser_session_id="bs")diff --git a/tests/unit/test_external_cdp_sessions.py b/tests/unit/test_external_cdp_sessions.pyindex 034f5fd57..b321e5899 100644--- a/tests/unit/test_external_cdp_sessions.py+++ b/tests/unit/test_external_cdp_sessions.py@@ -982,7 +982,7 @@ async def test_the_next_step_after_losing_a_registration_fails_with_that_fact_an) -> None:session_id = (await register_external(stack.client, timeout=5)).json()["browser_session_id"]if loss == "expired":- await backdate_registration(stack, session_id, minutes=5 - 0.5 / 60)+ await backdate_registration(stack, session_id, minutes=5 - 10 / 60)run_id = "tsk_1" if run_type == "task" else "wr_1"generation = await stack.manager.begin_session(browser_session_id=session_id, runnable_type=run_type, runnable_id=run_id, organization_id=ORG_A@@ -991,7 +991,7 @@ async def test_the_next_step_after_losing_a_registration_fails_with_that_fact_anwith patch.object(manager_mod, "attach_registered_cdp_browser", AsyncMock(return_value=lost)):assert await acquire_lease(stack.manager, session_id, run_id, generation) is lostif loss == "expired":- await asyncio.wait_for(stack.manager._external_deadlines[session_id], timeout=5)+ await asyncio.wait_for(stack.manager._external_deadlines[session_id], timeout=15)if loss in ("closed", "vanished"):await stack.repo.close_persistent_browser_session(session_id, ORG_A)context.browser.is_connected.return_value = False@@ -999,6 +999,7 @@ async def test_the_next_step_after_losing_a_registration_fails_with_that_fact_anbrowser_manager.pages[run_id] = lostlaunch = AsyncMock()rbm_app = MagicMock(PERSISTENT_SESSIONS_MANAGER=stack.manager)+ rbm_app.AGENT_FUNCTION.enforce_workflow_run_credential_use = AsyncMock()unreachable = AsyncMock(side_effect=ExternalBrowserUnavailable("connection failed"))with (@@ -1129,9 +1130,11 @@ async def test_a_later_task_block_on_a_lost_registration_fails_with_its_fact_andbrowser_manager = RealBrowserManager()launch = AsyncMock()+ browser_app = MagicMock(PERSISTENT_SESSIONS_MANAGER=stack.manager)+ browser_app.AGENT_FUNCTION.enforce_workflow_run_credential_use = AsyncMock()with (mock_block_execute_deps(working_page_url="https://example.test/") as deps,- patch.object(real_browser_manager_mod, "app", MagicMock(PERSISTENT_SESSIONS_MANAGER=stack.manager)),+ patch.object(real_browser_manager_mod, "app", browser_app),patch.object(browser_manager, "_create_browser_state", launch),pytest.raises(BrowserSessionClosed if end == "closed" else ExternalBrowserUnavailable),):diff --git a/tests/unit/test_forge_log.py b/tests/unit/test_forge_log.pyindex 348c17011..55c8bcc08 100644--- a/tests/unit/test_forge_log.py+++ b/tests/unit/test_forge_log.py@@ -237,6 +237,7 @@ async def test_browser_runtime_task_pbs_boundary_preserves_owner_log(raise ValueError("acquisition failed")with skyvern_context.scoped(owner), patch.object(real_browser_manager, "app") as app:+ app.AGENT_FUNCTION.enforce_workflow_run_credential_use = AsyncMock()app.PERSISTENT_SESSIONS_MANAGER.begin_session = AsyncMock(return_value="generation-owner")app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(side_effect=acquire)with pytest.raises(ValueError, match="acquisition failed"):diff --git a/tests/unit/test_non_secret_credential_fields.py b/tests/unit/test_non_secret_credential_fields.pyindex 89f2e9bd7..2c0e18921 100644--- a/tests/unit/test_non_secret_credential_fields.py+++ b/tests/unit/test_non_secret_credential_fields.py@@ -54,6 +54,7 @@ async def _register(app.DATABASE.credentials.get_credential = AsyncMock(return_value=db_credential)app.CREDENTIAL_VAULT_SERVICES.get.return_value = vault# Mirror the OSS no-op hook: return the resolved item unchanged.+ app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()app.AGENT_FUNCTION.process_registered_credential_item = AsyncMock(side_effect=lambda *, workflow_run_id, db_credential, credential_item: credential_item)diff --git a/tests/unit/test_otp_service.py b/tests/unit/test_otp_service.pyindex ca4004cb3..e7edab0f4 100644--- a/tests/unit/test_otp_service.py+++ b/tests/unit/test_otp_service.py@@ -1576,6 +1576,7 @@ class TestPollOtpValueRetry:mock_sleep: AsyncMock,) -> None:mock_settings.VERIFICATION_CODE_POLLING_TIMEOUT_MINS = 15+ mock_app.AGENT_FUNCTION.enforce_totp_identifier_credential_use = AsyncMock()mock_app.DATABASE.organizations.get_valid_org_auth_token = AsyncMock(return_value=_mock_org_token())otp = OTPValue(value="123456", type=OTPType.TOTP)mock_url.return_value = otp@@ -1612,6 +1613,7 @@ class TestPollOtpValueRetry:mock_sleep: AsyncMock,) -> None:mock_settings.VERIFICATION_CODE_POLLING_TIMEOUT_MINS = 15+ mock_app.AGENT_FUNCTION.enforce_totp_identifier_credential_use = AsyncMock()mock_app.DATABASE.organizations.get_valid_org_auth_token = AsyncMock(return_value=_mock_org_token())mock_url.return_value = Noneotp = OTPValue(value="123456", type=OTPType.TOTP)@@ -1652,6 +1654,7 @@ class TestPollOtpValueRetry:start = datetime(2026, 1, 1, 12, 0, 0)mock_datetime.utcnow.return_value = startmock_settings.VERIFICATION_CODE_POLLING_TIMEOUT_MINS = 15+ mock_app.AGENT_FUNCTION.enforce_totp_identifier_credential_use = AsyncMock()mock_app.DATABASE.organizations.get_valid_org_auth_token = AsyncMock(return_value=_mock_org_token())mock_url.return_value = Nonemock_email.return_value = None@@ -1725,6 +1728,7 @@ class TestPollOtpValueRetry:):mock_datetime.utcnow.side_effect = utcnow_returnsmock_settings.VERIFICATION_CODE_POLLING_TIMEOUT_MINS = 15+ mock_app.AGENT_FUNCTION.enforce_totp_identifier_credential_use = AsyncMock()mock_app.DATABASE.organizations.get_valid_org_auth_token = AsyncMock(return_value=_mock_org_token())raw_identifier = "[email protected]"raw_url = "https://example.com/mfa?token=secret"@@ -1855,6 +1859,7 @@ class TestPollOtpValueRetry:raw_identifier = "[email protected]"raw_url = "https://example.com/mfa"mock_settings.VERIFICATION_CODE_POLLING_TIMEOUT_MINS = 15+ mock_app.AGENT_FUNCTION.enforce_totp_identifier_credential_use = AsyncMock()mock_app.DATABASE.organizations.get_valid_org_auth_token = AsyncMock(return_value=_mock_org_token())mock_fetch.return_value = OTPValue(value=raw, type=OTPType.TOTP)diff --git a/tests/unit/test_real_browser_manager.py b/tests/unit/test_real_browser_manager.pyindex 440c55a37..f725f837f 100644--- a/tests/unit/test_real_browser_manager.py+++ b/tests/unit/test_real_browser_manager.py@@ -67,6 +67,13 @@ def make_workflow_run(return wfr+@contextmanager+def patch_browser_manager_app() -> Iterator[MagicMock]:+ with patch.object(real_browser_manager, "app") as mock_app:+ mock_app.AGENT_FUNCTION.enforce_workflow_run_credential_use = AsyncMock()+ yield mock_app++def configure_browser_context_acquired_hook(mock_app: MagicMock) -> None:mock_app.AGENT_FUNCTION.on_browser_context_acquired = AsyncMock()mock_app.DATABASE.browser_sessions.touch_last_activity = AsyncMock()@@ -245,7 +252,7 @@ async def test_browser_runtime_event_workflow_task_reuse_has_one_acquisition() -manager = RealBrowserManager()state = RealBrowserState(pw=MagicMock(), browser_context=MagicMock())manager.pages["workflow-owner"] = state- with patch.object(real_browser_manager, "app") as mock_app, capture_logs() as logs:+ with patch_browser_manager_app() as mock_app, capture_logs() as logs:configure_browser_context_acquired_hook(mock_app)await manager.get_or_create_for_task(make_task("task-one", workflow_run_id="workflow-owner"))await manager.get_or_create_for_task(make_task("task-two", workflow_run_id="workflow-owner"))@@ -295,7 +302,7 @@ async def test_cached_acquisition_commits_runtime_owner_after_hook(entrypoint: swith (skyvern_context.scoped(SkyvernContext(workflow_run_id="new-workflow", task_id="new-task")),- patch.object(real_browser_manager, "app") as mock_app,+ patch_browser_manager_app() as mock_app,capture_logs() as logs,):configure_browser_context_acquired_hook(mock_app)@@ -357,7 +364,7 @@ async def test_browser_request_to_ready_seconds_times_creation_and_skips_reuse()patch.object(real_browser_manager.BrowserContextFactory, "create_browser_context", AsyncMock(side_effect=slow_create)),- patch.object(real_browser_manager, "app") as mock_app,+ patch_browser_manager_app() as mock_app,capture_logs() as logs,):configure_browser_context_acquired_hook(mock_app)@@ -396,7 +403,7 @@ async def test_workflow_session_runtime_attribution_requires_acquisition(cached:browser_session_runnable_id="session-runnable" if owner == "ambient" else None,)),- patch.object(real_browser_manager, "app") as mock_app,+ patch_browser_manager_app() as mock_app,patch.object(real_browser_manager, "_rebind_pbs_download_dir", AsyncMock()),patch.object(manager, "_start_frame_publisher", AsyncMock()),patch.object(state, "get_working_page", AsyncMock(return_value=MagicMock())),@@ -532,7 +539,7 @@ async def test_pbs_workflow_run_cache_hit_on_second_call() -> None:manager.pages["wfr_child"] = cached_stateworkflow_run = make_workflow_run("wfr_child")- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ with patch_browser_manager_app() as mock_app:configure_browser_context_acquired_hook(mock_app)result = await manager.get_or_create_for_workflow_run(workflow_run=workflow_run,@@ -557,7 +564,7 @@ async def test_pbs_workflow_run_does_not_inherit_parent_browser() -> None:pbs_state.get_working_page = AsyncMock(return_value=None)pbs_state.get_or_create_page = AsyncMock()- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ with patch_browser_manager_app() as mock_app:configure_browser_context_acquired_hook(mock_app)mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=pbs_state)mock_app.PERSISTENT_SESSIONS_MANAGER.set_browser_state = AsyncMock()@@ -605,7 +612,7 @@ async def test_pbs_workflow_run_with_synthetic_run_does_not_assert_session_ownerskyvern_context.set(SkyvernContext(workflow_run_id="wfr_synthetic", workflow_run_is_synthetic=True))try:with (- patch("skyvern.webeye.real_browser_manager.app") as mock_app,+ patch_browser_manager_app() as mock_app,patch("skyvern.webeye.real_browser_manager._rebind_pbs_download_dir",new_callable=AsyncMock,@@ -642,7 +649,7 @@ async def test_pbs_workflow_run_without_lease_still_asserts_run_as_expected_ownepbs_state.get_working_page = AsyncMock(return_value=None)pbs_state.get_or_create_page = AsyncMock()- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ with patch_browser_manager_app() as mock_app:configure_browser_context_acquired_hook(mock_app)mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=pbs_state)mock_app.PERSISTENT_SESSIONS_MANAGER.set_browser_state = AsyncMock()@@ -1049,7 +1056,7 @@ async def test_task_browser_inherits_session_proxy_and_timezone_when_no_browser_session = make_session(proxy_location=session_proxy)session.browser_settings = BrowserSettings(timezone_id="Africa/Kampala")- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ with patch_browser_manager_app() as mock_app:configure_browser_context_acquired_hook(mock_app)mock_app.AGENT_FUNCTION.merge_proxy_session_extra_http_headers.side_effect = _merge_cloud_proxy_session_headersmock_app.PERSISTENT_SESSIONS_MANAGER.begin_session = AsyncMock()@@ -1081,7 +1088,7 @@ async def test_a_workflow_task_on_an_attached_session_records_the_run_receipt_asnew_browser_state.get_or_create_page = AsyncMock()new_browser_state.get_working_page = AsyncMock(return_value=_page_reporting("America/New_York", "Africa/Kampala"))- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ with patch_browser_manager_app() as mock_app:configure_browser_context_acquired_hook(mock_app)mock_app.PERSISTENT_SESSIONS_MANAGER.begin_session = AsyncMock()mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=None)@@ -1106,7 +1113,7 @@ async def test_task_does_not_cache_a_browser_rejected_by_terminal_session() -> Ncandidate = MagicMock()candidate.get_or_create_page = AsyncMock()- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ with patch_browser_manager_app() as mock_app:configure_browser_context_acquired_hook(mock_app)mock_app.PERSISTENT_SESSIONS_MANAGER.begin_session = AsyncMock()mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=None)@@ -1132,7 +1139,7 @@ async def test_task_browser_inherits_session_proxy_pin_when_no_browser_state() -session = make_session(proxy_location="RESIDENTIAL_ISP", proxy_session_id="abc1234567")- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ with patch_browser_manager_app() as mock_app:configure_browser_context_acquired_hook(mock_app)mock_app.AGENT_FUNCTION.merge_proxy_session_extra_http_headers.side_effect = _merge_cloud_proxy_session_headersmock_app.PERSISTENT_SESSIONS_MANAGER.begin_session = AsyncMock()@@ -1165,7 +1172,7 @@ async def test_task_browser_uses_task_proxy_when_session_has_no_proxy() -> None:session = make_session(proxy_location=None)- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ with patch_browser_manager_app() as mock_app:configure_browser_context_acquired_hook(mock_app)mock_app.PERSISTENT_SESSIONS_MANAGER.begin_session = AsyncMock()mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=None)@@ -1195,7 +1202,7 @@ async def test_workflow_run_browser_inherits_session_proxy_when_no_browser_statesession_proxy = "RESIDENTIAL_FR"session = make_session(proxy_location=session_proxy)- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ with patch_browser_manager_app() as mock_app:configure_browser_context_acquired_hook(mock_app)mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=None)mock_app.PERSISTENT_SESSIONS_MANAGER.get_session = AsyncMock(return_value=session)@@ -1222,7 +1229,7 @@ async def test_workflow_does_not_cache_a_browser_rejected_by_terminal_session()candidate = MagicMock()candidate.get_or_create_page = AsyncMock()- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ with patch_browser_manager_app() as mock_app:configure_browser_context_acquired_hook(mock_app)mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=None)mock_app.PERSISTENT_SESSIONS_MANAGER.get_session = AsyncMock(return_value=None)@@ -1252,7 +1259,7 @@ async def test_workflow_run_browser_inherits_session_proxy_pin_when_no_browser_ssession = make_session(proxy_location="RESIDENTIAL_ISP", proxy_session_id="abc1234567")- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ with patch_browser_manager_app() as mock_app:configure_browser_context_acquired_hook(mock_app)mock_app.AGENT_FUNCTION.merge_proxy_session_extra_http_headers.side_effect = _merge_cloud_proxy_session_headersmock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=None)@@ -1288,7 +1295,7 @@ async def test_workflow_run_browser_uses_workflow_proxy_when_session_has_no_proxsession = make_session(proxy_location=None)- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ with patch_browser_manager_app() as mock_app:configure_browser_context_acquired_hook(mock_app)mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=None)mock_app.PERSISTENT_SESSIONS_MANAGER.get_session = AsyncMock(return_value=session)@@ -1774,7 +1781,7 @@ async def test_script_acquisition_reports_a_live_session_before_the_lease_existsreturn pbs_statewith (- patch("skyvern.webeye.real_browser_manager.app") as mock_app,+ patch_browser_manager_app() as mock_app,skyvern_context.scoped(SkyvernContext(task_id="tsk_script_policy",@@ -1825,7 +1832,7 @@ async def test_attached_run_renews_the_session_activity_lease() -> None:pbs_state.get_or_create_page = AsyncMock()with (- patch("skyvern.webeye.real_browser_manager.app") as mock_app,+ patch_browser_manager_app() as mock_app,patch.object(real_browser_manager, "SESSION_ACTIVITY_RENEWAL_INTERVAL_SECONDS", 0.01),):configure_browser_context_acquired_hook(mock_app)@@ -1888,7 +1895,7 @@ async def test_session_activity_is_stamped_at_attach_not_an_interval_later() ->pbs_state.get_or_create_page = AsyncMock()with (- patch("skyvern.webeye.real_browser_manager.app") as mock_app,+ patch_browser_manager_app() as mock_app,patch.object(real_browser_manager, "SESSION_ACTIVITY_RENEWAL_INTERVAL_SECONDS", 600.0),):configure_browser_context_acquired_hook(mock_app)@@ -1927,7 +1934,7 @@ async def test_session_activity_cadence_is_not_reset_by_new_attaches() -> None:steady_stamps.append(asyncio.get_running_loop().time())with (- patch("skyvern.webeye.real_browser_manager.app") as mock_app,+ patch_browser_manager_app() as mock_app,patch.object(real_browser_manager, "SESSION_ACTIVITY_RENEWAL_INTERVAL_SECONDS", 0.4),):mock_app.DATABASE.browser_sessions.touch_last_activity = AsyncMock(side_effect=touch)@@ -1953,7 +1960,7 @@ def test_session_activity_renewer_recreates_event_for_a_new_loop() -> None:stamps: list[Any] = []async def run_once() -> None:- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ with patch_browser_manager_app() as mock_app:touch = AsyncMock()mock_app.DATABASE.browser_sessions.touch_last_activity = touchawait manager.begin_session_activity_renewal("pbs_loop")@@ -1996,7 +2003,7 @@ async def test_failed_script_acquisition_leaves_no_live_session_behind() -> None# that never started would protect the session from the reaper forever.manager = RealBrowserManager()- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ with patch_browser_manager_app() as mock_app:configure_browser_context_acquired_hook(mock_app)mock_app.PERSISTENT_SESSIONS_MANAGER.begin_session = AsyncMock(return_value="gen_cold")mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=None)@@ -2156,7 +2163,7 @@ async def test_pbs_adoption_rebinds_download_dir_to_run_id() -> None:pbs_state.get_or_create_page = AsyncMock()with (- patch("skyvern.webeye.real_browser_manager.app") as mock_app,+ patch_browser_manager_app() as mock_app,patch("skyvern.webeye.real_browser_manager.rebind_download_dir", new_callable=AsyncMock) as mock_rebind,):configure_browser_context_acquired_hook(mock_app)@@ -2207,7 +2214,7 @@ async def test_public_workflow_adoption_keeps_lease_identity_separate_from_downlpbs_state.get_or_create_page = AsyncMock()with (- patch("skyvern.webeye.real_browser_manager.app") as mock_app,+ patch_browser_manager_app() as mock_app,patch("skyvern.webeye.real_browser_manager.rebind_download_dir", new_callable=AsyncMock) as mock_rebind,skyvern_context.scoped(SkyvernContext(@@ -2258,7 +2265,7 @@ async def test_pbs_task_adoption_rebinds_regardless_of_remote_interceptor(has_repbs_state.get_or_create_page = AsyncMock()with (- patch("skyvern.webeye.real_browser_manager.app") as mock_app,+ patch_browser_manager_app() as mock_app,patch("skyvern.webeye.real_browser_manager._rebind_pbs_download_dir",new_callable=AsyncMock,@@ -2299,7 +2306,7 @@ async def test_workflow_task_inherits_workflow_session_lease_without_beginning_tpbs_state.get_working_page = AsyncMock(return_value=None)pbs_state.get_or_create_page = AsyncMock()- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ with patch_browser_manager_app() as mock_app:configure_browser_context_acquired_hook(mock_app)mock_app.PERSISTENT_SESSIONS_MANAGER.begin_session = AsyncMock()mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=pbs_state)@@ -2335,7 +2342,7 @@ async def test_pbs_adoption_skips_rebind_when_no_browser() -> None:pbs_state.get_or_create_page = AsyncMock()with (- patch("skyvern.webeye.real_browser_manager.app") as mock_app,+ patch_browser_manager_app() as mock_app,patch("skyvern.webeye.real_browser_manager.rebind_download_dir", new_callable=AsyncMock) as mock_rebind,):configure_browser_context_acquired_hook(mock_app)@@ -2387,7 +2394,7 @@ async def test_pbs_adoption_skips_rebind_when_session_dir_binding() -> None:pbs_state.get_or_create_page = AsyncMock()with (- patch("skyvern.webeye.real_browser_manager.app") as mock_app,+ patch_browser_manager_app() as mock_app,patch("skyvern.webeye.real_browser_manager.rebind_download_dir", new_callable=AsyncMock) as mock_rebind,):configure_browser_context_acquired_hook(mock_app)@@ -2417,7 +2424,7 @@ async def test_pbs_adoption_rebinds_when_run_dir_binding() -> None:pbs_state.get_or_create_page = AsyncMock()with (- patch("skyvern.webeye.real_browser_manager.app") as mock_app,+ patch_browser_manager_app() as mock_app,patch("skyvern.webeye.real_browser_manager.rebind_download_dir", new_callable=AsyncMock) as mock_rebind,):configure_browser_context_acquired_hook(mock_app)@@ -2473,7 +2480,7 @@ async def test_pbs_navigate_evicts_and_retries_on_connection_closed_driver_errorfresh = _fresh_pbs_browser_state()workflow_run = make_workflow_run("wfr_pbs")- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ with patch_browser_manager_app() as mock_app:configure_browser_context_acquired_hook(mock_app)mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(side_effect=[stale, fresh])mock_app.PERSISTENT_SESSIONS_MANAGER.evict_cached_browser_state = AsyncMock()@@ -2511,7 +2518,7 @@ async def test_pbs_navigate_does_not_retry_on_unrelated_error() -> None:)workflow_run = make_workflow_run("wfr_pbs")- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ with patch_browser_manager_app() as mock_app:configure_browser_context_acquired_hook(mock_app)mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=stale)mock_app.PERSISTENT_SESSIONS_MANAGER.evict_cached_browser_state = AsyncMock()@@ -2547,7 +2554,7 @@ async def test_pbs_navigate_does_not_evict_on_page_only_close() -> None:)workflow_run = make_workflow_run("wfr_pbs")- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ with patch_browser_manager_app() as mock_app:configure_browser_context_acquired_hook(mock_app)mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=stale)mock_app.PERSISTENT_SESSIONS_MANAGER.evict_cached_browser_state = AsyncMock()@@ -2585,7 +2592,7 @@ async def test_pbs_recovery_path_passes_expected_state_to_public_evict() -> Noneworkflow_run = make_workflow_run("wfr_pbs")with (- patch("skyvern.webeye.real_browser_manager.app") as mock_app,+ patch_browser_manager_app() as mock_app,patch("skyvern.webeye.real_browser_manager.rebind_download_dir", new_callable=AsyncMock),):configure_browser_context_acquired_hook(mock_app)@@ -2626,7 +2633,7 @@ async def test_pbs_recovery_path_rebinds_download_dir_on_fresh_browser() -> Noneworkflow_run = make_workflow_run("wfr_pbs")with (- patch("skyvern.webeye.real_browser_manager.app") as mock_app,+ patch_browser_manager_app() as mock_app,patch("skyvern.webeye.real_browser_manager.rebind_download_dir", new_callable=AsyncMock) as mock_rebind,):configure_browser_context_acquired_hook(mock_app)@@ -2666,7 +2673,7 @@ async def test_pbs_navigate_skips_recovery_when_manager_cannot_reconnect() -> No)workflow_run = make_workflow_run("wfr_pbs")- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ with patch_browser_manager_app() as mock_app:configure_browser_context_acquired_hook(mock_app)mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=stale)mock_app.PERSISTENT_SESSIONS_MANAGER.evict_cached_browser_state = AsyncMock()@@ -2708,7 +2715,7 @@ async def test_pbs_recovery_falls_through_to_get_or_create_page_when_fresh_statefresh.get_working_page = AsyncMock(return_value=None)workflow_run = make_workflow_run("wfr_pbs")- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ with patch_browser_manager_app() as mock_app:configure_browser_context_acquired_hook(mock_app)mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(side_effect=[stale, fresh])mock_app.PERSISTENT_SESSIONS_MANAGER.evict_cached_browser_state = AsyncMock()@@ -3302,7 +3309,7 @@ async def test_pbs_second_occupancy_rejected_leaves_no_local_lease() -> None:manager = RealBrowserManager()task = make_task("tsk_second", workflow_run_id=None)- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ with patch_browser_manager_app() as mock_app:configure_browser_context_acquired_hook(mock_app)mock_app.PERSISTENT_SESSIONS_MANAGER.begin_session = AsyncMock(side_effect=BrowserSessionAlreadyOccupiedError("pbs_busy", "wr_first_owner")@@ -3747,7 +3754,7 @@ async def test_a_run_occupying_a_persistent_session_drops_a_previous_runs_dialogdialog_handler.set_run_dialog_policy(context, "dismiss", None, "wr_dialog_previous")try:- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ with patch_browser_manager_app() as mock_app:configure_browser_context_acquired_hook(mock_app)mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=pbs_state)mock_app.PERSISTENT_SESSIONS_MANAGER.set_browser_state = AsyncMock()@@ -3776,7 +3783,7 @@ async def test_a_child_run_inheriting_its_parents_browser_keeps_the_parents_dialdialog_handler.set_run_dialog_policy(context, "accept", None, "wr_dialog_parent")try:- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ with patch_browser_manager_app() as mock_app:configure_browser_context_acquired_hook(mock_app)with patch.object(manager, "_start_frame_publisher", AsyncMock()):result = await manager.get_or_create_for_workflow_run(@@ -3807,7 +3814,7 @@ async def test_a_nested_run_keeps_every_live_ancestors_dialog_answer() -> None:dialog_handler.set_run_dialog_policy(context, "accept", None, run_id)try:- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ with patch_browser_manager_app() as mock_app:configure_browser_context_acquired_hook(mock_app)mock_app.WORKFLOW_CONTEXT_MANAGER.has_workflow_run_context = lambda run_id: run_id in livewith patch.object(manager, "_start_frame_publisher", AsyncMock()):@@ -4116,7 +4123,7 @@ async def test_run_timezone_receipt_claims_the_workflow_version_only_for_a_browsbound_workflow_permanent_id="wpid_tz" if bound_key else None,bound_key=bound_key,)- with patch.object(real_browser_manager, "app") as mock_app:+ with patch_browser_manager_app() as mock_app:mock_app.PERSISTENT_SESSIONS_MANAGER.get_session = AsyncMock(return_value=session)record = mock_app.DATABASE.workflow_runs.record_workflow_run_browser_settings_receipt = AsyncMock()await real_browser_manager._record_run_timezone_receipt(diff --git a/tests/unit/test_totp_identifier_fallback.py b/tests/unit/test_totp_identifier_fallback.pyindex 456697d73..f6f0d013b 100644--- a/tests/unit/test_totp_identifier_fallback.py+++ b/tests/unit/test_totp_identifier_fallback.py@@ -57,6 +57,7 @@ async def test_register_credential_parameter_uses_db_totp_identifier(monkeypatchDATABASE=FakeDatabase(),CREDENTIAL_VAULT_SERVICES={CredentialVaultType.BITWARDEN: FakeCredentialService()},AGENT_FUNCTION=SimpleNamespace(+ enforce_credential_use=AsyncMock(),parse_enterprise_totp_secret=AsyncMock(return_value=None),process_registered_credential_item=process_item,),@@ -122,6 +123,7 @@ async def _register_with_credential(DATABASE=FakeDatabase(),CREDENTIAL_VAULT_SERVICES={CredentialVaultType.BITWARDEN: FakeCredentialService()},AGENT_FUNCTION=SimpleNamespace(+ enforce_credential_use=AsyncMock(),parse_enterprise_totp_secret=AsyncMock(return_value=None),process_registered_credential_item=process_item,),diff --git a/tests/unit/test_workflow_run_parameter_batching.py b/tests/unit/test_workflow_run_parameter_batching.pyindex 546688acd..9608956e8 100644--- a/tests/unit/test_workflow_run_parameter_batching.py+++ b/tests/unit/test_workflow_run_parameter_batching.py@@ -643,6 +643,7 @@ async def test_setup_workflow_run_still_validates_provided_credential_for_at_wilwith patch("skyvern.forge.sdk.workflow.service.app") as mock_app:mock_app.DATABASE.workflows.get_browser_action_policy = AsyncMock(return_value=None)mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)mock_app.DATABASE.credentials.get_credentials_by_ids = AsyncMock(return_value=[])@@ -672,6 +673,7 @@ async def test_setup_workflow_run_credential_with_default_uses_default() -> Nonewith patch("skyvern.forge.sdk.workflow.service.app") as mock_app:mock_app.DATABASE.workflows.get_browser_action_policy = AsyncMock(return_value=None)mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)mock_app.DATABASE.credentials.get_credentials_by_ids = AsyncMock(return_value=[SimpleNamespace(credential_id="cred_id_0")]@@ -896,7 +898,7 @@ async def test_setup_workflow_run_validates_credentials_before_preparing_managedorganization=organization,)- service._validate_credential_ids.assert_awaited_once_with(["cred_missing"], organization)+ service._validate_credential_ids.assert_awaited_once_with(["cred_missing"], organization, workflow_run_id="wr_test")service._resolve_and_stamp_run_seed.assert_not_awaited()service.create_workflow_run_parameters.assert_not_awaited()service.mark_workflow_run_as_failed.assert_awaited_once()@@ -921,6 +923,7 @@ async def test_setup_workflow_run_batches_credential_validation() -> None:mock_app.DATABASE.workflows.get_browser_action_policy = AsyncMock(return_value=None)mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)mock_app.DATABASE.credentials.get_credentials_by_ids = AsyncMock(return_value=[SimpleNamespace(credential_id=f"cred_id_{i}") for i in range(3)]@@ -982,6 +985,7 @@ async def test_setup_workflow_run_raises_invalid_credential_when_missing() -> Nomock_app.DATABASE.workflows.get_browser_action_policy = AsyncMock(return_value=None)mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)mock_app.DATABASE.credentials.get_credentials_by_ids = AsyncMock(return_value=[])@@ -1015,6 +1019,7 @@ async def test_setup_workflow_run_surfaces_all_missing_credentials() -> None:mock_app.DATABASE.workflows.get_browser_action_policy = AsyncMock(return_value=None)mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)# Only cred_id_0 exists; cred_id_1 and cred_id_2 are missing.mock_app.DATABASE.credentials.get_credentials_by_ids = AsyncMock(@@ -1054,6 +1059,7 @@ async def test_setup_workflow_run_dedupes_repeated_credential_ids() -> None:mock_app.DATABASE.workflows.get_browser_action_policy = AsyncMock(return_value=None)mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)mock_app.DATABASE.credentials.get_credentials_by_ids = AsyncMock(return_value=[SimpleNamespace(credential_id="cred_shared")]