Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
feat(SKY-11051): back Save & Reuse Session with auto-managed browser profiles (#7032)
Suchintan03e23fe9ba0b
diff --git a/alembic/versions/2026_07_02_2317-ecf365563e98_managed_browser_profiles_for_save_and_reuse_session.py b/alembic/versions/2026_07_02_2317-ecf365563e98_managed_browser_profiles_for_save_and_reuse_session.pynew file mode 100644index 000000000..de4304f7d--- /dev/null+++ b/alembic/versions/2026_07_02_2317-ecf365563e98_managed_browser_profiles_for_save_and_reuse_session.py@@ -0,0 +1,67 @@+"""managed browser profiles for save and reuse session++Revision ID: ecf365563e98+Revises: a1cad008154a+Create Date: 2026-07-02T23:17:33.611632+00:00++"""++from typing import Sequence, Union++import sqlalchemy as sa++from alembic import op++# revision identifiers, used by Alembic.+revision: str = "ecf365563e98"+down_revision: Union[str, None] = "a1cad008154a"+branch_labels: Union[str, Sequence[str], None] = None+depends_on: Union[str, Sequence[str], None] = None+++def upgrade() -> None:+ op.add_column(+ "browser_profiles",+ sa.Column("is_managed", sa.Boolean(), server_default=sa.text("false"), nullable=False),+ )+ op.add_column("browser_profiles", sa.Column("workflow_permanent_id", sa.String(), nullable=True))+ op.add_column("browser_profiles", sa.Column("browser_profile_key_digest", sa.String(), nullable=True))+ op.create_index(+ "uq_browser_profiles_org_name_user",+ "browser_profiles",+ ["organization_id", "name"],+ unique=True,+ postgresql_where=sa.text("is_managed = false"),+ sqlite_where=sa.text("is_managed = false"),+ )+ op.create_index(+ "uq_browser_profiles_managed_segment",+ "browser_profiles",+ ["organization_id", "workflow_permanent_id", "browser_profile_key_digest"],+ unique=True,+ # Exclude soft-deleted rows so deleting a managed profile doesn't tombstone the+ # segment — the next run re-creates it instead of colliding on the unique key.+ postgresql_where=sa.text("is_managed = true AND deleted_at IS NULL"),+ sqlite_where=sa.text("is_managed = true AND deleted_at IS NULL"),+ )+ op.create_index("idx_browser_profiles_wpid", "browser_profiles", ["workflow_permanent_id"], unique=False)+ op.drop_constraint("uc_org_browser_profile_name", "browser_profiles", type_="unique")+++def downgrade() -> None:+ op.execute("DELETE FROM browser_profiles WHERE is_managed = true")+ op.create_unique_constraint("uc_org_browser_profile_name", "browser_profiles", ["organization_id", "name"])+ op.drop_index("idx_browser_profiles_wpid", table_name="browser_profiles")+ op.drop_index(+ "uq_browser_profiles_managed_segment",+ table_name="browser_profiles",+ postgresql_where=sa.text("is_managed = true AND deleted_at IS NULL"),+ )+ op.drop_index(+ "uq_browser_profiles_org_name_user",+ table_name="browser_profiles",+ postgresql_where=sa.text("is_managed = false"),+ )+ op.drop_column("browser_profiles", "browser_profile_key_digest")+ op.drop_column("browser_profiles", "workflow_permanent_id")+ op.drop_column("browser_profiles", "is_managed")diff --git a/skyvern-frontend/src/api/types.ts b/skyvern-frontend/src/api/types.tsindex 49755e853..bf6da1067 100644--- a/skyvern-frontend/src/api/types.ts+++ b/skyvern-frontend/src/api/types.ts@@ -842,6 +842,8 @@ export type BrowserProfileApiResponse = {source_browser_type: string | null;proxy_location?: ProxyLocation | null;proxy_session_id?: string | null;+ is_managed?: boolean;+ workflow_permanent_id?: string | null;created_at: string;modified_at: string;deleted_at: string | null;diff --git a/skyvern-frontend/src/routes/browserProfiles/BrowserProfileItem.tsx b/skyvern-frontend/src/routes/browserProfiles/BrowserProfileItem.tsxindex 4cb7306b7..05d7b1948 100644--- a/skyvern-frontend/src/routes/browserProfiles/BrowserProfileItem.tsx+++ b/skyvern-frontend/src/routes/browserProfiles/BrowserProfileItem.tsx@@ -3,7 +3,9 @@ import { Pencil1Icon } from "@radix-ui/react-icons";import { useNavigate } from "react-router-dom";import { BrowserProfileApiResponse } from "@/api/types";+import { CopyButton } from "@/components/CopyButton";import { SelectionCheckboxCell } from "@/components/SelectionCheckbox";+import { Badge } from "@/components/ui/badge";import { Button } from "@/components/ui/button";import { TableCell, TableRow } from "@/components/ui/table";import {@@ -67,7 +69,37 @@ function BrowserProfileItem({/>)}<TableCell className="truncate">- <span title={profile.name}>{profile.name}</span>+ <div className="flex min-w-0 flex-col gap-0.5">+ <div className="flex min-w-0 items-center gap-2">+ <span className="truncate" title={profile.name}>+ {profile.name}+ </span>+ {profile.is_managed ? (+ <Badge+ variant="secondary"+ className="shrink-0"+ title="Auto-saved from a Save & Reuse Session workflow. Recreated automatically on the next run."+ >+ Auto-managed+ </Badge>+ ) : null}+ </div>+ <div+ className="flex min-w-0 items-center gap-1 text-xs text-muted-foreground"+ onClick={stopRowClick}+ >+ <span+ className="truncate font-mono"+ title={profile.browser_profile_id}+ >+ {profile.browser_profile_id}+ </span>+ <CopyButton+ value={profile.browser_profile_id}+ className="size-5 shrink-0"+ />+ </div>+ </div></TableCell><TableCell className="truncate text-muted-foreground">{profile.description ? (diff --git a/skyvern-frontend/src/routes/browserProfiles/BrowserProfilesList.tsx b/skyvern-frontend/src/routes/browserProfiles/BrowserProfilesList.tsxindex 392fb4089..c4a358a52 100644--- a/skyvern-frontend/src/routes/browserProfiles/BrowserProfilesList.tsx+++ b/skyvern-frontend/src/routes/browserProfiles/BrowserProfilesList.tsx@@ -49,9 +49,10 @@ import { BrowserProfileItem } from "./BrowserProfileItem";type Props = {searchKey?: string;+ managed?: boolean;};-function BrowserProfilesList({ searchKey }: Props = {}) {+function BrowserProfilesList({ searchKey, managed }: Props = {}) {const [searchParams, setSearchParams] = useSearchParams();const page = searchParams.get("page") ? Number(searchParams.get("page")) : 1;const itemsPerPage = searchParams.get("page_size")@@ -84,12 +85,14 @@ function BrowserProfilesList({ searchKey }: Props = {}) {page,page_size: itemsPerPage,searchKey,+ managed,});const { data: nextPageProfiles } = useBrowserProfilesQuery({page: page + 1,page_size: itemsPerPage,searchKey,+ managed,enabled: (profiles?.length ?? 0) === itemsPerPage,});@@ -124,7 +127,7 @@ function BrowserProfilesList({ searchKey }: Props = {}) {} = useRowSelection({items: pageItems,getId: (profile) => profile.browser_profile_id,- resetKey: JSON.stringify([page, itemsPerPage, searchKey ?? ""]),+ resetKey: JSON.stringify([page, itemsPerPage, searchKey ?? "", managed]),});async function handleBulkDeleteConfirm() {@@ -211,6 +214,19 @@ function BrowserProfilesList({ searchKey }: Props = {}) {<div className="rounded-md border border-slate-700 bg-slate-elevation1 p-10 text-sm text-neutral-600 dark:text-slate-300">{hasSearch ? (<>No browser profiles match “{searchKey}”.</>+ ) : managed === true ? (+ <div className="flex flex-col items-center gap-3 text-center">+ <BrowserIcon className="size-10 text-neutral-600 dark:text-slate-400" />+ <div className="space-y-1">+ <p className="text-base font-medium text-slate-100">+ No auto-managed profiles yet+ </p>+ <p className="mx-auto max-w-md text-sm text-neutral-600 dark:text-slate-400">+ Run a workflow with Save & Reuse Session enabled and Skyvern+ creates one automatically.+ </p>+ </div>+ </div>) : (<div className="flex flex-col items-center gap-3 text-center"><BrowserIcon className="size-10 text-neutral-600 dark:text-slate-400" />diff --git a/skyvern-frontend/src/routes/browserProfiles/BrowserProfilesPage.tsx b/skyvern-frontend/src/routes/browserProfiles/BrowserProfilesPage.tsxindex 545e9fb3e..9b5db5747 100644--- a/skyvern-frontend/src/routes/browserProfiles/BrowserProfilesPage.tsx+++ b/skyvern-frontend/src/routes/browserProfiles/BrowserProfilesPage.tsx@@ -16,6 +16,16 @@ function BrowserProfilesPage() {const [searchParams, setSearchParams] = useSearchParams();const [search, setSearch] = useState("");const [debouncedSearch] = useDebounce(search, 250);+ const [profileType, setProfileType] = useState<"all" | "user" | "managed">(+ "all",+ );+ const managed = profileType === "all" ? undefined : profileType === "managed";++ function resetToFirstPage() {+ const params = new URLSearchParams(searchParams);+ params.set("page", "1");+ setSearchParams(params, { replace: true });+ }// Mounted for its side effects: rehydrates an in-progress create from// sessionStorage so the toast still fires if the user navigates here from@@ -34,20 +44,33 @@ function BrowserProfilesPage() {</p></div><div className="flex items-center justify-between gap-4">- <TableSearchInput- value={search}- onChange={(value) => {- setSearch(value);- const params = new URLSearchParams(searchParams);- params.set("page", "1");- setSearchParams(params, { replace: true });- }}- placeholder="Search browser profiles..."- className="w-48 lg:w-72"- />+ <div className="flex items-center gap-2">+ <TableSearchInput+ value={search}+ onChange={(value) => {+ setSearch(value);+ resetToFirstPage();+ }}+ placeholder="Search browser profiles..."+ className="w-48 lg:w-72"+ />+ <select+ aria-label="Filter browser profiles by type"+ className="h-9 rounded-md border border-input bg-background px-2 text-sm"+ value={profileType}+ onChange={(e) => {+ setProfileType(e.target.value as "all" | "user" | "managed");+ resetToFirstPage();+ }}+ >+ <option value="all">All</option>+ <option value="user">User profiles</option>+ <option value="managed">Auto-managed</option>+ </select>+ </div><CreateBrowserProfileButton /></div>- <BrowserProfilesList searchKey={debouncedSearch} />+ <BrowserProfilesList searchKey={debouncedSearch} managed={managed} /></div>);}diff --git a/skyvern-frontend/src/routes/workflows/components/BrowserProfileSelector.tsx b/skyvern-frontend/src/routes/workflows/components/BrowserProfileSelector.tsxindex 77bbc3183..79efbdc79 100644--- a/skyvern-frontend/src/routes/workflows/components/BrowserProfileSelector.tsx+++ b/skyvern-frontend/src/routes/workflows/components/BrowserProfileSelector.tsx@@ -57,6 +57,7 @@ function BrowserProfileSelector({page_size: PAGE_SIZE,searchKey: debouncedSearch,enabled: open,+ managed: false,});const profiles = useMemo(diff --git a/skyvern-frontend/src/routes/workflows/hooks/useBrowserProfilesQuery.ts b/skyvern-frontend/src/routes/workflows/hooks/useBrowserProfilesQuery.tsindex 7159fbe21..8e8bf436d 100644--- a/skyvern-frontend/src/routes/workflows/hooks/useBrowserProfilesQuery.ts+++ b/skyvern-frontend/src/routes/workflows/hooks/useBrowserProfilesQuery.ts@@ -14,6 +14,7 @@ type Props = UseQueryOptions & {page?: number;page_size?: number;searchKey?: string;+ managed?: boolean;};function useBrowserProfilesQuery(props: Props = {}) {@@ -22,12 +23,20 @@ function useBrowserProfilesQuery(props: Props = {}) {page,page_size,searchKey,+ managed,...queryOptions} = props;const credentialGetter = useCredentialGetter();return useQuery<QueryReturnType>({- queryKey: ["browserProfiles", includeDeleted, page, page_size, searchKey],+ queryKey: [+ "browserProfiles",+ includeDeleted,+ page,+ page_size,+ searchKey,+ managed,+ ],queryFn: async () => {const client = await getClient(credentialGetter, "sans-api-v1");const params = new URLSearchParams();@@ -43,6 +52,9 @@ function useBrowserProfilesQuery(props: Props = {}) {if (searchKey) {params.set("search_key", searchKey);}+ if (managed !== undefined) {+ params.set("managed", String(managed));+ }return client.get("/browser_profiles", { params }).then((res) => res.data);diff --git a/skyvern-frontend/src/routes/workflows/hooks/useInfiniteBrowserProfilesQuery.ts b/skyvern-frontend/src/routes/workflows/hooks/useInfiniteBrowserProfilesQuery.tsindex 471a3c613..1ee7cd665 100644--- a/skyvern-frontend/src/routes/workflows/hooks/useInfiniteBrowserProfilesQuery.ts+++ b/skyvern-frontend/src/routes/workflows/hooks/useInfiniteBrowserProfilesQuery.ts@@ -7,6 +7,7 @@ interface UseInfiniteBrowserProfilesQueryParams {page_size?: number;searchKey?: string;enabled?: boolean;+ managed?: boolean;}// Dedupe by id so concurrent-insert page-boundary repeats don't duplicate rows;@@ -35,9 +36,10 @@ function useInfiniteBrowserProfilesQuery(const credentialGetter = useCredentialGetter();const pageSize = params?.page_size ?? 20;const searchKey = params?.searchKey ?? "";+ const managed = params?.managed;return useInfiniteQuery<Array<BrowserProfileApiResponse>>({- queryKey: ["browserProfiles-infinite", searchKey, pageSize],+ queryKey: ["browserProfiles-infinite", searchKey, pageSize, managed],queryFn: async ({ pageParam = 1 }) => {const client = await getClient(credentialGetter, "sans-api-v1");const searchParams = new URLSearchParams();@@ -46,6 +48,9 @@ function useInfiniteBrowserProfilesQuery(if (searchKey) {searchParams.append("search_key", searchKey);}+ if (managed !== undefined) {+ searchParams.append("managed", String(managed));+ }return client.get<Array<BrowserProfileApiResponse>>("/browser_profiles", {params: searchParams,diff --git a/skyvern/forge/sdk/db/models.py b/skyvern/forge/sdk/db/models.pyindex 96dfa69d3..9988a8a86 100644--- a/skyvern/forge/sdk/db/models.py+++ b/skyvern/forge/sdk/db/models.py@@ -1211,7 +1211,24 @@ class BrowserProfileModel(Base):__table_args__ = (Index("idx_browser_profiles_org", "organization_id"),Index("idx_browser_profiles_org_name", "organization_id", "name"),- UniqueConstraint("organization_id", "name", name="uc_org_browser_profile_name"),+ Index(+ "uq_browser_profiles_org_name_user",+ "organization_id",+ "name",+ unique=True,+ postgresql_where=text("is_managed = false"),+ sqlite_where=text("is_managed = false"),+ ),+ Index(+ "uq_browser_profiles_managed_segment",+ "organization_id",+ "workflow_permanent_id",+ "browser_profile_key_digest",+ unique=True,+ postgresql_where=text("is_managed = true AND deleted_at IS NULL"),+ sqlite_where=text("is_managed = true AND deleted_at IS NULL"),+ ),+ Index("idx_browser_profiles_wpid", "workflow_permanent_id"),)browser_profile_id = Column(String, primary_key=True, default=generate_browser_profile_id)@@ -1221,6 +1238,9 @@ class BrowserProfileModel(Base):source_browser_type = Column(String, nullable=True)proxy_location = Column(String, nullable=True)proxy_session_id = Column(String, nullable=True)+ is_managed = Column(Boolean, nullable=False, server_default=sqlalchemy.false(), default=False)+ workflow_permanent_id = Column(String, nullable=True)+ browser_profile_key_digest = Column(String, 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)deleted_at = Column(DateTime, nullable=True)diff --git a/skyvern/forge/sdk/db/repositories/browser_sessions.py b/skyvern/forge/sdk/db/repositories/browser_sessions.pyindex 9cbd729d1..a13c77fa2 100644--- a/skyvern/forge/sdk/db/repositories/browser_sessions.py+++ b/skyvern/forge/sdk/db/repositories/browser_sessions.py@@ -5,6 +5,7 @@ from datetime import datetime, timedeltaimport structlogfrom sqlalchemy import case, desc, or_, select+from sqlalchemy.exc import IntegrityErrorfrom skyvern.config import settingsfrom skyvern.exceptions import BrowserProfileNotFound@@ -67,6 +68,51 @@ class BrowserSessionsRepository(BaseRepository):await session.refresh(browser_profile)return BrowserProfile.model_validate(browser_profile)+ @db_operation("get_or_create_managed_browser_profile")+ async def get_or_create_managed_browser_profile(+ self,+ *,+ organization_id: str,+ workflow_permanent_id: str,+ browser_profile_key_digest: str,+ name: str,+ ) -> tuple[BrowserProfile, bool]:+ digest = browser_profile_key_digest or ""+ async with self.Session() as session:+ query = (+ select(BrowserProfileModel)+ .filter_by(+ organization_id=organization_id,+ workflow_permanent_id=workflow_permanent_id,+ browser_profile_key_digest=digest,+ is_managed=True,+ )+ .filter(BrowserProfileModel.deleted_at.is_(None))+ )+ browser_profile = (await session.scalars(query)).first()+ if browser_profile:+ return BrowserProfile.model_validate(browser_profile), False++ browser_profile = BrowserProfileModel(+ browser_profile_id=generate_browser_profile_id(),+ organization_id=organization_id,+ name=name,+ is_managed=True,+ workflow_permanent_id=workflow_permanent_id,+ browser_profile_key_digest=digest,+ )+ session.add(browser_profile)+ try:+ await session.commit()+ except IntegrityError:+ await session.rollback()+ browser_profile = (await session.scalars(query)).first()+ if browser_profile:+ return BrowserProfile.model_validate(browser_profile), False+ raise+ await session.refresh(browser_profile)+ return BrowserProfile.model_validate(browser_profile), True+@db_operation("get_browser_profile")async def get_browser_profile(self,@@ -88,6 +134,25 @@ class BrowserSessionsRepository(BaseRepository):return Nonereturn BrowserProfile.model_validate(browser_profile)+ @db_operation("list_managed_browser_profiles_for_workflow")+ async def list_managed_browser_profiles_for_workflow(+ self,+ *,+ organization_id: str,+ workflow_permanent_id: str,+ include_deleted: bool = False,+ ) -> list[BrowserProfile]:+ async with self.Session() as session:+ query = select(BrowserProfileModel).filter_by(+ organization_id=organization_id,+ workflow_permanent_id=workflow_permanent_id,+ is_managed=True,+ )+ if not include_deleted:+ query = query.filter(BrowserProfileModel.deleted_at.is_(None))+ browser_profiles = await session.scalars(query)+ return [BrowserProfile.model_validate(profile) for profile in browser_profiles.all()]+@db_operation("list_browser_profiles")async def list_browser_profiles(self,@@ -96,6 +161,7 @@ class BrowserSessionsRepository(BaseRepository):page: int = 1,page_size: int = 10,search_key: str | None = None,+ managed: bool | None = None,) -> list[BrowserProfile]:if page < 1:raise ValueError(f"Page must be greater than 0, got {page}")@@ -104,6 +170,8 @@ class BrowserSessionsRepository(BaseRepository):query = select(BrowserProfileModel).filter_by(organization_id=organization_id)if not include_deleted:query = query.filter(BrowserProfileModel.deleted_at.is_(None))+ if managed is not None:+ query = query.filter(BrowserProfileModel.is_managed.is_(managed))if search_key:search_like = f"%{search_key}%"query = query.filter(diff --git a/skyvern/forge/sdk/routes/agent_protocol.py b/skyvern/forge/sdk/routes/agent_protocol.pyindex 265868c04..14fdb39eb 100644--- a/skyvern/forge/sdk/routes/agent_protocol.py+++ b/skyvern/forge/sdk/routes/agent_protocol.py@@ -111,6 +111,7 @@ from skyvern.forge.sdk.schemas.tasks import (from skyvern.forge.sdk.schemas.workflow_runs import WorkflowRunTimelinefrom skyvern.forge.sdk.services import org_auth_servicefrom skyvern.forge.sdk.settings_manager import SettingsManager+from skyvern.forge.sdk.workflow.browser_profile_key import build_workflow_browser_session_storage_key_from_digestfrom skyvern.forge.sdk.workflow.exceptions import (FailedToCreateWorkflow,FailedToUpdateWorkflow,@@ -4473,10 +4474,38 @@ async def reset_workflow_browser_profile(workflow_permanent_id=workflow_permanent_id,)try:+ # Include soft-deleted rows: their segment digests still address legacy archives+ # that would otherwise survive the reset and reseed state on the next run.+ managed_profiles = await app.DATABASE.browser_sessions.list_managed_browser_profiles_for_workflow(+ organization_id=current_org.organization_id,+ workflow_permanent_id=workflow_permanent_id,+ include_deleted=True,+ )await app.STORAGE.delete_browser_session(organization_id=current_org.organization_id,workflow_permanent_id=workflow_permanent_id,)+ segment_digests = {+ profile.browser_profile_key_digest for profile in managed_profiles if profile.browser_profile_key_digest+ }+ for digest in segment_digests:+ await app.STORAGE.delete_browser_session(+ organization_id=current_org.organization_id,+ workflow_permanent_id=build_workflow_browser_session_storage_key_from_digest(+ workflow_permanent_id, digest+ ),+ )+ for profile in managed_profiles:+ if profile.deleted_at is not None:+ continue+ await app.STORAGE.delete_browser_profile(+ organization_id=current_org.organization_id,+ profile_id=profile.browser_profile_id,+ )+ await app.DATABASE.browser_sessions.delete_browser_profile(+ profile_id=profile.browser_profile_id,+ organization_id=current_org.organization_id,+ )except SkyvernHTTPException:raiseexcept Exception as exc:diff --git a/skyvern/forge/sdk/routes/browser_profiles.py b/skyvern/forge/sdk/routes/browser_profiles.pyindex 4dbea6500..e6d3b6936 100644--- a/skyvern/forge/sdk/routes/browser_profiles.py+++ b/skyvern/forge/sdk/routes/browser_profiles.py@@ -37,6 +37,7 @@ from skyvern.forge.sdk.schemas.browser_profiles import (from skyvern.forge.sdk.schemas.organizations import Organizationfrom skyvern.forge.sdk.schemas.persistent_browser_sessions import export_profile_storage_idfrom skyvern.forge.sdk.services import org_auth_service+from 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_idfrom skyvern.schemas.runs import ProxyLocation, ProxyLocationInput@@ -210,6 +211,10 @@ async def list_browser_profiles(),examples=["my_profile", "production"],),+ managed: bool | None = Query(+ None,+ description="Omit to return all profiles; false returns only user-created profiles; true returns only auto-managed profiles.",+ ),current_org: Organization = Depends(org_auth_service.get_current_org),) -> list[BrowserProfile]:"""List all browser profiles for the current organization."""@@ -221,6 +226,7 @@ async def list_browser_profiles(page=page,page_size=page_size,search_key=search_key,+ managed=managed,)profiles = await app.DATABASE.browser_sessions.list_browser_profiles(@@ -229,6 +235,7 @@ async def list_browser_profiles(page=page,page_size=page_size,search_key=search_key,+ managed=managed,)LOG.info(@@ -828,15 +835,12 @@ async def _create_profile_from_workflow_run(# Poll for a short grace period so that immediate profile-creation requests# succeed without forcing clients to implement retry loops.poll_attempts = 30 # ~30 s max wait- browser_session_storage_key = await app.WORKFLOW_SERVICE.get_workflow_browser_session_storage_key(- workflow=workflow,- workflow_run=workflow_run,- )session_dir: str | None = Nonefor attempt in range(poll_attempts):- session_dir = await app.STORAGE.retrieve_browser_session(+ session_dir = await retrieve_persisted_workflow_browser_state_dir(organization_id=organization_id,- workflow_permanent_id=browser_session_storage_key,+ workflow=workflow,+ workflow_run=workflow_run,)if session_dir:break # session founddiff --git a/skyvern/forge/sdk/routes/credentials.py b/skyvern/forge/sdk/routes/credentials.pyindex a9bddcc22..36ab6e0ff 100644--- a/skyvern/forge/sdk/routes/credentials.py+++ b/skyvern/forge/sdk/routes/credentials.py@@ -118,6 +118,7 @@ from skyvern.forge.sdk.services.credentials import (normalize_totp_config,parse_totp_config,)+from 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, WorkflowRunStatusfrom skyvern.schemas.credential_folders import (@@ -1461,16 +1462,13 @@ async def _create_browser_profile_after_workflow(workflow_permanent_id=workflow_permanent_id,)return- browser_session_storage_key = await app.WORKFLOW_SERVICE.get_workflow_browser_session_storage_key(- workflow=workflow,- workflow_run=workflow_run,- )session_dir = Nonemax_retries = _SESSION_PERSIST_MAX_RETRIESfor attempt in range(max_retries):- session_dir = await app.STORAGE.retrieve_browser_session(+ session_dir = await retrieve_persisted_workflow_browser_state_dir(organization_id=organization_id,- workflow_permanent_id=browser_session_storage_key,+ workflow=workflow,+ workflow_run=workflow_run,)if session_dir:breakdiff --git a/skyvern/forge/sdk/schemas/browser_profiles.py b/skyvern/forge/sdk/schemas/browser_profiles.pyindex cb99d3efd..fd42bcfe9 100644--- a/skyvern/forge/sdk/schemas/browser_profiles.py+++ b/skyvern/forge/sdk/schemas/browser_profiles.py@@ -16,6 +16,9 @@ class BrowserProfile(BaseModel):source_browser_type: str | None = Noneproxy_location: ProxyLocationInput = Noneproxy_session_id: str | None = None+ is_managed: bool = False+ workflow_permanent_id: str | None = None+ browser_profile_key_digest: str | None = Nonecreated_at: datetimemodified_at: datetimedeleted_at: datetime | None = Nonediff --git a/skyvern/forge/sdk/workflow/browser_profile_key.py b/skyvern/forge/sdk/workflow/browser_profile_key.pyindex 9fdde9a44..1f0fa7e7f 100644--- a/skyvern/forge/sdk/workflow/browser_profile_key.py+++ b/skyvern/forge/sdk/workflow/browser_profile_key.py@@ -37,8 +37,21 @@ def build_workflow_browser_session_storage_key(workflow_permanent_id: str,rendered_browser_profile_key: str | None,) -> str:- rendered = rendered_browser_profile_key.strip() if rendered_browser_profile_key else ""- if not rendered:+ digest = build_browser_profile_key_digest(rendered_browser_profile_key)+ return build_workflow_browser_session_storage_key_from_digest(workflow_permanent_id, digest)+++def build_workflow_browser_session_storage_key_from_digest(+ workflow_permanent_id: str,+ digest: str | None,+) -> str:+ if not digest:return workflow_permanent_id- digest = sha256(rendered.encode("utf-8")).hexdigest()[:_PROFILE_SEGMENT_DIGEST_LENGTH]return f"{workflow_permanent_id}/{_PROFILE_SEGMENT_PATH}/{digest}"+++def build_browser_profile_key_digest(rendered_browser_profile_key: str | None) -> str:+ rendered = rendered_browser_profile_key.strip() if rendered_browser_profile_key else ""+ if not rendered:+ return ""+ return sha256(rendered.encode("utf-8")).hexdigest()[:_PROFILE_SEGMENT_DIGEST_LENGTH]diff --git a/skyvern/forge/sdk/workflow/browser_session_persistence.py b/skyvern/forge/sdk/workflow/browser_session_persistence.pynew file mode 100644index 000000000..2f64179c8--- /dev/null+++ b/skyvern/forge/sdk/workflow/browser_session_persistence.py@@ -0,0 +1,37 @@+from __future__ import annotations++from skyvern.forge import app+from skyvern.forge.sdk.workflow.models.workflow import Workflow, WorkflowRun+++async def retrieve_persisted_workflow_browser_state_dir(+ *,+ organization_id: str,+ workflow: Workflow,+ workflow_run: WorkflowRun,+) -> str | None:+ browser_profile_id = workflow_run.browser_profile_id+ if browser_profile_id:+ profile = await app.DATABASE.browser_sessions.get_browser_profile(+ profile_id=browser_profile_id,+ organization_id=organization_id,+ )+ # Only managed profiles owned by this workflow receive the run's end-of-run+ # write-back; a user (or foreign managed) profile's blob is curated starting+ # state, so reading it here would return stale data.+ if profile and profile.is_managed and profile.workflow_permanent_id == workflow_run.workflow_permanent_id:+ session_dir = await app.STORAGE.retrieve_browser_profile(+ organization_id=organization_id,+ profile_id=browser_profile_id,+ )+ if session_dir:+ return session_dir++ browser_session_storage_key = await app.WORKFLOW_SERVICE.get_workflow_browser_session_storage_key(+ workflow=workflow,+ workflow_run=workflow_run,+ )+ return await app.STORAGE.retrieve_browser_session(+ organization_id=organization_id,+ workflow_permanent_id=browser_session_storage_key,+ )diff --git a/skyvern/forge/sdk/workflow/service.py b/skyvern/forge/sdk/workflow/service.pyindex da5865658..f7b0eb1d4 100644--- a/skyvern/forge/sdk/workflow/service.py+++ b/skyvern/forge/sdk/workflow/service.py@@ -73,6 +73,7 @@ from skyvern.forge.sdk.schemas.tasks import Task, TaskStatusfrom skyvern.forge.sdk.schemas.workflow_runs import WorkflowRunBlock, WorkflowRunTimeline, WorkflowRunTimelineTypefrom skyvern.forge.sdk.trace import tracedfrom skyvern.forge.sdk.workflow.browser_profile_key import (+ build_browser_profile_key_digest,build_workflow_browser_session_storage_key,render_browser_profile_key,)@@ -174,6 +175,8 @@ LOG = structlog.get_logger()DEFAULT_FIRST_BLOCK_LABEL = "block_1"DEFAULT_WORKFLOW_TITLE = "New Workflow"+MANAGED_BROWSER_PROFILE_NAME_MAX_LENGTH = 120+MANAGED_BROWSER_PROFILE_KEY_MAX_LENGTH = 40# Empirical S3 upload SLA; no start buffer (back-to-back leakage is worse than late uploads to the next run).RECORDING_WINDOW_END_BUFFER = timedelta(minutes=15)@@ -510,6 +513,27 @@ def _resolve_first_block_url(return None+def _truncate_managed_browser_profile_part(value: str, max_length: int) -> str:+ if len(value) <= max_length:+ return value+ if max_length <= 3:+ return value[:max_length]+ return f"{value[: max_length - 3]}..."+++def _build_managed_browser_profile_name(workflow_title: str | None, rendered_key: str | None) -> str:+ title = (workflow_title or DEFAULT_WORKFLOW_TITLE).strip() or DEFAULT_WORKFLOW_TITLE+ if not rendered_key:+ suffix = " (auto-saved session)"+ title = _truncate_managed_browser_profile_part(title, MANAGED_BROWSER_PROFILE_NAME_MAX_LENGTH - len(suffix))+ return f"{title}{suffix}"++ key = _truncate_managed_browser_profile_part(rendered_key, MANAGED_BROWSER_PROFILE_KEY_MAX_LENGTH)+ suffix = f" (auto-saved: {key})"+ title = _truncate_managed_browser_profile_part(title, MANAGED_BROWSER_PROFILE_NAME_MAX_LENGTH - len(suffix))+ return f"{title}{suffix}"++class WorkflowService:# Prevent GC of fire-and-forget asyncio tasks (e.g. task_run sync)._background_tasks: set[asyncio.Task] = set() # noqa: RUF012@@ -1266,14 +1290,6 @@ class WorkflowService:workflow_run_id=workflow_run.workflow_run_id,)- browser_profile_key = getattr(workflow, "browser_profile_key", None)- if getattr(workflow, "persist_browser_session", False) and browser_profile_key:- await self.get_workflow_browser_session_storage_key(- workflow=workflow,- workflow_run=workflow_run,- parameter_values={param.key: value for param, value in workflow_parameter_values},- )-await self._validate_credential_ids([value@@ -1283,6 +1299,12 @@ class WorkflowService:organization,)+ workflow_run = await self._prepare_persisted_workflow_browser_profile(+ workflow=workflow,+ workflow_run=workflow_run,+ parameter_values={param.key: value for param, value in workflow_parameter_values},+ )+if workflow_parameter_values:try:await self.create_workflow_run_parameters(@@ -1342,15 +1364,102 @@ class WorkflowService:return "value cannot be null"return "database error while saving parameter value"- async def get_workflow_browser_session_storage_key(+ async def _prepare_persisted_workflow_browser_profile(self,*,workflow: Workflow,workflow_run: WorkflowRun,- parameter_values: dict[str, Any] | None = None,- ) -> str:+ parameter_values: dict[str, Any],+ ) -> WorkflowRun:+ if not workflow.persist_browser_session:+ return workflow_run++ if workflow_run.browser_profile_id:+ return workflow_run++ rendered_key = await self._render_workflow_browser_profile_key(+ workflow=workflow,+ workflow_run=workflow_run,+ parameter_values=parameter_values,+ )+ digest = build_browser_profile_key_digest(rendered_key)+ profile, created = await app.DATABASE.browser_sessions.get_or_create_managed_browser_profile(+ organization_id=workflow_run.organization_id,+ workflow_permanent_id=workflow.workflow_permanent_id,+ browser_profile_key_digest=digest,+ name=_build_managed_browser_profile_name(workflow.title, rendered_key),+ )+ if created:+ try:+ await self._seed_managed_browser_profile_from_legacy_session(+ workflow=workflow,+ workflow_run=workflow_run,+ rendered_key=rendered_key,+ browser_profile_id=profile.browser_profile_id,+ )+ except Exception:+ # Roll back the empty row so the next run re-attempts creation + seed;+ # this run degrades to the legacy session path instead of failing setup.+ LOG.warning(+ "Failed to seed managed browser profile from legacy session; rolling back and using legacy path",+ workflow_run_id=workflow_run.workflow_run_id,+ browser_profile_id=profile.browser_profile_id,+ exc_info=True,+ )+ await app.DATABASE.browser_sessions.hard_delete_browser_profile(+ profile_id=profile.browser_profile_id,+ organization_id=workflow_run.organization_id,+ )+ return workflow_run+ updated_workflow_run = await app.DATABASE.workflow_runs.update_workflow_run(+ workflow_run_id=workflow_run.workflow_run_id,+ browser_profile_id=profile.browser_profile_id,+ )+ LOG.info(+ "Stamped workflow run with managed browser profile",+ workflow_run_id=workflow_run.workflow_run_id,+ workflow_permanent_id=workflow.workflow_permanent_id,+ browser_profile_id=profile.browser_profile_id,+ browser_profile_key_digest=digest,+ )+ return updated_workflow_run++ async def _seed_managed_browser_profile_from_legacy_session(+ self,+ *,+ workflow: Workflow,+ workflow_run: WorkflowRun,+ rendered_key: str | None,+ browser_profile_id: str,+ ) -> None:+ # Lazy migration: carry a workflow's accumulated Save & Reuse login state onto its new+ # managed profile the first time we create it, so the next run starts logged in. The OSS+ # launch path has no legacy-archive fallback, so this copy must happen here, not at launch.+ storage_key = build_workflow_browser_session_storage_key(workflow.workflow_permanent_id, rendered_key)+ legacy_session_dir = await app.STORAGE.retrieve_browser_session(workflow_run.organization_id, storage_key)+ if not legacy_session_dir:+ return+ await app.STORAGE.store_browser_profile(+ workflow_run.organization_id,+ profile_id=browser_profile_id,+ directory=legacy_session_dir,+ )+ LOG.info(+ "Seeded managed browser profile from legacy session archive",+ workflow_run_id=workflow_run.workflow_run_id,+ browser_profile_id=browser_profile_id,+ browser_session_storage_key=storage_key,+ )++ async def _render_workflow_browser_profile_key(+ self,+ *,+ workflow: Workflow,+ workflow_run: WorkflowRun,+ parameter_values: dict[str, Any] | None,+ ) -> str | None:if not workflow.browser_profile_key:- return workflow.workflow_permanent_id+ return Noneif parameter_values is None:try:@@ -1377,6 +1486,23 @@ class WorkflowService:workflow_run_id=workflow_run.workflow_run_id,)+ return rendered_key++ async def get_workflow_browser_session_storage_key(+ self,+ *,+ workflow: Workflow,+ workflow_run: WorkflowRun,+ parameter_values: dict[str, Any] | None = None,+ ) -> str:+ if not workflow.browser_profile_key:+ return workflow.workflow_permanent_id++ rendered_key = await self._render_workflow_browser_profile_key(+ workflow=workflow,+ workflow_run=workflow_run,+ parameter_values=parameter_values,+ )storage_key = build_workflow_browser_session_storage_key(workflow.workflow_permanent_id, rendered_key)LOG.info("Resolved workflow browser session storage key",@@ -1453,6 +1579,7 @@ class WorkflowService:workflow: Workflow,*,browser_session_id: str | None = None,+ browser_profile_id: str | None = None,proxy_location: ProxyLocationInput = None,) -> PersistentBrowserSession | None:if browser_session_id: # the user has supplied an id, so no need to create one@@ -1469,6 +1596,7 @@ class WorkflowService:browser_session = await app.PERSISTENT_SESSIONS_MANAGER.create_session(organization_id=organization_id,timeout_minutes=timeout_seconds // 60,+ browser_profile_id=browser_profile_id,proxy_location=proxy_location,)@@ -1476,6 +1604,15 @@ class WorkflowService:return None+ async def _browser_profile_is_managed(self, *, organization_id: str, browser_profile_id: str | None) -> bool:+ if not browser_profile_id:+ return False+ profile = await app.DATABASE.browser_sessions.get_browser_profile(+ profile_id=browser_profile_id,+ organization_id=organization_id,+ )+ return bool(profile and profile.is_managed)+async def auto_create_browser_session_for_code_block_if_needed(self,organization_id: str,@@ -1862,11 +1999,16 @@ class WorkflowService:return workflow_runbrowser_session = None- if not browser_profile_id:+ using_managed_browser_profile = await self._browser_profile_is_managed(+ organization_id=organization.organization_id,+ browser_profile_id=browser_profile_id,+ )+ if not browser_profile_id or using_managed_browser_profile:browser_session = await self.auto_create_browser_session_if_needed(organization.organization_id,workflow,browser_session_id=browser_session_id,+ browser_profile_id=browser_profile_id if using_managed_browser_profile else None,proxy_location=workflow_run.proxy_location,)@@ -6141,41 +6283,74 @@ class WorkflowService:)if tasks:await self.persist_debug_artifacts(browser_state, tasks[-1], workflow, workflow_run)- # Skip workflow-scoped session save when using browser_profile_id to avoid conflicts- # (profile persistence is handled separately via the profile storage)- if (- workflow.persist_browser_session- and browser_state.browser_artifacts.browser_session_dir- and not workflow_run.browser_profile_id- ):- if workflow_run.status == WorkflowRunStatus.completed:- browser_session_storage_key = await self.get_workflow_browser_session_storage_key(- workflow=workflow,- workflow_run=workflow_run,- )- if not close_browser_on_completion:- # Browser stays alive here, so close()'s cookie snapshot never ran; capture- # session cookies now or they're missing from the archived profile on reuse.- await persist_session_cookies(- browser_state.browser_context,- browser_state.browser_artifacts.browser_session_dir,- )- await app.STORAGE.store_browser_session(- workflow_run.organization_id,- browser_session_storage_key,- browser_state.browser_artifacts.browser_session_dir,- )- LOG.info(- "Persisted browser session for workflow run",- workflow_run_id=workflow_run.workflow_run_id,- browser_session_storage_key=browser_session_storage_key,- )- else:+ if workflow.persist_browser_session and browser_state.browser_artifacts.browser_session_dir:+ if workflow_run.status != WorkflowRunStatus.completed:LOG.info("Skipped persisting browser session for non-completed workflow run",workflow_run_id=workflow_run.workflow_run_id,workflow_run_status=workflow_run.status,)+ else:+ browser_profile = None+ if workflow_run.browser_profile_id:+ browser_profile = await app.DATABASE.browser_sessions.get_browser_profile(+ workflow_run.browser_profile_id,+ organization_id=workflow_run.organization_id,+ )++ if (+ browser_profile+ and browser_profile.is_managed+ # Only write back to a managed profile this workflow owns; a foreign+ # managed id supplied explicitly is treated like a user profile.+ and browser_profile.workflow_permanent_id == workflow_run.workflow_permanent_id+ ):+ if not close_browser_on_completion:+ await persist_session_cookies(+ browser_state.browser_context,+ browser_state.browser_artifacts.browser_session_dir,+ )+ await app.STORAGE.store_browser_profile(+ workflow_run.organization_id,+ profile_id=browser_profile.browser_profile_id,+ directory=browser_state.browser_artifacts.browser_session_dir,+ )+ LOG.info(+ "Persisted managed browser profile for workflow run",+ workflow_run_id=workflow_run.workflow_run_id,+ browser_profile_id=browser_profile.browser_profile_id,+ )+ elif browser_profile is None:+ # No managed profile to write back to: either none was stamped, or a+ # stamped managed profile was deleted between setup and finalization.+ # Persist to the legacy session archive so the run's state isn't lost —+ # the next run reseeds a managed profile from it. Only the deleted-mid-run+ # case is unexpected, so warn there.+ if workflow_run.browser_profile_id:+ LOG.warning(+ "Managed browser profile missing at finalization; persisting to legacy session archive instead",+ workflow_run_id=workflow_run.workflow_run_id,+ browser_profile_id=workflow_run.browser_profile_id,+ )+ browser_session_storage_key = await self.get_workflow_browser_session_storage_key(+ workflow=workflow,+ workflow_run=workflow_run,+ )+ if not close_browser_on_completion:+ await persist_session_cookies(+ browser_state.browser_context,+ browser_state.browser_artifacts.browser_session_dir,+ )+ await app.STORAGE.store_browser_session(+ workflow_run.organization_id,+ browser_session_storage_key,+ browser_state.browser_artifacts.browser_session_dir,+ )+ LOG.info(+ "Persisted browser session for workflow run",+ workflow_run_id=workflow_run.workflow_run_id,+ browser_session_storage_key=browser_session_storage_key,+ )await app.ARTIFACT_MANAGER.wait_for_upload_aiotasks(all_workflow_task_ids)diff --git a/skyvern/webeye/default_persistent_sessions_manager.py b/skyvern/webeye/default_persistent_sessions_manager.pyindex 9cb241be0..faf91a19e 100644--- a/skyvern/webeye/default_persistent_sessions_manager.py+++ b/skyvern/webeye/default_persistent_sessions_manager.py@@ -408,6 +408,7 @@ class DefaultPersistentSessionsManager(PersistentSessionsManager):url=url,organization_id=organization_id,extra_http_headers=extra_http_headers,+ browser_profile_id=session.browser_profile_id,)await browser_state.get_or_create_page(url=url or "about:blank",diff --git a/tests/unit/forge/sdk/db/test_list_browser_profiles_ordering.py b/tests/unit/forge/sdk/db/test_list_browser_profiles_ordering.pyindex b92ef430b..6e1d435ae 100644--- a/tests/unit/forge/sdk/db/test_list_browser_profiles_ordering.py+++ b/tests/unit/forge/sdk/db/test_list_browser_profiles_ordering.py@@ -3,9 +3,11 @@ Selectors paginate this endpoint, so newest-first must come from the database."""from datetime import datetime+from typing import Anyimport pytestimport pytest_asyncio+from sqlalchemy.exc import IntegrityErrorfrom sqlalchemy.ext.asyncio import async_sessionmaker, create_async_enginefrom skyvern.forge.sdk.db.models import Base, BrowserProfileModel@@ -31,14 +33,28 @@ async def repo_and_session() -> tuple:await engine.dispose()-async def _add_profile(session_factory, name: str, created_at: datetime) -> str:+async def _add_profile(+ session_factory,+ name: str,+ created_at: datetime,+ *,+ profile_id: str | None = None,+ is_managed: bool = False,+ workflow_permanent_id: str | None = None,+ browser_profile_key_digest: str | None = None,+ deleted_at: datetime | None = None,+) -> str:async with session_factory() as session:profile = BrowserProfileModel(- browser_profile_id=f"bp_{name}",+ browser_profile_id=profile_id or f"bp_{name}",organization_id=ORG,name=name,created_at=created_at,modified_at=created_at,+ is_managed=is_managed,+ workflow_permanent_id=workflow_permanent_id,+ browser_profile_key_digest=browser_profile_key_digest,+ deleted_at=deleted_at,)session.add(profile)await session.commit()@@ -84,3 +100,186 @@ async def test_pagination_walks_from_newest_to_oldest(repo_and_session) -> None:assert [p.name for p in page_1] == ["newest"]assert [p.name for p in page_2] == ["middle"]assert [p.name for p in page_3] == ["oldest"]+++async def test_list_filters_managed_profiles(repo_and_session) -> None:+ repo, session_factory = repo_and_session+ await _add_profile(session_factory, "user", datetime(2026, 1, 1))+ await _add_profile(+ session_factory,+ "managed",+ datetime(2026, 1, 2),+ is_managed=True,+ workflow_permanent_id="wpid_test",+ browser_profile_key_digest="",+ )++ all_profiles = await repo.list_browser_profiles(organization_id=ORG)+ user_profiles = await repo.list_browser_profiles(organization_id=ORG, managed=False)+ managed_profiles = await repo.list_browser_profiles(organization_id=ORG, managed=True)++ assert [p.name for p in all_profiles] == ["managed", "user"]+ assert [p.name for p in user_profiles] == ["user"]+ assert [p.name for p in managed_profiles] == ["managed"]+++async def test_sqlite_partial_index_allows_managed_profile_name_to_match_user_profile(repo_and_session) -> None:+ _, session_factory = repo_and_session+ await _add_profile(session_factory, "shared", datetime(2026, 1, 1), profile_id="bp_user")++ await _add_profile(+ session_factory,+ "shared",+ datetime(2026, 1, 2),+ profile_id="bp_managed",+ is_managed=True,+ workflow_permanent_id="wpid_test",+ browser_profile_key_digest="",+ )+++async def test_sqlite_partial_index_allows_recreating_soft_deleted_managed_segment(repo_and_session) -> None:+ _, session_factory = repo_and_session+ await _add_profile(+ session_factory,+ "managed old",+ datetime(2026, 1, 1),+ profile_id="bp_managed_old",+ is_managed=True,+ workflow_permanent_id="wpid_test",+ browser_profile_key_digest="digest",+ deleted_at=datetime(2026, 1, 2),+ )++ await _add_profile(+ session_factory,+ "managed new",+ datetime(2026, 1, 3),+ profile_id="bp_managed_new",+ is_managed=True,+ workflow_permanent_id="wpid_test",+ browser_profile_key_digest="digest",+ )+++async def test_list_managed_browser_profiles_for_workflow_returns_active_managed_rows(repo_and_session) -> None:+ repo, session_factory = repo_and_session+ await _add_profile(session_factory, "user", datetime(2026, 1, 1), workflow_permanent_id="wpid_test")+ await _add_profile(+ session_factory,+ "managed active",+ datetime(2026, 1, 2),+ is_managed=True,+ workflow_permanent_id="wpid_test",+ browser_profile_key_digest="",+ )+ await _add_profile(+ session_factory,+ "managed deleted",+ datetime(2026, 1, 3),+ is_managed=True,+ workflow_permanent_id="wpid_test",+ browser_profile_key_digest="deleted",+ deleted_at=datetime(2026, 1, 4),+ )+ await _add_profile(+ session_factory,+ "managed other",+ datetime(2026, 1, 5),+ is_managed=True,+ workflow_permanent_id="wpid_other",+ browser_profile_key_digest="",+ )++ profiles = await repo.list_managed_browser_profiles_for_workflow(+ organization_id=ORG,+ workflow_permanent_id="wpid_test",+ )++ assert [profile.name for profile in profiles] == ["managed active"]+++async def test_get_or_create_managed_browser_profile_returns_existing(repo_and_session) -> None:+ repo, _ = repo_and_session++ first, first_created = await repo.get_or_create_managed_browser_profile(+ organization_id=ORG,+ workflow_permanent_id="wpid_test",+ browser_profile_key_digest="",+ name="Workflow (auto-saved session)",+ )+ second, second_created = await repo.get_or_create_managed_browser_profile(+ organization_id=ORG,+ workflow_permanent_id="wpid_test",+ browser_profile_key_digest="",+ name="Workflow (auto-saved session)",+ )++ assert first.browser_profile_id == second.browser_profile_id+ assert first.is_managed is True+ assert first.workflow_permanent_id == "wpid_test"+ assert first_created is True+ assert second_created is False+++class _CommitRaceSessionFactory:+ def __init__(self, session_factory: async_sessionmaker) -> None:+ self.session_factory = session_factory+ self.raised = False++ def __call__(self) -> Any:+ context = self.session_factory()+ factory = self++ class _Context:+ async def __aenter__(self) -> Any:+ session = await context.__aenter__()+ original_commit = session.commit++ async def commit() -> None:+ if not factory.raised:+ factory.raised = True+ async with factory.session_factory() as winner_session:+ winner = BrowserProfileModel(+ browser_profile_id="bp_race_winner",+ organization_id=ORG,+ name="Race winner",+ is_managed=True,+ workflow_permanent_id="wpid_race",+ browser_profile_key_digest="digest_race",+ created_at=datetime(2026, 1, 1),+ modified_at=datetime(2026, 1, 1),+ )+ winner_session.add(winner)+ await winner_session.commit()+ raise IntegrityError("insert", {}, Exception("duplicate"))+ await original_commit()++ session.commit = commit+ return session++ async def __aexit__(self, *args: object) -> None:+ await context.__aexit__(*args)++ return _Context()+++async def test_get_or_create_managed_browser_profile_recovers_from_integrity_race(repo_and_session) -> None:+ _, session_factory = repo_and_session+ repo = BrowserSessionsRepository(_CommitRaceSessionFactory(session_factory))++ profile, created = await repo.get_or_create_managed_browser_profile(+ organization_id=ORG,+ workflow_permanent_id="wpid_race",+ browser_profile_key_digest="digest_race",+ name="Race loser",+ )++ assert profile.browser_profile_id == "bp_race_winner"+ assert created is Falsediff --git a/tests/unit/forge/sdk/test_create_browser_profile_from_session_route.py b/tests/unit/forge/sdk/test_create_browser_profile_from_session_route.pyindex c6ceb2b8a..c921aa1e2 100644--- a/tests/unit/forge/sdk/test_create_browser_profile_from_session_route.py+++ b/tests/unit/forge/sdk/test_create_browser_profile_from_session_route.py@@ -72,6 +72,7 @@ def _build_client(get_workflow_run=AsyncMock(),get_workflow=AsyncMock(),create_profile=AsyncMock(return_value=_profile()),+ get_db_profile=AsyncMock(return_value=SimpleNamespace(is_managed=True, workflow_permanent_id="wp_1")),delete_db_profile=AsyncMock(),hard_delete_db_profile=AsyncMock(),retrieve_profile=AsyncMock(),@@ -92,6 +93,7 @@ def _build_client(browser_sessions=SimpleNamespace(get_persistent_browser_session=mocks.get_session,create_browser_profile=mocks.create_profile,+ get_browser_profile=mocks.get_db_profile,delete_browser_profile=mocks.delete_db_profile,hard_delete_browser_profile=mocks.hard_delete_db_profile,),@@ -420,6 +422,7 @@ async def test_create_profile_from_workflow_run_still_stores_workflow_archive(mocks.get_workflow_run.return_value = SimpleNamespace(workflow_id="wf_1",workflow_permanent_id="wp_1",+ browser_profile_id=None,)mocks.get_workflow.return_value = SimpleNamespace(workflow_permanent_id="wp_1",@@ -446,6 +449,107 @@ async def test_create_profile_from_workflow_run_still_stores_workflow_archive()+async def test_create_profile_from_workflow_run_reads_managed_profile_blob(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ _client, mocks = _build_client(monkeypatch)+ mocks.get_workflow_run.return_value = SimpleNamespace(+ workflow_id="wf_1",+ workflow_permanent_id="wp_1",+ browser_profile_id="bp_managed",+ )+ mocks.get_workflow.return_value = SimpleNamespace(+ workflow_permanent_id="wp_1",+ persist_browser_session=True,+ )+ mocks.retrieve_profile.return_value = "/tmp/managed_profile_dir"++ profile = await browser_profiles_route._create_profile_from_workflow_run(+ organization_id="org_oss",+ name="my profile",+ description=None,+ workflow_run_id="wr_1",+ )++ assert profile == _profile()+ mocks.retrieve_profile.assert_awaited_once_with(organization_id="org_oss", profile_id="bp_managed")+ mocks.retrieve_session.assert_not_awaited()+ mocks.store_profile.assert_awaited_once_with(+ organization_id="org_oss",+ profile_id="bp_new",+ directory="/tmp/managed_profile_dir",+ )+++async def test_create_profile_from_workflow_run_falls_back_to_legacy_archive_for_managed_run(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ _client, mocks = _build_client(monkeypatch)+ mocks.get_workflow_run.return_value = SimpleNamespace(+ workflow_id="wf_1",+ workflow_permanent_id="wp_1",+ browser_profile_id="bp_managed",+ )+ mocks.get_workflow.return_value = SimpleNamespace(+ workflow_permanent_id="wp_1",+ persist_browser_session=True,+ )+ mocks.retrieve_profile.return_value = None+ mocks.retrieve_session.return_value = "/tmp/workflow_session_dir"++ await browser_profiles_route._create_profile_from_workflow_run(+ organization_id="org_oss",+ name="my profile",+ description=None,+ workflow_run_id="wr_1",+ )++ mocks.retrieve_profile.assert_awaited_once_with(organization_id="org_oss", profile_id="bp_managed")+ mocks.retrieve_session.assert_awaited_once_with(+ organization_id="org_oss",+ workflow_permanent_id="wp_1",+ )+ mocks.store_profile.assert_awaited_once_with(+ organization_id="org_oss",+ profile_id="bp_new",+ directory="/tmp/workflow_session_dir",+ )+++async def test_create_profile_from_workflow_run_skips_user_profile_blob(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ _client, mocks = _build_client(monkeypatch)+ mocks.get_workflow_run.return_value = SimpleNamespace(+ workflow_id="wf_1",+ workflow_permanent_id="wp_1",+ browser_profile_id="bp_user",+ )+ mocks.get_workflow.return_value = SimpleNamespace(+ workflow_permanent_id="wp_1",+ persist_browser_session=True,+ )+ mocks.get_db_profile.return_value = SimpleNamespace(is_managed=False)+ mocks.retrieve_session.return_value = "/tmp/workflow_session_dir"++ await browser_profiles_route._create_profile_from_workflow_run(+ organization_id="org_oss",+ name="my profile",+ description=None,+ workflow_run_id="wr_1",+ )++ # A user profile's blob is its curated start state, not the run's end state.+ mocks.retrieve_profile.assert_not_awaited()+ mocks.retrieve_session.assert_awaited_once_with(+ organization_id="org_oss",+ workflow_permanent_id="wp_1",+ )++@pytest.mark.asyncioasync def test_failed_workflow_run_profile_creation_hard_deletes_half_created_profile(monkeypatch: pytest.MonkeyPatch,@@ -454,6 +558,7 @@ async def test_failed_workflow_run_profile_creation_hard_deletes_half_created_prmocks.get_workflow_run.return_value = SimpleNamespace(workflow_id="wf_1",workflow_permanent_id="wp_1",+ browser_profile_id=None,)mocks.get_workflow.return_value = SimpleNamespace(workflow_permanent_id="wp_1",diff --git a/tests/unit/forge/sdk/test_list_browser_profiles_route.py b/tests/unit/forge/sdk/test_list_browser_profiles_route.pyindex a3e88b472..a44d7f28e 100644--- a/tests/unit/forge/sdk/test_list_browser_profiles_route.py+++ b/tests/unit/forge/sdk/test_list_browser_profiles_route.py@@ -71,6 +71,7 @@ def test_list_browser_profiles_default_pagination(monkeypatch: pytest.MonkeyPatcpage=1,page_size=10,search_key=None,+ managed=None,)@@ -87,6 +88,7 @@ def test_list_browser_profiles_explicit_pagination(monkeypatch: pytest.MonkeyPatpage=2,page_size=10,search_key=None,+ managed=None,)@@ -121,6 +123,7 @@ def test_list_browser_profiles_alias_trailing_slash(monkeypatch: pytest.MonkeyPapage=3,page_size=5,search_key=None,+ managed=None,)@@ -139,6 +142,7 @@ def test_list_browser_profiles_search_key_hit_on_name(monkeypatch: pytest.Monkeypage=1,page_size=10,search_key="production",+ managed=None,)@@ -157,6 +161,7 @@ def test_list_browser_profiles_search_key_hit_on_description(monkeypatch: pytestpage=1,page_size=10,search_key="staging_login",+ managed=None,)@@ -174,6 +179,7 @@ def test_list_browser_profiles_search_key_miss(monkeypatch: pytest.MonkeyPatch)page=1,page_size=10,search_key="no_such_profile",+ managed=None,)@@ -190,6 +196,7 @@ def test_list_browser_profiles_search_key_with_pagination(monkeypatch: pytest.Mopage=2,page_size=5,search_key="prod",+ managed=None,)@@ -206,4 +213,5 @@ def test_list_browser_profiles_search_key_with_include_deleted(monkeypatch: pytepage=1,page_size=10,search_key="archived",+ managed=None,)diff --git a/tests/unit/forge/sdk/test_reset_browser_profile_route.py b/tests/unit/forge/sdk/test_reset_browser_profile_route.pyindex 1875a93a9..caf57fd03 100644--- a/tests/unit/forge/sdk/test_reset_browser_profile_route.py+++ b/tests/unit/forge/sdk/test_reset_browser_profile_route.py@@ -3,7 +3,7 @@from __future__ import annotationsfrom types import SimpleNamespace-from unittest.mock import AsyncMock+from unittest.mock import AsyncMock, callimport pytestfrom fastapi import FastAPI, Request@@ -16,14 +16,26 @@ from skyvern.forge.sdk.routes import routers as routers_modulefrom skyvern.forge.sdk.services import org_auth_service-def _build_client(monkeypatch: pytest.MonkeyPatch) -> tuple[TestClient, AsyncMock, AsyncMock]:+def _build_client(monkeypatch: pytest.MonkeyPatch) -> tuple[TestClient, SimpleNamespace]:async def _fake_org() -> SimpleNamespace:return SimpleNamespace(organization_id="org_oss")- get_workflow = AsyncMock()- delete_browser_session = AsyncMock()- monkeypatch.setattr(forge_app.WORKFLOW_SERVICE, "get_workflow_by_permanent_id", get_workflow)- monkeypatch.setattr(forge_app.STORAGE, "delete_browser_session", delete_browser_session)+ mocks = SimpleNamespace(+ get_workflow=AsyncMock(),+ delete_browser_session=AsyncMock(),+ list_managed_profiles=AsyncMock(return_value=[]),+ delete_profile_blob=AsyncMock(),+ delete_db_profile=AsyncMock(),+ )+ monkeypatch.setattr(forge_app.WORKFLOW_SERVICE, "get_workflow_by_permanent_id", mocks.get_workflow)+ monkeypatch.setattr(forge_app.STORAGE, "delete_browser_session", mocks.delete_browser_session)+ monkeypatch.setattr(forge_app.STORAGE, "delete_browser_profile", mocks.delete_profile_blob)+ monkeypatch.setattr(+ forge_app.DATABASE.browser_sessions,+ "list_managed_browser_profiles_for_workflow",+ mocks.list_managed_profiles,+ )+ monkeypatch.setattr(forge_app.DATABASE.browser_sessions, "delete_browser_profile", mocks.delete_db_profile)fastapi_app = FastAPI()fastapi_app.dependency_overrides[org_auth_service.get_current_org] = _fake_org@@ -33,37 +45,40 @@ def _build_client(monkeypatch: pytest.MonkeyPatch) -> tuple[TestClient, AsyncMocasync def _handle_skyvern_http_exception(request: Request, exc: SkyvernHTTPException) -> JSONResponse:return JSONResponse(status_code=exc.status_code, content={"detail": exc.message})- return TestClient(fastapi_app), get_workflow, delete_browser_session+ return TestClient(fastapi_app), mocksdef test_reset_browser_profile_clears_storage(monkeypatch: pytest.MonkeyPatch) -> None:- client, get_workflow, delete_browser_session = _build_client(monkeypatch)- get_workflow.return_value = SimpleNamespace(workflow_permanent_id="wpid_123")+ client, mocks = _build_client(monkeypatch)+ mocks.get_workflow.return_value = SimpleNamespace(workflow_permanent_id="wpid_123")response = client.post("/v1/workflows/wpid_123/browser_session/reset_profile")assert response.status_code == 204- get_workflow.assert_awaited_once_with(workflow_permanent_id="wpid_123", organization_id="org_oss")- delete_browser_session.assert_awaited_once_with(+ mocks.get_workflow.assert_awaited_once_with(workflow_permanent_id="wpid_123", organization_id="org_oss")+ mocks.delete_browser_session.assert_awaited_once_with(organization_id="org_oss",workflow_permanent_id="wpid_123",)+ mocks.delete_profile_blob.assert_not_awaited()+ mocks.delete_db_profile.assert_not_awaited()def test_reset_browser_profile_workflow_not_found(monkeypatch: pytest.MonkeyPatch) -> None:- client, get_workflow, delete_browser_session = _build_client(monkeypatch)- get_workflow.side_effect = WorkflowNotFound(workflow_permanent_id="wpid_missing")+ client, mocks = _build_client(monkeypatch)+ mocks.get_workflow.side_effect = WorkflowNotFound(workflow_permanent_id="wpid_missing")response = client.post("/v1/workflows/wpid_missing/browser_session/reset_profile")assert response.status_code == 404- delete_browser_session.assert_not_awaited()+ mocks.delete_browser_session.assert_not_awaited()+ mocks.list_managed_profiles.assert_not_awaited()def test_reset_browser_profile_storage_failure_returns_500(monkeypatch: pytest.MonkeyPatch) -> None:- client, get_workflow, delete_browser_session = _build_client(monkeypatch)- get_workflow.return_value = SimpleNamespace(workflow_permanent_id="wpid_123")- delete_browser_session.side_effect = RuntimeError("s3 AccessDenied")+ client, mocks = _build_client(monkeypatch)+ mocks.get_workflow.return_value = SimpleNamespace(workflow_permanent_id="wpid_123")+ mocks.delete_browser_session.side_effect = RuntimeError("s3 AccessDenied")response = client.post("/v1/workflows/wpid_123/browser_session/reset_profile")@@ -71,6 +86,56 @@ def test_reset_browser_profile_storage_failure_returns_500(monkeypatch: pytest.Massert "retry" in response.json()["detail"].lower()+def test_reset_browser_profile_clears_managed_profile_blobs_and_rows(monkeypatch: pytest.MonkeyPatch) -> None:+ client, mocks = _build_client(monkeypatch)+ mocks.get_workflow.return_value = SimpleNamespace(workflow_permanent_id="wpid_123")+ mocks.list_managed_profiles.return_value = [+ SimpleNamespace(browser_profile_id="bp_one", browser_profile_key_digest="", deleted_at=None),+ SimpleNamespace(browser_profile_id="bp_two", browser_profile_key_digest="", deleted_at=None),+ ]++ response = client.post("/v1/workflows/wpid_123/browser_session/reset_profile")++ assert response.status_code == 204+ mocks.list_managed_profiles.assert_awaited_once_with(+ organization_id="org_oss",+ workflow_permanent_id="wpid_123",+ include_deleted=True,+ )+ assert mocks.delete_profile_blob.await_args_list == [+ call(organization_id="org_oss", profile_id="bp_one"),+ call(organization_id="org_oss", profile_id="bp_two"),+ ]+ assert mocks.delete_db_profile.await_args_list == [+ call(profile_id="bp_one", organization_id="org_oss"),+ call(profile_id="bp_two", organization_id="org_oss"),+ ]+++def test_reset_browser_profile_clears_segmented_legacy_archives(monkeypatch: pytest.MonkeyPatch) -> None:+ client, mocks = _build_client(monkeypatch)+ mocks.get_workflow.return_value = SimpleNamespace(workflow_permanent_id="wpid_123")+ mocks.list_managed_profiles.return_value = [+ SimpleNamespace(browser_profile_id="bp_seg", browser_profile_key_digest="abc123digest", deleted_at=None),+ # Soft-deleted row: its blob/row are already gone, but its segment archive must still be cleared.+ SimpleNamespace(+ browser_profile_id="bp_gone", browser_profile_key_digest="def456digest", deleted_at="2026-01-01"+ ),+ ]++ response = client.post("/v1/workflows/wpid_123/browser_session/reset_profile")++ assert response.status_code == 204+ session_deletes = {c.kwargs["workflow_permanent_id"] for c in mocks.delete_browser_session.await_args_list}+ assert session_deletes == {+ "wpid_123",+ "wpid_123/profile_segments/abc123digest",+ "wpid_123/profile_segments/def456digest",+ }+ mocks.delete_profile_blob.assert_awaited_once_with(organization_id="org_oss", profile_id="bp_seg")+ mocks.delete_db_profile.assert_awaited_once_with(profile_id="bp_seg", organization_id="org_oss")++@pytest.mark.parametrize("path",[@@ -80,13 +145,13 @@ def test_reset_browser_profile_storage_failure_returns_500(monkeypatch: pytest.M],)def test_alias_paths_still_work(monkeypatch: pytest.MonkeyPatch, path: str) -> None:- client, get_workflow, delete_browser_session = _build_client(monkeypatch)- get_workflow.return_value = SimpleNamespace(workflow_permanent_id="wpid_123")+ client, mocks = _build_client(monkeypatch)+ mocks.get_workflow.return_value = SimpleNamespace(workflow_permanent_id="wpid_123")response = client.post(path)assert response.status_code == 204- delete_browser_session.assert_awaited_once_with(+ mocks.delete_browser_session.assert_awaited_once_with(organization_id="org_oss",workflow_permanent_id="wpid_123",)diff --git a/tests/unit/test_browser_profile_key.py b/tests/unit/test_browser_profile_key.pyindex fe988a2a2..1fcbef366 100644--- a/tests/unit/test_browser_profile_key.py+++ b/tests/unit/test_browser_profile_key.py@@ -6,6 +6,7 @@ import pytestfrom jinja2 import TemplateSyntaxErrorfrom skyvern.forge.sdk.workflow.browser_profile_key import (+ build_browser_profile_key_digest,build_workflow_browser_session_storage_key,render_browser_profile_key,validate_browser_profile_key,@@ -40,7 +41,9 @@ def test_validate_browser_profile_key_rejects_invalid_jinja() -> None:def test_segmented_storage_key_uses_stable_hashed_suffix() -> None:digest = sha256(b"cred_123").hexdigest()[:24]assert build_workflow_browser_session_storage_key("wpid_test", "cred_123") == f"wpid_test/profile_segments/{digest}"+ assert build_browser_profile_key_digest("cred_123") == digestdef test_empty_storage_key_keeps_legacy_workflow_key() -> None:assert build_workflow_browser_session_storage_key("wpid_test", None) == "wpid_test"+ assert build_browser_profile_key_digest(None) == ""diff --git a/tests/unit/test_credential_test_trigger_type.py b/tests/unit/test_credential_test_trigger_type.pyindex 3126082c3..12d2ffc89 100644--- a/tests/unit/test_credential_test_trigger_type.py+++ b/tests/unit/test_credential_test_trigger_type.py@@ -46,9 +46,9 @@ def _patch_executor(monkeypatch: pytest.MonkeyPatch) -> None:def _patch_cloud_proxy_session_headers(monkeypatch: pytest.MonkeyPatch) -> None:agent_function = SimpleNamespace(- build_proxy_session_extra_http_headers=lambda proxy_session_id: {"dedicated-ip": proxy_session_id}- if proxy_session_id- else None+ build_proxy_session_extra_http_headers=lambda proxy_session_id: (+ {"dedicated-ip": proxy_session_id} if proxy_session_id else None+ ))monkeypatch.setattr(credentials.app, "AGENT_FUNCTION", agent_function)diff --git a/tests/unit/test_credential_update_params.py b/tests/unit/test_credential_update_params.pyindex 10894b439..9886648e6 100644--- a/tests/unit/test_credential_update_params.py+++ b/tests/unit/test_credential_update_params.py@@ -431,7 +431,7 @@ async def test_browser_profile_resave_updates_proxy_pin_after_storage_write(monkmonkeypatch.setattr(forge_app.DATABASE.workflow_runs,"get_workflow_run",- AsyncMock(return_value=SimpleNamespace(status=WorkflowRunStatus.completed)),+ AsyncMock(return_value=SimpleNamespace(status=WorkflowRunStatus.completed, browser_profile_id=None)),)monkeypatch.setattr(forge_app.STORAGE, "retrieve_browser_session", AsyncMock(return_value="/tmp/session"))monkeypatch.setattr(forge_app.STORAGE, "store_browser_profile", store_browser_profile)@@ -491,7 +491,7 @@ async def test_browser_profile_resave_leaves_existing_profile_pin_when_credentiamonkeypatch.setattr(forge_app.DATABASE.workflow_runs,"get_workflow_run",- AsyncMock(return_value=SimpleNamespace(status=WorkflowRunStatus.completed)),+ AsyncMock(return_value=SimpleNamespace(status=WorkflowRunStatus.completed, browser_profile_id=None)),)monkeypatch.setattr(forge_app.STORAGE, "retrieve_browser_session", AsyncMock(return_value="/tmp/session"))monkeypatch.setattr(forge_app.STORAGE, "store_browser_profile", store_browser_profile)@@ -546,7 +546,7 @@ async def test_browser_profile_resave_preserves_different_existing_profile_pin(monkeypatch.setattr(forge_app.DATABASE.workflow_runs,"get_workflow_run",- AsyncMock(return_value=SimpleNamespace(status=WorkflowRunStatus.completed)),+ AsyncMock(return_value=SimpleNamespace(status=WorkflowRunStatus.completed, browser_profile_id=None)),)monkeypatch.setattr(forge_app.STORAGE, "retrieve_browser_session", AsyncMock(return_value="/tmp/session"))monkeypatch.setattr(forge_app.STORAGE, "store_browser_profile", store_browser_profile)@@ -583,6 +583,131 @@ async def test_browser_profile_resave_preserves_different_existing_profile_pin(assert events == ["store", "touch_profile", "update_credential"]+async def test_credential_browser_profile_save_reads_managed_profile_blob(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ create_browser_profile = AsyncMock(return_value=SimpleNamespace(browser_profile_id="bp_created"))+ update_credential = AsyncMock(return_value=SimpleNamespace())+ store_browser_profile = AsyncMock()+ retrieve_profile = AsyncMock(return_value="/tmp/managed_profile")+ retrieve_session = AsyncMock()++ monkeypatch.setattr(+ forge_app.DATABASE.workflow_runs,+ "get_workflow_run",+ AsyncMock(+ return_value=SimpleNamespace(+ status=WorkflowRunStatus.completed,+ browser_profile_id="bp_managed",+ workflow_permanent_id="wpid_123",+ )+ ),+ )+ monkeypatch.setattr(+ forge_app.DATABASE.workflows,+ "get_workflow",+ AsyncMock(return_value=SimpleNamespace(workflow_permanent_id="wpid_123")),+ )+ monkeypatch.setattr(+ forge_app.DATABASE.browser_sessions,+ "get_browser_profile",+ AsyncMock(return_value=SimpleNamespace(is_managed=True, workflow_permanent_id="wpid_123")),+ )+ monkeypatch.setattr(forge_app.STORAGE, "retrieve_browser_profile", retrieve_profile)+ monkeypatch.setattr(forge_app.STORAGE, "retrieve_browser_session", retrieve_session)+ monkeypatch.setattr(forge_app.STORAGE, "store_browser_profile", store_browser_profile)+ monkeypatch.setattr(+ forge_app.DATABASE.credentials,+ "get_credential",+ AsyncMock(return_value=SimpleNamespace(proxy_location=None, proxy_session_id=None)),+ )+ monkeypatch.setattr(forge_app.DATABASE.credentials, "update_credential", update_credential)+ monkeypatch.setattr(forge_app.DATABASE.browser_sessions, "create_browser_profile", create_browser_profile)++ await credentials_routes._create_browser_profile_after_workflow(+ credential_id="cred_123",+ workflow_run_id="wr_123",+ workflow_id="wf_123",+ workflow_permanent_id="wpid_123",+ organization_id="org_123",+ credential_name="test",+ test_url="https://example.com/login",+ )++ retrieve_profile.assert_awaited_once_with(organization_id="org_123", profile_id="bp_managed")+ retrieve_session.assert_not_awaited()+ store_browser_profile.assert_awaited_once_with(+ organization_id="org_123",+ profile_id="bp_created",+ directory="/tmp/managed_profile",+ )+ update_credential.assert_awaited_once()+++async def test_credential_browser_profile_save_falls_back_to_legacy_archive_for_managed_run(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ create_browser_profile = AsyncMock(return_value=SimpleNamespace(browser_profile_id="bp_created"))+ update_credential = AsyncMock(return_value=SimpleNamespace())+ store_browser_profile = AsyncMock()+ retrieve_profile = AsyncMock(return_value=None)+ retrieve_session = AsyncMock(return_value="/tmp/legacy_session")+ get_storage_key = AsyncMock(return_value="wpid_123")++ monkeypatch.setattr(+ forge_app.DATABASE.workflow_runs,+ "get_workflow_run",+ AsyncMock(+ return_value=SimpleNamespace(+ status=WorkflowRunStatus.completed,+ browser_profile_id="bp_managed",+ workflow_permanent_id="wpid_123",+ )+ ),+ )+ monkeypatch.setattr(+ forge_app.DATABASE.workflows,+ "get_workflow",+ AsyncMock(return_value=SimpleNamespace(workflow_permanent_id="wpid_123")),+ )+ monkeypatch.setattr(+ forge_app.DATABASE.browser_sessions,+ "get_browser_profile",+ AsyncMock(return_value=SimpleNamespace(is_managed=True, workflow_permanent_id="wpid_123")),+ )+ monkeypatch.setattr(forge_app.WORKFLOW_SERVICE, "get_workflow_browser_session_storage_key", get_storage_key)+ monkeypatch.setattr(forge_app.STORAGE, "retrieve_browser_profile", retrieve_profile)+ monkeypatch.setattr(forge_app.STORAGE, "retrieve_browser_session", retrieve_session)+ monkeypatch.setattr(forge_app.STORAGE, "store_browser_profile", store_browser_profile)+ monkeypatch.setattr(+ forge_app.DATABASE.credentials,+ "get_credential",+ AsyncMock(return_value=SimpleNamespace(proxy_location=None, proxy_session_id=None)),+ )+ monkeypatch.setattr(forge_app.DATABASE.credentials, "update_credential", update_credential)+ monkeypatch.setattr(forge_app.DATABASE.browser_sessions, "create_browser_profile", create_browser_profile)++ await credentials_routes._create_browser_profile_after_workflow(+ credential_id="cred_123",+ workflow_run_id="wr_123",+ workflow_id="wf_123",+ workflow_permanent_id="wpid_123",+ organization_id="org_123",+ credential_name="test",+ test_url="https://example.com/login",+ )++ retrieve_profile.assert_awaited_once_with(organization_id="org_123", profile_id="bp_managed")+ retrieve_session.assert_awaited_once_with(organization_id="org_123", workflow_permanent_id="wpid_123")+ store_browser_profile.assert_awaited_once_with(+ organization_id="org_123",+ profile_id="bp_created",+ directory="/tmp/legacy_session",+ )++def test_credential_route_treats_null_advanced_key_as_no_explicit_identity() -> None:update_kwargs: dict[str, object] = {}diff --git a/tests/unit/test_workflow_browser_profile_id.py b/tests/unit/test_workflow_browser_profile_id.pyindex 1cbff4935..df2fdad8d 100644--- a/tests/unit/test_workflow_browser_profile_id.py+++ b/tests/unit/test_workflow_browser_profile_id.py@@ -233,6 +233,7 @@ def _make_workflow_stub(extra_http_headers=None,cdp_connect_headers=None,browser_profile_id=browser_profile_id,+ persist_browser_session=False,max_elapsed_time_minutes=max_elapsed_time_minutes,run_with="agent",code_version=None,diff --git a/tests/unit/test_workflow_elapsed_timeout.py b/tests/unit/test_workflow_elapsed_timeout.pyindex ab3018a95..775503f40 100644--- a/tests/unit/test_workflow_elapsed_timeout.py+++ b/tests/unit/test_workflow_elapsed_timeout.py@@ -228,6 +228,7 @@ async def test_execute_workflow_returns_after_elapsed_timeout_without_finally(momonkeypatch.setattr(svc, "get_workflow_output_parameters", AsyncMock(return_value=[]))monkeypatch.setattr(svc, "_collect_inherited_workflow_system_prompt", AsyncMock(return_value=None))monkeypatch.setattr(svc, "auto_create_browser_session_if_needed", AsyncMock(return_value=None))+ monkeypatch.setattr(svc, "_browser_profile_is_managed", AsyncMock(return_value=False))monkeypatch.setattr(svc, "mark_workflow_run_as_timed_out", mark_workflow_run_as_timed_out)monkeypatch.setattr(svc, "_execute_workflow_blocks", execute_workflow_blocks)monkeypatch.setattr(svc, "generate_script_if_needed", generate_script_if_needed)@@ -306,6 +307,7 @@ async def test_execute_workflow_times_out_slow_pre_block_script_lookup(monkeypatmonkeypatch.setattr(svc, "get_workflow_output_parameters", AsyncMock(return_value=[]))monkeypatch.setattr(svc, "_collect_inherited_workflow_system_prompt", AsyncMock(return_value=None))monkeypatch.setattr(svc, "auto_create_browser_session_if_needed", AsyncMock(return_value=None))+ monkeypatch.setattr(svc, "_browser_profile_is_managed", AsyncMock(return_value=False))monkeypatch.setattr(svc, "mark_workflow_run_as_timed_out", mark_workflow_run_as_timed_out)monkeypatch.setattr(svc, "_execute_workflow_blocks", execute_workflow_blocks)monkeypatch.setattr(svc, "clean_up_workflow", clean_up_workflow)@@ -390,6 +392,7 @@ async def test_execute_workflow_preserves_completed_status_after_post_run_timeoumonkeypatch.setattr(svc, "get_workflow_output_parameters", AsyncMock(return_value=[]))monkeypatch.setattr(svc, "_collect_inherited_workflow_system_prompt", AsyncMock(return_value=None))monkeypatch.setattr(svc, "auto_create_browser_session_if_needed", AsyncMock(return_value=None))+ monkeypatch.setattr(svc, "_browser_profile_is_managed", AsyncMock(return_value=False))monkeypatch.setattr(svc, "mark_workflow_run_as_timed_out", mark_workflow_run_as_timed_out)monkeypatch.setattr(svc, "_execute_workflow_blocks", AsyncMock(return_value=(completed_run, set())))monkeypatch.setattr(svc, "generate_script_if_needed", AsyncMock(return_value=running_run))@@ -479,6 +482,7 @@ async def test_execute_workflow_preserves_timed_out_status_after_non_terminal_pomonkeypatch.setattr(svc, "get_workflow_output_parameters", AsyncMock(return_value=[]))monkeypatch.setattr(svc, "_collect_inherited_workflow_system_prompt", AsyncMock(return_value=None))monkeypatch.setattr(svc, "auto_create_browser_session_if_needed", AsyncMock(return_value=None))+ monkeypatch.setattr(svc, "_browser_profile_is_managed", AsyncMock(return_value=False))monkeypatch.setattr(svc, "mark_workflow_run_as_timed_out", mark_workflow_run_as_timed_out)monkeypatch.setattr(svc, "_execute_workflow_blocks", AsyncMock(return_value=(running_run, set())))monkeypatch.setattr(svc, "generate_script_if_needed", AsyncMock(return_value=running_run))@@ -572,6 +576,7 @@ async def test_execute_workflow_marks_timed_out_when_post_run_budget_is_exhaustemonkeypatch.setattr(svc, "get_workflow_output_parameters", AsyncMock(return_value=[]))monkeypatch.setattr(svc, "_collect_inherited_workflow_system_prompt", AsyncMock(return_value=None))monkeypatch.setattr(svc, "auto_create_browser_session_if_needed", AsyncMock(return_value=None))+ monkeypatch.setattr(svc, "_browser_profile_is_managed", AsyncMock(return_value=False))monkeypatch.setattr(svc, "mark_workflow_run_as_timed_out", mark_workflow_run_as_timed_out)monkeypatch.setattr(svc, "_execute_workflow_blocks", AsyncMock(return_value=(running_run, set())))monkeypatch.setattr(svc, "generate_script_if_needed", generate_script_if_needed)@@ -747,6 +752,7 @@ async def test_execute_workflow_refreshes_terminal_status_after_immediate_post_rmonkeypatch.setattr(svc, "get_workflow_output_parameters", AsyncMock(return_value=[]))monkeypatch.setattr(svc, "_collect_inherited_workflow_system_prompt", AsyncMock(return_value=None))monkeypatch.setattr(svc, "auto_create_browser_session_if_needed", AsyncMock(return_value=None))+ monkeypatch.setattr(svc, "_browser_profile_is_managed", AsyncMock(return_value=False))monkeypatch.setattr(svc, "mark_workflow_run_as_timed_out", mark_workflow_run_as_timed_out)monkeypatch.setattr(svc, "_execute_workflow_blocks", AsyncMock(return_value=(completed_run, set())))monkeypatch.setattr(svc, "generate_script_if_needed", AsyncMock())@@ -836,6 +842,7 @@ async def test_execute_workflow_returns_finalized_status_after_post_run_timeout(monkeypatch.setattr(svc, "get_workflow_output_parameters", AsyncMock(return_value=[]))monkeypatch.setattr(svc, "_collect_inherited_workflow_system_prompt", AsyncMock(return_value=None))monkeypatch.setattr(svc, "auto_create_browser_session_if_needed", AsyncMock(return_value=None))+ monkeypatch.setattr(svc, "_browser_profile_is_managed", AsyncMock(return_value=False))monkeypatch.setattr(svc, "mark_workflow_run_as_timed_out", mark_workflow_run_as_timed_out)monkeypatch.setattr(svc, "_execute_workflow_blocks", AsyncMock(return_value=(failed_run, set())))monkeypatch.setattr(svc, "generate_script_if_needed", AsyncMock())@@ -923,6 +930,7 @@ async def test_execute_workflow_runs_finally_for_existing_timed_out_status(monkeypatch.setattr(svc, "get_workflow_output_parameters", AsyncMock(return_value=[]))monkeypatch.setattr(svc, "_collect_inherited_workflow_system_prompt", AsyncMock(return_value=None))monkeypatch.setattr(svc, "auto_create_browser_session_if_needed", AsyncMock(return_value=None))+ monkeypatch.setattr(svc, "_browser_profile_is_managed", AsyncMock(return_value=False))monkeypatch.setattr(svc, "mark_workflow_run_as_timed_out", mark_workflow_run_as_timed_out)monkeypatch.setattr(svc, "_execute_workflow_blocks", AsyncMock(return_value=(timed_out_run, set())))monkeypatch.setattr(svc, "generate_script_if_needed", AsyncMock())diff --git a/tests/unit/test_workflow_run_parameter_batching.py b/tests/unit/test_workflow_run_parameter_batching.pyindex b2ca3ca35..501963c60 100644--- a/tests/unit/test_workflow_run_parameter_batching.py+++ b/tests/unit/test_workflow_run_parameter_batching.py@@ -47,6 +47,7 @@ def _make_service_with_mocks(workflow_parameters: list[WorkflowParameter],batch_side_effect: Exception | None = None,single_side_effect: Exception | None = None,+ persist_browser_session: bool = False,) -> tuple[WorkflowService, SimpleNamespace, SimpleNamespace]:"""Helper to build a WorkflowService with mocked internals for setup_workflow_run tests."""service = WorkflowService()@@ -59,6 +60,9 @@ def _make_service_with_mocks(extra_http_headers=None,cdp_connect_headers=None,browser_profile_id=None,+ persist_browser_session=persist_browser_session,+ browser_profile_key=None,+ title="Workflow",max_elapsed_time_minutes=None,run_with="agent",code_version=None,@@ -192,6 +196,41 @@ async def test_setup_workflow_run_raises_on_non_string_credential_id() -> None:service.create_workflow_run_parameters.assert_not_awaited()+async def test_setup_workflow_run_validates_credentials_before_preparing_managed_profile() -> None:+ cred_param = _make_workflow_parameter(+ "credential",+ workflow_parameter_type=WorkflowParameterType.CREDENTIAL_ID,+ )+ service, organization, _ = _make_service_with_mocks(+ workflow_parameters=[cred_param],+ persist_browser_session=True,+ )+ service._validate_credential_ids = AsyncMock( # type: ignore[method-assign]+ side_effect=InvalidCredentialId("Credential not found")+ )+ service._prepare_persisted_workflow_browser_profile = AsyncMock() # type: ignore[method-assign]++ request = WorkflowRequestBody(data={"credential": "cred_missing"})++ with patch("skyvern.forge.sdk.workflow.service.app") as mock_app:+ mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)+ mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)++ with pytest.raises(InvalidCredentialId):+ await service.setup_workflow_run(+ request_id="req_test",+ workflow_request=request,+ workflow_permanent_id="wpid_test",+ organization=organization,+ )++ service._validate_credential_ids.assert_awaited_once_with(["cred_missing"], organization)+ service._prepare_persisted_workflow_browser_profile.assert_not_awaited()+ service.create_workflow_run_parameters.assert_not_awaited()+ service.mark_workflow_run_as_failed.assert_awaited_once()++@pytest.mark.asyncioasync def test_setup_workflow_run_batches_credential_validation() -> None:"""N credential parameters should issue a single get_credentials_by_ids call, not N get_credential calls."""diff --git a/tests/unit/test_workflow_service_managed_browser_profile.py b/tests/unit/test_workflow_service_managed_browser_profile.pynew file mode 100644index 000000000..a425c54b0--- /dev/null+++ b/tests/unit/test_workflow_service_managed_browser_profile.py@@ -0,0 +1,253 @@+from __future__ import annotations++from types import SimpleNamespace+from unittest.mock import AsyncMock++import pytest++from skyvern.forge import app+from skyvern.forge.sdk.workflow.browser_profile_key import (+ build_browser_profile_key_digest,+ build_workflow_browser_session_storage_key,+)+from skyvern.forge.sdk.workflow.models.block import BlockType+from skyvern.forge.sdk.workflow.service import WorkflowService+++def _workflow(browser_profile_key: str | None = None) -> SimpleNamespace:+ return SimpleNamespace(+ persist_browser_session=True,+ browser_profile_key=browser_profile_key,+ workflow_permanent_id="wpid_test",+ title="Workflow",+ )+++def _workflow_run(browser_profile_id: str | None = None) -> SimpleNamespace:+ return SimpleNamespace(+ workflow_run_id="wr_test",+ organization_id="o_test",+ browser_profile_id=browser_profile_id,+ )+++def _mock_storage(monkeypatch: pytest.MonkeyPatch, *, legacy_dir: str | None) -> AsyncMock:+ monkeypatch.setattr(app.STORAGE, "retrieve_browser_session", AsyncMock(return_value=legacy_dir))+ store = AsyncMock()+ monkeypatch.setattr(app.STORAGE, "store_browser_profile", store)+ return store+++async def test_prepare_persisted_workflow_browser_profile_stamps_managed_profile(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ profile = SimpleNamespace(browser_profile_id="bp_managed")+ updated_run = _workflow_run(browser_profile_id="bp_managed")+ get_or_create = AsyncMock(return_value=(profile, True))+ update_run = AsyncMock(return_value=updated_run)+ monkeypatch.setattr(app.DATABASE.browser_sessions, "get_or_create_managed_browser_profile", get_or_create)+ monkeypatch.setattr(app.DATABASE.workflow_runs, "update_workflow_run", update_run)+ _mock_storage(monkeypatch, legacy_dir=None)++ result = await WorkflowService()._prepare_persisted_workflow_browser_profile(+ workflow=_workflow(browser_profile_key="{{ credential_id }}"),+ workflow_run=_workflow_run(),+ parameter_values={"credential_id": "cred_123"},+ )++ assert result is updated_run+ get_or_create.assert_awaited_once_with(+ organization_id="o_test",+ workflow_permanent_id="wpid_test",+ browser_profile_key_digest=build_browser_profile_key_digest("cred_123"),+ name="Workflow (auto-saved: cred_123)",+ )+ update_run.assert_awaited_once_with(workflow_run_id="wr_test", browser_profile_id="bp_managed")+++async def test_prepare_persisted_workflow_browser_profile_uses_empty_digest_for_unkeyed_workflow(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ profile = SimpleNamespace(browser_profile_id="bp_managed")+ updated_run = _workflow_run(browser_profile_id="bp_managed")+ get_or_create = AsyncMock(return_value=(profile, True))+ monkeypatch.setattr(app.DATABASE.browser_sessions, "get_or_create_managed_browser_profile", get_or_create)+ monkeypatch.setattr(app.DATABASE.workflow_runs, "update_workflow_run", AsyncMock(return_value=updated_run))+ _mock_storage(monkeypatch, legacy_dir=None)++ await WorkflowService()._prepare_persisted_workflow_browser_profile(+ workflow=_workflow(),+ workflow_run=_workflow_run(),+ parameter_values={},+ )++ get_or_create.assert_awaited_once_with(+ organization_id="o_test",+ workflow_permanent_id="wpid_test",+ browser_profile_key_digest="",+ name="Workflow (auto-saved session)",+ )+++async def test_prepare_persisted_workflow_browser_profile_keeps_explicit_profile(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ get_or_create = AsyncMock()+ update_run = AsyncMock()+ monkeypatch.setattr(app.DATABASE.browser_sessions, "get_or_create_managed_browser_profile", get_or_create)+ monkeypatch.setattr(app.DATABASE.workflow_runs, "update_workflow_run", update_run)+ workflow_run = _workflow_run(browser_profile_id="bp_user")++ result = await WorkflowService()._prepare_persisted_workflow_browser_profile(+ workflow=_workflow(browser_profile_key="{{ credential_id }}"),+ workflow_run=workflow_run,+ parameter_values={"credential_id": "cred_123"},+ )++ assert result is workflow_run+ get_or_create.assert_not_awaited()+ update_run.assert_not_awaited()+++async def test_prepare_persisted_workflow_browser_profile_seeds_new_profile_from_legacy_archive(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ profile = SimpleNamespace(browser_profile_id="bp_managed")+ get_or_create = AsyncMock(return_value=(profile, True))+ monkeypatch.setattr(app.DATABASE.browser_sessions, "get_or_create_managed_browser_profile", get_or_create)+ monkeypatch.setattr(+ app.DATABASE.workflow_runs, "update_workflow_run", AsyncMock(return_value=_workflow_run("bp_managed"))+ )+ store = _mock_storage(monkeypatch, legacy_dir="/tmp/legacy_session")++ await WorkflowService()._prepare_persisted_workflow_browser_profile(+ workflow=_workflow(),+ workflow_run=_workflow_run(),+ parameter_values={},+ )++ store.assert_awaited_once_with(+ "o_test",+ profile_id="bp_managed",+ directory="/tmp/legacy_session",+ )+++async def test_prepare_persisted_workflow_browser_profile_rolls_back_on_seed_failure(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ profile = SimpleNamespace(browser_profile_id="bp_managed")+ monkeypatch.setattr(+ app.DATABASE.browser_sessions,+ "get_or_create_managed_browser_profile",+ AsyncMock(return_value=(profile, True)),+ )+ hard_delete = AsyncMock()+ monkeypatch.setattr(app.DATABASE.browser_sessions, "hard_delete_browser_profile", hard_delete)+ update_run = AsyncMock()+ monkeypatch.setattr(app.DATABASE.workflow_runs, "update_workflow_run", update_run)+ monkeypatch.setattr(app.STORAGE, "retrieve_browser_session", AsyncMock(return_value="/tmp/legacy_session"))+ monkeypatch.setattr(app.STORAGE, "store_browser_profile", AsyncMock(side_effect=RuntimeError("upload failed")))+ workflow_run = _workflow_run()++ result = await WorkflowService()._prepare_persisted_workflow_browser_profile(+ workflow=_workflow(),+ workflow_run=workflow_run,+ parameter_values={},+ )++ assert result is workflow_run+ hard_delete.assert_awaited_once_with(profile_id="bp_managed", organization_id="o_test")+ update_run.assert_not_awaited()+++async def test_prepare_persisted_workflow_browser_profile_does_not_seed_existing_profile(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ profile = SimpleNamespace(browser_profile_id="bp_managed")+ get_or_create = AsyncMock(return_value=(profile, False))+ monkeypatch.setattr(app.DATABASE.browser_sessions, "get_or_create_managed_browser_profile", get_or_create)+ monkeypatch.setattr(+ app.DATABASE.workflow_runs, "update_workflow_run", AsyncMock(return_value=_workflow_run("bp_managed"))+ )+ retrieve = AsyncMock(return_value="/tmp/legacy_session")+ monkeypatch.setattr(app.STORAGE, "retrieve_browser_session", retrieve)+ store = AsyncMock()+ monkeypatch.setattr(app.STORAGE, "store_browser_profile", store)++ await WorkflowService()._prepare_persisted_workflow_browser_profile(+ workflow=_workflow(),+ workflow_run=_workflow_run(),+ parameter_values={},+ )++ retrieve.assert_not_awaited()+ store.assert_not_awaited()+++def test_legacy_storage_key_matches_managed_digest_for_keyed_workflow() -> None:+ # Read-compat invariant: the managed profile digest and the legacy archive segment must+ # derive from the same rendered key, so seeding finds the right archive.+ rendered = "cred_123"+ storage_key = build_workflow_browser_session_storage_key("wpid_test", rendered)+ assert storage_key.endswith(build_browser_profile_key_digest(rendered))+++async def test_auto_create_browser_session_for_human_interaction_loads_managed_profile(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ create_session = AsyncMock(return_value=SimpleNamespace(persistent_browser_session_id="pbs_test"))+ monkeypatch.setattr(app.PERSISTENT_SESSIONS_MANAGER, "create_session", create_session)+ workflow = SimpleNamespace(+ workflow_definition=SimpleNamespace(+ blocks=[SimpleNamespace(block_type=BlockType.HUMAN_INTERACTION, timeout_seconds=60)]+ )+ )++ browser_session = await WorkflowService().auto_create_browser_session_if_needed(+ "o_test",+ workflow,+ browser_profile_id="bp_managed",+ )++ assert browser_session.persistent_browser_session_id == "pbs_test"+ create_session.assert_awaited_once_with(+ organization_id="o_test",+ timeout_minutes=61,+ browser_profile_id="bp_managed",+ proxy_location=None,+ )+++async def test_browser_profile_is_managed_distinguishes_user_profiles(monkeypatch: pytest.MonkeyPatch) -> None:+ get_browser_profile = AsyncMock(return_value=SimpleNamespace(is_managed=False))+ monkeypatch.setattr(app.DATABASE.browser_sessions, "get_browser_profile", get_browser_profile)++ is_managed = await WorkflowService()._browser_profile_is_managed(+ organization_id="o_test",+ browser_profile_id="bp_user",+ )++ assert is_managed is False+ get_browser_profile.assert_awaited_once_with(profile_id="bp_user", organization_id="o_test")+++async def test_browser_profile_is_managed_detects_managed_profile(monkeypatch: pytest.MonkeyPatch) -> None:+ get_browser_profile = AsyncMock(return_value=SimpleNamespace(is_managed=True))+ monkeypatch.setattr(app.DATABASE.browser_sessions, "get_browser_profile", get_browser_profile)++ is_managed = await WorkflowService()._browser_profile_is_managed(+ organization_id="o_test",+ browser_profile_id="bp_managed",+ )++ assert is_managed is Truediff --git a/tests/unit/test_workflow_service_profile_writeback.py b/tests/unit/test_workflow_service_profile_writeback.pyindex b9e84937d..a5b7821b7 100644--- a/tests/unit/test_workflow_service_profile_writeback.py+++ b/tests/unit/test_workflow_service_profile_writeback.py@@ -25,12 +25,12 @@ def _make_workflow(persist: bool = True) -> MagicMock:return wf-def _make_workflow_run(status: WorkflowRunStatus) -> MagicMock:+def _make_workflow_run(status: WorkflowRunStatus, browser_profile_id: str | None = None) -> MagicMock:wr = MagicMock()wr.workflow_run_id = "wr_test"wr.organization_id = "o_test"wr.status = status- wr.browser_profile_id = None+ wr.browser_profile_id = browser_profile_idwr.browser_address = Nonewr.webhook_callback_url = Nonewr.created_at = None@@ -48,6 +48,7 @@ def _patch_clean_up_deps(monkeypatch: pytest.MonkeyPatch, browser_state: MagicMo"""Patch all external dependencies of clean_up_workflow. Returns the store mock."""store_mock = AsyncMock()monkeypatch.setattr(app.STORAGE, "store_browser_session", store_mock)+ monkeypatch.setattr(app.STORAGE, "store_browser_profile", AsyncMock())monkeypatch.setattr(app.STORAGE, "save_downloaded_files", AsyncMock())monkeypatch.setattr(app.BROWSER_MANAGER, "cleanup_for_workflow_run", AsyncMock(return_value=browser_state))monkeypatch.setattr(app.ARTIFACT_MANAGER, "wait_for_upload_aiotasks", AsyncMock())@@ -60,8 +61,9 @@ def _patch_clean_up_deps(monkeypatch: pytest.MonkeyPatch, browser_state: MagicMo@pytest.mark.asyncio-async def test_profile_persisted_on_completed_run(monkeypatch: pytest.MonkeyPatch) -> None:- """Completed runs should write the browser profile back to S3."""+async def test_legacy_session_persisted_on_completed_run_without_managed_profile(+ monkeypatch: pytest.MonkeyPatch,+) -> None:from skyvern.forge.sdk.workflow.service import WorkflowServiceworkflow = _make_workflow(persist=True)@@ -76,6 +78,117 @@ async def test_profile_persisted_on_completed_run(monkeypatch: pytest.MonkeyPatcawait svc.clean_up_workflow(workflow=workflow, workflow_run=workflow_run, need_call_webhook=False)store_mock.assert_awaited_once_with("o_test", "wpid_test", "/tmp/fake_profile")+ app.STORAGE.store_browser_profile.assert_not_awaited()+++async def test_managed_profile_persisted_on_completed_run(monkeypatch: pytest.MonkeyPatch) -> None:+ from skyvern.forge.sdk.workflow.service import WorkflowService++ workflow = _make_workflow(persist=True)+ workflow_run = _make_workflow_run(WorkflowRunStatus.completed, browser_profile_id="bp_managed")+ browser_state = _make_browser_state()+ store_session_mock = _patch_clean_up_deps(monkeypatch, browser_state)+ monkeypatch.setattr(+ app.DATABASE.browser_sessions,+ "get_browser_profile",+ AsyncMock(+ return_value=SimpleNamespace(+ is_managed=True, browser_profile_id="bp_managed", workflow_permanent_id="wpid_test"+ )+ ),+ )++ svc = WorkflowService()+ monkeypatch.setattr(svc, "persist_video_data", AsyncMock())+ monkeypatch.setattr(svc, "get_tasks_by_workflow_run_id", AsyncMock(return_value=[]))++ await svc.clean_up_workflow(workflow=workflow, workflow_run=workflow_run, need_call_webhook=False)++ app.STORAGE.store_browser_profile.assert_awaited_once_with(+ "o_test",+ profile_id="bp_managed",+ directory="/tmp/fake_profile",+ )+ store_session_mock.assert_not_awaited()+++async def test_foreign_managed_profile_not_persisted_on_completed_run(monkeypatch: pytest.MonkeyPatch) -> None:+ """A managed profile owned by another workflow must not receive this run's write-back."""+ from skyvern.forge.sdk.workflow.service import WorkflowService++ workflow = _make_workflow(persist=True)+ workflow_run = _make_workflow_run(WorkflowRunStatus.completed, browser_profile_id="bp_foreign")+ browser_state = _make_browser_state()+ store_session_mock = _patch_clean_up_deps(monkeypatch, browser_state)+ monkeypatch.setattr(+ app.DATABASE.browser_sessions,+ "get_browser_profile",+ AsyncMock(+ return_value=SimpleNamespace(+ is_managed=True, browser_profile_id="bp_foreign", workflow_permanent_id="wpid_other"+ )+ ),+ )++ svc = WorkflowService()+ monkeypatch.setattr(svc, "persist_video_data", AsyncMock())+ monkeypatch.setattr(svc, "get_tasks_by_workflow_run_id", AsyncMock(return_value=[]))++ await svc.clean_up_workflow(workflow=workflow, workflow_run=workflow_run, need_call_webhook=False)++ app.STORAGE.store_browser_profile.assert_not_awaited()+ store_session_mock.assert_not_awaited()+++async def test_missing_managed_profile_falls_back_to_legacy_session(monkeypatch: pytest.MonkeyPatch) -> None:+ """A managed profile stamped at setup but deleted before finalization must recover, not drop state."""+ from skyvern.forge.sdk.workflow.service import WorkflowService++ workflow = _make_workflow(persist=True)+ workflow_run = _make_workflow_run(WorkflowRunStatus.completed, browser_profile_id="bp_gone")+ browser_state = _make_browser_state()+ store_mock = _patch_clean_up_deps(monkeypatch, browser_state)+ monkeypatch.setattr(+ app.DATABASE.browser_sessions,+ "get_browser_profile",+ AsyncMock(return_value=None),+ )++ svc = WorkflowService()+ monkeypatch.setattr(svc, "persist_video_data", AsyncMock())+ monkeypatch.setattr(svc, "get_tasks_by_workflow_run_id", AsyncMock(return_value=[]))++ await svc.clean_up_workflow(workflow=workflow, workflow_run=workflow_run, need_call_webhook=False)++ store_mock.assert_awaited_once_with("o_test", "wpid_test", "/tmp/fake_profile")+ app.STORAGE.store_browser_profile.assert_not_awaited()+++async def test_user_profile_not_persisted_on_completed_persist_run(monkeypatch: pytest.MonkeyPatch) -> None:+ from skyvern.forge.sdk.workflow.service import WorkflowService++ workflow = _make_workflow(persist=True)+ workflow_run = _make_workflow_run(WorkflowRunStatus.completed, browser_profile_id="bp_user")+ browser_state = _make_browser_state()+ store_session_mock = _patch_clean_up_deps(monkeypatch, browser_state)+ monkeypatch.setattr(+ app.DATABASE.browser_sessions,+ "get_browser_profile",+ AsyncMock(return_value=SimpleNamespace(is_managed=False)),+ )++ svc = WorkflowService()+ monkeypatch.setattr(svc, "persist_video_data", AsyncMock())+ monkeypatch.setattr(svc, "get_tasks_by_workflow_run_id", AsyncMock(return_value=[]))++ await svc.clean_up_workflow(workflow=workflow, workflow_run=workflow_run, need_call_webhook=False)++ app.STORAGE.store_browser_profile.assert_not_awaited()+ store_session_mock.assert_not_awaited()@pytest.mark.asyncio