Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
Restrict member temporary cleanup to test-login credentials (#9004)
Aaron Perez0f23931b8784
diff --git a/alembic/versions/2026_10_22_1208-bbc28e00784e_add_a_marker_for_incomplete_passkey_setup.py b/alembic/versions/2026_10_22_1208-bbc28e00784e_add_a_marker_for_incomplete_passkey_setup.pynew file mode 100644index 000000000..394e6e168--- /dev/null+++ b/alembic/versions/2026_10_22_1208-bbc28e00784e_add_a_marker_for_incomplete_passkey_setup.py@@ -0,0 +1,29 @@+"""add a marker for incomplete passkey setup++Revision ID: bbc28e00784e+Revises: dcbaab676398+Create Date: 2026-10-22T12:08:44.264921+00:00++"""++from typing import Sequence, Union++import sqlalchemy as sa++from alembic import op++# revision identifiers, used by Alembic.+revision: str = "bbc28e00784e"+down_revision: Union[str, None] = "dcbaab676398"+branch_labels: Union[str, Sequence[str], None] = None+depends_on: Union[str, Sequence[str], None] = None+++def upgrade() -> None:+ op.execute("SET LOCAL lock_timeout = '5s'")+ op.add_column("credentials", sa.Column("is_passkey_setup_pending", sa.Boolean(), nullable=True))+++def downgrade() -> None:+ op.execute("SET LOCAL lock_timeout = '5s'")+ op.drop_column("credentials", "is_passkey_setup_pending")diff --git a/alembic/versions/2026_10_22_1208-dcbaab676398_add_a_marker_for_temporary_test_login_credentials.py b/alembic/versions/2026_10_22_1208-dcbaab676398_add_a_marker_for_temporary_test_login_credentials.pynew file mode 100644index 000000000..fdec31039--- /dev/null+++ b/alembic/versions/2026_10_22_1208-dcbaab676398_add_a_marker_for_temporary_test_login_credentials.py@@ -0,0 +1,29 @@+"""add a marker for temporary test-login credentials++Revision ID: dcbaab676398+Revises: 5112f44a9e61+Create Date: 2026-10-22T12:08:44.262351+00:00++"""++from typing import Sequence, Union++import sqlalchemy as sa++from alembic import op++# revision identifiers, used by Alembic.+revision: str = "dcbaab676398"+down_revision: Union[str, None] = "5112f44a9e61"+branch_labels: Union[str, Sequence[str], None] = None+depends_on: Union[str, Sequence[str], None] = None+++def upgrade() -> None:+ op.execute("SET LOCAL lock_timeout = '5s'")+ op.add_column("credentials", sa.Column("is_test_login_temporary", sa.Boolean(), nullable=True))+++def downgrade() -> None:+ op.execute("SET LOCAL lock_timeout = '5s'")+ op.drop_column("credentials", "is_test_login_temporary")diff --git a/skyvern-frontend/src/routes/credentials/CredentialsModal.test.tsx b/skyvern-frontend/src/routes/credentials/CredentialsModal.test.tsxindex 8c9ac7df9..a2f569fb0 100644--- a/skyvern-frontend/src/routes/credentials/CredentialsModal.test.tsx+++ b/skyvern-frontend/src/routes/credentials/CredentialsModal.test.tsx@@ -12,6 +12,7 @@ import { AxiosError, AxiosHeaders } from "axios";import { MemoryRouter } from "react-router-dom";import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";+import { getClient } from "@/api/AxiosClient";import type { CredentialApiResponse } from "@/api/types";import { PageSlotsProvider, type PermissionsState } from "@/store/PageSlots";@@ -490,6 +491,8 @@ describe("CredentialsModal additional two-factor methods", () => {expect.objectContaining({ credentialId: "cred-passkey" }),);});+ expect(postMock.mock.calls[0]?.[0]).toBe("/credentials/passkey/setup");+ expect(getClient).toHaveBeenNthCalledWith(1, null, "sans-api-v1");await waitFor(() => {expect(deleteMock.mock.calls.map(([path]) => path)).toEqual(retrydiff --git a/skyvern-frontend/src/routes/credentials/CredentialsModal.tsx b/skyvern-frontend/src/routes/credentials/CredentialsModal.tsxindex 54c59d00c..563a58ca2 100644--- a/skyvern-frontend/src/routes/credentials/CredentialsModal.tsx+++ b/skyvern-frontend/src/routes/credentials/CredentialsModal.tsx@@ -1045,8 +1045,17 @@ function CredentialsModal({const createCredentialMutation = useMutation({mutationFn: async (request: CreateCredentialRequest) => {- const client = await getClient(credentialGetter);- const response = await client.post("/credentials", request);+ const isPasskeySetup =+ "totp_type" in request.credential &&+ request.credential.totp_type === "passkey";+ const client = await getClient(+ credentialGetter,+ isPasskeySetup ? "sans-api-v1" : "v1",+ );+ const response = await client.post(+ isPasskeySetup ? "/credentials/passkey/setup" : "/credentials",+ request,+ );return response.data;},onSuccess: async (data) => {@@ -1531,6 +1540,9 @@ function CredentialsModal({isEditMode &&Boolean(editingCredential?.credential_id) &&selectedAdditionalTwoFactorMethod?.saveBeforeCredentialUpdate === true;+ const createPendingPasskey =+ !isEditMode &&+ selectedAdditionalTwoFactorMethod?.requestType === "passkey";saveIntentRef.current = {shouldTestAfterSave:supportsInlineTest &&@@ -1585,12 +1597,13 @@ function CredentialsModal({username,...(preservesStoredPassword ? {} : { password }),totp: selectedAdditionalTwoFactorMethod || totp === "" ? null : totp,- // Stage "none" for methods that attach after the base update. Methods- // that opt into attach-first keep their server-written type here.- totp_type:- selectedAdditionalTwoFactorMethod &&- selectedAdditionalTwoFactorMethod.value !==- configuredAdditionalTwoFactorMethod?.value+ // Create passkeys through the dedicated setup route; other methods+ // that attach after an edit stage "none" until their material is saved.+ totp_type: createPendingPasskey+ ? selectedAdditionalTwoFactorMethod.requestType+ : selectedAdditionalTwoFactorMethod &&+ selectedAdditionalTwoFactorMethod.value !==+ configuredAdditionalTwoFactorMethod?.value? saveAdditionalTwoFactorBeforeUpdate? selectedAdditionalTwoFactorMethod.requestType: "none"diff --git a/skyvern/forge/sdk/db/models.py b/skyvern/forge/sdk/db/models.pyindex 5a179065c..71404d0c5 100644--- a/skyvern/forge/sdk/db/models.py+++ b/skyvern/forge/sdk/db/models.py@@ -2010,6 +2010,8 @@ class CredentialModel(Base):proxy_session_id = Column(String, nullable=True)folder_id = Column(String, ForeignKey("credential_folders.folder_id", ondelete="SET NULL"), nullable=True)created_by = Column(String, nullable=True)+ is_test_login_temporary = Column(Boolean, nullable=True)+ is_passkey_setup_pending = Column(Boolean, nullable=True)created_at = Column(DateTime, default=datetime.datetime.utcnow, nullable=False)modified_at = Column(DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow, nullable=False)diff --git a/skyvern/forge/sdk/db/repositories/credentials.py b/skyvern/forge/sdk/db/repositories/credentials.pyindex bac449cd0..78b4ffa8a 100644--- a/skyvern/forge/sdk/db/repositories/credentials.py+++ b/skyvern/forge/sdk/db/repositories/credentials.py@@ -20,6 +20,7 @@ from skyvern.forge.sdk.schemas.credentials import (Credential,CredentialType,CredentialVaultType,+ TotpType,)from skyvern.forge.sdk.schemas.organization_bitwarden_collections import OrganizationBitwardenCollectionfrom skyvern.schemas.proxy_pinning import generate_proxy_session_id, should_generate_proxy_session_id@@ -82,6 +83,7 @@ class CredentialRepository(BaseRepository):proxy_session_id: str | None = None,created_by: str | None = None,vault_id: str | None = None,+ is_passkey_setup_pending: bool | None = None,) -> Credential:proxy_location, proxy_session_id = normalize_proxy_pin_for_create(proxy_location=proxy_location,@@ -107,6 +109,7 @@ class CredentialRepository(BaseRepository):proxy_location=serialized_proxy_location,proxy_session_id=proxy_session_id,created_by=created_by,+ is_passkey_setup_pending=is_passkey_setup_pending,)session.add(credential)await session.flush()@@ -561,6 +564,8 @@ class CredentialRepository(BaseRepository):proxy_location: ProxyLocationInput | object = _UNSET,proxy_session_id: str | None | object = _UNSET,rotate_proxy_session_id: bool = False,+ is_test_login_temporary: bool | None = None,+ is_passkey_setup_pending: bool | None = None,) -> Credential:async with self.Session() as session:credential = (@@ -591,6 +596,10 @@ class CredentialRepository(BaseRepository):credential.auto_profile_disabled = auto_profile_disabledif run_sequentially is not None:credential.run_sequentially = run_sequentially+ if is_test_login_temporary is not None:+ credential.is_test_login_temporary = is_test_login_temporary+ if is_passkey_setup_pending is not None:+ credential.is_passkey_setup_pending = is_passkey_setup_pendingapply_proxy_pin_to_model(credential,entity_id=credential_id,@@ -683,6 +692,12 @@ class CredentialRepository(BaseRepository):credential.credential_type = credential_typecredential.username = usernamecredential.totp_type = totp_type+ if credential.is_test_login_temporary is True:+ credential.is_test_login_temporary = False+ if credential.is_passkey_setup_pending is True and (+ credential_type != CredentialType.PASSWORD or totp_type != TotpType.PASSKEY+ ):+ credential.is_passkey_setup_pending = Falsecredential.totp_identifier = totp_identifierif has_totp_seed is not None:credential.has_totp_seed = has_totp_seeddiff --git a/skyvern/forge/sdk/routes/credentials.py b/skyvern/forge/sdk/routes/credentials.pyindex 04f4b3810..d0181a4d7 100644--- a/skyvern/forge/sdk/routes/credentials.py+++ b/skyvern/forge/sdk/routes/credentials.py@@ -45,7 +45,6 @@ from fastapi import BackgroundTasks, Body, Depends, Header, HTTPException, Path,from onepassword.client import Client as OnePasswordClientfrom onepassword.errors import DesktopSessionExpiredException, RateLimitExceededExceptionfrom onepassword.types import Item-from sqlalchemy.exc import IntegrityErrorfrom sqlalchemy.ext.asyncio import AsyncSessionfrom skyvern.config import settings@@ -96,7 +95,6 @@ from skyvern.forge.sdk.schemas.credentials import (CredentialTotpCodeResponse,CredentialType,CredentialVaultType,- CreditCardCredentialResponse,ImportOnePasswordCredentialsRequest,ImportOnePasswordCredentialsResponse,NonEmptyPasswordCredential,@@ -105,10 +103,8 @@ from skyvern.forge.sdk.schemas.credentials import (OnePasswordItemOverview,OnePasswordItemsResponse,PasswordCredential,- PasswordCredentialResponse,RefreshOnePasswordCredentialsRequest,RefreshOnePasswordCredentialsResponse,- SecretCredentialResponse,TestCredentialRequest,TestCredentialResponse,TestCredentialStatusResponse,@@ -144,9 +140,24 @@ from skyvern.forge.sdk.schemas.organizations import (from skyvern.forge.sdk.schemas.totp_codes import OTPType, RawTOTPCodeAccepted, TOTPCode, TOTPCodeCreatefrom skyvern.forge.sdk.services import org_auth_servicefrom skyvern.forge.sdk.services.bitwarden import BitwardenService+from skyvern.forge.sdk.services.credential import credential_creation_service+from skyvern.forge.sdk.services.credential.credential_creation_service import (+ convert_to_response as _convert_to_response,+)+from skyvern.forge.sdk.services.credential.credential_creation_service import (+ fetch_credential_item_background,+)+from skyvern.forge.sdk.services.credential.credential_creation_service import (+ get_credential_vault_service as _get_credential_vault_service,+)+from skyvern.forge.sdk.services.credential.credential_creation_service import (+ update_credential_or_profile_conflict as _update_credential_or_profile_conflict,+)+from skyvern.forge.sdk.services.credential.credential_creation_service import (+ validate_credential_browser_profile_id as _validate_credential_browser_profile_id,+)from skyvern.forge.sdk.services.credential.credential_vault_service import CredentialVaultServicefrom skyvern.forge.sdk.services.credential.custom_credential_vault_service import (- CustomCredentialConfigurationError,CustomCredentialNotConfiguredError,)from skyvern.forge.sdk.services.credentials import (@@ -160,7 +171,6 @@ from skyvern.forge.sdk.services.credentials import (from skyvern.forge.sdk.services.onepassword_token_service import resolve_onepassword_token, to_statusfrom skyvern.forge.sdk.services.request_principal import RequestPrincipal, get_request_principal, synthetic_user_idfrom skyvern.forge.sdk.services.route_authorization import require_request_actions-from skyvern.forge.sdk.settings_manager import SettingsManagerfrom skyvern.forge.sdk.workflow.browser_session_persistence import retrieve_persisted_workflow_browser_state_dirfrom skyvern.forge.sdk.workflow.models.parameter import WorkflowParameterTypefrom skyvern.forge.sdk.workflow.models.workflow import WorkflowRequestBody, WorkflowRunStatus@@ -487,19 +497,6 @@ def _cache_totp_code_preview()-async def fetch_credential_item_background(item_id: str) -> None:- """- Background task to fetch the recently added credential item from Bitwarden.- This triggers Bitwarden to sync the vault earlier so the next request does not have to wait for the sync.- """- try:- LOG.info("Pre-fetching credential item from Bitwarden in background", item_id=item_id)- credential_item = await BitwardenService.get_credential_item(item_id)- LOG.info("Successfully fetched credential item from Bitwarden", item_id=item_id, name=credential_item.name)- except Exception as e:- LOG.exception("Failed to fetch credential item from Bitwarden in background", item_id=item_id, error=str(e))--@legacy_base_router.post("/totp",responses={402: {"description": "Insufficient credits to parse OTP content"}},@@ -782,51 +779,6 @@ async def get_totp_codes(return codes[:limit]-async def _validate_credential_browser_profile_id(- browser_profile_id: str,- organization_id: str,- current_credential_id: str | None = None,-) -> None:- """A credential may only link a PLAIN, unowned profile from its own org: not a workflow-managed- profile and not one another credential already owns (living credential profiles are auto-created,- never hand-linked). Raises HTTP 400 otherwise."""- profile = await app.DATABASE.browser_sessions.get_browser_profile(- profile_id=browser_profile_id, organization_id=organization_id- )- if profile is None:- raise HTTPException(- status_code=400, detail=f"Browser profile not found, browser_profile_id={browser_profile_id}"- )- if profile.is_managed or profile.workflow_permanent_id is not None:- raise HTTPException(- status_code=400,- detail="A credential can only link a plain browser profile, not a workflow-managed one.",- )- links_by_profile = await app.DATABASE.credentials.get_browser_profile_credential_links(- {browser_profile_id}, organization_id- )- 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.",- )---async def _update_credential_or_profile_conflict(**kwargs: Any) -> Credential:- """Apply a credential update, translating the one-credential-per-profile unique-constraint violation- — the atomic backstop when a concurrent link slips past the read-before-write ownership check — into- the same 400 the read-check raises."""- try:- return await app.DATABASE.credentials.update_credential(**kwargs)- except IntegrityError as exc:- if "uq_credentials_browser_profile_id" in str(getattr(exc, "orig", exc)):- raise HTTPException(status_code=400, detail="This browser profile is already linked to another credential.")- raise--@legacy_base_router.post("/credentials")@legacy_base_router.post("/credentials/", include_in_schema=False)@base_router.post(@@ -877,90 +829,16 @@ async def create_credential(current_org: Organization = Depends(org_auth_service.get_current_org_for_credential_routes),current_user_id: str | None = Depends(org_auth_service.get_current_user_id_or_none),) -> CredentialResponse:- credential_service = await prepare_credential_create(current_org.organization_id, data)- credential = await store_new_credential(- current_org.organization_id, data, current_user_id, credential_service, background_tasks- )- return _convert_to_response(credential)---async def prepare_credential_create(organization_id: str, data: CreateCredentialRequest) -> CredentialVaultService:- """Every check a create runs before it touches a vault; raising here means nothing was stored."""if isinstance(data.credential, NonEmptyPasswordCredential):await _normalize_authenticator_totp_for_organization_or_raise(data.credential,- organization_id=organization_id,- )-- await app.AGENT_FUNCTION.validate_credential_write(- organization_id=organization_id,- credential_type=data.credential_type,- credential=data.credential,- existing_credential=None,- )-- # Validate the profile link BEFORE provisioning, so an invalid/managed/cross-org/owned profile- # rejects with a 400 without leaving an orphan credential (and vault secret) behind.- if data.browser_profile_id is not None:- await _validate_credential_browser_profile_id(data.browser_profile_id, organization_id)-- return await _get_credential_vault_service(- vault_type_override=data.vault_type,- organization_id=organization_id,- )---async def store_new_credential(- organization_id: str,- data: CreateCredentialRequest,- created_by: str | None,- credential_service: CredentialVaultService,- background_tasks: BackgroundTasks,-) -> Credential:- try:- credential = await credential_service.create_credential(- organization_id=organization_id,- data=data,- created_by=created_by,- )- except SkyvernHttpException as e:- detail = (- f"Custom credential service returned {e.error_message}"- if e.error_message- else f"Custom credential service returned HTTP {e.status_code}"- )- raise HTTPException(status_code=502, detail=detail) from e-- await record_request_audit_event(organization_id, "credential.create", "credential", credential.credential_id)- if credential.vault_type == CredentialVaultType.BITWARDEN:- # Early resyncing the Bitwarden vault- background_tasks.add_task(fetch_credential_item_background, credential.item_id)-- pin_provided = "pin_saved_session_ip" in data.model_fields_set- bpid_provided = "browser_profile_id" in data.model_fields_set- auto_profile_disabled_provided = "auto_profile_disabled" in data.model_fields_set- if bpid_provided or pin_provided or auto_profile_disabled_provided:- # Only pass browser_profile_id when the caller sent it, so a pin-only request never passes the- # omitted default (None) into the repo's unlink sentinel.- profile_update: dict[str, Any] = {"browser_profile_id": data.browser_profile_id} if bpid_provided else {}- credential = await _update_credential_or_profile_conflict(- credential_id=credential.credential_id,- organization_id=organization_id,- **profile_update,- # Only touch the pin when the caller sent it — supplying a profile alone must not reset it.- pin_saved_session_ip=data.pin_saved_session_ip if pin_provided else None,- auto_profile_disabled=data.auto_profile_disabled if auto_profile_disabled_provided else None,+ organization_id=current_org.organization_id,)-- background_tasks.add_task(- app.AGENT_FUNCTION.on_credential_saved,- organization_id=organization_id,- credential_id=credential.credential_id,- credential_type=data.credential_type,- actor_user_id=created_by,- vault=credential.vault_type.value if credential.vault_type is not None else None,+ credential_service = await credential_creation_service.prepare_credential_create(current_org.organization_id, data)+ credential = await credential_creation_service.store_new_credential(+ current_org.organization_id, data, current_user_id, credential_service, background_tasks)- return credential+ return _convert_to_response(credential)LOGIN_TEST_PROMPT = (@@ -1088,8 +966,11 @@ async def rename_credential("credential_id": credential_id,"organization_id": current_org.organization_id,}- if "name" in data.model_fields_set:+ if data.name is not None:update_kwargs["name"] = data.name+ if credential.is_test_login_temporary is True:+ # The modal saves an inline test-login credential by renaming it.+ update_kwargs["is_test_login_temporary"] = Falseif "browser_profile_id" in data.model_fields_set:# Explicit null unlinks (user picked Auto after attaching a profile); a non-null value still# validates plain/unowned before linking. Omitted leaves the existing link untouched.@@ -1207,11 +1088,12 @@ async def test_login(background_tasks.add_task(fetch_credential_item_background, credential.item_id)credential_id = credential.credential_id+ update_kwargs: dict[str, Any] = {+ "credential_id": credential_id,+ "organization_id": organization_id,+ "is_test_login_temporary": True,+ }if "proxy_location" in data.model_fields_set or "proxy_session_id" in data.model_fields_set:- update_kwargs: dict[str, Any] = {- "credential_id": credential_id,- "organization_id": organization_id,- }_apply_proxy_pin_update(update_kwargs,proxy_location_was_set="proxy_location" in data.model_fields_set,@@ -1219,7 +1101,6 @@ async def test_login(proxy_session_id_was_set="proxy_session_id" in data.model_fields_set,proxy_session_id=data.proxy_session_id,)- credential = await app.DATABASE.credentials.update_credential(**update_kwargs)LOG.info("Testing login with inline credentials",@@ -1268,6 +1149,8 @@ async def test_login()try:+ # Mark before workflow setup so any member cleanup can only target this test-login row.+ credential = await app.DATABASE.credentials.update_credential(**update_kwargs)workflow = await app.WORKFLOW_SERVICE.create_workflow_from_request(organization=current_org,request=workflow_create_request,@@ -2337,8 +2220,8 @@ TEMP_CREDENTIAL_CLEANUP_WINDOW = timedelta(hours=24)@legacy_base_router.delete("/credentials/{credential_id}/temporary",status_code=204,- summary="Delete a recently created credential",- description="Deletes only a credential created by the current user in the last 24 hours.",+ summary="Delete a temporary credential",+ description="Deletes a temporary test-login or incomplete passkey credential created by the current user in the last 24 hours.",tags=["Credentials"],include_in_schema=False,)@@ -2371,7 +2254,9 @@ async def delete_temporary_credential()-def _is_recent_credential_created_by(credential: Credential, user_id: str) -> bool:+def _is_recent_temporary_credential_created_by(credential: Credential, user_id: str) -> bool:+ if credential.is_test_login_temporary is not True and credential.is_passkey_setup_pending is not True:+ return Falsecreated_at = to_naive_utc(credential.created_at)if credential.created_by != user_id or created_at is None:return False@@ -2392,10 +2277,12 @@ async def delete_organization_credential()if not credential:raise HTTPException(status_code=404, detail=f"Credential not found, credential_id={credential_id}")- if expected_created_by is not None and not _is_recent_credential_created_by(credential, expected_created_by):+ if expected_created_by is not None and not _is_recent_temporary_credential_created_by(+ credential, expected_created_by+ ):raise HTTPException(status_code=404, detail=f"Credential not found, credential_id={credential_id}")- requires_write_lock = await app.AGENT_FUNCTION.should_lock_credential_write(+ requires_write_lock = expected_created_by is not None or await app.AGENT_FUNCTION.should_lock_credential_write(credential=None,existing_credential=credential,)@@ -2412,7 +2299,7 @@ async def delete_organization_credential()if not latest_credential:raise HTTPException(status_code=404, detail=f"Credential not found, credential_id={credential_id}")- if expected_created_by is not None and not _is_recent_credential_created_by(+ if expected_created_by is not None and not _is_recent_temporary_credential_created_by(latest_credential, expected_created_by):raise HTTPException(status_code=404, detail=f"Credential not found, credential_id={credential_id}")@@ -2449,69 +2336,69 @@ async def delete_organization_credential(vault_type=vault_type,)- # Reap the credential's living browser profile so deleting a credential doesn't silently orphan- # its cookie-bearing archive (unbounded S3 growth). Kept if a live owner still references it. The- # reap hard-deletes the profile's S3 archive (irreversible, version-purging), so it rides the engine- # kill-switch: flag-off orgs never lose a saved profile on credential delete (v1 has no unlink to- # recover with), and a rollback disables it.- profile_id = credential.browser_profile_id- if profile_id and await app.AGENT_FUNCTION.is_browser_memory_engine_enabled_for_org(organization_id):- try:- # Narrow accepted race: a concurrent re-link between this check and the delete below.- if await app.DATABASE.browser_sessions.has_live_browser_profile_references(- profile_id=profile_id,- organization_id=organization_id,- exclude_credential_id=credential_id,- ):- LOG.info(- "browser_memory.credential_profile_kept",- organization_id=organization_id,- credential_id=credential_id,- browser_profile_id=profile_id,- )- else:- # Erase the S3 archive first (idempotent, version-purging) so cookies are gone even if- # the DB row was already soft-deleted; then soft-delete the row for bookkeeping.- await app.STORAGE.delete_browser_profile(- organization_id=organization_id,+ # Reap the credential's living browser profile so deleting a credential doesn't silently orphan+ # its cookie-bearing archive (unbounded S3 growth). Kept if a live owner still references it. The+ # reap hard-deletes the profile's S3 archive (irreversible, version-purging), so it rides the engine+ # kill-switch: flag-off orgs never lose a saved profile on credential delete (v1 has no unlink to+ # recover with), and a rollback disables it.+ profile_id = credential.browser_profile_id+ if profile_id and await app.AGENT_FUNCTION.is_browser_memory_engine_enabled_for_org(organization_id):+ try:+ # Narrow accepted race: a concurrent re-link between this check and the delete below.+ if await app.DATABASE.browser_sessions.has_live_browser_profile_references(profile_id=profile_id,- hard_delete=True,- )- try:- await app.DATABASE.browser_sessions.delete_browser_profile(- profile_id=profile_id,+ organization_id=organization_id,+ exclude_credential_id=credential_id,+ ):+ LOG.info(+ "browser_memory.credential_profile_kept",+ organization_id=organization_id,+ credential_id=credential_id,+ browser_profile_id=profile_id,+ )+ else:+ # Erase the S3 archive first (idempotent, version-purging) so cookies are gone even if+ # the DB row was already soft-deleted; then soft-delete the row for bookkeeping.+ await app.STORAGE.delete_browser_profile(organization_id=organization_id,+ profile_id=profile_id,+ hard_delete=True,)- except BrowserProfileNotFound:- pass- except Exception:- # Erasure already succeeded; only the row soft-delete failed, leaving the row- # alive with its blob gone. Log distinctly (not reap_failed) — the stale-memory- # sweep reaps such rows.- LOG.exception(- "browser_memory.credential_profile_row_delete_failed",+ try:+ await app.DATABASE.browser_sessions.delete_browser_profile(+ profile_id=profile_id,+ organization_id=organization_id,+ )+ except BrowserProfileNotFound:+ pass+ except Exception:+ # Erasure already succeeded; only the row soft-delete failed, leaving the row+ # alive with its blob gone. Log distinctly (not reap_failed) — the stale-memory+ # sweep reaps such rows.+ LOG.exception(+ "browser_memory.credential_profile_row_delete_failed",+ organization_id=organization_id,+ credential_id=credential_id,+ browser_profile_id=profile_id,+ )+ LOG.info(+ "browser_memory.credential_profile_reaped",organization_id=organization_id,credential_id=credential_id,browser_profile_id=profile_id,)- LOG.info(- "browser_memory.credential_profile_reaped",+ except Exception as exc:+ # The reap did not complete (typically the S3 hard-delete raised): the cookie-bearing archive+ # is RETAINED and the row is left alive (the soft-delete runs only after a successful erase),+ # so it stays discoverable for the stale-memory sweep. Never fail the user-facing delete for+ # this (204 stands) — but log LOUD + alertable so the retained archive is not silently orphaned.+ LOG.exception(+ "browser_memory.credential_profile_reap_failed",organization_id=organization_id,credential_id=credential_id,browser_profile_id=profile_id,+ error=str(exc),)- except Exception as exc:- # The reap did not complete (typically the S3 hard-delete raised): the cookie-bearing archive- # is RETAINED and the row is left alive (the soft-delete runs only after a successful erase),- # so it stays discoverable for the stale-memory sweep. Never fail the user-facing delete for- # this (204 stands) — but log LOUD + alertable so the retained archive is not silently orphaned.- LOG.exception(- "browser_memory.credential_profile_reap_failed",- organization_id=organization_id,- credential_id=credential_id,- browser_profile_id=profile_id,- error=str(exc),- )_clear_cached_totp_code_preview(organization_id=organization_id, credential_id=credential_id)await record_request_audit_event(@@ -4448,53 +4335,6 @@ async def test_custom_credential_service_connection() from e-async def _get_credential_vault_service(- vault_type_override: CredentialVaultType | None = None,- organization_id: str | None = None,-) -> CredentialVaultService:- """Resolve the vault service for a request.-- Callers about to write a secret pass ``organization_id`` so a vault configured per organization- is preflighted here and an unusable configuration is refused before the write is attempted.- """- settings = SettingsManager.get_settings()- vault_type = vault_type_override or settings.CREDENTIAL_VAULT_TYPE- service: CredentialVaultService- if vault_type == CredentialVaultType.SKYVERN:- if not settings.is_local_credential_vault_enabled():- raise HTTPException(status_code=400, detail="Skyvern local credential vault is not enabled")- if not app.SKYVERN_CREDENTIAL_VAULT_SERVICE:- raise HTTPException(status_code=400, detail="Skyvern local credential vault is not configured")- service = app.SKYVERN_CREDENTIAL_VAULT_SERVICE- elif vault_type == CredentialVaultType.BITWARDEN:- service = app.BITWARDEN_CREDENTIAL_VAULT_SERVICE- elif vault_type == CredentialVaultType.AZURE_VAULT:- if not app.AZURE_CREDENTIAL_VAULT_SERVICE:- raise HTTPException(status_code=400, detail="Azure Vault credential is not supported")- service = app.AZURE_CREDENTIAL_VAULT_SERVICE- elif vault_type == CredentialVaultType.GCP:- if not app.GCP_CREDENTIAL_VAULT_SERVICE:- raise HTTPException(status_code=400, detail="GCP credential vault is not supported")- service = app.GCP_CREDENTIAL_VAULT_SERVICE- elif vault_type == CredentialVaultType.CUSTOM:- if not app.CUSTOM_CREDENTIAL_VAULT_SERVICE:- raise HTTPException(status_code=400, detail="Custom credential vault is not supported")- service = app.CUSTOM_CREDENTIAL_VAULT_SERVICE- elif vault_type == CredentialVaultType.ONEPASSWORD:- service = app.ONEPASSWORD_CREDENTIAL_VAULT_SERVICE- else:- raise HTTPException(status_code=400, detail="Credential storage not supported")-- if organization_id is not None:- try:- await service.validate_organization_configuration(organization_id)- except CustomCredentialConfigurationError as e:- # Already reported by the vault service; re-logging here would double-count.- raise HTTPException(status_code=400, detail=str(e)) from e-- return service--async def _delete_temporary_test_login_credential(*,credential_id: str,@@ -4517,94 +4357,3 @@ async def _delete_temporary_test_login_credential(organization_id=organization_id,reason=reason,)---def _convert_to_response(credential: Credential) -> CredentialResponse:- """Convert an internal ``Credential`` to a safe API response.-- SECURITY: This function must ONLY copy non-sensitive metadata into the- response. Never include passwords, TOTP secrets, full card numbers, CVVs,- expiration dates, card holder names, credit card billing/contact fields,- credit card metadata, or secret values. See the module- docstring for the full security invariant.- """- is_onepassword = credential.vault_type == CredentialVaultType.ONEPASSWORD- if credential.credential_type == CredentialType.PASSWORD:- credential_response = PasswordCredentialResponse(- username=credential.username or credential.credential_id,- totp_type=credential.totp_type,- totp_identifier=credential.totp_identifier,- has_totp=bool(credential.has_totp_seed),- )- return CredentialResponse(- credential=credential_response,- credential_id=credential.credential_id,- credential_type=credential.credential_type,- name=credential.name,- vault_type=credential.vault_type,- vault_id=credential.vault_id if is_onepassword else None,- item_id=credential.item_id if is_onepassword else None,- upstream_missing_at=credential.upstream_missing_at if is_onepassword else None,- browser_profile_id=credential.browser_profile_id,- auto_profile_disabled=credential.auto_profile_disabled,- pin_saved_session_ip=credential.pin_saved_session_ip,- tested_url=credential.tested_url,- user_context=credential.user_context,- save_browser_session_intent=credential.save_browser_session_intent,- run_sequentially=credential.run_sequentially,- folder_id=credential.folder_id,- proxy_location=credential.proxy_location,- proxy_session_id=credential.proxy_session_id,- created_by=credential.created_by,- )- elif credential.credential_type == CredentialType.CREDIT_CARD:- credential_response = CreditCardCredentialResponse(- last_four=credential.card_last4 or "****",- brand=credential.card_brand or "Card Brand",- )- return CredentialResponse(- credential=credential_response,- credential_id=credential.credential_id,- credential_type=credential.credential_type,- name=credential.name,- vault_type=credential.vault_type,- vault_id=credential.vault_id if is_onepassword else None,- item_id=credential.item_id if is_onepassword else None,- upstream_missing_at=credential.upstream_missing_at if is_onepassword else None,- browser_profile_id=credential.browser_profile_id,- auto_profile_disabled=credential.auto_profile_disabled,- pin_saved_session_ip=credential.pin_saved_session_ip,- tested_url=credential.tested_url,- user_context=credential.user_context,- save_browser_session_intent=credential.save_browser_session_intent,- run_sequentially=credential.run_sequentially,- folder_id=credential.folder_id,- proxy_location=credential.proxy_location,- proxy_session_id=credential.proxy_session_id,- created_by=credential.created_by,- )- elif credential.credential_type == CredentialType.SECRET:- credential_response = SecretCredentialResponse(secret_label=credential.secret_label)- return CredentialResponse(- credential=credential_response,- credential_id=credential.credential_id,- credential_type=credential.credential_type,- name=credential.name,- vault_type=credential.vault_type,- vault_id=credential.vault_id if is_onepassword else None,- item_id=credential.item_id if is_onepassword else None,- upstream_missing_at=credential.upstream_missing_at if is_onepassword else None,- browser_profile_id=credential.browser_profile_id,- auto_profile_disabled=credential.auto_profile_disabled,- pin_saved_session_ip=credential.pin_saved_session_ip,- tested_url=credential.tested_url,- user_context=credential.user_context,- save_browser_session_intent=credential.save_browser_session_intent,- run_sequentially=credential.run_sequentially,- folder_id=credential.folder_id,- proxy_location=credential.proxy_location,- proxy_session_id=credential.proxy_session_id,- created_by=credential.created_by,- )- else:- raise HTTPException(status_code=400, detail="Credential type not supported")diff --git a/skyvern/forge/sdk/routes/workflow_copilot.py b/skyvern/forge/sdk/routes/workflow_copilot.pyindex 07357b7fc..75c0414dc 100644--- a/skyvern/forge/sdk/routes/workflow_copilot.py+++ b/skyvern/forge/sdk/routes/workflow_copilot.py@@ -169,11 +169,7 @@ from skyvern.forge.sdk.routes.browser_profiles import (_hard_delete_created_profile_after_store_failure,create_profile_from_running_session,)-from skyvern.forge.sdk.routes.credentials import (- delete_organization_credential,- prepare_credential_create,- store_new_credential,-)+from skyvern.forge.sdk.routes.credentials import delete_organization_credentialfrom skyvern.forge.sdk.routes.routers import base_routerfrom skyvern.forge.sdk.schemas.copilot_turn_outcome import PersistedCopilotComposerMode, ResponseKind, TurnOutcomefrom skyvern.forge.sdk.schemas.credentials import (@@ -236,6 +232,10 @@ from skyvern.forge.sdk.schemas.workflow_copilot import (copilot_proposal_metadata,)from skyvern.forge.sdk.services import org_auth_service+from skyvern.forge.sdk.services.credential.credential_creation_service import (+ prepare_credential_create,+ store_new_credential,+)from skyvern.forge.sdk.services.credential.credential_vault_service import CredentialVaultServicefrom skyvern.forge.sdk.services.request_principal import get_request_principalfrom skyvern.forge.sdk.services.route_authorization import require_request_actionsdiff --git a/skyvern/forge/sdk/schemas/credentials.py b/skyvern/forge/sdk/schemas/credentials.pyindex a1fb7af5e..7d28a12b1 100644--- a/skyvern/forge/sdk/schemas/credentials.py+++ b/skyvern/forge/sdk/schemas/credentials.py@@ -497,6 +497,8 @@ class Credential(BaseModel):default=None,description="ID of the credential folder this credential belongs to, if any",)+ is_test_login_temporary: bool | None = Field(default=None, exclude=True)+ is_passkey_setup_pending: bool | None = Field(default=None, exclude=True)proxy_location: ProxyLocationInput = Field(default=None,description="Optional proxy location used for the credential's pinned proxy identity.",diff --git a/skyvern/forge/sdk/services/credential/azure_credential_vault_service.py b/skyvern/forge/sdk/services/credential/azure_credential_vault_service.pyindex 08af0a709..6ad01bb9d 100644--- a/skyvern/forge/sdk/services/credential/azure_credential_vault_service.py+++ b/skyvern/forge/sdk/services/credential/azure_credential_vault_service.py@@ -63,6 +63,7 @@ class AzureCredentialVaultService(CredentialVaultService):organization_id: str,data: CreateCredentialRequest,created_by: str | None = None,+ is_passkey_setup_pending: bool = False,) -> Credential:item_id = await self._create_azure_secret_item(organization_id=organization_id,@@ -75,6 +76,7 @@ class AzureCredentialVaultService(CredentialVaultService):item_id=item_id,vault_type=CredentialVaultType.AZURE_VAULT,created_by=created_by,+ is_passkey_setup_pending=is_passkey_setup_pending,)return credentialdiff --git a/skyvern/forge/sdk/services/credential/bitwarden_credential_service.py b/skyvern/forge/sdk/services/credential/bitwarden_credential_service.pyindex 197163002..5465697a9 100644--- a/skyvern/forge/sdk/services/credential/bitwarden_credential_service.py+++ b/skyvern/forge/sdk/services/credential/bitwarden_credential_service.py@@ -24,6 +24,7 @@ class BitwardenCredentialVaultService(CredentialVaultService):organization_id: str,data: CreateCredentialRequest,created_by: str | None = None,+ is_passkey_setup_pending: bool = False,) -> Credential:org_collection = await app.DATABASE.credentials.get_organization_bitwarden_collection(organization_id)@@ -52,6 +53,7 @@ class BitwardenCredentialVaultService(CredentialVaultService):item_id=item_id,vault_type=CredentialVaultType.BITWARDEN,created_by=created_by,+ is_passkey_setup_pending=is_passkey_setup_pending,)return credentialdiff --git a/skyvern/forge/sdk/services/credential/credential_creation_service.py b/skyvern/forge/sdk/services/credential/credential_creation_service.pynew file mode 100644index 000000000..b4c22b2c3--- /dev/null+++ b/skyvern/forge/sdk/services/credential/credential_creation_service.py@@ -0,0 +1,294 @@+from __future__ import annotations++from typing import Any++import structlog+from fastapi import BackgroundTasks, HTTPException+from sqlalchemy.exc import IntegrityError++from skyvern.exceptions import HttpException as SkyvernHttpException+from skyvern.forge import app+from skyvern.forge.agent_functions import record_request_audit_event+from skyvern.forge.sdk.schemas.credentials import (+ CreateCredentialRequest,+ Credential,+ CredentialResponse,+ CredentialType,+ CredentialVaultType,+ CreditCardCredentialResponse,+ NonEmptyPasswordCredential,+ PasswordCredentialResponse,+ SecretCredentialResponse,+ TotpType,+)+from skyvern.forge.sdk.services.bitwarden import BitwardenService+from skyvern.forge.sdk.services.credential.credential_vault_service import CredentialVaultService+from skyvern.forge.sdk.services.credential.custom_credential_vault_service import CustomCredentialConfigurationError+from skyvern.forge.sdk.settings_manager import SettingsManager++LOG = structlog.get_logger()+++async def fetch_credential_item_background(item_id: str) -> None:+ """Fetch a new Bitwarden item early so the next request does not wait for vault sync."""+ try:+ LOG.info("Pre-fetching credential item from Bitwarden in background", item_id=item_id)+ credential_item = await BitwardenService.get_credential_item(item_id)+ LOG.info("Successfully fetched credential item from Bitwarden", item_id=item_id, name=credential_item.name)+ except Exception as e:+ LOG.exception("Failed to fetch credential item from Bitwarden in background", item_id=item_id, error=str(e))+++async def validate_credential_browser_profile_id(+ browser_profile_id: str,+ organization_id: str,+ current_credential_id: str | None = None,+) -> None:+ """Only allow linking an unowned, unmanaged profile from the same organization."""+ profile = await app.DATABASE.browser_sessions.get_browser_profile(+ profile_id=browser_profile_id, organization_id=organization_id+ )+ if profile is None:+ raise HTTPException(+ status_code=400, detail=f"Browser profile not found, browser_profile_id={browser_profile_id}"+ )+ if profile.is_managed or profile.workflow_permanent_id is not None:+ raise HTTPException(+ status_code=400,+ detail="A credential can only link a plain browser profile, not a workflow-managed one.",+ )+ links_by_profile = await app.DATABASE.credentials.get_browser_profile_credential_links(+ {browser_profile_id}, organization_id+ )+ 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.")+++async def update_credential_or_profile_conflict(**kwargs: Any) -> Credential:+ """Translate the profile-link unique constraint into the same 400 as the pre-write check."""+ try:+ return await app.DATABASE.credentials.update_credential(**kwargs)+ except IntegrityError as exc:+ if "uq_credentials_browser_profile_id" in str(getattr(exc, "orig", exc)):+ raise HTTPException(status_code=400, detail="This browser profile is already linked to another credential.")+ raise+++async def get_credential_vault_service(+ vault_type_override: CredentialVaultType | None = None,+ organization_id: str | None = None,+) -> CredentialVaultService:+ """Resolve and, when writing, preflight the configured vault service."""+ settings = SettingsManager.get_settings()+ vault_type = vault_type_override or settings.CREDENTIAL_VAULT_TYPE+ service: CredentialVaultService+ if vault_type == CredentialVaultType.SKYVERN:+ if not settings.is_local_credential_vault_enabled():+ raise HTTPException(status_code=400, detail="Skyvern local credential vault is not enabled")+ if not app.SKYVERN_CREDENTIAL_VAULT_SERVICE:+ raise HTTPException(status_code=400, detail="Skyvern local credential vault is not configured")+ service = app.SKYVERN_CREDENTIAL_VAULT_SERVICE+ elif vault_type == CredentialVaultType.BITWARDEN:+ service = app.BITWARDEN_CREDENTIAL_VAULT_SERVICE+ elif vault_type == CredentialVaultType.AZURE_VAULT:+ if not app.AZURE_CREDENTIAL_VAULT_SERVICE:+ raise HTTPException(status_code=400, detail="Azure Vault credential is not supported")+ service = app.AZURE_CREDENTIAL_VAULT_SERVICE+ elif vault_type == CredentialVaultType.GCP:+ if not app.GCP_CREDENTIAL_VAULT_SERVICE:+ raise HTTPException(status_code=400, detail="GCP credential vault is not supported")+ service = app.GCP_CREDENTIAL_VAULT_SERVICE+ elif vault_type == CredentialVaultType.CUSTOM:+ if not app.CUSTOM_CREDENTIAL_VAULT_SERVICE:+ raise HTTPException(status_code=400, detail="Custom credential vault is not configured")+ service = app.CUSTOM_CREDENTIAL_VAULT_SERVICE+ elif vault_type == CredentialVaultType.ONEPASSWORD:+ service = app.ONEPASSWORD_CREDENTIAL_VAULT_SERVICE+ else:+ raise HTTPException(status_code=400, detail="Credential storage not supported")++ if organization_id is not None:+ try:+ await service.validate_organization_configuration(organization_id)+ except CustomCredentialConfigurationError as e:+ # The vault service already reported this error; avoid double-counting it.+ raise HTTPException(status_code=400, detail=str(e)) from e+ return service+++async def prepare_credential_create(+ organization_id: str,+ data: CreateCredentialRequest,+ *,+ is_passkey_setup_pending: bool = False,+) -> CredentialVaultService:+ """Validate a create before it touches a vault and resolve its service."""+ is_passkey_setup = (+ data.credential_type == CredentialType.PASSWORD+ and isinstance(data.credential, NonEmptyPasswordCredential)+ and data.credential.totp_type == TotpType.PASSKEY+ )+ if is_passkey_setup != is_passkey_setup_pending:+ raise HTTPException(status_code=400, detail="Passkey credentials must use the passkey setup route")++ await app.AGENT_FUNCTION.validate_credential_write(+ organization_id=organization_id,+ credential_type=data.credential_type,+ credential=data.credential,+ existing_credential=None,+ )+ if data.browser_profile_id is not None:+ await validate_credential_browser_profile_id(data.browser_profile_id, organization_id)+ return await get_credential_vault_service(+ vault_type_override=data.vault_type,+ organization_id=organization_id,+ )+++async def store_new_credential(+ organization_id: str,+ data: CreateCredentialRequest,+ created_by: str | None,+ credential_service: CredentialVaultService,+ background_tasks: BackgroundTasks,+ *,+ is_passkey_setup_pending: bool = False,+) -> Credential:+ try:+ if is_passkey_setup_pending:+ credential = await credential_service.create_credential(+ organization_id=organization_id,+ data=data,+ created_by=created_by,+ is_passkey_setup_pending=True,+ )+ else:+ credential = await credential_service.create_credential(+ organization_id=organization_id,+ data=data,+ created_by=created_by,+ )+ except SkyvernHttpException as e:+ detail = (+ f"Custom credential service returned {e.error_message}"+ if e.error_message+ else f"Custom credential service returned HTTP {e.status_code}"+ )+ raise HTTPException(status_code=502, detail=detail) from e++ await record_request_audit_event(organization_id, "credential.create", "credential", credential.credential_id)+ if credential.vault_type == CredentialVaultType.BITWARDEN:+ background_tasks.add_task(fetch_credential_item_background, credential.item_id)++ pin_provided = "pin_saved_session_ip" in data.model_fields_set+ bpid_provided = "browser_profile_id" in data.model_fields_set+ auto_profile_disabled_provided = "auto_profile_disabled" in data.model_fields_set+ if bpid_provided or pin_provided or auto_profile_disabled_provided:+ profile_update: dict[str, Any] = {"browser_profile_id": data.browser_profile_id} if bpid_provided else {}+ credential = await update_credential_or_profile_conflict(+ credential_id=credential.credential_id,+ organization_id=organization_id,+ **profile_update,+ pin_saved_session_ip=data.pin_saved_session_ip if pin_provided else None,+ auto_profile_disabled=data.auto_profile_disabled if auto_profile_disabled_provided else None,+ )++ background_tasks.add_task(+ app.AGENT_FUNCTION.on_credential_saved,+ organization_id=organization_id,+ credential_id=credential.credential_id,+ credential_type=data.credential_type,+ actor_user_id=created_by,+ vault=credential.vault_type.value if credential.vault_type is not None else None,+ )+ return credential+++def convert_to_response(credential: Credential) -> CredentialResponse:+ """Convert an internal ``Credential`` to a safe API response.++ SECURITY: Copy only non-sensitive metadata. Never include passwords, TOTP secrets, full card numbers, CVVs,+ expiration dates, card holder names, credit card billing/contact fields, credit card metadata, or secret values.+ See the route module docstring for the full security invariant.+ """+ is_onepassword = credential.vault_type == CredentialVaultType.ONEPASSWORD+ if credential.credential_type == CredentialType.PASSWORD:+ credential_response = PasswordCredentialResponse(+ username=credential.username or credential.credential_id,+ totp_type=credential.totp_type,+ totp_identifier=credential.totp_identifier,+ has_totp=bool(credential.has_totp_seed),+ )+ return CredentialResponse(+ credential=credential_response,+ credential_id=credential.credential_id,+ credential_type=credential.credential_type,+ name=credential.name,+ vault_type=credential.vault_type,+ vault_id=credential.vault_id if is_onepassword else None,+ item_id=credential.item_id if is_onepassword else None,+ upstream_missing_at=credential.upstream_missing_at if is_onepassword else None,+ browser_profile_id=credential.browser_profile_id,+ auto_profile_disabled=credential.auto_profile_disabled,+ pin_saved_session_ip=credential.pin_saved_session_ip,+ tested_url=credential.tested_url,+ user_context=credential.user_context,+ save_browser_session_intent=credential.save_browser_session_intent,+ run_sequentially=credential.run_sequentially,+ folder_id=credential.folder_id,+ proxy_location=credential.proxy_location,+ proxy_session_id=credential.proxy_session_id,+ created_by=credential.created_by,+ )+ if credential.credential_type == CredentialType.CREDIT_CARD:+ credential_response = CreditCardCredentialResponse(+ last_four=credential.card_last4 or "****",+ brand=credential.card_brand or "Card Brand",+ )+ return CredentialResponse(+ credential=credential_response,+ credential_id=credential.credential_id,+ credential_type=credential.credential_type,+ name=credential.name,+ vault_type=credential.vault_type,+ vault_id=credential.vault_id if is_onepassword else None,+ item_id=credential.item_id if is_onepassword else None,+ upstream_missing_at=credential.upstream_missing_at if is_onepassword else None,+ browser_profile_id=credential.browser_profile_id,+ auto_profile_disabled=credential.auto_profile_disabled,+ pin_saved_session_ip=credential.pin_saved_session_ip,+ tested_url=credential.tested_url,+ user_context=credential.user_context,+ save_browser_session_intent=credential.save_browser_session_intent,+ run_sequentially=credential.run_sequentially,+ folder_id=credential.folder_id,+ proxy_location=credential.proxy_location,+ proxy_session_id=credential.proxy_session_id,+ created_by=credential.created_by,+ )+ if credential.credential_type == CredentialType.SECRET:+ return CredentialResponse(+ credential=SecretCredentialResponse(secret_label=credential.secret_label),+ credential_id=credential.credential_id,+ credential_type=credential.credential_type,+ name=credential.name,+ vault_type=credential.vault_type,+ vault_id=credential.vault_id if is_onepassword else None,+ item_id=credential.item_id if is_onepassword else None,+ upstream_missing_at=credential.upstream_missing_at if is_onepassword else None,+ browser_profile_id=credential.browser_profile_id,+ auto_profile_disabled=credential.auto_profile_disabled,+ pin_saved_session_ip=credential.pin_saved_session_ip,+ tested_url=credential.tested_url,+ user_context=credential.user_context,+ save_browser_session_intent=credential.save_browser_session_intent,+ run_sequentially=credential.run_sequentially,+ folder_id=credential.folder_id,+ proxy_location=credential.proxy_location,+ proxy_session_id=credential.proxy_session_id,+ created_by=credential.created_by,+ )+ raise HTTPException(status_code=400, detail="Credential type not supported")diff --git a/skyvern/forge/sdk/services/credential/credential_vault_service.py b/skyvern/forge/sdk/services/credential/credential_vault_service.pyindex a1e7f45ee..75f438737 100644--- a/skyvern/forge/sdk/services/credential/credential_vault_service.py+++ b/skyvern/forge/sdk/services/credential/credential_vault_service.py@@ -15,6 +15,7 @@ from skyvern.forge.sdk.schemas.credentials import (CreditCardBillingAddress,CreditCardCredential,PasswordCredential,+ TotpType,)LOG = structlog.get_logger()@@ -44,6 +45,7 @@ class CredentialVaultService(ABC):organization_id: str,data: CreateCredentialRequest,created_by: str | None = None,+ is_passkey_setup_pending: bool = False,) -> Credential:"""Create a new credential in the vault and database."""@@ -269,6 +271,7 @@ class CredentialVaultService(ABC):item_id: str,vault_type: CredentialVaultType,created_by: str | None = None,+ is_passkey_setup_pending: bool = False,) -> Credential:if data.credential_type == CredentialType.PASSWORD:return await app.DATABASE.credentials.create_credential(@@ -287,6 +290,9 @@ class CredentialVaultService(ABC):proxy_location=data.proxy_location,proxy_session_id=data.proxy_session_id,created_by=created_by,+ is_passkey_setup_pending=(+ True if is_passkey_setup_pending and data.credential.totp_type == TotpType.PASSKEY else None+ ),)elif data.credential_type == CredentialType.CREDIT_CARD:return await app.DATABASE.credentials.create_credential(diff --git a/skyvern/forge/sdk/services/credential/custom_credential_vault_service.py b/skyvern/forge/sdk/services/credential/custom_credential_vault_service.pyindex 64e846b81..188db95e6 100644--- a/skyvern/forge/sdk/services/credential/custom_credential_vault_service.py+++ b/skyvern/forge/sdk/services/credential/custom_credential_vault_service.py@@ -131,6 +131,7 @@ class CustomCredentialVaultService(CredentialVaultService):organization_id: str,data: CreateCredentialRequest,created_by: str | None = None,+ is_passkey_setup_pending: bool = False,) -> Credential:"""Create a new credential in the custom vault and database.@@ -167,6 +168,7 @@ class CustomCredentialVaultService(CredentialVaultService):item_id=item_id,vault_type=CredentialVaultType.CUSTOM,created_by=created_by,+ is_passkey_setup_pending=is_passkey_setup_pending,)except Exception:# Attempt to clean up the external credentialdiff --git a/skyvern/forge/sdk/services/credential/gcp_credential_vault_service.py b/skyvern/forge/sdk/services/credential/gcp_credential_vault_service.pyindex 357d7eaf1..9978153d4 100644--- a/skyvern/forge/sdk/services/credential/gcp_credential_vault_service.py+++ b/skyvern/forge/sdk/services/credential/gcp_credential_vault_service.py@@ -73,6 +73,7 @@ class GcpCredentialVaultService(CredentialVaultService):organization_id: str,data: CreateCredentialRequest,created_by: str | None = None,+ is_passkey_setup_pending: bool = False,) -> Credential:item_id = await self._create_gcp_secret_item(organization_id=organization_id,@@ -85,6 +86,7 @@ class GcpCredentialVaultService(CredentialVaultService):item_id=item_id,vault_type=CredentialVaultType.GCP,created_by=created_by,+ is_passkey_setup_pending=is_passkey_setup_pending,)return credentialdiff --git a/skyvern/forge/sdk/services/credential/onepassword_credential_vault_service.py b/skyvern/forge/sdk/services/credential/onepassword_credential_vault_service.pyindex dee93d1a5..657d1a071 100644--- a/skyvern/forge/sdk/services/credential/onepassword_credential_vault_service.py+++ b/skyvern/forge/sdk/services/credential/onepassword_credential_vault_service.py@@ -114,6 +114,7 @@ class OnePasswordCredentialVaultService(CredentialVaultService):organization_id: str,data: CreateCredentialRequest,created_by: str | None = None,+ is_passkey_setup_pending: bool = False,) -> Credential:raise HTTPException(status_code=405, detail="Creating 1Password-backed credentials is not supported")diff --git a/skyvern/forge/sdk/services/credential/skyvern_credential_vault_service.py b/skyvern/forge/sdk/services/credential/skyvern_credential_vault_service.pyindex 663a36584..f668cd26f 100644--- a/skyvern/forge/sdk/services/credential/skyvern_credential_vault_service.py+++ b/skyvern/forge/sdk/services/credential/skyvern_credential_vault_service.py@@ -39,6 +39,7 @@ class SkyvernCredentialVaultService(CredentialVaultService):organization_id: str,data: CreateCredentialRequest,created_by: str | None = None,+ is_passkey_setup_pending: bool = False,) -> Credential:item_id = self._generate_item_id()item = CredentialItem(@@ -56,6 +57,7 @@ class SkyvernCredentialVaultService(CredentialVaultService):item_id=item_id,vault_type=CredentialVaultType.SKYVERN,created_by=created_by,+ is_passkey_setup_pending=is_passkey_setup_pending,)except BaseException:await self._reclaim_orphaned_vault_item(diff --git a/tests/unit/forge/sdk/db/test_credentials_repository.py b/tests/unit/forge/sdk/db/test_credentials_repository.pyindex 44f9c118f..360bdcf67 100644--- a/tests/unit/forge/sdk/db/test_credentials_repository.py+++ b/tests/unit/forge/sdk/db/test_credentials_repository.py@@ -57,6 +57,102 @@ async def test_search_matches_an_exact_credential_id_within_the_org(repo_and_sesassert await found(ORG_A, "portal") == [portal]+async def test_test_login_temporary_marker_can_be_set_and_cleared(repo_and_session) -> None:+ repo, _session_factory = repo_and_session+ credential_id = await _add_credential(_session_factory, ORG_A, "Login")++ marked = await repo.update_credential(+ credential_id=credential_id,+ organization_id=ORG_A,+ is_test_login_temporary=True,+ )+ assert marked.is_test_login_temporary is True++ saved = await repo.update_credential(+ credential_id=credential_id,+ organization_id=ORG_A,+ is_test_login_temporary=False,+ )+ assert saved.is_test_login_temporary is False+++async def test_pending_passkey_setup_marker_can_be_set_and_cleared(repo_and_session) -> None:+ repo, _session_factory = repo_and_session+ credential = await repo.create_credential(+ organization_id=ORG_A,+ name="Passkey login",+ vault_type=CredentialVaultType.CUSTOM,+ item_id="passkey-item",+ credential_type=CredentialType.PASSWORD,+ username="[email protected]",+ totp_type="passkey",+ card_last4=None,+ card_brand=None,+ is_passkey_setup_pending=True,+ )+ assert credential.is_passkey_setup_pending is True++ saved = await repo.update_credential(+ credential_id=credential.credential_id,+ organization_id=ORG_A,+ is_passkey_setup_pending=False,+ )+ assert saved.is_passkey_setup_pending is False+++ ("credential_type", "totp_type", "is_pending"),+ [+ (CredentialType.PASSWORD, "none", False),+ (CredentialType.PASSWORD, "authenticator", False),+ (CredentialType.PASSWORD, "passkey", True),+ (CredentialType.CREDIT_CARD, "none", False),+ (CredentialType.SECRET, "none", False),+ ],+)+async def test_generic_update_tracks_pending_passkey_marker(+ repo_and_session, credential_type: CredentialType, totp_type: str, is_pending: bool+) -> None:+ repo, _session_factory = repo_and_session+ credential = await repo.create_credential(+ organization_id=ORG_A,+ name="Passkey login",+ vault_type=CredentialVaultType.CUSTOM,+ item_id="passkey-item",+ credential_type=CredentialType.PASSWORD,+ username="[email protected]",+ totp_type="passkey",+ card_last4=None,+ card_brand=None,+ is_passkey_setup_pending=True,+ )+ await repo.update_credential(+ credential_id=credential.credential_id,+ organization_id=ORG_A,+ is_test_login_temporary=True,+ )++ updated = await repo.update_credential_vault_data(+ credential_id=credential.credential_id,+ organization_id=ORG_A,+ item_id="updated-item",+ name="Saved login",+ credential_type=credential_type,+ username="[email protected]",+ totp_type=totp_type,+ totp_identifier=None,+ card_last4=None,+ card_brand=None,+ )++ assert updated.totp_type == totp_type+ assert updated.is_passkey_setup_pending is is_pending+ assert updated.is_test_login_temporary is False++@pytest.mark.asyncioasync def test_vault_item_link_is_unique_per_organization_and_round_trips(repo_and_session) -> None:repo, _session_factory = repo_and_sessiondiff --git a/tests/unit/test_credential_delete_reaps_profile.py b/tests/unit/test_credential_delete_reaps_profile.pyindex 6820b83e2..677cc714a 100644--- a/tests/unit/test_credential_delete_reaps_profile.py+++ b/tests/unit/test_credential_delete_reaps_profile.py@@ -1,3 +1,4 @@+from contextlib import asynccontextmanagerfrom types import SimpleNamespacefrom unittest.mock import AsyncMock@@ -5,6 +6,7 @@ import pytestimport structlog.testingfrom fastapi import BackgroundTasks+from skyvern.forge.sdk.db.datetime_utils import naive_utc_nowfrom skyvern.forge.sdk.routes import credentials@@ -16,21 +18,44 @@ def _setup_app(reap_raises: bool = False,db_raises: bool = False,engine_enabled: bool = True,+ is_test_login_temporary: bool = False,+ assert_lock_during_reap: bool = False,) -> SimpleNamespace:+ lock_state = {"held": False}+ lock_calls: list[tuple[str, str]] = []get_credential = AsyncMock(return_value=SimpleNamespace(vault_type=credentials.CredentialVaultType.BITWARDEN,item_id="item_1",organization_id="o_test",browser_profile_id=browser_profile_id,+ created_by="user_1",+ created_at=naive_utc_now(),+ is_test_login_temporary=is_test_login_temporary,))has_live = AsyncMock(return_value=has_refs)db_delete_profile = AsyncMock(side_effect=RuntimeError("db down") if db_raises else None)# reap_raises fails the S3 erasure (the security-critical path), which must be best-effort.- storage_delete_profile = AsyncMock(side_effect=RuntimeError("boom") if reap_raises else None)++ async def delete_profile(**kwargs: object) -> None:+ if assert_lock_during_reap:+ assert lock_state["held"]+ if reap_raises:+ raise RuntimeError("boom")++ storage_delete_profile = AsyncMock(side_effect=delete_profile)vault_service = SimpleNamespace(delete_credential=AsyncMock(), post_delete_credential_item=AsyncMock())+ @asynccontextmanager+ async def credential_write_lock(*, organization_id: str, credential_id: str):+ lock_calls.append((organization_id, credential_id))+ lock_state["held"] = True+ try:+ yield+ finally:+ lock_state["held"] = False+fake_app = SimpleNamespace(DATABASE=SimpleNamespace(credentials=SimpleNamespace(get_credential=get_credential),@@ -44,15 +69,19 @@ def _setup_app(AGENT_FUNCTION=SimpleNamespace(is_browser_memory_engine_enabled_for_org=AsyncMock(return_value=engine_enabled),should_lock_credential_write=AsyncMock(return_value=False),+ credential_write_lock=credential_write_lock,),)monkeypatch.setattr(credentials, "app", fake_app)monkeypatch.setattr(credentials, "_clear_cached_totp_code_preview", lambda **kwargs: None)+ monkeypatch.setattr(credentials, "record_request_audit_event", AsyncMock())return SimpleNamespace(has_live=has_live,db_delete_profile=db_delete_profile,storage_delete_profile=storage_delete_profile,vault_service=vault_service,+ lock_state=lock_state,+ lock_calls=lock_calls,)@@ -64,6 +93,15 @@ async def _delete() -> None:)+async def _delete_temporary() -> None:+ await credentials.delete_organization_credential(+ organization_id="o_test",+ credential_id="cred_1",+ background_tasks=BackgroundTasks(),+ expected_created_by="user_1",+ )++@pytest.mark.asyncioasync def test_reaps_profile_when_no_live_owner(monkeypatch: pytest.MonkeyPatch) -> None:mocks = _setup_app(monkeypatch, browser_profile_id="bp_1", has_refs=False)@@ -76,6 +114,21 @@ async def test_reaps_profile_when_no_live_owner(monkeypatch: pytest.MonkeyPatch)mocks.storage_delete_profile.assert_awaited_once_with(organization_id="o_test", profile_id="bp_1", hard_delete=True)+async def test_temporary_delete_holds_credential_lock_through_profile_reap(monkeypatch: pytest.MonkeyPatch) -> None:+ mocks = _setup_app(+ monkeypatch,+ browser_profile_id="bp_1",+ is_test_login_temporary=True,+ assert_lock_during_reap=True,+ )++ await _delete_temporary()++ assert mocks.lock_calls == [("o_test", "cred_1")]+ assert mocks.lock_state["held"] is False++@pytest.mark.asyncioasync def test_skips_reap_when_engine_off(monkeypatch: pytest.MonkeyPatch) -> None:# Flag-off orgs must not hit the irreversible S3 archive delete on credential delete (v1 has nodiff --git a/tests/unit/test_credential_test_trigger_type.py b/tests/unit/test_credential_test_trigger_type.pyindex 9153e236e..1b3933f90 100644--- a/tests/unit/test_credential_test_trigger_type.py+++ b/tests/unit/test_credential_test_trigger_type.py@@ -137,8 +137,20 @@ async def test_test_login_trigger_type_from_user_agent(return_value=SimpleNamespace(vault_type=None, credential_id="cred_test", totp_identifier=None)))+ update_credential = AsyncMock(+ return_value=SimpleNamespace(+ vault_type=None,+ credential_id="cred_test",+ totp_identifier=None,+ proxy_location=None,+ proxy_session_id=None,+ )+ )monkeypatch.setattr(credentials, "_get_credential_vault_service", AsyncMock(return_value=vault_service))monkeypatch.setattr(credentials, "_create_browser_profile_after_workflow", AsyncMock())+ monkeypatch.setattr(+ credentials.app, "DATABASE", SimpleNamespace(credentials=SimpleNamespace(update_credential=update_credential))+ )monkeypatch.setattr(credentials.app, "WORKFLOW_SERVICE", _workflow_service(setup_mock))_patch_executor(monkeypatch)@@ -150,6 +162,7 @@ async def test_test_login_trigger_type_from_user_agent()setup_mock.assert_awaited_once()+ assert update_credential.await_args.kwargs["is_test_login_temporary"] is Trueassert setup_mock.call_args.kwargs["trigger_type"] == expectedassert response.workflow_run_id == "wr_test"# test_login fires _create_browser_profile_after_workflow via create_task; drain the@@ -196,6 +209,7 @@ async def test_test_login_seeds_proxy_pin_workflow_request(monkeypatch: pytest.M)workflow_request = setup_mock.call_args.kwargs["workflow_request"]+ assert mock_credentials.update_credential.await_args.kwargs["is_test_login_temporary"] is Trueassert workflow_request.proxy_location == ProxyLocation.RESIDENTIAL_ISPassert workflow_request.extra_http_headers == {"dedicated-ip": "abc1234567"}await asyncio.sleep(0)@@ -274,8 +288,20 @@ def test_test_login_endpoint_wires_user_agent_header(return_value=SimpleNamespace(vault_type=None, credential_id="cred_test", totp_identifier=None)))+ update_credential = AsyncMock(+ return_value=SimpleNamespace(+ vault_type=None,+ credential_id="cred_test",+ totp_identifier=None,+ proxy_location=None,+ proxy_session_id=None,+ )+ )monkeypatch.setattr(credentials, "_get_credential_vault_service", AsyncMock(return_value=vault_service))monkeypatch.setattr(credentials, "_create_browser_profile_after_workflow", AsyncMock())+ monkeypatch.setattr(+ credentials.app, "DATABASE", SimpleNamespace(credentials=SimpleNamespace(update_credential=update_credential))+ )monkeypatch.setattr(credentials.app, "WORKFLOW_SERVICE", _workflow_service(setup_mock))_patch_executor(monkeypatch)@@ -291,5 +317,6 @@ def test_test_login_endpoint_wires_user_agent_header()assert resp.status_code == 200+ assert update_credential.await_args.kwargs["is_test_login_temporary"] is Truesetup_mock.assert_awaited_once()assert setup_mock.call_args.kwargs["trigger_type"] == expecteddiff --git a/tests/unit/test_credential_update_params.py b/tests/unit/test_credential_update_params.pyindex 2f74609c5..7de3d8412 100644--- a/tests/unit/test_credential_update_params.py+++ b/tests/unit/test_credential_update_params.py@@ -34,6 +34,7 @@ from skyvern.forge.sdk.schemas.credentials import (TotpType,UpdateCredentialRequest,)+from skyvern.forge.sdk.services.credential import credential_creation_servicefrom skyvern.forge.sdk.services.credential.credential_vault_service import CredentialVaultServicefrom skyvern.forge.sdk.services.credential.skyvern_credential_vault_service import SkyvernCredentialVaultServicefrom skyvern.forge.sdk.workflow.models.workflow import WorkflowRunStatus@@ -127,7 +128,9 @@ async def test_create_credential_response_includes_generated_proxy_pin(monkeypattotp_type=TotpType.AUTHENTICATOR,)vault_service = SimpleNamespace(create_credential=AsyncMock(return_value=stored_credential))- monkeypatch.setattr(credentials_routes, "_get_credential_vault_service", AsyncMock(return_value=vault_service))+ monkeypatch.setattr(+ credential_creation_service, "get_credential_vault_service", AsyncMock(return_value=vault_service)+ )data = CreateCredentialRequest(name="test",@@ -198,7 +201,9 @@ async def test_credential_vault_service_update_db_credential_skips_tested_url_whasync def test_create_credential_then_get_credential_returns_tested_url(monkeypatch: pytest.MonkeyPatch) -> None:stored_credential = _make_password_credential(tested_url="https://example.com/login")vault_service = SimpleNamespace(create_credential=AsyncMock(return_value=stored_credential))- monkeypatch.setattr(credentials_routes, "_get_credential_vault_service", AsyncMock(return_value=vault_service))+ monkeypatch.setattr(+ credential_creation_service, "get_credential_vault_service", AsyncMock(return_value=vault_service)+ )monkeypatch.setattr(forge_app.DATABASE.credentials,"get_credential",@@ -1155,7 +1160,9 @@ def _stored_credential(@pytest.mark.asyncioasync def test_create_credential_links_validated_browser_profile_id(monkeypatch: pytest.MonkeyPatch) -> None:vault_service = SimpleNamespace(create_credential=AsyncMock(return_value=_stored_credential()))- monkeypatch.setattr(credentials_routes, "_get_credential_vault_service", AsyncMock(return_value=vault_service))+ monkeypatch.setattr(+ credential_creation_service, "get_credential_vault_service", AsyncMock(return_value=vault_service)+ )monkeypatch.setattr(forge_app.DATABASE.browser_sessions,"get_browser_profile",@@ -1194,7 +1201,9 @@ async def test_create_credential_links_validated_browser_profile_id(monkeypatch:@pytest.mark.asyncioasync def test_create_credential_persists_auto_profile_disabled(monkeypatch: pytest.MonkeyPatch) -> None:vault_service = SimpleNamespace(create_credential=AsyncMock(return_value=_stored_credential()))- monkeypatch.setattr(credentials_routes, "_get_credential_vault_service", AsyncMock(return_value=vault_service))+ monkeypatch.setattr(+ credential_creation_service, "get_credential_vault_service", AsyncMock(return_value=vault_service)+ )update_credential = AsyncMock(return_value=_stored_credential(auto_profile_disabled=True))monkeypatch.setattr(forge_app.DATABASE.credentials, "update_credential", update_credential)@@ -1217,7 +1226,9 @@ async def test_create_credential_persists_auto_profile_disabled(monkeypatch: pytasync def test_create_credential_rejects_managed_browser_profile_id(monkeypatch: pytest.MonkeyPatch) -> None:vault_create = AsyncMock(return_value=_stored_credential())vault_service = SimpleNamespace(create_credential=vault_create)- monkeypatch.setattr(credentials_routes, "_get_credential_vault_service", AsyncMock(return_value=vault_service))+ monkeypatch.setattr(+ credential_creation_service, "get_credential_vault_service", AsyncMock(return_value=vault_service)+ )monkeypatch.setattr(forge_app.DATABASE.browser_sessions,"get_browser_profile",@@ -1553,7 +1564,9 @@ async def test_create_credential_profile_alone_does_not_reset_pin(monkeypatch: p# K: supplying a browser_profile_id without a pin field must NOT reset the pin — pass None (leave# unchanged), not the request model's default False.vault_service = SimpleNamespace(create_credential=AsyncMock(return_value=_stored_credential()))- monkeypatch.setattr(credentials_routes, "_get_credential_vault_service", AsyncMock(return_value=vault_service))+ monkeypatch.setattr(+ credential_creation_service, "get_credential_vault_service", AsyncMock(return_value=vault_service)+ )monkeypatch.setattr(forge_app.DATABASE.browser_sessions,"get_browser_profile",@@ -1748,7 +1761,13 @@ class _PreservingVaultService(CredentialVaultService):self.stored = storedself.written: PasswordCredential | None = None- async def create_credential(self, organization_id: str, data: CreateCredentialRequest) -> Credential:+ async def create_credential(+ self,+ organization_id: str,+ data: CreateCredentialRequest,+ created_by: str | None = None,+ is_passkey_setup_pending: bool = False,+ ) -> Credential:raise NotImplementedErrorasync def update_credential(self, credential: Credential, data: CreateCredentialRequest) -> Credential:@@ -1847,8 +1866,8 @@ async def test_create_credential_records_the_caller_as_creator(monkeypatch.setattr(settings, "LOCAL_CREDENTIAL_VAULT_KEY", None)monkeypatch.setattr(forge_app.DATABASE, "credentials", db.credentials)monkeypatch.setattr(- credentials_routes,- "_get_credential_vault_service",+ credential_creation_service,+ "get_credential_vault_service",AsyncMock(return_value=SkyvernCredentialVaultService()),)diff --git a/tests/unit/test_credential_vault_type_override.py b/tests/unit/test_credential_vault_type_override.pyindex f41532cf5..6dd8df8c3 100644--- a/tests/unit/test_credential_vault_type_override.py+++ b/tests/unit/test_credential_vault_type_override.py@@ -9,10 +9,7 @@ from fastapi import BackgroundTasks, HTTPExceptionfrom skyvern.config import Settingsfrom skyvern.forge.sdk.routes import credentials as credentials_routes-from skyvern.forge.sdk.routes.credentials import (- _delete_temporary_test_login_credential,- _get_credential_vault_service,-)+from skyvern.forge.sdk.routes.credentials import _delete_temporary_test_login_credentialfrom skyvern.forge.sdk.schemas.credentials import (CreateCredentialRequest,CredentialResponse,@@ -24,6 +21,9 @@ from skyvern.forge.sdk.schemas.credentials import (SecretCredentialResponse,)from skyvern.forge.sdk.services.credential import custom_credential_vault_service as custom_vault_module+from skyvern.forge.sdk.services.credential.credential_creation_service import (+ get_credential_vault_service as _get_credential_vault_service,+)from skyvern.forge.sdk.services.credential.credential_vault_service import CredentialVaultServicefrom skyvern.forge.sdk.services.credential.custom_credential_vault_service import (CONFIGURATION_INVALID_MESSAGE,@@ -178,8 +178,11 @@ class TestGetCredentialVaultServiceRouting:mock_bw = MagicMock(spec=CredentialVaultService)mock_settings = MagicMock(CREDENTIAL_VAULT_TYPE=CredentialVaultType.BITWARDEN)with (- patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,- patch("skyvern.forge.sdk.routes.credentials.SettingsManager.get_settings", return_value=mock_settings),+ patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app,+ patch(+ "skyvern.forge.sdk.services.credential.credential_creation_service.SettingsManager.get_settings",+ return_value=mock_settings,+ ),):mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bwresult = await _get_credential_vault_service()@@ -191,8 +194,11 @@ class TestGetCredentialVaultServiceRouting:mock_settings = MagicMock(CREDENTIAL_VAULT_TYPE=CredentialVaultType.SKYVERN)mock_settings.is_local_credential_vault_enabled.return_value = Truewith (- patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,- patch("skyvern.forge.sdk.routes.credentials.SettingsManager.get_settings", return_value=mock_settings),+ patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app,+ patch(+ "skyvern.forge.sdk.services.credential.credential_creation_service.SettingsManager.get_settings",+ return_value=mock_settings,+ ),):mock_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = mock_skyvernresult = await _get_credential_vault_service()@@ -203,8 +209,11 @@ class TestGetCredentialVaultServiceRouting:mock_settings = MagicMock(CREDENTIAL_VAULT_TYPE=CredentialVaultType.SKYVERN)mock_settings.is_local_credential_vault_enabled.return_value = Falsewith (- patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,- patch("skyvern.forge.sdk.routes.credentials.SettingsManager.get_settings", return_value=mock_settings),+ patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app,+ patch(+ "skyvern.forge.sdk.services.credential.credential_creation_service.SettingsManager.get_settings",+ return_value=mock_settings,+ ),):mock_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = MagicMock(spec=CredentialVaultService)with pytest.raises(HTTPException) as exc_info:@@ -219,8 +228,11 @@ class TestGetCredentialVaultServiceRouting:mock_settings = MagicMock(CREDENTIAL_VAULT_TYPE=CredentialVaultType.BITWARDEN)mock_settings.is_local_credential_vault_enabled.return_value = Truewith (- patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,- patch("skyvern.forge.sdk.routes.credentials.SettingsManager.get_settings", return_value=mock_settings),+ patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app,+ patch(+ "skyvern.forge.sdk.services.credential.credential_creation_service.SettingsManager.get_settings",+ return_value=mock_settings,+ ),):mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bwmock_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = mock_skyvern@@ -236,8 +248,11 @@ class TestGetCredentialVaultServiceRouting:mock_settings = MagicMock(CREDENTIAL_VAULT_TYPE=CredentialVaultType.BITWARDEN)mock_settings.is_local_credential_vault_enabled.return_value = Falsewith (- patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,- patch("skyvern.forge.sdk.routes.credentials.SettingsManager.get_settings", return_value=mock_settings),+ patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app,+ patch(+ "skyvern.forge.sdk.services.credential.credential_creation_service.SettingsManager.get_settings",+ return_value=mock_settings,+ ),):mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bwmock_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = mock_skyvern@@ -252,7 +267,7 @@ class TestGetCredentialVaultServiceRouting:async def test_override_custom_ignores_global(self) -> None:mock_bw = MagicMock(spec=CredentialVaultService)mock_custom = MagicMock(spec=CredentialVaultService)- with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:+ with patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app:mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bwmock_app.CUSTOM_CREDENTIAL_VAULT_SERVICE = mock_customresult = await _get_credential_vault_service(@@ -264,7 +279,7 @@ class TestGetCredentialVaultServiceRouting:async def test_override_azure_ignores_global(self) -> None:mock_bw = MagicMock(spec=CredentialVaultService)mock_azure = MagicMock(spec=CredentialVaultService)- with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:+ with patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app:mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bwmock_app.AZURE_CREDENTIAL_VAULT_SERVICE = mock_azureresult = await _get_credential_vault_service(@@ -276,7 +291,7 @@ class TestGetCredentialVaultServiceRouting:async def test_override_gcp_ignores_global(self) -> None:mock_bw = MagicMock(spec=CredentialVaultService)mock_gcp = MagicMock(spec=CredentialVaultService)- with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:+ with patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app:mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bwmock_app.GCP_CREDENTIAL_VAULT_SERVICE = mock_gcpresult = await _get_credential_vault_service(@@ -287,7 +302,7 @@ class TestGetCredentialVaultServiceRouting:@pytest.mark.asyncioasync def test_override_onepassword_uses_registered_service(self) -> None:mock_onepassword = MagicMock(spec=CredentialVaultService)- with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:+ with patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app:mock_app.ONEPASSWORD_CREDENTIAL_VAULT_SERVICE = mock_onepasswordresult = await _get_credential_vault_service(vault_type_override=CredentialVaultType.ONEPASSWORD,@@ -296,7 +311,7 @@ class TestGetCredentialVaultServiceRouting:@pytest.mark.asyncioasync def test_override_gcp_raises_when_not_configured(self) -> None:- with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:+ with patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app:mock_app.GCP_CREDENTIAL_VAULT_SERVICE = Nonewith pytest.raises(HTTPException) as exc_info:await _get_credential_vault_service(@@ -307,7 +322,7 @@ class TestGetCredentialVaultServiceRouting:@pytest.mark.asyncioasync def test_override_custom_raises_when_not_configured(self) -> None:- with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:+ with patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app:mock_app.CUSTOM_CREDENTIAL_VAULT_SERVICE = Nonewith pytest.raises(HTTPException) as exc_info:await _get_credential_vault_service(@@ -321,8 +336,11 @@ class TestGetCredentialVaultServiceRouting:mock_custom = MagicMock(spec=CredentialVaultService)mock_settings = MagicMock(CREDENTIAL_VAULT_TYPE=CredentialVaultType.CUSTOM)with (- patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,- patch("skyvern.forge.sdk.routes.credentials.SettingsManager.get_settings", return_value=mock_settings),+ patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app,+ patch(+ "skyvern.forge.sdk.services.credential.credential_creation_service.SettingsManager.get_settings",+ return_value=mock_settings,+ ),):mock_app.CUSTOM_CREDENTIAL_VAULT_SERVICE = mock_customresult = await _get_credential_vault_service(vault_type_override=None)@@ -376,7 +394,7 @@ class TestCustomVaultOrganizationPreflight:_install_stored_config(monkeypatch, stored_config)monkeypatch.setattr(custom_vault_module, "CustomCredentialAPIClient", api_client)- with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:+ with patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app:mock_app.CUSTOM_CREDENTIAL_VAULT_SERVICE = CustomCredentialVaultService()with pytest.raises(HTTPException) as exc_info:await _get_credential_vault_service(@@ -395,7 +413,7 @@ class TestCustomVaultOrganizationPreflight:) -> None:_install_stored_config(monkeypatch, json.dumps({"api_token": "super-secret-token"}))- with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:+ with patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app:mock_app.CUSTOM_CREDENTIAL_VAULT_SERVICE = CustomCredentialVaultService()with pytest.raises(HTTPException) as exc_info:await _get_credential_vault_service(@@ -416,7 +434,7 @@ class TestCustomVaultOrganizationPreflight:)service = CustomCredentialVaultService()- with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:+ with patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app:mock_app.CUSTOM_CREDENTIAL_VAULT_SERVICE = serviceresult = await _get_credential_vault_service(vault_type_override=CredentialVaultType.CUSTOM,@@ -430,8 +448,11 @@ class TestCustomVaultOrganizationPreflight:mock_bw = MagicMock(spec=CredentialVaultService)mock_settings = MagicMock(CREDENTIAL_VAULT_TYPE=CredentialVaultType.BITWARDEN)with (- patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,- patch("skyvern.forge.sdk.routes.credentials.SettingsManager.get_settings", return_value=mock_settings),+ patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app,+ patch(+ "skyvern.forge.sdk.services.credential.credential_creation_service.SettingsManager.get_settings",+ return_value=mock_settings,+ ),):mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bwresult = await _get_credential_vault_service(organization_id="org_test")@@ -444,7 +465,7 @@ class TestCustomVaultOrganizationPreflight:# The TOTP read path relies on this: it needs CustomCredentialNotConfiguredError to reach# its own handler rather than being converted at the gate.mock_custom = MagicMock(spec=CredentialVaultService)- with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:+ with patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app:mock_app.CUSTOM_CREDENTIAL_VAULT_SERVICE = mock_customresult = await _get_credential_vault_service(vault_type_override=CredentialVaultType.CUSTOM)@@ -470,7 +491,7 @@ class TestCustomVaultOrganizationPreflight:vault_type=CredentialVaultType.CUSTOM,)- with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:+ with patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app:mock_app.CUSTOM_CREDENTIAL_VAULT_SERVICE = servicemock_app.AGENT_FUNCTION.validate_credential_write = AsyncMock()with pytest.raises(HTTPException) as exc_info:@@ -547,10 +568,14 @@ class TestTemporaryTestLoginCredentialCleanup:with (patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,- patch("skyvern.forge.sdk.routes.credentials.SettingsManager.get_settings", return_value=mock_settings),+ patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_creation_app,+ patch(+ "skyvern.forge.sdk.services.credential.credential_creation_service.SettingsManager.get_settings",+ return_value=mock_settings,+ ),):mock_app.DATABASE.credentials = mock_repository- mock_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = mock_service+ mock_creation_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = mock_serviceawait _delete_temporary_test_login_credential(credential_id="cred_temp",@@ -573,9 +598,12 @@ class TestTemporaryTestLoginCredentialCleanup:mock_service = MagicMock(spec=CredentialVaultService)mock_service.delete_credential = AsyncMock()- with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:+ with (+ patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,+ patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_creation_app,+ ):mock_app.DATABASE.credentials = mock_repository- mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_service+ mock_creation_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_serviceawait _delete_temporary_test_login_credential(credential_id="cred_temp",