Skip to content

Automate browser based workflows with AI

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.py
index 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.py
index 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"]