Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
Re-arm the sequential-gate wait every 900s instead of 120s (#8069)
pedrohsdbb76a8f71173e
diff --git a/skyvern/forge/sdk/db/repositories/workflow_runs.py b/skyvern/forge/sdk/db/repositories/workflow_runs.pyindex 569a5da35..093cb75a1 100644--- a/skyvern/forge/sdk/db/repositories/workflow_runs.py+++ b/skyvern/forge/sdk/db/repositories/workflow_runs.py@@ -918,6 +918,83 @@ class WorkflowRunsRepository(BaseRepository):"""Alias satisfying the RunReader protocol."""return await self.get_workflow_run(run_id, organization_id=organization_id)+ @db_operation("get_queued_runs_sharing_sequential_lanes")+ async def get_queued_runs_sharing_sequential_lanes(+ self,+ workflow_run_id: str,+ limit: int = 2,+ ) -> list[WorkflowRun]:+ """Earliest queued runs a just-finished run may have been blocking: same credential,+ browser session, browser address, (workflow, sequential_key), or run_sequentially+ whole-workflow lane, queued after it, ordered by the gate's (queued_at, workflow_run_id)+ ticket. Recall-oriented: a woken run re-runs the full gate scan itself, so lanes only+ need to cover, not decide — the blocker's self_forced/debug exclusions are deliberately+ not replicated (an over-woken waiter just re-scans once). One index-eligible query per+ lane, mirroring get_blocking_sequential_workflow_run's no-de-indexing-OR shape. The+ result is bounded at lanes x limit, never truncated across lanes: a dropped lane head+ has no depends_on edge and would sleep until the fallback poll.+ """+ async with self.Session() as session:+ run = (await session.scalars(select(WorkflowRunModel).filter_by(workflow_run_id=workflow_run_id))).first()+ if run is None:+ return []++ lane_filters: list[ColumnElement[bool]] = []+ if run.sequential_credential_id:+ lane_filters.append(WorkflowRunModel.sequential_credential_id == run.sequential_credential_id)+ if run.browser_session_id:+ lane_filters.append(WorkflowRunModel.browser_session_id == run.browser_session_id)+ if run.browser_address:+ lane_filters.append(WorkflowRunModel.browser_address == run.browser_address)+ if run.sequential_key:+ lane_filters.append(+ and_(+ WorkflowRunModel.workflow_permanent_id == run.workflow_permanent_id,+ WorkflowRunModel.sequential_key == run.sequential_key,+ )+ )+ if run.workflow_id:+ run_workflow = await session.get(WorkflowModel, run.workflow_id)+ if run_workflow and run_workflow.run_sequentially:+ lane_filters.append(+ and_(+ WorkflowRunModel.workflow_permanent_id == run.workflow_permanent_id,+ or_(+ WorkflowRunModel.browser_session_id.is_(None),+ WorkflowRunModel.sequential_credential_id.isnot(None),+ ),+ )+ )+ if not lane_filters:+ return []++ self_queued_at = run.queued_at if run.queued_at is not None else run.created_at+ candidates: dict[str, WorkflowRunModel] = {}+ for lane_filter in lane_filters:+ lane_query = (+ select(WorkflowRunModel)+ .filter_by(organization_id=run.organization_id, status=WorkflowRunStatus.queued)+ .filter(WorkflowRunModel.workflow_run_id != run.workflow_run_id)+ .filter(lane_filter)+ .filter(WorkflowRunModel.queued_at.isnot(None))+ .filter(+ or_(+ WorkflowRunModel.queued_at > self_queued_at,+ and_(+ WorkflowRunModel.queued_at == self_queued_at,+ WorkflowRunModel.workflow_run_id > run.workflow_run_id,+ ),+ )+ )+ .order_by(WorkflowRunModel.queued_at.asc(), WorkflowRunModel.workflow_run_id.asc())+ .limit(limit)+ )+ for candidate in (await session.scalars(lane_query)).all():+ candidates.setdefault(candidate.workflow_run_id, candidate)++ ordered = sorted(candidates.values(), key=lambda r: (r.queued_at, r.workflow_run_id))+ return [convert_to_workflow_run(candidate) for candidate in ordered]+@db_operation("get_last_queued_workflow_run")async def get_last_queued_workflow_run(self,diff --git a/tests/unit/forge/sdk/db/test_workflow_runs_repository.py b/tests/unit/forge/sdk/db/test_workflow_runs_repository.pyindex 073de1278..7d45891fa 100644--- a/tests/unit/forge/sdk/db/test_workflow_runs_repository.py+++ b/tests/unit/forge/sdk/db/test_workflow_runs_repository.py@@ -1668,3 +1668,157 @@ async def test_gate_noncredential_key_lane_keeps_index_eligible_shape(for statement in statements:assert not _DEINDEXING_OR.search(statement), f"gate keyed lane de-indexed by widened OR: {statement}"+++async def test_wake_candidates_share_credential_lane_by_gate_ticket(sqlite_db: AgentDB) -> None:+ # Excluded peers are all same-credential so any predicate regression (org scope, queued-only+ # status, queued-after ordering) would surface as an extra or misordered candidate.+ early_at = datetime(2026, 8, 4, 9, 0, tzinfo=timezone.utc)+ done_at = datetime(2026, 8, 4, 10, 0, tzinfo=timezone.utc)+ next_at = datetime(2026, 8, 4, 11, 0, tzinfo=timezone.utc)+ third_at = datetime(2026, 8, 4, 12, 0, tzinfo=timezone.utc)+ fourth_at = datetime(2026, 8, 4, 13, 0, tzinfo=timezone.utc)+ async with sqlite_db.Session() as session:+ session.add_all(+ [+ _credential_run("wr_fan_done", done_at, "cred_f", status=WorkflowRunStatus.completed.value),+ _credential_run("wr_fan_before", early_at, "cred_f"),+ _credential_run("wr_fan_other_org", next_at, "cred_f", organization_id="org_other"),+ _credential_run("wr_fan_running", next_at, "cred_f", status=WorkflowRunStatus.running.value),+ _credential_run("wr_fan_next", next_at, "cred_f"),+ _credential_run("wr_fan_third", third_at, "cred_f"),+ _credential_run("wr_fan_fourth", fourth_at, "cred_f"),+ ]+ )+ await session.commit()++ waiters = await sqlite_db.workflow_runs.get_queued_runs_sharing_sequential_lanes("wr_fan_done")++ assert [w.workflow_run_id for w in waiters] == ["wr_fan_next", "wr_fan_third"]+++async def test_wake_candidates_cover_run_sequentially_whole_workflow(sqlite_db: AgentDB) -> None:+ # A different-credential waiter in a run_sequentially workflow has no depends_on edge and no+ # shared credential/key, so only the whole-workflow lane can wake it; a plain session row+ # fails the lane's admission condition.+ done_at = datetime(2026, 8, 4, 10, 0, tzinfo=timezone.utc)+ next_at = datetime(2026, 8, 4, 11, 0, tzinfo=timezone.utc)+ async with sqlite_db.Session() as session:+ session.add(+ WorkflowModel(+ workflow_id="wf_seq_wake",+ workflow_permanent_id="wpid_ws_wake",+ title="seq",+ workflow_definition={},+ run_sequentially=True,+ )+ )+ session.add_all(+ [+ _credential_run(+ "wr_wsw_done",+ done_at,+ "cred_p",+ workflow_permanent_id="wpid_ws_wake",+ workflow_id="wf_seq_wake",+ status=WorkflowRunStatus.completed.value,+ ),+ _credential_run(+ "wr_wsw_next", next_at, "cred_q", workflow_permanent_id="wpid_ws_wake", workflow_id="wf_seq_wake"+ ),+ _workflow_run_model(+ workflow_run_id="wr_wsw_plain_session",+ queued_at=next_at,+ workflow_permanent_id="wpid_ws_wake",+ workflow_id="wf_seq_wake",+ browser_session_id="pbs_wsw_plain",+ ),+ ]+ )+ await session.commit()++ waiters = await sqlite_db.workflow_runs.get_queued_runs_sharing_sequential_lanes("wr_wsw_done")++ assert [w.workflow_run_id for w in waiters] == ["wr_wsw_next"]+++async def test_wake_candidates_merge_lanes_and_keep_the_earliest(sqlite_db: AgentDB) -> None:+ # The key-lane waiter is queued earlier than the credential-lane waiter, so the cross-lane+ # merge must return it first; the later credential waiter survives because the merge never+ # truncates across lanes (only the per-lane limit applies).+ done_at = datetime(2026, 8, 4, 10, 0, tzinfo=timezone.utc)+ key_at = datetime(2026, 8, 4, 10, 30, tzinfo=timezone.utc)+ cred_at = datetime(2026, 8, 4, 11, 0, tzinfo=timezone.utc)+ late_at = datetime(2026, 8, 4, 12, 0, tzinfo=timezone.utc)+ async with sqlite_db.Session() as session:+ session.add_all(+ [+ _credential_run(+ "wr_merge_done",+ done_at,+ "cred_m",+ workflow_permanent_id="wpid_merge",+ sequential_key="KM",+ status=WorkflowRunStatus.completed.value,+ ),+ _workflow_run_model(+ workflow_run_id="wr_merge_key",+ queued_at=key_at,+ workflow_permanent_id="wpid_merge",+ sequential_key="KM",+ ),+ _credential_run("wr_merge_cred", cred_at, "cred_m", workflow_permanent_id="wpid_other_merge"),+ _credential_run("wr_merge_late", late_at, "cred_m", workflow_permanent_id="wpid_other_merge"),+ ]+ )+ await session.commit()++ waiters = await sqlite_db.workflow_runs.get_queued_runs_sharing_sequential_lanes("wr_merge_done")++ assert [w.workflow_run_id for w in waiters] == ["wr_merge_key", "wr_merge_cred", "wr_merge_late"]+++async def test_wake_candidates_signal_every_lane_head(sqlite_db: AgentDB) -> None:+ # A predecessor in three lanes (credential, browser session, workflow+key) with three distinct+ # lane heads: a global cap of 2 would drop the latest-queued lane's head, which has no+ # depends_on edge and would sleep until the fallback poll instead of starting.+ done_at = datetime(2026, 8, 4, 10, 0, tzinfo=timezone.utc)+ key_at = datetime(2026, 8, 4, 10, 30, tzinfo=timezone.utc)+ cred_at = datetime(2026, 8, 4, 11, 0, tzinfo=timezone.utc)+ sess_at = datetime(2026, 8, 4, 11, 30, tzinfo=timezone.utc)+ async with sqlite_db.Session() as session:+ session.add_all(+ [+ _credential_run(+ "wr_tri_done",+ done_at,+ "cred_t",+ browser_session_id="pbs_shared",+ workflow_permanent_id="wpid_tri",+ sequential_key="KT",+ status=WorkflowRunStatus.completed.value,+ ),+ _workflow_run_model(+ workflow_run_id="wr_tri_key",+ queued_at=key_at,+ workflow_permanent_id="wpid_tri",+ sequential_key="KT",+ ),+ _credential_run("wr_tri_cred", cred_at, "cred_t", workflow_permanent_id="wpid_other_tri"),+ _workflow_run_model(+ workflow_run_id="wr_tri_sess",+ queued_at=sess_at,+ browser_session_id="pbs_shared",+ workflow_permanent_id="wpid_other_tri2",+ ),+ ]+ )+ await session.commit()++ waiters = await sqlite_db.workflow_runs.get_queued_runs_sharing_sequential_lanes("wr_tri_done")++ assert [w.workflow_run_id for w in waiters] == ["wr_tri_key", "wr_tri_cred", "wr_tri_sess"]