Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
Repository Design Pattern (#SKY-8139) (#5279)
Aaron Perezc91cd98d506d
diff --git a/skyvern/forge/sdk/db/agent_db.py b/skyvern/forge/sdk/db/agent_db.pyindex 6729577ed..c8f921583 100644--- a/skyvern/forge/sdk/db/agent_db.py+++ b/skyvern/forge/sdk/db/agent_db.py@@ -13,20 +13,21 @@ from sqlalchemy.ext.asyncio import AsyncEngine, create_async_enginefrom skyvern.config import settingsfrom skyvern.forge.sdk.db.base_alchemy_db import BaseAlchemyDB-from skyvern.forge.sdk.db.mixins.artifacts import ArtifactsMixin-from skyvern.forge.sdk.db.mixins.browser_sessions import BrowserSessionsMixin-from skyvern.forge.sdk.db.mixins.credentials import CredentialsMixin-from skyvern.forge.sdk.db.mixins.debug import DebugMixin-from skyvern.forge.sdk.db.mixins.folders import FoldersMixin-from skyvern.forge.sdk.db.mixins.observer import ObserverMixin-from skyvern.forge.sdk.db.mixins.organizations import OrganizationsMixin-from skyvern.forge.sdk.db.mixins.otp import OTPMixin-from skyvern.forge.sdk.db.mixins.schedules import ScheduleLimitExceededError, SchedulesMixin-from skyvern.forge.sdk.db.mixins.scripts import ScriptsMixin-from skyvern.forge.sdk.db.mixins.tasks import TasksMixin-from skyvern.forge.sdk.db.mixins.workflow_parameters import WorkflowParametersMixin-from skyvern.forge.sdk.db.mixins.workflow_runs import WorkflowRunsMixin-from skyvern.forge.sdk.db.mixins.workflows import WorkflowsMixin+from skyvern.forge.sdk.db.exceptions import ScheduleLimitExceededError # noqa: F401+from skyvern.forge.sdk.db.repositories.artifacts import ArtifactsRepository+from skyvern.forge.sdk.db.repositories.browser_sessions import BrowserSessionsRepository+from skyvern.forge.sdk.db.repositories.credentials import CredentialRepository+from skyvern.forge.sdk.db.repositories.debug import DebugRepository+from skyvern.forge.sdk.db.repositories.folders import FoldersRepository+from skyvern.forge.sdk.db.repositories.observer import ObserverRepository+from skyvern.forge.sdk.db.repositories.organizations import OrganizationsRepository+from skyvern.forge.sdk.db.repositories.otp import OTPRepository+from skyvern.forge.sdk.db.repositories.schedules import SchedulesRepository+from skyvern.forge.sdk.db.repositories.scripts import ScriptsRepository+from skyvern.forge.sdk.db.repositories.tasks import TasksRepository+from skyvern.forge.sdk.db.repositories.workflow_parameters import WorkflowParametersRepository+from skyvern.forge.sdk.db.repositories.workflow_runs import WorkflowRunsRepository+from skyvern.forge.sdk.db.repositories.workflows import WorkflowsRepositoryfrom skyvern.forge.sdk.db.utils import (_custom_json_serializer,)@@ -104,23 +105,7 @@ def _build_engine(database_string: str) -> AsyncEngine:__all__ = ["AgentDB", "ScheduleLimitExceededError"]-class AgentDB(- TasksMixin,- WorkflowsMixin,- WorkflowRunsMixin,- WorkflowParametersMixin,- SchedulesMixin,- ArtifactsMixin,- BrowserSessionsMixin,- ScriptsMixin,- OTPMixin,- CredentialsMixin,- FoldersMixin,- OrganizationsMixin,- ObserverMixin,- DebugMixin,- BaseAlchemyDB,-):+class AgentDB(BaseAlchemyDB):def __init__(self, database_string: str, debug_enabled: bool = False, db_engine: AsyncEngine | None = None) -> None:super().__init__(db_engine or _build_engine(database_string))self.debug_enabled = debug_enabled@@ -131,6 +116,819 @@ class AgentDB(asyncio.Lock() if self.engine.dialect.name == "sqlite" else None)+ # -- Zero-dependency repositories --+ self.tasks = TasksRepository(self.Session, debug_enabled, self.is_retryable_error)+ self.workflows = WorkflowsRepository(self.Session, debug_enabled, self.is_retryable_error)+ self.workflow_params = WorkflowParametersRepository(self.Session, debug_enabled, self.is_retryable_error)+ self.credentials = CredentialRepository(self.Session, debug_enabled, self.is_retryable_error)+ self.otp = OTPRepository(self.Session, debug_enabled, self.is_retryable_error)+ self.debug = DebugRepository(self.Session, debug_enabled, self.is_retryable_error)+ self.organizations = OrganizationsRepository(self.Session, debug_enabled, self.is_retryable_error)+ self.scripts = ScriptsRepository(self.Session, debug_enabled, self.is_retryable_error)+ self.browser_sessions = BrowserSessionsRepository(self.Session, debug_enabled, self.is_retryable_error)+ self.schedules = SchedulesRepository(+ self.Session,+ debug_enabled,+ self.is_retryable_error,+ sqlite_schedule_lock=self._sqlite_schedule_lock,+ )++ # -- Cross-dependency repositories --+ self.workflow_runs = WorkflowRunsRepository(+ self.Session,+ debug_enabled,+ self.is_retryable_error,+ workflow_parameter_reader=self.workflow_params,+ dialect_name=self.engine.dialect.name,+ )+ self.artifacts = ArtifactsRepository(+ self.Session,+ debug_enabled,+ self.is_retryable_error,+ run_reader=self.workflow_runs,+ )+ self.folders = FoldersRepository(+ self.Session,+ debug_enabled,+ self.is_retryable_error,+ workflow_reader=self.workflows,+ )+ self.observer = ObserverRepository(+ self.Session,+ debug_enabled,+ self.is_retryable_error,+ task_reader=self.tasks,+ )+def is_retryable_error(self, error: SQLAlchemyError) -> bool:error_msg = str(error).lower()return "server closed the connection" in error_msg++ # ======================================================================+ # Backward-compatible delegate methods+ # TODO(SKY-62): These delegates erase type information (*args: Any -> Any).+ # Migrate callers to use typed repository attributes directly+ # (e.g., db.tasks.get_task(...) instead of db.get_task(...)), then remove.+ # ======================================================================++ # -- Task delegates --++ async def create_task(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.create_task(*args, **kwargs)++ async def create_step(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.create_step(*args, **kwargs)++ async def get_task(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.get_task(*args, **kwargs)++ async def get_tasks_by_ids(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.get_tasks_by_ids(*args, **kwargs)++ async def get_step(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.get_step(*args, **kwargs)++ async def get_task_steps(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.get_task_steps(*args, **kwargs)++ async def get_steps_by_task_ids(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.get_steps_by_task_ids(*args, **kwargs)++ async def get_total_unique_step_order_count_by_task_ids(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.get_total_unique_step_order_count_by_task_ids(*args, **kwargs)++ async def get_task_step_models(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.get_task_step_models(*args, **kwargs)++ async def get_task_step_count(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.get_task_step_count(*args, **kwargs)++ async def get_task_actions(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.get_task_actions(*args, **kwargs)++ async def get_task_actions_hydrated(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.get_task_actions_hydrated(*args, **kwargs)++ async def get_tasks_actions(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.get_tasks_actions(*args, **kwargs)++ async def get_action_count_for_step(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.get_action_count_for_step(*args, **kwargs)++ async def get_first_step(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.get_first_step(*args, **kwargs)++ async def get_latest_step(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.get_latest_step(*args, **kwargs)++ async def update_step(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.update_step(*args, **kwargs)++ async def clear_task_failure_reason(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.clear_task_failure_reason(*args, **kwargs)++ async def update_task(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.update_task(*args, **kwargs)++ async def update_task_2fa_state(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.update_task_2fa_state(*args, **kwargs)++ async def bulk_update_tasks(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.bulk_update_tasks(*args, **kwargs)++ async def get_tasks(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.get_tasks(*args, **kwargs)++ async def get_tasks_count(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.get_tasks_count(*args, **kwargs)++ async def get_running_tasks_info_globally(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.get_running_tasks_info_globally(*args, **kwargs)++ async def get_latest_task_by_workflow_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.get_latest_task_by_workflow_id(*args, **kwargs)++ async def get_last_task_for_workflow_run(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.get_last_task_for_workflow_run(*args, **kwargs)++ async def get_tasks_by_workflow_run_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.get_tasks_by_workflow_run_id(*args, **kwargs)++ async def delete_task_steps(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.delete_task_steps(*args, **kwargs)++ async def get_previous_actions_for_task(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.get_previous_actions_for_task(*args, **kwargs)++ async def delete_task_actions(self, *args: Any, **kwargs: Any) -> Any:+ return await self.tasks.delete_task_actions(*args, **kwargs)++ # -- Workflow delegates --++ async def create_workflow(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflows.create_workflow(*args, **kwargs)++ async def soft_delete_workflow_by_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflows.soft_delete_workflow_by_id(*args, **kwargs)++ async def get_workflow(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflows.get_workflow(*args, **kwargs)++ async def get_workflow_by_permanent_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflows.get_workflow_by_permanent_id(*args, **kwargs)++ async def get_workflow_for_workflow_run(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflows.get_workflow_for_workflow_run(*args, **kwargs)++ async def get_workflow_versions_by_permanent_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflows.get_workflow_versions_by_permanent_id(*args, **kwargs)++ async def get_workflows_by_permanent_ids(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflows.get_workflows_by_permanent_ids(*args, **kwargs)++ async def get_workflows_by_organization_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflows.get_workflows_by_organization_id(*args, **kwargs)++ async def update_workflow(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflows.update_workflow(*args, **kwargs)++ async def soft_delete_workflow_and_schedules_by_permanent_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflows.soft_delete_workflow_and_schedules_by_permanent_id(*args, **kwargs)++ async def add_workflow_template(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflows.add_workflow_template(*args, **kwargs)++ async def remove_workflow_template(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflows.remove_workflow_template(*args, **kwargs)++ async def get_org_template_permanent_ids(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflows.get_org_template_permanent_ids(*args, **kwargs)++ async def is_workflow_template(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflows.is_workflow_template(*args, **kwargs)++ # -- Workflow run delegates --++ async def get_running_workflow_runs_info_globally(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_runs.get_running_workflow_runs_info_globally(*args, **kwargs)++ async def create_workflow_run(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_runs.create_workflow_run(*args, **kwargs)++ async def update_workflow_run(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_runs.update_workflow_run(*args, **kwargs)++ async def bulk_update_workflow_runs(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_runs.bulk_update_workflow_runs(*args, **kwargs)++ async def clear_workflow_run_failure_reason(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_runs.clear_workflow_run_failure_reason(*args, **kwargs)++ async def get_all_runs(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_runs.get_all_runs(*args, **kwargs)++ async def get_workflow_run(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_runs.get_workflow_run(*args, **kwargs)++ async def get_last_queued_workflow_run(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_runs.get_last_queued_workflow_run(*args, **kwargs)++ async def get_workflow_runs_by_ids(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_runs.get_workflow_runs_by_ids(*args, **kwargs)++ async def get_last_running_workflow_run(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_runs.get_last_running_workflow_run(*args, **kwargs)++ async def get_last_workflow_run_for_browser_session(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_runs.get_last_workflow_run_for_browser_session(*args, **kwargs)++ async def get_last_workflow_run_for_browser_address(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_runs.get_last_workflow_run_for_browser_address(*args, **kwargs)++ async def get_workflows_depending_on(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_runs.get_workflows_depending_on(*args, **kwargs)++ async def get_workflow_runs(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_runs.get_workflow_runs(*args, **kwargs)++ async def get_workflow_runs_count(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_runs.get_workflow_runs_count(*args, **kwargs)++ async def get_workflow_runs_for_workflow_permanent_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_runs.get_workflow_runs_for_workflow_permanent_id(*args, **kwargs)++ async def get_workflow_runs_by_parent_workflow_run_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_runs.get_workflow_runs_by_parent_workflow_run_id(*args, **kwargs)++ async def get_workflow_run_output_parameters(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_runs.get_workflow_run_output_parameters(*args, **kwargs)++ async def get_workflow_run_output_parameter_by_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_runs.get_workflow_run_output_parameter_by_id(*args, **kwargs)++ async def create_or_update_workflow_run_output_parameter(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_runs.create_or_update_workflow_run_output_parameter(*args, **kwargs)++ async def update_workflow_run_output_parameter(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_runs.update_workflow_run_output_parameter(*args, **kwargs)++ async def create_workflow_run_parameter(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_runs.create_workflow_run_parameter(*args, **kwargs)++ async def get_workflow_run_parameters(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_runs.get_workflow_run_parameters(*args, **kwargs)++ async def get_workflow_run_block_errors(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_runs.get_workflow_run_block_errors(*args, **kwargs)++ # -- Workflow parameter delegates --++ async def create_workflow_parameter(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.create_workflow_parameter(*args, **kwargs)++ async def create_aws_secret_parameter(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.create_aws_secret_parameter(*args, **kwargs)++ async def create_output_parameter(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.create_output_parameter(*args, **kwargs)++ async def save_workflow_definition_parameters(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.save_workflow_definition_parameters(*args, **kwargs)++ async def get_workflow_output_parameters(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.get_workflow_output_parameters(*args, **kwargs)++ async def get_workflow_output_parameters_by_ids(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.get_workflow_output_parameters_by_ids(*args, **kwargs)++ async def get_workflow_parameters(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.get_workflow_parameters(*args, **kwargs)++ async def get_workflow_parameter(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.get_workflow_parameter(*args, **kwargs)++ async def create_task_generation(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.create_task_generation(*args, **kwargs)++ async def create_ai_suggestion(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.create_ai_suggestion(*args, **kwargs)++ async def create_workflow_copilot_chat(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.create_workflow_copilot_chat(*args, **kwargs)++ async def update_workflow_copilot_chat(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.update_workflow_copilot_chat(*args, **kwargs)++ async def create_workflow_copilot_chat_message(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.create_workflow_copilot_chat_message(*args, **kwargs)++ async def get_workflow_copilot_chat_messages(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.get_workflow_copilot_chat_messages(*args, **kwargs)++ async def get_workflow_copilot_chat_by_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.get_workflow_copilot_chat_by_id(*args, **kwargs)++ async def get_latest_workflow_copilot_chat(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.get_latest_workflow_copilot_chat(*args, **kwargs)++ async def get_task_generation_by_prompt_hash(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.get_task_generation_by_prompt_hash(*args, **kwargs)++ async def create_action(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.create_action(*args, **kwargs)++ async def update_action_reasoning(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.update_action_reasoning(*args, **kwargs)++ async def retrieve_action_plan(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.retrieve_action_plan(*args, **kwargs)++ async def create_task_run(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.create_task_run(*args, **kwargs)++ async def update_task_run(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.update_task_run(*args, **kwargs)++ async def update_job_run_compute_cost(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.update_job_run_compute_cost(*args, **kwargs)++ async def cache_task_run(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.cache_task_run(*args, **kwargs)++ async def get_cached_task_run(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.get_cached_task_run(*args, **kwargs)++ async def get_run(self, *args: Any, **kwargs: Any) -> Any:+ return await self.workflow_params.get_run(*args, **kwargs)++ # -- Artifact delegates --++ async def create_artifact(self, *args: Any, **kwargs: Any) -> Any:+ return await self.artifacts.create_artifact(*args, **kwargs)++ async def bulk_create_artifacts(self, *args: Any, **kwargs: Any) -> Any:+ return await self.artifacts.bulk_create_artifacts(*args, **kwargs)++ async def get_artifacts_for_task_v2(self, *args: Any, **kwargs: Any) -> Any:+ return await self.artifacts.get_artifacts_for_task_v2(*args, **kwargs)++ async def get_artifacts_for_task_step(self, *args: Any, **kwargs: Any) -> Any:+ return await self.artifacts.get_artifacts_for_task_step(*args, **kwargs)++ async def get_artifacts_for_run(self, *args: Any, **kwargs: Any) -> Any:+ return await self.artifacts.get_artifacts_for_run(*args, **kwargs)++ async def get_artifact_by_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.artifacts.get_artifact_by_id(*args, **kwargs)++ async def get_artifacts_by_ids(self, *args: Any, **kwargs: Any) -> Any:+ return await self.artifacts.get_artifacts_by_ids(*args, **kwargs)++ async def get_artifacts_by_entity_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.artifacts.get_artifacts_by_entity_id(*args, **kwargs)++ async def get_artifact_by_entity_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.artifacts.get_artifact_by_entity_id(*args, **kwargs)++ async def get_artifact(self, *args: Any, **kwargs: Any) -> Any:+ return await self.artifacts.get_artifact(*args, **kwargs)++ async def get_artifact_for_run(self, *args: Any, **kwargs: Any) -> Any:+ return await self.artifacts.get_artifact_for_run(*args, **kwargs)++ async def get_latest_artifact(self, *args: Any, **kwargs: Any) -> Any:+ return await self.artifacts.get_latest_artifact(*args, **kwargs)++ async def get_latest_n_artifacts(self, *args: Any, **kwargs: Any) -> Any:+ return await self.artifacts.get_latest_n_artifacts(*args, **kwargs)++ async def delete_task_artifacts(self, *args: Any, **kwargs: Any) -> Any:+ return await self.artifacts.delete_task_artifacts(*args, **kwargs)++ async def delete_task_v2_artifacts(self, *args: Any, **kwargs: Any) -> Any:+ return await self.artifacts.delete_task_v2_artifacts(*args, **kwargs)++ async def update_action_screenshot_artifact_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.artifacts.update_action_screenshot_artifact_id(*args, **kwargs)++ # -- Browser session delegates --++ async def create_browser_profile(self, *args: Any, **kwargs: Any) -> Any:+ return await self.browser_sessions.create_browser_profile(*args, **kwargs)++ async def get_browser_profile(self, *args: Any, **kwargs: Any) -> Any:+ return await self.browser_sessions.get_browser_profile(*args, **kwargs)++ async def list_browser_profiles(self, *args: Any, **kwargs: Any) -> Any:+ return await self.browser_sessions.list_browser_profiles(*args, **kwargs)++ async def delete_browser_profile(self, *args: Any, **kwargs: Any) -> Any:+ return await self.browser_sessions.delete_browser_profile(*args, **kwargs)++ async def get_active_persistent_browser_sessions(self, *args: Any, **kwargs: Any) -> Any:+ return await self.browser_sessions.get_active_persistent_browser_sessions(*args, **kwargs)++ async def get_persistent_browser_sessions_history(self, *args: Any, **kwargs: Any) -> Any:+ return await self.browser_sessions.get_persistent_browser_sessions_history(*args, **kwargs)++ async def get_persistent_browser_session_by_runnable_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.browser_sessions.get_persistent_browser_session_by_runnable_id(*args, **kwargs)++ async def get_persistent_browser_session(self, *args: Any, **kwargs: Any) -> Any:+ return await self.browser_sessions.get_persistent_browser_session(*args, **kwargs)++ async def create_persistent_browser_session(self, *args: Any, **kwargs: Any) -> Any:+ return await self.browser_sessions.create_persistent_browser_session(*args, **kwargs)++ async def update_persistent_browser_session(self, *args: Any, **kwargs: Any) -> Any:+ return await self.browser_sessions.update_persistent_browser_session(*args, **kwargs)++ async def set_persistent_browser_session_browser_address(self, *args: Any, **kwargs: Any) -> Any:+ return await self.browser_sessions.set_persistent_browser_session_browser_address(*args, **kwargs)++ async def update_persistent_browser_session_compute_cost(self, *args: Any, **kwargs: Any) -> Any:+ return await self.browser_sessions.update_persistent_browser_session_compute_cost(*args, **kwargs)++ async def mark_persistent_browser_session_deleted(self, *args: Any, **kwargs: Any) -> Any:+ return await self.browser_sessions.mark_persistent_browser_session_deleted(*args, **kwargs)++ async def occupy_persistent_browser_session(self, *args: Any, **kwargs: Any) -> Any:+ return await self.browser_sessions.occupy_persistent_browser_session(*args, **kwargs)++ async def release_persistent_browser_session(self, *args: Any, **kwargs: Any) -> Any:+ return await self.browser_sessions.release_persistent_browser_session(*args, **kwargs)++ async def close_persistent_browser_session(self, *args: Any, **kwargs: Any) -> Any:+ return await self.browser_sessions.close_persistent_browser_session(*args, **kwargs)++ async def get_all_active_persistent_browser_sessions(self, *args: Any, **kwargs: Any) -> Any:+ return await self.browser_sessions.get_all_active_persistent_browser_sessions(*args, **kwargs)++ async def archive_browser_session_address(self, *args: Any, **kwargs: Any) -> Any:+ return await self.browser_sessions.archive_browser_session_address(*args, **kwargs)++ async def get_uncompleted_persistent_browser_sessions(self, *args: Any, **kwargs: Any) -> Any:+ return await self.browser_sessions.get_uncompleted_persistent_browser_sessions(*args, **kwargs)++ async def get_debug_session_by_browser_session_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.browser_sessions.get_debug_session_by_browser_session_id(*args, **kwargs)++ # -- Schedule delegates --++ async def create_workflow_schedule(self, *args: Any, **kwargs: Any) -> Any:+ return await self.schedules.create_workflow_schedule(*args, **kwargs)++ async def create_workflow_schedule_with_limit(self, *args: Any, **kwargs: Any) -> Any:+ return await self.schedules.create_workflow_schedule_with_limit(*args, **kwargs)++ async def set_temporal_schedule_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.schedules.set_temporal_schedule_id(*args, **kwargs)++ async def update_workflow_schedule(self, *args: Any, **kwargs: Any) -> Any:+ return await self.schedules.update_workflow_schedule(*args, **kwargs)++ async def get_workflow_schedule_by_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.schedules.get_workflow_schedule_by_id(*args, **kwargs)++ async def get_workflow_schedules(self, *args: Any, **kwargs: Any) -> Any:+ return await self.schedules.get_workflow_schedules(*args, **kwargs)++ async def get_all_enabled_schedules(self, *args: Any, **kwargs: Any) -> Any:+ return await self.schedules.get_all_enabled_schedules(*args, **kwargs)++ async def has_schedule_fired_since(self, *args: Any, **kwargs: Any) -> Any:+ return await self.schedules.has_schedule_fired_since(*args, **kwargs)++ async def update_workflow_schedule_enabled(self, *args: Any, **kwargs: Any) -> Any:+ return await self.schedules.update_workflow_schedule_enabled(*args, **kwargs)++ async def delete_workflow_schedule(self, *args: Any, **kwargs: Any) -> Any:+ return await self.schedules.delete_workflow_schedule(*args, **kwargs)++ async def restore_workflow_schedule(self, *args: Any, **kwargs: Any) -> Any:+ return await self.schedules.restore_workflow_schedule(*args, **kwargs)++ async def count_workflow_schedules(self, *args: Any, **kwargs: Any) -> Any:+ return await self.schedules.count_workflow_schedules(*args, **kwargs)++ async def list_organization_schedules(self, *args: Any, **kwargs: Any) -> Any:+ return await self.schedules.list_organization_schedules(*args, **kwargs)++ async def soft_delete_orphaned_schedules(self, *args: Any, **kwargs: Any) -> Any:+ return await self.schedules.soft_delete_orphaned_schedules(*args, **kwargs)++ # -- Script delegates --++ async def create_script(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.create_script(*args, **kwargs)++ async def get_scripts(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_scripts(*args, **kwargs)++ async def get_script(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_script(*args, **kwargs)++ async def get_script_revision(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_script_revision(*args, **kwargs)++ async def get_latest_script_version(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_latest_script_version(*args, **kwargs)++ async def get_script_versions(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_script_versions(*args, **kwargs)++ async def get_script_version_stats(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_script_version_stats(*args, **kwargs)++ async def soft_delete_script_by_revision(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.soft_delete_script_by_revision(*args, **kwargs)++ async def create_script_file(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.create_script_file(*args, **kwargs)++ async def create_script_block(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.create_script_block(*args, **kwargs)++ async def update_script_block(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.update_script_block(*args, **kwargs)++ async def get_script_files(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_script_files(*args, **kwargs)++ async def get_script_file_by_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_script_file_by_id(*args, **kwargs)++ async def get_script_file_by_path(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_script_file_by_path(*args, **kwargs)++ async def update_script_file(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.update_script_file(*args, **kwargs)++ async def get_script_block(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_script_block(*args, **kwargs)++ async def get_script_block_by_label(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_script_block_by_label(*args, **kwargs)++ async def get_script_blocks_by_script_revision_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_script_blocks_by_script_revision_id(*args, **kwargs)++ async def create_workflow_script(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.create_workflow_script(*args, **kwargs)++ async def get_workflow_script(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_workflow_script(*args, **kwargs)++ async def get_workflow_script_by_cache_key_value(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_workflow_script_by_cache_key_value(*args, **kwargs)++ async def get_workflow_cache_key_count(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_workflow_cache_key_count(*args, **kwargs)++ async def get_workflow_cache_key_values(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_workflow_cache_key_values(*args, **kwargs)++ async def delete_workflow_cache_key_value(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.delete_workflow_cache_key_value(*args, **kwargs)++ async def delete_workflow_scripts_by_permanent_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.delete_workflow_scripts_by_permanent_id(*args, **kwargs)++ async def get_workflow_scripts_by_permanent_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_workflow_scripts_by_permanent_id(*args, **kwargs)++ async def get_workflow_runs_for_script(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_workflow_runs_for_script(*args, **kwargs)++ async def get_script_run_stats(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_script_run_stats(*args, **kwargs)++ async def is_script_pinned(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.is_script_pinned(*args, **kwargs)++ async def pin_workflow_script(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.pin_workflow_script(*args, **kwargs)++ async def unpin_workflow_script(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.unpin_workflow_script(*args, **kwargs)++ async def create_fallback_episode(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.create_fallback_episode(*args, **kwargs)++ async def get_unreviewed_episodes(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_unreviewed_episodes(*args, **kwargs)++ async def update_fallback_episode(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.update_fallback_episode(*args, **kwargs)++ async def delete_fallback_episode(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.delete_fallback_episode(*args, **kwargs)++ async def get_fallback_episodes(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_fallback_episodes(*args, **kwargs)++ async def get_fallback_episodes_count(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_fallback_episodes_count(*args, **kwargs)++ async def get_fallback_episode(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_fallback_episode(*args, **kwargs)++ async def mark_episode_reviewed(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.mark_episode_reviewed(*args, **kwargs)++ async def get_recent_reviewed_episodes(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_recent_reviewed_episodes(*args, **kwargs)++ async def record_branch_hit(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.record_branch_hit(*args, **kwargs)++ async def get_stale_branches(self, *args: Any, **kwargs: Any) -> Any:+ return await self.scripts.get_stale_branches(*args, **kwargs)++ # -- OTP delegates --++ async def get_otp_codes(self, *args: Any, **kwargs: Any) -> Any:+ return await self.otp.get_otp_codes(*args, **kwargs)++ async def get_otp_codes_by_run(self, *args: Any, **kwargs: Any) -> Any:+ return await self.otp.get_otp_codes_by_run(*args, **kwargs)++ async def get_recent_otp_codes(self, *args: Any, **kwargs: Any) -> Any:+ return await self.otp.get_recent_otp_codes(*args, **kwargs)++ async def create_otp_code(self, *args: Any, **kwargs: Any) -> Any:+ return await self.otp.create_otp_code(*args, **kwargs)++ # -- Credential delegates --++ async def create_credential(self, *args: Any, **kwargs: Any) -> Any:+ return await self.credentials.create_credential(*args, **kwargs)++ async def get_credential(self, *args: Any, **kwargs: Any) -> Any:+ return await self.credentials.get_credential(*args, **kwargs)++ async def get_credentials(self, *args: Any, **kwargs: Any) -> Any:+ return await self.credentials.get_credentials(*args, **kwargs)++ async def update_credential(self, *args: Any, **kwargs: Any) -> Any:+ return await self.credentials.update_credential(*args, **kwargs)++ async def update_credential_vault_data(self, *args: Any, **kwargs: Any) -> Any:+ return await self.credentials.update_credential_vault_data(*args, **kwargs)++ async def delete_credential(self, *args: Any, **kwargs: Any) -> Any:+ return await self.credentials.delete_credential(*args, **kwargs)++ async def create_organization_bitwarden_collection(self, *args: Any, **kwargs: Any) -> Any:+ return await self.credentials.create_organization_bitwarden_collection(*args, **kwargs)++ async def get_organization_bitwarden_collection(self, *args: Any, **kwargs: Any) -> Any:+ return await self.credentials.get_organization_bitwarden_collection(*args, **kwargs)++ # -- Folder delegates --++ async def create_folder(self, *args: Any, **kwargs: Any) -> Any:+ return await self.folders.create_folder(*args, **kwargs)++ async def get_folders(self, *args: Any, **kwargs: Any) -> Any:+ return await self.folders.get_folders(*args, **kwargs)++ async def get_folder(self, *args: Any, **kwargs: Any) -> Any:+ return await self.folders.get_folder(*args, **kwargs)++ async def update_folder(self, *args: Any, **kwargs: Any) -> Any:+ return await self.folders.update_folder(*args, **kwargs)++ async def get_workflow_permanent_ids_in_folder(self, *args: Any, **kwargs: Any) -> Any:+ return await self.folders.get_workflow_permanent_ids_in_folder(*args, **kwargs)++ async def soft_delete_folder(self, *args: Any, **kwargs: Any) -> Any:+ return await self.folders.soft_delete_folder(*args, **kwargs)++ async def get_folder_workflow_count(self, *args: Any, **kwargs: Any) -> Any:+ return await self.folders.get_folder_workflow_count(*args, **kwargs)++ async def get_folder_workflow_counts_batch(self, *args: Any, **kwargs: Any) -> Any:+ return await self.folders.get_folder_workflow_counts_batch(*args, **kwargs)++ async def update_workflow_folder(self, *args: Any, **kwargs: Any) -> Any:+ return await self.folders.update_workflow_folder(*args, **kwargs)++ # -- Organization delegates --++ async def get_active_verification_requests(self, *args: Any, **kwargs: Any) -> Any:+ return await self.organizations.get_active_verification_requests(*args, **kwargs)++ async def get_all_organizations(self, *args: Any, **kwargs: Any) -> Any:+ return await self.organizations.get_all_organizations(*args, **kwargs)++ async def get_organization(self, *args: Any, **kwargs: Any) -> Any:+ return await self.organizations.get_organization(*args, **kwargs)++ async def get_organization_by_domain(self, *args: Any, **kwargs: Any) -> Any:+ return await self.organizations.get_organization_by_domain(*args, **kwargs)++ async def create_organization(self, *args: Any, **kwargs: Any) -> Any:+ return await self.organizations.create_organization(*args, **kwargs)++ async def update_organization(self, *args: Any, **kwargs: Any) -> Any:+ return await self.organizations.update_organization(*args, **kwargs)++ async def get_valid_org_auth_token(self, *args: Any, **kwargs: Any) -> Any:+ return await self.organizations.get_valid_org_auth_token(*args, **kwargs)++ async def get_valid_org_auth_tokens(self, *args: Any, **kwargs: Any) -> Any:+ return await self.organizations.get_valid_org_auth_tokens(*args, **kwargs)++ async def validate_org_auth_token(self, *args: Any, **kwargs: Any) -> Any:+ return await self.organizations.validate_org_auth_token(*args, **kwargs)++ async def create_org_auth_token(self, *args: Any, **kwargs: Any) -> Any:+ return await self.organizations.create_org_auth_token(*args, **kwargs)++ async def invalidate_org_auth_tokens(self, *args: Any, **kwargs: Any) -> Any:+ return await self.organizations.invalidate_org_auth_tokens(*args, **kwargs)++ # -- Observer delegates --++ async def get_task_v2(self, *args: Any, **kwargs: Any) -> Any:+ return await self.observer.get_task_v2(*args, **kwargs)++ async def delete_thoughts(self, *args: Any, **kwargs: Any) -> Any:+ return await self.observer.delete_thoughts(*args, **kwargs)++ async def get_task_v2_by_workflow_run_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.observer.get_task_v2_by_workflow_run_id(*args, **kwargs)++ async def get_thought(self, *args: Any, **kwargs: Any) -> Any:+ return await self.observer.get_thought(*args, **kwargs)++ async def get_thoughts(self, *args: Any, **kwargs: Any) -> Any:+ return await self.observer.get_thoughts(*args, **kwargs)++ async def create_task_v2(self, *args: Any, **kwargs: Any) -> Any:+ return await self.observer.create_task_v2(*args, **kwargs)++ async def create_thought(self, *args: Any, **kwargs: Any) -> Any:+ return await self.observer.create_thought(*args, **kwargs)++ async def update_thought(self, *args: Any, **kwargs: Any) -> Any:+ return await self.observer.update_thought(*args, **kwargs)++ async def update_task_v2(self, *args: Any, **kwargs: Any) -> Any:+ return await self.observer.update_task_v2(*args, **kwargs)++ async def create_workflow_run_block(self, *args: Any, **kwargs: Any) -> Any:+ return await self.observer.create_workflow_run_block(*args, **kwargs)++ async def delete_workflow_run_blocks(self, *args: Any, **kwargs: Any) -> Any:+ return await self.observer.delete_workflow_run_blocks(*args, **kwargs)++ async def update_workflow_run_block(self, *args: Any, **kwargs: Any) -> Any:+ return await self.observer.update_workflow_run_block(*args, **kwargs)++ async def get_workflow_run_block(self, *args: Any, **kwargs: Any) -> Any:+ return await self.observer.get_workflow_run_block(*args, **kwargs)++ async def get_workflow_run_block_by_task_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.observer.get_workflow_run_block_by_task_id(*args, **kwargs)++ async def get_workflow_run_blocks(self, *args: Any, **kwargs: Any) -> Any:+ return await self.observer.get_workflow_run_blocks(*args, **kwargs)++ # -- Debug delegates --++ async def get_debug_session(self, *args: Any, **kwargs: Any) -> Any:+ return await self.debug.get_debug_session(*args, **kwargs)++ async def get_latest_block_run(self, *args: Any, **kwargs: Any) -> Any:+ return await self.debug.get_latest_block_run(*args, **kwargs)++ async def get_latest_completed_block_run(self, *args: Any, **kwargs: Any) -> Any:+ return await self.debug.get_latest_completed_block_run(*args, **kwargs)++ async def create_block_run(self, *args: Any, **kwargs: Any) -> Any:+ return await self.debug.create_block_run(*args, **kwargs)++ async def get_latest_debug_session_for_user(self, *args: Any, **kwargs: Any) -> Any:+ return await self.debug.get_latest_debug_session_for_user(*args, **kwargs)++ async def get_debug_session_by_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.debug.get_debug_session_by_id(*args, **kwargs)++ async def get_workflow_runs_by_debug_session_id(self, *args: Any, **kwargs: Any) -> Any:+ return await self.debug.get_workflow_runs_by_debug_session_id(*args, **kwargs)++ async def complete_debug_sessions(self, *args: Any, **kwargs: Any) -> Any:+ return await self.debug.complete_debug_sessions(*args, **kwargs)++ async def create_debug_session(self, *args: Any, **kwargs: Any) -> Any:+ return await self.debug.create_debug_session(*args, **kwargs)++ # -- NEW delegate methods (missing from branch) --++ async def get_artifact_by_id_no_org(self, *args: Any, **kwargs: Any) -> Any:+ return await self.artifacts.get_artifact_by_id_no_org(*args, **kwargs)++ async def replace_org_auth_token(self, *args: Any, **kwargs: Any) -> Any:+ return await self.organizations.replace_org_auth_token(*args, **kwargs)diff --git a/skyvern/forge/sdk/db/base_repository.py b/skyvern/forge/sdk/db/base_repository.pynew file mode 100644index 000000000..3f7a0a25b--- /dev/null+++ b/skyvern/forge/sdk/db/base_repository.py@@ -0,0 +1,33 @@+"""Base class for all repository classes extracted from AgentDB mixins."""++from __future__ import annotations++from typing import TYPE_CHECKING, Callable++from sqlalchemy.exc import SQLAlchemyError++if TYPE_CHECKING:+ from skyvern.forge.sdk.db.base_alchemy_db import _SessionFactory+++class BaseRepository:+ """Base for domain-specific repositories.++ Provides the session factory, debug flag, and retryable-error check+ that decorators like ``read_retry`` and ``db_operation`` rely on.+ """++ def __init__(+ self,+ session_factory: _SessionFactory,+ debug_enabled: bool = False,+ is_retryable_error_fn: Callable[[SQLAlchemyError], bool] | None = None,+ ) -> None:+ self.Session = session_factory+ self.debug_enabled = debug_enabled+ self._is_retryable_error_fn = is_retryable_error_fn++ def is_retryable_error(self, error: SQLAlchemyError) -> bool:+ if self._is_retryable_error_fn:+ return self._is_retryable_error_fn(error)+ return Falsediff --git a/skyvern/forge/sdk/db/exceptions.py b/skyvern/forge/sdk/db/exceptions.pyindex c901a5c9f..e1d9bbbb9 100644--- a/skyvern/forge/sdk/db/exceptions.py+++ b/skyvern/forge/sdk/db/exceptions.py@@ -1,2 +1,13 @@class NotFoundError(Exception):pass+++class ScheduleLimitExceededError(Exception):+ """Raised when attempting to create a schedule that would exceed the per-workflow limit."""++ def __init__(self, organization_id: str, workflow_permanent_id: str, current_count: int, max_allowed: int):+ self.organization_id = organization_id+ self.workflow_permanent_id = workflow_permanent_id+ self.current_count = current_count+ self.max_allowed = max_allowed+ super().__init__(f"Schedule limit {max_allowed} reached (current: {current_count})")diff --git a/skyvern/forge/sdk/db/mixins/__init__.py b/skyvern/forge/sdk/db/mixins/__init__.pyindex 37b163b9f..cdff30a18 100644--- a/skyvern/forge/sdk/db/mixins/__init__.py+++ b/skyvern/forge/sdk/db/mixins/__init__.py@@ -1,3 +1,8 @@+# DEPRECATED: These mixin classes have been superseded by the repository pattern+# in skyvern/forge/sdk/db/repositories/. AgentDB no longer inherits from these+# mixins — it composes repository instances instead. These files are retained+# temporarily to avoid breaking any downstream code that may import from here.+# TODO(SKY-62): Remove after 2026-Q2 once all imports are verified migrated.from skyvern.forge.sdk.db.mixins.artifacts import ArtifactsMixinfrom skyvern.forge.sdk.db.mixins.base import BaseAlchemyDB, read_retryfrom skyvern.forge.sdk.db.mixins.browser_sessions import BrowserSessionsMixindiff --git a/skyvern/forge/sdk/db/mixins/schedules.py b/skyvern/forge/sdk/db/mixins/schedules.pyindex d7db4cb0e..fcc382edd 100644--- a/skyvern/forge/sdk/db/mixins/schedules.py+++ b/skyvern/forge/sdk/db/mixins/schedules.py@@ -7,7 +7,8 @@ from typing import TYPE_CHECKING, Anyimport structlogfrom sqlalchemy import func, or_, select, text, update-from skyvern.forge.sdk.db._error_handling import db_operation, register_passthrough_exception+from skyvern.forge.sdk.db._error_handling import db_operation+from skyvern.forge.sdk.db.exceptions import ScheduleLimitExceededErrorfrom skyvern.forge.sdk.db.models import (WorkflowModel,WorkflowRunModel,@@ -26,20 +27,6 @@ LOG = structlog.get_logger()_UNSET = object()-class ScheduleLimitExceededError(Exception):- """Raised when attempting to create a schedule that would exceed the per-workflow limit."""-- def __init__(self, organization_id: str, workflow_permanent_id: str, current_count: int, max_allowed: int):- self.organization_id = organization_id- self.workflow_permanent_id = workflow_permanent_id- self.current_count = current_count- self.max_allowed = max_allowed- super().__init__(f"Schedule limit {max_allowed} reached (current: {current_count})")---register_passthrough_exception(ScheduleLimitExceededError)--class SchedulesMixin:"""Database operations for workflow schedules."""diff --git a/skyvern/forge/sdk/db/protocols.py b/skyvern/forge/sdk/db/protocols.pynew file mode 100644index 000000000..43fedb192--- /dev/null+++ b/skyvern/forge/sdk/db/protocols.py@@ -0,0 +1,42 @@+"""Typed Protocol contracts for cross-repository dependencies."""++from __future__ import annotations++from typing import TYPE_CHECKING, Protocol, runtime_checkable++if TYPE_CHECKING:+ from skyvern.forge.sdk.schemas.tasks import Task+ from skyvern.forge.sdk.workflow.models.parameter import WorkflowParameter+ from skyvern.forge.sdk.workflow.models.workflow import Workflow, WorkflowRun+++@runtime_checkable+class TaskReader(Protocol):+ async def get_task(self, task_id: str, organization_id: str | None = None) -> Task | None: ...+ async def get_tasks_by_workflow_run_id(self, workflow_run_id: str) -> list[Task]: ...+++@runtime_checkable+class WorkflowReader(Protocol):+ async def get_workflow_by_permanent_id(+ self,+ workflow_permanent_id: str,+ organization_id: str | None = None,+ version: int | None = None,+ ignore_version: int | None = None,+ filter_deleted: bool = True,+ ) -> Workflow | None: ...+++@runtime_checkable+class WorkflowParameterReader(Protocol):+ async def get_workflow_parameter(+ self,+ workflow_parameter_id: str,+ organization_id: str | None = None,+ ) -> WorkflowParameter | None: ...+++@runtime_checkable+class RunReader(Protocol):+ async def get_run(self, run_id: str, organization_id: str | None = None) -> WorkflowRun | None: ...diff --git a/skyvern/forge/sdk/db/repositories/__init__.py b/skyvern/forge/sdk/db/repositories/__init__.pynew file mode 100644index 000000000..b2f630134--- /dev/null+++ b/skyvern/forge/sdk/db/repositories/__init__.py@@ -0,0 +1,4 @@+"""Domain-specific repository classes extracted from AgentDB mixins."""++# Sentinel for distinguishing "not passed" from "passed as None" in update methods.+_UNSET = object()diff --git a/skyvern/forge/sdk/db/repositories/artifacts.py b/skyvern/forge/sdk/db/repositories/artifacts.pynew file mode 100644index 000000000..488723b86--- /dev/null+++ b/skyvern/forge/sdk/db/repositories/artifacts.py@@ -0,0 +1,452 @@+from __future__ import annotations++from typing import TYPE_CHECKING, Callable++import structlog+from sqlalchemy import and_, delete, or_, select, update+from sqlalchemy.exc import SQLAlchemyError++from skyvern.forge.sdk.artifact.models import Artifact, ArtifactType+from skyvern.forge.sdk.db._error_handling import db_operation+from skyvern.forge.sdk.db.base_repository import BaseRepository+from skyvern.forge.sdk.db.models import ActionModel, ArtifactModel+from skyvern.forge.sdk.db.protocols import RunReader+from skyvern.forge.sdk.db.utils import convert_to_artifact++if TYPE_CHECKING:+ from skyvern.forge.sdk.db.base_alchemy_db import _SessionFactory++LOG = structlog.get_logger()+++class ArtifactsRepository(BaseRepository):+ """Database operations for artifact management."""++ def __init__(+ self,+ session_factory: _SessionFactory,+ debug_enabled: bool = False,+ is_retryable_error_fn: Callable[[SQLAlchemyError], bool] | None = None,+ run_reader: RunReader | None = None,+ ) -> None:+ super().__init__(session_factory, debug_enabled, is_retryable_error_fn)+ self._run_reader = run_reader++ @db_operation("create_artifact")+ async def create_artifact(+ self,+ artifact_id: str,+ artifact_type: str,+ uri: str,+ organization_id: str,+ step_id: str | None = None,+ task_id: str | None = None,+ workflow_run_id: str | None = None,+ workflow_run_block_id: str | None = None,+ task_v2_id: str | None = None,+ run_id: str | None = None,+ thought_id: str | None = None,+ ai_suggestion_id: str | None = None,+ ) -> Artifact:+ async with self.Session() as session:+ new_artifact = ArtifactModel(+ artifact_id=artifact_id,+ artifact_type=artifact_type,+ uri=uri,+ task_id=task_id,+ step_id=step_id,+ workflow_run_id=workflow_run_id,+ workflow_run_block_id=workflow_run_block_id,+ observer_cruise_id=task_v2_id,+ observer_thought_id=thought_id,+ run_id=run_id,+ ai_suggestion_id=ai_suggestion_id,+ organization_id=organization_id,+ )+ session.add(new_artifact)+ await session.commit()+ await session.refresh(new_artifact)+ return convert_to_artifact(new_artifact, self.debug_enabled)++ @db_operation("bulk_create_artifacts")+ async def bulk_create_artifacts(+ self,+ artifact_models: list[ArtifactModel],+ ) -> list[Artifact]:+ """+ Bulk create multiple artifacts in a single database transaction.++ Args:+ artifact_models: List of ArtifactModel instances to insert++ Returns:+ List of created Artifact objects+ """+ if not artifact_models:+ return []++ async with self.Session() as session:+ session.add_all(artifact_models)+ await session.commit()++ # Refresh all artifacts to get their created_at and modified_at values+ for artifact in artifact_models:+ await session.refresh(artifact)++ return [convert_to_artifact(artifact, self.debug_enabled) for artifact in artifact_models]++ @db_operation("get_artifacts_for_task_v2")+ async def get_artifacts_for_task_v2(+ self,+ task_v2_id: str,+ organization_id: str | None = None,+ artifact_types: list[ArtifactType] | None = None,+ ) -> list[Artifact]:+ async with self.Session() as session:+ query = (+ select(ArtifactModel)+ .filter_by(observer_cruise_id=task_v2_id)+ .filter_by(organization_id=organization_id)+ )+ if artifact_types:+ query = query.filter(ArtifactModel.artifact_type.in_(artifact_types))++ query = query.order_by(ArtifactModel.created_at)+ if artifacts := (await session.scalars(query)).all():+ return [convert_to_artifact(artifact, self.debug_enabled) for artifact in artifacts]+ else:+ return []++ @db_operation("get_artifacts_for_task_step")+ async def get_artifacts_for_task_step(+ self,+ task_id: str,+ step_id: str,+ organization_id: str | None = None,+ ) -> list[Artifact]:+ async with self.Session() as session:+ if artifacts := (+ await session.scalars(+ select(ArtifactModel)+ .filter_by(task_id=task_id)+ .filter_by(step_id=step_id)+ .filter_by(organization_id=organization_id)+ .order_by(ArtifactModel.created_at)+ )+ ).all():+ return [convert_to_artifact(artifact, self.debug_enabled) for artifact in artifacts]+ else:+ return []++ @db_operation("get_artifacts_for_run")+ async def get_artifacts_for_run(+ self,+ run_id: str,+ organization_id: str,+ artifact_types: list[ArtifactType] | None = None,+ group_by_type: bool = False,+ sort_by: str = "created_at",+ ) -> dict[ArtifactType, list[Artifact]] | list[Artifact]:+ """Return artifacts associated with a run.++ Args:+ run_id: The ID of the run to get artifacts for+ organization_id: The ID of the organization that owns the run+ artifact_types: Optional list of artifact types to filter by+ group_by_type: If True, returns a dictionary mapping artifact types to lists of artifacts.+ If False, returns a flat list of artifacts. Defaults to False.+ sort_by: Field to sort artifacts by. Must be one of: 'created_at', 'step_id', 'task_id'.+ Defaults to 'created_at'.++ Returns:+ If group_by_type is True, returns a dictionary mapping artifact types to lists of artifacts.+ If group_by_type is False, returns a list of artifacts sorted by the specified field.++ Raises:+ ValueError: If sort_by is not one of the allowed values+ """+ allowed_sort_fields = {"created_at", "step_id", "task_id"}+ if sort_by not in allowed_sort_fields:+ raise ValueError(f"sort_by must be one of {allowed_sort_fields}")+ if self._run_reader is None:+ raise RuntimeError("run_reader dependency not set")+ run = await self._run_reader.get_run(run_id, organization_id=organization_id)+ if not run:+ return []++ async with self.Session() as session:+ query = select(ArtifactModel).filter_by(organization_id=organization_id)++ query = query.filter_by(run_id=run.run_id)++ if artifact_types:+ query = query.filter(ArtifactModel.artifact_type.in_(artifact_types))++ # Apply sorting+ if sort_by == "created_at":+ query = query.order_by(ArtifactModel.created_at)+ elif sort_by == "step_id":+ query = query.order_by(ArtifactModel.step_id, ArtifactModel.created_at)+ elif sort_by == "task_id":+ query = query.order_by(ArtifactModel.task_id, ArtifactModel.created_at)++ # Execute query and convert to Artifact objects+ artifacts = [+ convert_to_artifact(artifact, self.debug_enabled) for artifact in (await session.scalars(query)).all()+ ]++ # Group artifacts by type if requested+ if group_by_type:+ result: dict[ArtifactType, list[Artifact]] = {}+ for artifact in artifacts:+ if artifact.artifact_type not in result:+ result[artifact.artifact_type] = []+ result[artifact.artifact_type].append(artifact)+ return result++ return artifacts++ @db_operation("get_artifact_by_id")+ async def get_artifact_by_id(+ self,+ artifact_id: str,+ organization_id: str,+ ) -> Artifact | None:+ async with self.Session() as session:+ if artifact := (+ await session.scalars(+ select(ArtifactModel).filter_by(artifact_id=artifact_id).filter_by(organization_id=organization_id)+ )+ ).first():+ return convert_to_artifact(artifact, self.debug_enabled)+ else:+ return None++ async def get_artifact_by_id_no_org(+ self,+ artifact_id: str,+ ) -> Artifact | None:+ """Fetch an artifact by ID without an organization filter.++ Only use this when the caller has already verified authorization through+ an out-of-band mechanism (e.g. a valid HMAC-signed URL).+ """+ async with self.Session() as session:+ if artifact := (await session.scalars(select(ArtifactModel).filter_by(artifact_id=artifact_id))).first():+ return convert_to_artifact(artifact, self.debug_enabled)+ else:+ return None++ @db_operation("get_artifacts_by_ids")+ async def get_artifacts_by_ids(+ self,+ artifact_ids: list[str],+ organization_id: str,+ ) -> list[Artifact]:+ if not artifact_ids:+ return []+ async with self.Session() as session:+ artifacts = (+ await session.scalars(+ select(ArtifactModel)+ .filter(ArtifactModel.artifact_id.in_(artifact_ids))+ .filter_by(organization_id=organization_id)+ )+ ).all()+ return [convert_to_artifact(artifact, self.debug_enabled) for artifact in artifacts]++ @db_operation("get_artifacts_by_entity_id")+ async def get_artifacts_by_entity_id(+ self,+ *,+ organization_id: str | None,+ artifact_type: ArtifactType | None = None,+ task_id: str | None = None,+ step_id: str | None = None,+ workflow_run_id: str | None = None,+ workflow_run_block_id: str | None = None,+ thought_id: str | None = None,+ task_v2_id: str | None = None,+ limit: int | None = None,+ ) -> list[Artifact]:+ async with self.Session() as session:+ # Build base query+ query = select(ArtifactModel)++ if artifact_type is not None:+ query = query.filter_by(artifact_type=artifact_type)+ if task_id is not None:+ query = query.filter_by(task_id=task_id)+ if step_id is not None:+ query = query.filter_by(step_id=step_id)+ if workflow_run_id is not None:+ query = query.filter_by(workflow_run_id=workflow_run_id)+ if workflow_run_block_id is not None:+ query = query.filter_by(workflow_run_block_id=workflow_run_block_id)+ if thought_id is not None:+ query = query.filter_by(observer_thought_id=thought_id)+ if task_v2_id is not None:+ query = query.filter_by(observer_cruise_id=task_v2_id)+ # Handle backward compatibility where old artifact rows were stored with organization_id NULL+ if organization_id is not None:+ query = query.filter(+ or_(ArtifactModel.organization_id == organization_id, ArtifactModel.organization_id.is_(None))+ )++ query = query.order_by(ArtifactModel.created_at.desc())++ if limit is not None:+ query = query.limit(limit)++ artifacts = (await session.scalars(query)).all()+ LOG.debug("Artifacts fetched", count=len(artifacts))+ return [convert_to_artifact(a, self.debug_enabled) for a in artifacts]++ @db_operation("get_artifact_by_entity_id")+ async def get_artifact_by_entity_id(+ self,+ *,+ artifact_type: ArtifactType,+ organization_id: str,+ task_id: str | None = None,+ step_id: str | None = None,+ workflow_run_id: str | None = None,+ workflow_run_block_id: str | None = None,+ thought_id: str | None = None,+ task_v2_id: str | None = None,+ ) -> Artifact | None:+ artifacts = await self.get_artifacts_by_entity_id(+ organization_id=organization_id,+ artifact_type=artifact_type,+ task_id=task_id,+ step_id=step_id,+ workflow_run_id=workflow_run_id,+ workflow_run_block_id=workflow_run_block_id,+ thought_id=thought_id,+ task_v2_id=task_v2_id,+ limit=1,+ )+ return artifacts[0] if artifacts else None++ @db_operation("get_artifact")+ async def get_artifact(+ self,+ task_id: str,+ step_id: str,+ artifact_type: ArtifactType,+ organization_id: str | None = None,+ ) -> Artifact | None:+ async with self.Session() as session:+ artifact = (+ await session.scalars(+ select(ArtifactModel)+ .filter_by(task_id=task_id)+ .filter_by(step_id=step_id)+ .filter_by(organization_id=organization_id)+ .filter_by(artifact_type=artifact_type)+ .order_by(ArtifactModel.created_at.desc())+ )+ ).first()+ if artifact:+ return convert_to_artifact(artifact, self.debug_enabled)+ return None++ @db_operation("get_artifact_for_run")+ async def get_artifact_for_run(+ self,+ run_id: str,+ artifact_type: ArtifactType,+ organization_id: str | None = None,+ ) -> Artifact | None:+ async with self.Session() as session:+ artifact = (+ await session.scalars(+ select(ArtifactModel)+ .filter(ArtifactModel.run_id == run_id)+ .filter(ArtifactModel.artifact_type == artifact_type)+ .filter(ArtifactModel.organization_id == organization_id)+ .order_by(ArtifactModel.created_at.desc())+ )+ ).first()+ if artifact:+ return convert_to_artifact(artifact, self.debug_enabled)+ return None++ @db_operation("get_latest_artifact")+ async def get_latest_artifact(+ self,+ task_id: str,+ step_id: str | None = None,+ artifact_types: list[ArtifactType] | None = None,+ organization_id: str | None = None,+ ) -> Artifact | None:+ artifacts = await self.get_latest_n_artifacts(+ task_id=task_id,+ step_id=step_id,+ artifact_types=artifact_types,+ organization_id=organization_id,+ n=1,+ )+ if artifacts:+ return artifacts[0]+ return None++ @db_operation("get_latest_n_artifacts")+ async def get_latest_n_artifacts(+ self,+ task_id: str,+ step_id: str | None = None,+ artifact_types: list[ArtifactType] | None = None,+ organization_id: str | None = None,+ n: int = 1,+ ) -> list[Artifact] | None:+ async with self.Session() as session:+ artifact_query = select(ArtifactModel).filter_by(task_id=task_id)+ if organization_id:+ artifact_query = artifact_query.filter_by(organization_id=organization_id)+ if step_id:+ artifact_query = artifact_query.filter_by(step_id=step_id)+ if artifact_types:+ artifact_query = artifact_query.filter(ArtifactModel.artifact_type.in_(artifact_types))++ artifacts = (await session.scalars(artifact_query.order_by(ArtifactModel.created_at.desc()))).fetchmany(n)+ if artifacts:+ return [convert_to_artifact(artifact, self.debug_enabled) for artifact in artifacts]+ return None++ @db_operation("delete_task_artifacts")+ async def delete_task_artifacts(self, organization_id: str, task_id: str) -> None:+ async with self.Session() as session:+ # delete artifacts by filtering organization_id and task_id+ stmt = delete(ArtifactModel).where(+ and_(+ ArtifactModel.organization_id == organization_id,+ ArtifactModel.task_id == task_id,+ )+ )+ await session.execute(stmt)+ await session.commit()++ @db_operation("delete_task_v2_artifacts")+ async def delete_task_v2_artifacts(self, task_v2_id: str, organization_id: str | None = None) -> None:+ async with self.Session() as session:+ stmt = delete(ArtifactModel).where(+ and_(+ ArtifactModel.observer_cruise_id == task_v2_id,+ ArtifactModel.organization_id == organization_id,+ )+ )+ await session.execute(stmt)+ await session.commit()++ @db_operation("update_action_screenshot_artifact_id")+ async def update_action_screenshot_artifact_id(+ self, *, organization_id: str, action_id: str, screenshot_artifact_id: str+ ) -> None:+ async with self.Session() as session:+ await session.execute(+ update(ActionModel)+ .where(ActionModel.action_id == action_id, ActionModel.organization_id == organization_id)+ .values(screenshot_artifact_id=screenshot_artifact_id)+ )+ await session.commit()diff --git a/skyvern/forge/sdk/db/repositories/browser_sessions.py b/skyvern/forge/sdk/db/repositories/browser_sessions.pynew file mode 100644index 000000000..7af27782c--- /dev/null+++ b/skyvern/forge/sdk/db/repositories/browser_sessions.py@@ -0,0 +1,472 @@+from __future__ import annotations++import uuid+from datetime import datetime, timedelta, timezone++import structlog+from sqlalchemy import asc, case, select++from skyvern.exceptions import BrowserProfileNotFound+from skyvern.forge.sdk.db._error_handling import db_operation+from skyvern.forge.sdk.db.base_alchemy_db import read_retry+from skyvern.forge.sdk.db.base_repository import BaseRepository+from skyvern.forge.sdk.db.exceptions import NotFoundError+from skyvern.forge.sdk.db.models import (+ BrowserProfileModel,+ DebugSessionModel,+ PersistentBrowserSessionModel,+)+from skyvern.forge.sdk.db.utils import serialize_proxy_location+from skyvern.forge.sdk.schemas.browser_profiles import BrowserProfile+from skyvern.forge.sdk.schemas.debug_sessions import DebugSession+from skyvern.forge.sdk.schemas.persistent_browser_sessions import (+ Extensions,+ PersistentBrowserSession,+ PersistentBrowserType,+)+from skyvern.schemas.runs import ProxyLocation, ProxyLocationInput++LOG = structlog.get_logger()+++class BrowserSessionsRepository(BaseRepository):+ """Database operations for browser profiles and persistent browser sessions."""++ @db_operation("create_browser_profile")+ async def create_browser_profile(+ self,+ organization_id: str,+ name: str,+ description: str | None = None,+ ) -> BrowserProfile:+ async with self.Session() as session:+ browser_profile = BrowserProfileModel(+ organization_id=organization_id,+ name=name,+ description=description,+ )+ session.add(browser_profile)+ await session.commit()+ await session.refresh(browser_profile)+ return BrowserProfile.model_validate(browser_profile)++ @db_operation("get_browser_profile")+ async def get_browser_profile(+ self,+ profile_id: str,+ organization_id: str,+ include_deleted: bool = False,+ ) -> BrowserProfile | None:+ async with self.Session() as session:+ query = (+ select(BrowserProfileModel)+ .filter_by(browser_profile_id=profile_id)+ .filter_by(organization_id=organization_id)+ )+ if not include_deleted:+ query = query.filter(BrowserProfileModel.deleted_at.is_(None))++ browser_profile = (await session.scalars(query)).first()+ if not browser_profile:+ return None+ return BrowserProfile.model_validate(browser_profile)++ @db_operation("list_browser_profiles")+ async def list_browser_profiles(+ self,+ organization_id: str,+ include_deleted: bool = False,+ ) -> list[BrowserProfile]:+ async with self.Session() as session:+ query = select(BrowserProfileModel).filter_by(organization_id=organization_id)+ if not include_deleted:+ query = query.filter(BrowserProfileModel.deleted_at.is_(None))+ browser_profiles = await session.scalars(query.order_by(asc(BrowserProfileModel.created_at)))+ return [BrowserProfile.model_validate(profile) for profile in browser_profiles.all()]++ @db_operation("delete_browser_profile")+ async def delete_browser_profile(+ self,+ profile_id: str,+ organization_id: str,+ ) -> None:+ async with self.Session() as session:+ query = (+ select(BrowserProfileModel)+ .filter_by(browser_profile_id=profile_id)+ .filter_by(organization_id=organization_id)+ .filter(BrowserProfileModel.deleted_at.is_(None))+ )+ browser_profile = (await session.scalars(query)).first()+ if not browser_profile:+ raise BrowserProfileNotFound(profile_id=profile_id, organization_id=organization_id)+ browser_profile.deleted_at = datetime.now(timezone.utc)+ await session.commit()++ @db_operation("get_active_persistent_browser_sessions")+ async def get_active_persistent_browser_sessions(+ self,+ organization_id: str,+ active_hours: int = 24,+ ) -> list[PersistentBrowserSession]:+ """Get all active persistent browser sessions for an organization."""+ async with self.Session() as session:+ result = await session.execute(+ select(PersistentBrowserSessionModel)+ .filter_by(organization_id=organization_id)+ .filter_by(deleted_at=None)+ .filter_by(completed_at=None)+ .filter(+ PersistentBrowserSessionModel.created_at+ > datetime.now(timezone.utc) - timedelta(hours=active_hours)+ )+ )+ sessions = result.scalars().all()+ return [PersistentBrowserSession.model_validate(session) for session in sessions]++ @db_operation("get_persistent_browser_sessions_history")+ async def get_persistent_browser_sessions_history(+ self,+ organization_id: str,+ page: int = 1,+ page_size: int = 10,+ lookback_hours: int = 24 * 7,+ ) -> list[PersistentBrowserSession]:+ """Get persistent browser sessions history for an organization."""+ async with self.Session() as session:+ open_first = case(+ (+ PersistentBrowserSessionModel.status == "running",+ 0, # open+ ),+ else_=1, # not open+ )++ result = await session.execute(+ select(PersistentBrowserSessionModel)+ .filter_by(organization_id=organization_id)+ .filter_by(deleted_at=None)+ .filter(+ PersistentBrowserSessionModel.created_at+ > (datetime.now(timezone.utc) - timedelta(hours=lookback_hours))+ )+ .order_by(+ open_first.asc(), # open sessions first+ PersistentBrowserSessionModel.created_at.desc(), # then newest within each group+ )+ .offset((page - 1) * page_size)+ .limit(page_size)+ )+ sessions = result.scalars().all()+ return [PersistentBrowserSession.model_validate(session) for session in sessions]++ @read_retry()+ @db_operation("get_persistent_browser_session_by_runnable_id", log_errors=False)+ async def get_persistent_browser_session_by_runnable_id(+ self, runnable_id: str, organization_id: str | None = None+ ) -> PersistentBrowserSession | None:+ """Get a specific persistent browser session."""+ async with self.Session() as session:+ query = (+ select(PersistentBrowserSessionModel)+ .filter_by(runnable_id=runnable_id)+ .filter_by(deleted_at=None)+ .filter_by(completed_at=None)+ )+ if organization_id:+ query = query.filter_by(organization_id=organization_id)+ persistent_browser_session = (await session.scalars(query)).first()+ if persistent_browser_session:+ return PersistentBrowserSession.model_validate(persistent_browser_session)+ return None++ @db_operation("get_persistent_browser_session")+ async def get_persistent_browser_session(+ self,+ session_id: str,+ organization_id: str | None = None,+ ) -> PersistentBrowserSession | None:+ """Get a specific persistent browser session."""+ async with self.Session() as session:+ persistent_browser_session = (+ await session.scalars(+ select(PersistentBrowserSessionModel)+ .filter_by(persistent_browser_session_id=session_id)+ .filter_by(organization_id=organization_id)+ .filter_by(deleted_at=None)+ )+ ).first()+ if persistent_browser_session:+ return PersistentBrowserSession.model_validate(persistent_browser_session)+ return None++ @db_operation("create_persistent_browser_session")+ async def create_persistent_browser_session(+ self,+ organization_id: str,+ runnable_type: str | None = None,+ runnable_id: str | None = None,+ timeout_minutes: int | None = None,+ proxy_location: ProxyLocationInput = ProxyLocation.RESIDENTIAL,+ extensions: list[Extensions] | None = None,+ browser_type: PersistentBrowserType | None = None,+ browser_profile_id: str | None = None,+ ) -> PersistentBrowserSession:+ """Create a new persistent browser session."""+ extensions_str: list[str] | None = (+ [extension.value for extension in extensions] if extensions is not None else None+ )+ async with self.Session() as session:+ browser_session = PersistentBrowserSessionModel(+ organization_id=organization_id,+ runnable_type=runnable_type,+ runnable_id=runnable_id,+ timeout_minutes=timeout_minutes,+ proxy_location=serialize_proxy_location(proxy_location),+ extensions=extensions_str,+ browser_type=browser_type.value if browser_type else None,+ browser_profile_id=browser_profile_id,+ )+ session.add(browser_session)+ await session.commit()+ await session.refresh(browser_session)+ return PersistentBrowserSession.model_validate(browser_session)++ @db_operation("update_persistent_browser_session")+ async def update_persistent_browser_session(+ self,+ browser_session_id: str,+ *,+ status: str | None = None,+ timeout_minutes: int | None = None,+ organization_id: str | None = None,+ completed_at: datetime | None = None,+ ) -> PersistentBrowserSession:+ async with self.Session() as session:+ persistent_browser_session = (+ await session.scalars(+ select(PersistentBrowserSessionModel)+ .filter_by(persistent_browser_session_id=browser_session_id)+ .filter_by(organization_id=organization_id)+ .filter_by(deleted_at=None)+ )+ ).first()+ if not persistent_browser_session:+ raise NotFoundError(f"PersistentBrowserSession {browser_session_id} not found")++ if status:+ persistent_browser_session.status = status+ if timeout_minutes:+ persistent_browser_session.timeout_minutes = timeout_minutes+ if completed_at:+ persistent_browser_session.completed_at = completed_at++ await session.commit()+ await session.refresh(persistent_browser_session)+ return PersistentBrowserSession.model_validate(persistent_browser_session)++ @db_operation("set_persistent_browser_session_browser_address")+ async def set_persistent_browser_session_browser_address(+ self,+ browser_session_id: str,+ browser_address: str | None,+ ip_address: str | None,+ ecs_task_arn: str | None,+ organization_id: str | None = None,+ ) -> None:+ """Set the browser address for a persistent browser session."""+ async with self.Session() as session:+ persistent_browser_session = (+ await session.scalars(+ select(PersistentBrowserSessionModel)+ .filter_by(persistent_browser_session_id=browser_session_id)+ .filter_by(organization_id=organization_id)+ .filter_by(deleted_at=None)+ )+ ).first()+ if persistent_browser_session:+ if browser_address:+ persistent_browser_session.browser_address = browser_address+ # once the address is set, the session is started+ persistent_browser_session.started_at = datetime.now(timezone.utc)+ if ip_address:+ persistent_browser_session.ip_address = ip_address+ if ecs_task_arn:+ persistent_browser_session.ecs_task_arn = ecs_task_arn+ await session.commit()+ await session.refresh(persistent_browser_session)+ else:+ raise NotFoundError(f"PersistentBrowserSession {browser_session_id} not found")++ @db_operation("update_persistent_browser_session_compute_cost")+ async def update_persistent_browser_session_compute_cost(+ self,+ session_id: str,+ organization_id: str,+ instance_type: str,+ vcpu_millicores: int,+ memory_mb: int,+ duration_ms: int,+ compute_cost: float,+ ) -> None:+ """Update the compute cost fields for a persistent browser session"""+ async with self.Session() as session:+ persistent_browser_session = (+ await session.scalars(+ select(PersistentBrowserSessionModel)+ .filter_by(persistent_browser_session_id=session_id)+ .filter_by(organization_id=organization_id)+ .filter_by(deleted_at=None)+ )+ ).first()+ if persistent_browser_session:+ persistent_browser_session.instance_type = instance_type+ persistent_browser_session.vcpu_millicores = vcpu_millicores+ persistent_browser_session.memory_mb = memory_mb+ persistent_browser_session.duration_ms = duration_ms+ persistent_browser_session.compute_cost = compute_cost+ await session.commit()+ await session.refresh(persistent_browser_session)+ else:+ raise NotFoundError(f"PersistentBrowserSession {session_id} not found")++ @db_operation("mark_persistent_browser_session_deleted")+ async def mark_persistent_browser_session_deleted(self, session_id: str, organization_id: str) -> None:+ """Mark a persistent browser session as deleted."""+ async with self.Session() as session:+ persistent_browser_session = (+ await session.scalars(+ select(PersistentBrowserSessionModel)+ .filter_by(persistent_browser_session_id=session_id)+ .filter_by(organization_id=organization_id)+ )+ ).first()+ if persistent_browser_session:+ persistent_browser_session.deleted_at = datetime.now(timezone.utc)+ await session.commit()+ await session.refresh(persistent_browser_session)+ else:+ raise NotFoundError(f"PersistentBrowserSession {session_id} not found")++ @db_operation("occupy_persistent_browser_session")+ async def occupy_persistent_browser_session(+ self, session_id: str, runnable_type: str, runnable_id: str, organization_id: str+ ) -> None:+ """Occupy a specific persistent browser session."""+ async with self.Session() as session:+ persistent_browser_session = (+ await session.scalars(+ select(PersistentBrowserSessionModel)+ .filter_by(persistent_browser_session_id=session_id)+ .filter_by(organization_id=organization_id)+ .filter_by(deleted_at=None)+ )+ ).first()+ if persistent_browser_session:+ persistent_browser_session.runnable_type = runnable_type+ persistent_browser_session.runnable_id = runnable_id+ await session.commit()+ await session.refresh(persistent_browser_session)+ else:+ raise NotFoundError(f"PersistentBrowserSession {session_id} not found")++ @db_operation("release_persistent_browser_session")+ async def release_persistent_browser_session(+ self,+ session_id: str,+ organization_id: str,+ ) -> PersistentBrowserSession:+ """Release a specific persistent browser session."""+ async with self.Session() as session:+ persistent_browser_session = (+ await session.scalars(+ select(PersistentBrowserSessionModel)+ .filter_by(persistent_browser_session_id=session_id)+ .filter_by(organization_id=organization_id)+ .filter_by(deleted_at=None)+ )+ ).first()+ if persistent_browser_session:+ persistent_browser_session.runnable_type = None+ persistent_browser_session.runnable_id = None+ await session.commit()+ await session.refresh(persistent_browser_session)+ return PersistentBrowserSession.model_validate(persistent_browser_session)+ else:+ raise NotFoundError(f"PersistentBrowserSession {session_id} not found")++ @db_operation("close_persistent_browser_session")+ async def close_persistent_browser_session(self, session_id: str, organization_id: str) -> PersistentBrowserSession:+ """Close a specific persistent browser session."""+ async with self.Session() as session:+ persistent_browser_session = (+ await session.scalars(+ select(PersistentBrowserSessionModel)+ .filter_by(persistent_browser_session_id=session_id)+ .filter_by(organization_id=organization_id)+ .filter_by(deleted_at=None)+ )+ ).first()+ if persistent_browser_session:+ if persistent_browser_session.completed_at:+ return PersistentBrowserSession.model_validate(persistent_browser_session)+ persistent_browser_session.completed_at = datetime.now(timezone.utc)+ persistent_browser_session.status = "completed"+ await session.commit()+ await session.refresh(persistent_browser_session)+ return PersistentBrowserSession.model_validate(persistent_browser_session)+ raise NotFoundError(f"PersistentBrowserSession {session_id} not found")++ @db_operation("get_all_active_persistent_browser_sessions")+ async def get_all_active_persistent_browser_sessions(self) -> list[PersistentBrowserSessionModel]:+ """Get all active persistent browser sessions across all organizations."""+ async with self.Session() as session:+ result = await session.execute(select(PersistentBrowserSessionModel).filter_by(deleted_at=None))+ return result.scalars().all()++ @db_operation("archive_browser_session_address")+ async def archive_browser_session_address(self, session_id: str, organization_id: str) -> None:+ """Suffix browser_address with a unique tag so the unique constraint+ no longer blocks new sessions that reuse the same local address."""+ async with self.Session() as session:+ row = (+ await session.scalars(+ select(PersistentBrowserSessionModel)+ .filter_by(persistent_browser_session_id=session_id)+ .filter_by(organization_id=organization_id)+ .filter_by(deleted_at=None)+ )+ ).first()++ if not row or not row.browser_address:+ return+ if "::closed::" in row.browser_address:+ return++ row.browser_address = f"{row.browser_address}::closed::{uuid.uuid4().hex}"+ await session.commit()++ @db_operation("get_uncompleted_persistent_browser_sessions")+ async def get_uncompleted_persistent_browser_sessions(self) -> list[PersistentBrowserSessionModel]:+ """Get all browser sessions that have not been completed or deleted."""+ async with self.Session() as session:+ result = await session.execute(+ select(PersistentBrowserSessionModel).filter_by(deleted_at=None).filter_by(completed_at=None)+ )+ return result.scalars().all()++ @db_operation("get_debug_session_by_browser_session_id")+ async def get_debug_session_by_browser_session_id(+ self,+ browser_session_id: str,+ organization_id: str,+ ) -> DebugSession | None:+ async with self.Session() as session:+ query = (+ select(DebugSessionModel)+ .filter_by(browser_session_id=browser_session_id)+ .filter_by(organization_id=organization_id)+ .filter_by(deleted_at=None)+ )+ model = (await session.scalars(query)).first()+ return DebugSession.model_validate(model) if model else Nonediff --git a/skyvern/forge/sdk/db/repositories/credentials.py b/skyvern/forge/sdk/db/repositories/credentials.pynew file mode 100644index 000000000..9eb0ecf22--- /dev/null+++ b/skyvern/forge/sdk/db/repositories/credentials.py@@ -0,0 +1,209 @@+from __future__ import annotations++from datetime import datetime, timezone++from sqlalchemy import select++from skyvern.forge.sdk.db._error_handling import db_operation+from skyvern.forge.sdk.db.base_repository import BaseRepository+from skyvern.forge.sdk.db.exceptions import NotFoundError+from skyvern.forge.sdk.db.models import CredentialModel, OrganizationBitwardenCollectionModel+from skyvern.forge.sdk.schemas.credentials import Credential, CredentialType, CredentialVaultType+from skyvern.forge.sdk.schemas.organization_bitwarden_collections import OrganizationBitwardenCollection++from . import _UNSET+++class CredentialRepository(BaseRepository):+ """Database operations for credential and Bitwarden collection management."""++ @db_operation("create_credential")+ async def create_credential(+ self,+ organization_id: str,+ name: str,+ vault_type: CredentialVaultType,+ item_id: str,+ credential_type: CredentialType,+ username: str | None,+ totp_type: str,+ card_last4: str | None,+ card_brand: str | None,+ totp_identifier: str | None = None,+ secret_label: str | None = None,+ ) -> Credential:+ async with self.Session() as session:+ credential = CredentialModel(+ organization_id=organization_id,+ name=name,+ vault_type=vault_type,+ item_id=item_id,+ credential_type=credential_type,+ username=username,+ totp_type=totp_type,+ totp_identifier=totp_identifier,+ card_last4=card_last4,+ card_brand=card_brand,+ secret_label=secret_label,+ )+ session.add(credential)+ await session.commit()+ await session.refresh(credential)+ return Credential.model_validate(credential)++ @db_operation("get_credential")+ async def get_credential(self, credential_id: str, organization_id: str) -> Credential | None:+ async with self.Session() as session:+ credential = (+ await session.scalars(+ select(CredentialModel)+ .filter_by(credential_id=credential_id)+ .filter_by(organization_id=organization_id)+ .filter(CredentialModel.deleted_at.is_(None))+ )+ ).first()+ if credential:+ return Credential.model_validate(credential)+ return None++ @db_operation("get_credentials")+ async def get_credentials(+ self,+ organization_id: str,+ page: int = 1,+ page_size: int = 10,+ vault_type: str | None = None,+ ) -> list[Credential]:+ async with self.Session() as session:+ query = (+ select(CredentialModel)+ .filter_by(organization_id=organization_id)+ .filter(CredentialModel.deleted_at.is_(None))+ )+ if vault_type is not None:+ query = query.filter(CredentialModel.vault_type == vault_type)+ credentials = (+ await session.scalars(+ query.order_by(CredentialModel.created_at.desc()).offset((page - 1) * page_size).limit(page_size)+ )+ ).all()+ return [Credential.model_validate(credential) for credential in credentials]++ @db_operation("update_credential")+ async def update_credential(+ self,+ credential_id: str,+ organization_id: str,+ name: str | None = None,+ browser_profile_id: str | None | object = _UNSET,+ tested_url: str | None | object = _UNSET,+ ) -> Credential:+ async with self.Session() as session:+ credential = (+ await session.scalars(+ select(CredentialModel)+ .filter_by(credential_id=credential_id)+ .filter_by(organization_id=organization_id)+ .filter(CredentialModel.deleted_at.is_(None))+ )+ ).first()+ if not credential:+ raise NotFoundError(f"Credential {credential_id} not found")+ if name is not None:+ credential.name = name+ if browser_profile_id is not _UNSET:+ credential.browser_profile_id = browser_profile_id+ if tested_url is not _UNSET:+ credential.tested_url = tested_url+ await session.commit()+ await session.refresh(credential)+ return Credential.model_validate(credential)++ @db_operation("update_credential_vault_data")+ async def update_credential_vault_data(+ self,+ credential_id: str,+ organization_id: str,+ item_id: str,+ name: str,+ credential_type: CredentialType,+ username: str | None = None,+ totp_type: str = "none",+ totp_identifier: str | None = None,+ card_last4: str | None = None,+ card_brand: str | None = None,+ secret_label: str | None = None,+ ) -> Credential:+ async with self.Session() as session:+ credential = (+ await session.scalars(+ select(CredentialModel)+ .filter_by(credential_id=credential_id)+ .filter_by(organization_id=organization_id)+ .filter(CredentialModel.deleted_at.is_(None))+ .with_for_update()+ )+ ).first()+ if not credential:+ raise NotFoundError(f"Credential {credential_id} not found")+ credential.item_id = item_id+ credential.name = name+ credential.credential_type = credential_type+ credential.username = username+ credential.totp_type = totp_type+ credential.totp_identifier = totp_identifier+ credential.card_last4 = card_last4+ credential.card_brand = card_brand+ credential.secret_label = secret_label+ await session.commit()+ await session.refresh(credential)+ return Credential.model_validate(credential)++ @db_operation("delete_credential")+ async def delete_credential(self, credential_id: str, organization_id: str) -> None:+ async with self.Session() as session:+ credential = (+ await session.scalars(+ select(CredentialModel)+ .filter_by(credential_id=credential_id)+ .filter_by(organization_id=organization_id)+ )+ ).first()+ if not credential:+ raise NotFoundError(f"Credential {credential_id} not found")+ credential.deleted_at = datetime.now(timezone.utc)+ await session.commit()+ await session.refresh(credential)+ return None++ @db_operation("create_organization_bitwarden_collection")+ async def create_organization_bitwarden_collection(+ self,+ organization_id: str,+ collection_id: str,+ ) -> OrganizationBitwardenCollection:+ async with self.Session() as session:+ organization_bitwarden_collection = OrganizationBitwardenCollectionModel(+ organization_id=organization_id, collection_id=collection_id+ )+ session.add(organization_bitwarden_collection)+ await session.commit()+ await session.refresh(organization_bitwarden_collection)+ return OrganizationBitwardenCollection.model_validate(organization_bitwarden_collection)++ @db_operation("get_organization_bitwarden_collection")+ async def get_organization_bitwarden_collection(+ self,+ organization_id: str,+ ) -> OrganizationBitwardenCollection | None:+ async with self.Session() as session:+ organization_bitwarden_collection = (+ await session.scalars(+ select(OrganizationBitwardenCollectionModel)+ .filter_by(organization_id=organization_id)+ .filter_by(deleted_at=None)+ )+ ).first()+ if organization_bitwarden_collection:+ return OrganizationBitwardenCollection.model_validate(organization_bitwarden_collection)+ return Nonediff --git a/skyvern/forge/sdk/db/repositories/debug.py b/skyvern/forge/sdk/db/repositories/debug.pynew file mode 100644index 000000000..0627a4d86--- /dev/null+++ b/skyvern/forge/sdk/db/repositories/debug.py@@ -0,0 +1,254 @@+from __future__ import annotations++from sqlalchemy import select++from skyvern.forge.sdk.db._error_handling import db_operation+from skyvern.forge.sdk.db.base_repository import BaseRepository+from skyvern.forge.sdk.db.models import (+ BlockRunModel,+ DebugSessionModel,+ WorkflowRunModel,+)+from skyvern.forge.sdk.schemas.debug_sessions import BlockRun, DebugSession, DebugSessionRun+from skyvern.forge.sdk.workflow.models.workflow import WorkflowRunStatus+++class DebugRepository(BaseRepository):+ """Database operations for debug sessions and block runs."""++ @db_operation("get_debug_session")+ async def get_debug_session(+ self,+ *,+ organization_id: str,+ user_id: str,+ workflow_permanent_id: str,+ ) -> DebugSession | None:+ async with self.Session() as session:+ debug_session = (+ await session.scalars(+ select(DebugSessionModel)+ .filter_by(organization_id=organization_id)+ .filter_by(workflow_permanent_id=workflow_permanent_id)+ .filter_by(user_id=user_id)+ .filter_by(deleted_at=None)+ .filter_by(status="created")+ .order_by(DebugSessionModel.created_at.desc())+ )+ ).first()++ if not debug_session:+ return None++ return DebugSession.model_validate(debug_session)++ @db_operation("get_latest_block_run")+ async def get_latest_block_run(+ self,+ *,+ organization_id: str,+ user_id: str,+ block_label: str,+ ) -> BlockRun | None:+ async with self.Session() as session:+ query = (+ select(BlockRunModel)+ .filter_by(organization_id=organization_id)+ .filter_by(user_id=user_id)+ .filter_by(block_label=block_label)+ .order_by(BlockRunModel.created_at.desc())+ )++ model = (await session.scalars(query)).first()++ return BlockRun.model_validate(model) if model else None++ @db_operation("get_latest_completed_block_run")+ async def get_latest_completed_block_run(+ self,+ *,+ organization_id: str,+ user_id: str,+ block_label: str,+ workflow_permanent_id: str,+ ) -> BlockRun | None:+ async with self.Session() as session:+ query = (+ select(BlockRunModel)+ .join(WorkflowRunModel, BlockRunModel.workflow_run_id == WorkflowRunModel.workflow_run_id)+ .filter(BlockRunModel.organization_id == organization_id)+ .filter(BlockRunModel.user_id == user_id)+ .filter(BlockRunModel.block_label == block_label)+ .filter(WorkflowRunModel.status == WorkflowRunStatus.completed)+ .filter(WorkflowRunModel.workflow_permanent_id == workflow_permanent_id)+ .order_by(BlockRunModel.created_at.desc())+ )++ model = (await session.scalars(query)).first()++ return BlockRun.model_validate(model) if model else None++ @db_operation("create_block_run")+ async def create_block_run(+ self,+ *,+ organization_id: str,+ user_id: str,+ block_label: str,+ output_parameter_id: str,+ workflow_run_id: str,+ ) -> None:+ async with self.Session() as session:+ block_run = BlockRunModel(+ organization_id=organization_id,+ user_id=user_id,+ block_label=block_label,+ output_parameter_id=output_parameter_id,+ workflow_run_id=workflow_run_id,+ )++ session.add(block_run)++ await session.commit()++ @db_operation("get_latest_debug_session_for_user")+ async def get_latest_debug_session_for_user(+ self,+ *,+ organization_id: str,+ user_id: str,+ workflow_permanent_id: str,+ ) -> DebugSession | None:+ async with self.Session() as session:+ query = (+ select(DebugSessionModel)+ .filter_by(organization_id=organization_id)+ .filter_by(deleted_at=None)+ .filter_by(status="created")+ .filter_by(user_id=user_id)+ .filter_by(workflow_permanent_id=workflow_permanent_id)+ .order_by(DebugSessionModel.created_at.desc())+ )++ model = (await session.scalars(query)).first()++ return DebugSession.model_validate(model) if model else None++ @db_operation("get_debug_session_by_id")+ async def get_debug_session_by_id(+ self,+ debug_session_id: str,+ organization_id: str,+ ) -> DebugSession | None:+ async with self.Session() as session:+ query = (+ select(DebugSessionModel)+ .filter_by(organization_id=organization_id)+ .filter_by(deleted_at=None)+ .filter_by(debug_session_id=debug_session_id)+ )++ model = (await session.scalars(query)).first()++ return DebugSession.model_validate(model) if model else None++ @db_operation("get_workflow_runs_by_debug_session_id")+ async def get_workflow_runs_by_debug_session_id(+ self,+ debug_session_id: str,+ organization_id: str,+ ) -> list[DebugSessionRun]:+ async with self.Session() as session:+ query = (+ select(WorkflowRunModel, BlockRunModel)+ .join(BlockRunModel, BlockRunModel.workflow_run_id == WorkflowRunModel.workflow_run_id)+ .filter(WorkflowRunModel.organization_id == organization_id)+ .filter(WorkflowRunModel.debug_session_id == debug_session_id)+ .order_by(WorkflowRunModel.created_at.desc())+ )++ results = (await session.execute(query)).all()++ debug_session_runs = []+ for workflow_run, block_run in results:+ debug_session_runs.append(+ DebugSessionRun(+ ai_fallback=workflow_run.ai_fallback,+ block_label=block_run.block_label,+ browser_session_id=workflow_run.browser_session_id,+ code_gen=workflow_run.code_gen,+ debug_session_id=workflow_run.debug_session_id,+ failure_reason=workflow_run.failure_reason,+ output_parameter_id=block_run.output_parameter_id,+ run_with=workflow_run.run_with,+ script_run_id=workflow_run.script_run.get("script_run_id") if workflow_run.script_run else None,+ status=workflow_run.status,+ workflow_id=workflow_run.workflow_id,+ workflow_permanent_id=workflow_run.workflow_permanent_id,+ workflow_run_id=workflow_run.workflow_run_id,+ created_at=workflow_run.created_at,+ queued_at=workflow_run.queued_at,+ started_at=workflow_run.started_at,+ finished_at=workflow_run.finished_at,+ )+ )++ return debug_session_runs++ @db_operation("complete_debug_sessions")+ async def complete_debug_sessions(+ self,+ *,+ organization_id: str,+ user_id: str | None = None,+ workflow_permanent_id: str | None = None,+ ) -> list[DebugSession]:+ async with self.Session() as session:+ query = (+ select(DebugSessionModel)+ .filter_by(organization_id=organization_id)+ .filter_by(deleted_at=None)+ .filter_by(status="created")+ )++ if user_id:+ query = query.filter_by(user_id=user_id)+ if workflow_permanent_id:+ query = query.filter_by(workflow_permanent_id=workflow_permanent_id)++ models = (await session.scalars(query)).all()++ for model in models:+ model.status = "completed"++ debug_sessions = [DebugSession.model_validate(model) for model in models]++ await session.commit()++ return debug_sessions++ @db_operation("create_debug_session")+ async def create_debug_session(+ self,+ *,+ browser_session_id: str,+ organization_id: str,+ user_id: str,+ workflow_permanent_id: str,+ vnc_streaming_supported: bool,+ ) -> DebugSession:+ async with self.Session() as session:+ debug_session = DebugSessionModel(+ organization_id=organization_id,+ workflow_permanent_id=workflow_permanent_id,+ user_id=user_id,+ browser_session_id=browser_session_id,+ vnc_streaming_supported=vnc_streaming_supported,+ status="created",+ )++ session.add(debug_session)+ await session.commit()+ await session.refresh(debug_session)++ return DebugSession.model_validate(debug_session)diff --git a/skyvern/forge/sdk/db/repositories/folders.py b/skyvern/forge/sdk/db/repositories/folders.pynew file mode 100644index 000000000..f85ac5d63--- /dev/null+++ b/skyvern/forge/sdk/db/repositories/folders.py@@ -0,0 +1,370 @@+from __future__ import annotations++from datetime import datetime, timezone+from typing import TYPE_CHECKING, Callable++from sqlalchemy import func, or_, select, update+from sqlalchemy.exc import SQLAlchemyError++from skyvern.forge.sdk.db._error_handling import db_operation+from skyvern.forge.sdk.db.base_repository import BaseRepository+from skyvern.forge.sdk.db.models import FolderModel, WorkflowModel+from skyvern.forge.sdk.db.protocols import WorkflowReader+from skyvern.forge.sdk.db.utils import convert_to_workflow+from skyvern.forge.sdk.workflow.models.workflow import Workflow++if TYPE_CHECKING:+ from skyvern.forge.sdk.db.base_alchemy_db import _SessionFactory+++class FoldersRepository(BaseRepository):+ """Database operations for folder management."""++ def __init__(+ self,+ session_factory: _SessionFactory,+ debug_enabled: bool = False,+ is_retryable_error_fn: Callable[[SQLAlchemyError], bool] | None = None,+ workflow_reader: WorkflowReader | None = None,+ ) -> None:+ super().__init__(session_factory, debug_enabled, is_retryable_error_fn)+ self._workflow_reader = workflow_reader++ @db_operation("create_folder")+ async def create_folder(+ self,+ organization_id: str,+ title: str,+ description: str | None = None,+ ) -> FolderModel:+ """Create a new folder."""+ async with self.Session() as session:+ folder = FolderModel(+ organization_id=organization_id,+ title=title,+ description=description,+ )+ session.add(folder)+ await session.commit()+ await session.refresh(folder)+ return folder++ @db_operation("get_folders")+ async def get_folders(+ self,+ organization_id: str,+ page: int = 1,+ page_size: int = 10,+ search_query: str | None = None,+ ) -> list[FolderModel]:+ """Get all folders for an organization with pagination and optional search."""+ async with self.Session() as session:+ stmt = (+ select(FolderModel).filter_by(organization_id=organization_id).filter(FolderModel.deleted_at.is_(None))+ )++ if search_query:+ search_pattern = f"%{search_query}%"+ stmt = stmt.filter(+ or_(+ FolderModel.title.ilike(search_pattern),+ FolderModel.description.ilike(search_pattern),+ )+ )++ stmt = stmt.order_by(FolderModel.modified_at.desc())+ stmt = stmt.offset((page - 1) * page_size).limit(page_size)++ result = await session.execute(stmt)+ return list(result.scalars().all())++ @db_operation("get_folder")+ async def get_folder(+ self,+ folder_id: str,+ organization_id: str,+ ) -> FolderModel | None:+ """Get a folder by ID."""+ async with self.Session() as session:+ stmt = (+ select(FolderModel)+ .filter_by(folder_id=folder_id, organization_id=organization_id)+ .filter(FolderModel.deleted_at.is_(None))+ )+ result = await session.execute(stmt)+ return result.scalar_one_or_none()++ @db_operation("update_folder")+ async def update_folder(+ self,+ folder_id: str,+ organization_id: str,+ title: str | None = None,+ description: str | None = None,+ ) -> FolderModel | None:+ """Update a folder's title or description."""+ async with self.Session() as session:+ stmt = (+ select(FolderModel)+ .filter_by(folder_id=folder_id, organization_id=organization_id)+ .filter(FolderModel.deleted_at.is_(None))+ )+ result = await session.execute(stmt)+ folder = result.scalar_one_or_none()+ if not folder:+ return None++ if title is not None:+ folder.title = title+ if description is not None:+ folder.description = description++ folder.modified_at = datetime.now(timezone.utc)+ await session.commit()+ await session.refresh(folder)+ return folder++ @db_operation("get_workflow_permanent_ids_in_folder")+ async def get_workflow_permanent_ids_in_folder(+ self,+ folder_id: str,+ organization_id: str,+ ) -> list[str]:+ """Get workflow permanent IDs (latest versions only) in a folder."""+ async with self.Session() as session:+ # Subquery to get the latest version for each workflow+ subquery = (+ select(+ WorkflowModel.organization_id,+ WorkflowModel.workflow_permanent_id,+ func.max(WorkflowModel.version).label("max_version"),+ )+ .where(WorkflowModel.organization_id == organization_id)+ .where(WorkflowModel.deleted_at.is_(None))+ .group_by(+ WorkflowModel.organization_id,+ WorkflowModel.workflow_permanent_id,+ )+ .subquery()+ )++ # Get workflow_permanent_ids where the latest version is in this folder+ stmt = (+ select(WorkflowModel.workflow_permanent_id)+ .join(+ subquery,+ (WorkflowModel.organization_id == subquery.c.organization_id)+ & (WorkflowModel.workflow_permanent_id == subquery.c.workflow_permanent_id)+ & (WorkflowModel.version == subquery.c.max_version),+ )+ .where(WorkflowModel.folder_id == folder_id)+ )+ result = await session.execute(stmt)+ return list(result.scalars().all())++ @db_operation("soft_delete_folder")+ async def soft_delete_folder(+ self,+ folder_id: str,+ organization_id: str,+ delete_workflows: bool = False,+ ) -> bool:+ """Soft delete a folder. Optionally delete all workflows in the folder."""+ async with self.Session() as session:+ # Check if folder exists+ folder_stmt = (+ select(FolderModel)+ .filter_by(folder_id=folder_id, organization_id=organization_id)+ .filter(FolderModel.deleted_at.is_(None))+ )+ folder_result = await session.execute(folder_stmt)+ folder = folder_result.scalar_one_or_none()+ if not folder:+ return False++ # If delete_workflows is True, delete all workflows in the folder+ if delete_workflows:+ # Get workflow permanent IDs in the folder (inline logic)+ subquery = (+ select(+ WorkflowModel.organization_id,+ WorkflowModel.workflow_permanent_id,+ func.max(WorkflowModel.version).label("max_version"),+ )+ .where(WorkflowModel.organization_id == organization_id)+ .where(WorkflowModel.deleted_at.is_(None))+ .group_by(+ WorkflowModel.organization_id,+ WorkflowModel.workflow_permanent_id,+ )+ .subquery()+ )++ workflow_permanent_ids_stmt = (+ select(WorkflowModel.workflow_permanent_id)+ .join(+ subquery,+ (WorkflowModel.organization_id == subquery.c.organization_id)+ & (WorkflowModel.workflow_permanent_id == subquery.c.workflow_permanent_id)+ & (WorkflowModel.version == subquery.c.max_version),+ )+ .where(WorkflowModel.folder_id == folder_id)+ )+ result = await session.execute(workflow_permanent_ids_stmt)+ workflow_permanent_ids = list(result.scalars().all())++ # Soft delete all workflows with these permanent IDs in a single bulk update+ if workflow_permanent_ids:+ update_workflows_query = (+ update(WorkflowModel)+ .where(WorkflowModel.workflow_permanent_id.in_(workflow_permanent_ids))+ .where(WorkflowModel.organization_id == organization_id)+ .where(WorkflowModel.deleted_at.is_(None))+ .values(deleted_at=datetime.now(timezone.utc))+ )+ await session.execute(update_workflows_query)+ else:+ # Just remove folder_id from all workflows in this folder+ update_workflows_query = (+ update(WorkflowModel)+ .where(WorkflowModel.folder_id == folder_id)+ .where(WorkflowModel.organization_id == organization_id)+ .values(folder_id=None, modified_at=datetime.now(timezone.utc))+ )+ await session.execute(update_workflows_query)++ # Soft delete the folder+ folder.deleted_at = datetime.now(timezone.utc)+ await session.commit()+ return True++ @db_operation("get_folder_workflow_count")+ async def get_folder_workflow_count(+ self,+ folder_id: str,+ organization_id: str,+ ) -> int:+ """Get the count of workflows (latest versions only) in a folder."""+ async with self.Session() as session:+ # Subquery to get the latest version for each workflow (same pattern as get_workflows_by_organization_id)+ subquery = (+ select(+ WorkflowModel.organization_id,+ WorkflowModel.workflow_permanent_id,+ func.max(WorkflowModel.version).label("max_version"),+ )+ .where(WorkflowModel.organization_id == organization_id)+ .where(WorkflowModel.deleted_at.is_(None))+ .group_by(+ WorkflowModel.organization_id,+ WorkflowModel.workflow_permanent_id,+ )+ .subquery()+ )++ # Count workflows where the latest version is in this folder+ stmt = (+ select(func.count(WorkflowModel.workflow_permanent_id))+ .join(+ subquery,+ (WorkflowModel.organization_id == subquery.c.organization_id)+ & (WorkflowModel.workflow_permanent_id == subquery.c.workflow_permanent_id)+ & (WorkflowModel.version == subquery.c.max_version),+ )+ .where(WorkflowModel.folder_id == folder_id)+ )+ result = await session.execute(stmt)+ return result.scalar_one()++ @db_operation("get_folder_workflow_counts_batch")+ async def get_folder_workflow_counts_batch(+ self,+ folder_ids: list[str],+ organization_id: str,+ ) -> dict[str, int]:+ """Get workflow counts for multiple folders in a single query."""+ async with self.Session() as session:+ # Subquery to get the latest version for each workflow+ subquery = (+ select(+ WorkflowModel.organization_id,+ WorkflowModel.workflow_permanent_id,+ func.max(WorkflowModel.version).label("max_version"),+ )+ .where(WorkflowModel.organization_id == organization_id)+ .where(WorkflowModel.deleted_at.is_(None))+ .group_by(+ WorkflowModel.organization_id,+ WorkflowModel.workflow_permanent_id,+ )+ .subquery()+ )++ # Count workflows grouped by folder_id+ stmt = (+ select(+ WorkflowModel.folder_id,+ func.count(WorkflowModel.workflow_permanent_id).label("count"),+ )+ .join(+ subquery,+ (WorkflowModel.organization_id == subquery.c.organization_id)+ & (WorkflowModel.workflow_permanent_id == subquery.c.workflow_permanent_id)+ & (WorkflowModel.version == subquery.c.max_version),+ )+ .where(WorkflowModel.folder_id.in_(folder_ids))+ .group_by(WorkflowModel.folder_id)+ )+ result = await session.execute(stmt)+ rows = result.all()++ # Convert to dict; folders with no workflows will be absent from the result+ return {row.folder_id: row.count for row in rows}++ @db_operation("update_workflow_folder")+ async def update_workflow_folder(+ self,+ workflow_permanent_id: str,+ organization_id: str,+ folder_id: str | None,+ ) -> Workflow | None:+ """Update folder assignment for the latest version of a workflow."""+ # Get the latest version of the workflow+ if self._workflow_reader is None:+ raise RuntimeError("workflow_reader dependency not set")+ latest_workflow = await self._workflow_reader.get_workflow_by_permanent_id(+ workflow_permanent_id=workflow_permanent_id,+ organization_id=organization_id,+ )++ if not latest_workflow:+ return None++ async with self.Session() as session:+ # Validate folder exists in-org if folder_id is provided+ if folder_id:+ stmt = (+ select(FolderModel.folder_id)+ .where(FolderModel.folder_id == folder_id)+ .where(FolderModel.organization_id == organization_id)+ .where(FolderModel.deleted_at.is_(None))+ )+ if (await session.scalar(stmt)) is None:+ raise ValueError(f"Folder {folder_id} not found")++ workflow_model = await session.get(WorkflowModel, latest_workflow.workflow_id)+ if workflow_model:+ workflow_model.folder_id = folder_id+ workflow_model.modified_at = datetime.now(timezone.utc)++ # Update folder's modified_at in the same transaction+ if folder_id:+ folder_model = await session.get(FolderModel, folder_id)+ if folder_model:+ folder_model.modified_at = datetime.now(timezone.utc)++ await session.commit()+ await session.refresh(workflow_model)++ return convert_to_workflow(workflow_model, self.debug_enabled)+ return Nonediff --git a/skyvern/forge/sdk/db/repositories/observer.py b/skyvern/forge/sdk/db/repositories/observer.pynew file mode 100644index 000000000..11373e9b9--- /dev/null+++ b/skyvern/forge/sdk/db/repositories/observer.py@@ -0,0 +1,588 @@+from __future__ import annotations++from datetime import datetime, timezone+from typing import TYPE_CHECKING, Any, Callable++from sqlalchemy import and_, delete, select+from sqlalchemy.exc import SQLAlchemyError++from skyvern.forge.sdk.db._error_handling import db_operation+from skyvern.forge.sdk.db.base_alchemy_db import read_retry+from skyvern.forge.sdk.db.base_repository import BaseRepository+from skyvern.forge.sdk.db.exceptions import NotFoundError++if TYPE_CHECKING:+ from skyvern.forge.sdk.db.base_alchemy_db import _SessionFactory++from skyvern.forge.sdk.db.models import (+ TaskV2Model,+ ThoughtModel,+ WorkflowRunBlockModel,+)+from skyvern.forge.sdk.db.protocols import TaskReader+from skyvern.forge.sdk.db.utils import (+ convert_to_task_v2,+ convert_to_workflow_run_block,+ serialize_proxy_location,+)+from skyvern.forge.sdk.schemas.task_v2 import TaskV2, TaskV2Status, Thought, ThoughtType+from skyvern.forge.sdk.schemas.workflow_runs import WorkflowRunBlock+from skyvern.schemas.runs import ProxyLocationInput, RunEngine+from skyvern.schemas.workflows import BlockStatus, BlockType+++class ObserverRepository(BaseRepository):+ """Database operations for observer tasks (TaskV2), thoughts, and workflow run blocks."""++ def __init__(+ self,+ session_factory: _SessionFactory,+ debug_enabled: bool = False,+ is_retryable_error_fn: Callable[[SQLAlchemyError], bool] | None = None,+ task_reader: TaskReader | None = None,+ ) -> None:+ super().__init__(session_factory, debug_enabled, is_retryable_error_fn)+ self._task_reader = task_reader++ @read_retry()+ @db_operation("get_task_v2", log_errors=False)+ async def get_task_v2(self, task_v2_id: str, organization_id: str | None = None) -> TaskV2 | None:+ async with self.Session() as session:+ if task_v2 := (+ await session.scalars(+ select(TaskV2Model)+ .filter_by(observer_cruise_id=task_v2_id)+ .filter_by(organization_id=organization_id)+ )+ ).first():+ return convert_to_task_v2(task_v2, debug_enabled=self.debug_enabled)+ return None++ @db_operation("delete_thoughts")+ async def delete_thoughts(self, task_v2_id: str, organization_id: str | None = None) -> None:+ async with self.Session() as session:+ stmt = delete(ThoughtModel).where(+ and_(+ ThoughtModel.observer_cruise_id == task_v2_id,+ ThoughtModel.organization_id == organization_id,+ )+ )+ await session.execute(stmt)+ await session.commit()++ @db_operation("get_task_v2_by_workflow_run_id")+ async def get_task_v2_by_workflow_run_id(+ self,+ workflow_run_id: str,+ organization_id: str | None = None,+ ) -> TaskV2 | None:+ async with self.Session() as session:+ if task_v2 := (+ await session.scalars(+ select(TaskV2Model)+ .filter_by(organization_id=organization_id)+ .filter_by(workflow_run_id=workflow_run_id)+ )+ ).first():+ return convert_to_task_v2(task_v2, debug_enabled=self.debug_enabled)+ return None++ @db_operation("get_thought")+ async def get_thought(self, thought_id: str, organization_id: str | None = None) -> Thought | None:+ async with self.Session() as session:+ if thought := (+ await session.scalars(+ select(ThoughtModel)+ .filter_by(observer_thought_id=thought_id)+ .filter_by(organization_id=organization_id)+ )+ ).first():+ return Thought.model_validate(thought)+ return None++ @db_operation("get_thoughts")+ async def get_thoughts(+ self,+ *,+ task_v2_id: str,+ thought_types: list[ThoughtType],+ organization_id: str,+ ) -> list[Thought]:+ async with self.Session() as session:+ query = (+ select(ThoughtModel)+ .filter_by(observer_cruise_id=task_v2_id)+ .filter_by(organization_id=organization_id)+ .order_by(ThoughtModel.created_at)+ )+ if thought_types:+ query = query.filter(ThoughtModel.observer_thought_type.in_(thought_types))+ thoughts = (await session.scalars(query)).all()+ return [Thought.model_validate(thought) for thought in thoughts]++ @db_operation("create_task_v2")+ async def create_task_v2(+ self,+ workflow_run_id: str | None = None,+ workflow_id: str | None = None,+ workflow_permanent_id: str | None = None,+ prompt: str | None = None,+ url: str | None = None,+ organization_id: str | None = None,+ proxy_location: ProxyLocationInput = None,+ totp_identifier: str | None = None,+ totp_verification_url: str | None = None,+ webhook_callback_url: str | None = None,+ extracted_information_schema: dict | list | str | None = None,+ error_code_mapping: dict | None = None,+ model: dict[str, Any] | None = None,+ max_screenshot_scrolling_times: int | None = None,+ extra_http_headers: dict[str, str] | None = None,+ browser_address: str | None = None,+ run_with: str | None = None,+ ) -> TaskV2:+ async with self.Session() as session:+ new_task_v2 = TaskV2Model(+ workflow_run_id=workflow_run_id,+ workflow_id=workflow_id,+ workflow_permanent_id=workflow_permanent_id,+ prompt=prompt,+ url=url,+ proxy_location=serialize_proxy_location(proxy_location),+ totp_identifier=totp_identifier,+ totp_verification_url=totp_verification_url,+ webhook_callback_url=webhook_callback_url,+ extracted_information_schema=extracted_information_schema,+ error_code_mapping=error_code_mapping,+ organization_id=organization_id,+ model=model,+ max_screenshot_scrolling_times=max_screenshot_scrolling_times,+ extra_http_headers=extra_http_headers,+ browser_address=browser_address,+ run_with=run_with,+ )+ session.add(new_task_v2)+ await session.commit()+ await session.refresh(new_task_v2)+ return convert_to_task_v2(new_task_v2, debug_enabled=self.debug_enabled)++ @db_operation("create_thought")+ async def create_thought(+ self,+ task_v2_id: str,+ workflow_run_id: str | None = None,+ workflow_id: str | None = None,+ workflow_permanent_id: str | None = None,+ workflow_run_block_id: str | None = None,+ user_input: str | None = None,+ observation: str | None = None,+ thought: str | None = None,+ answer: str | None = None,+ thought_scenario: str | None = None,+ thought_type: str = ThoughtType.plan,+ output: dict[str, Any] | None = None,+ input_token_count: int | None = None,+ output_token_count: int | None = None,+ reasoning_token_count: int | None = None,+ cached_token_count: int | None = None,+ thought_cost: float | None = None,+ organization_id: str | None = None,+ ) -> Thought:+ async with self.Session() as session:+ new_thought = ThoughtModel(+ observer_cruise_id=task_v2_id,+ workflow_run_id=workflow_run_id,+ workflow_id=workflow_id,+ workflow_permanent_id=workflow_permanent_id,+ workflow_run_block_id=workflow_run_block_id,+ user_input=user_input,+ observation=observation,+ thought=thought,+ answer=answer,+ observer_thought_scenario=thought_scenario,+ observer_thought_type=thought_type,+ output=output,+ input_token_count=input_token_count,+ output_token_count=output_token_count,+ reasoning_token_count=reasoning_token_count,+ cached_token_count=cached_token_count,+ thought_cost=thought_cost,+ organization_id=organization_id,+ )+ session.add(new_thought)+ await session.commit()+ await session.refresh(new_thought)+ return Thought.model_validate(new_thought)++ @db_operation("update_thought")+ async def update_thought(+ self,+ thought_id: str,+ workflow_run_block_id: str | None = None,+ workflow_run_id: str | None = None,+ workflow_id: str | None = None,+ workflow_permanent_id: str | None = None,+ observation: str | None = None,+ thought: str | None = None,+ answer: str | None = None,+ output: dict[str, Any] | None = None,+ input_token_count: int | None = None,+ output_token_count: int | None = None,+ reasoning_token_count: int | None = None,+ cached_token_count: int | None = None,+ thought_cost: float | None = None,+ organization_id: str | None = None,+ ) -> Thought:+ async with self.Session() as session:+ thought_obj = (+ await session.scalars(+ select(ThoughtModel)+ .filter_by(observer_thought_id=thought_id)+ .filter_by(organization_id=organization_id)+ )+ ).first()+ if thought_obj:+ if workflow_run_block_id:+ thought_obj.workflow_run_block_id = workflow_run_block_id+ if workflow_run_id:+ thought_obj.workflow_run_id = workflow_run_id+ if workflow_id:+ thought_obj.workflow_id = workflow_id+ if workflow_permanent_id:+ thought_obj.workflow_permanent_id = workflow_permanent_id+ if observation:+ thought_obj.observation = observation+ if thought:+ thought_obj.thought = thought+ if answer:+ thought_obj.answer = answer+ if output:+ thought_obj.output = output+ if input_token_count:+ thought_obj.input_token_count = input_token_count+ if output_token_count:+ thought_obj.output_token_count = output_token_count+ if reasoning_token_count:+ thought_obj.reasoning_token_count = reasoning_token_count+ if cached_token_count:+ thought_obj.cached_token_count = cached_token_count+ if thought_cost:+ thought_obj.thought_cost = thought_cost+ await session.commit()+ await session.refresh(thought_obj)+ return Thought.model_validate(thought_obj)+ raise NotFoundError(f"Thought {thought_id}")++ @db_operation("update_task_v2")+ async def update_task_v2(+ self,+ task_v2_id: str,+ status: TaskV2Status | None = None,+ workflow_run_id: str | None = None,+ workflow_id: str | None = None,+ workflow_permanent_id: str | None = None,+ url: str | None = None,+ prompt: str | None = None,+ summary: str | None = None,+ output: dict[str, Any] | None = None,+ organization_id: str | None = None,+ webhook_failure_reason: str | None = None,+ failure_category: list[dict[str, Any]] | None = None,+ ) -> TaskV2:+ async with self.Session() as session:+ task_v2 = (+ await session.scalars(+ select(TaskV2Model)+ .filter_by(observer_cruise_id=task_v2_id)+ .filter_by(organization_id=organization_id)+ )+ ).first()+ if task_v2:+ if status:+ task_v2.status = status+ if status == TaskV2Status.queued and task_v2.queued_at is None:+ task_v2.queued_at = datetime.now(timezone.utc)+ if status == TaskV2Status.running and task_v2.started_at is None:+ task_v2.started_at = datetime.now(timezone.utc)+ if status.is_final() and task_v2.finished_at is None:+ task_v2.finished_at = datetime.now(timezone.utc)+ if workflow_run_id:+ task_v2.workflow_run_id = workflow_run_id+ if workflow_id:+ task_v2.workflow_id = workflow_id+ if workflow_permanent_id:+ task_v2.workflow_permanent_id = workflow_permanent_id+ if url:+ task_v2.url = url+ if prompt:+ task_v2.prompt = prompt+ if summary:+ task_v2.summary = summary+ if output:+ task_v2.output = output+ if webhook_failure_reason is not None:+ task_v2.webhook_failure_reason = webhook_failure_reason+ if failure_category is not None:+ task_v2.failure_category = failure_category+ await session.commit()+ await session.refresh(task_v2)+ return convert_to_task_v2(task_v2, debug_enabled=self.debug_enabled)+ raise NotFoundError(f"TaskV2 {task_v2_id} not found")++ @db_operation("create_workflow_run_block")+ async def create_workflow_run_block(+ self,+ workflow_run_id: str,+ parent_workflow_run_block_id: str | None = None,+ organization_id: str | None = None,+ task_id: str | None = None,+ label: str | None = None,+ block_type: BlockType | None = None,+ status: BlockStatus = BlockStatus.running,+ output: dict | list | str | None = None,+ continue_on_failure: bool = False,+ engine: RunEngine | None = None,+ current_value: str | None = None,+ current_index: int | None = None,+ ) -> WorkflowRunBlock:+ async with self.Session() as session:+ new_workflow_run_block = WorkflowRunBlockModel(+ workflow_run_id=workflow_run_id,+ parent_workflow_run_block_id=parent_workflow_run_block_id,+ organization_id=organization_id,+ task_id=task_id,+ label=label,+ block_type=block_type,+ status=status,+ output=output,+ continue_on_failure=continue_on_failure,+ engine=engine,+ current_value=current_value,+ current_index=current_index,+ )+ session.add(new_workflow_run_block)+ await session.commit()+ await session.refresh(new_workflow_run_block)++ task = None+ if task_id:+ if self._task_reader is None:+ raise RuntimeError("task_reader dependency not set")+ task = await self._task_reader.get_task(task_id, organization_id=organization_id)+ return convert_to_workflow_run_block(new_workflow_run_block, task=task)++ @db_operation("delete_workflow_run_blocks")+ async def delete_workflow_run_blocks(self, workflow_run_id: str, organization_id: str | None = None) -> None:+ async with self.Session() as session:+ stmt = delete(WorkflowRunBlockModel).where(+ and_(+ WorkflowRunBlockModel.workflow_run_id == workflow_run_id,+ WorkflowRunBlockModel.organization_id == organization_id,+ )+ )+ await session.execute(stmt)+ await session.commit()++ @db_operation("update_workflow_run_block")+ async def update_workflow_run_block(+ self,+ workflow_run_block_id: str,+ organization_id: str | None = None,+ status: BlockStatus | None = None,+ output: dict | list | str | None = None,+ failure_reason: str | None = None,+ task_id: str | None = None,+ loop_values: list | None = None,+ current_value: str | None = None,+ current_index: int | None = None,+ recipients: list[str] | None = None,+ attachments: list[str] | None = None,+ subject: str | None = None,+ body: str | None = None,+ prompt: str | None = None,+ wait_sec: int | None = None,+ description: str | None = None,+ block_workflow_run_id: str | None = None,+ engine: str | None = None,+ # HTTP request block parameters+ http_request_method: str | None = None,+ http_request_url: str | None = None,+ http_request_headers: dict[str, str] | None = None,+ http_request_body: dict[str, Any] | None = None,+ http_request_parameters: dict[str, Any] | None = None,+ http_request_timeout: int | None = None,+ http_request_follow_redirects: bool | None = None,+ ai_fallback_triggered: bool | None = None,+ # block-level error codes (e.g. ["FILE_PARSER_ERROR"])+ error_codes: list[str] | None = None,+ # human interaction block+ instructions: str | None = None,+ positive_descriptor: str | None = None,+ negative_descriptor: str | None = None,+ # conditional block+ executed_branch_id: str | None = None,+ executed_branch_expression: str | None = None,+ executed_branch_result: bool | None = None,+ executed_branch_next_block: str | None = None,+ ) -> WorkflowRunBlock:+ async with self.Session() as session:+ workflow_run_block = (+ await session.scalars(+ select(WorkflowRunBlockModel)+ .filter_by(workflow_run_block_id=workflow_run_block_id)+ .filter_by(organization_id=organization_id)+ )+ ).first()+ if workflow_run_block:+ if status:+ workflow_run_block.status = status+ if output:+ workflow_run_block.output = output+ if task_id:+ workflow_run_block.task_id = task_id+ if failure_reason:+ workflow_run_block.failure_reason = failure_reason+ # Use `is not None` instead of truthiness checks so that falsy+ # values like current_index=0, empty loop_values=[], or+ # current_value="" are correctly persisted. Without this,+ # the first loop iteration (index 0) loses its metadata.+ if loop_values is not None:+ workflow_run_block.loop_values = loop_values+ if current_value is not None:+ workflow_run_block.current_value = current_value+ if current_index is not None:+ workflow_run_block.current_index = current_index+ if recipients:+ workflow_run_block.recipients = recipients+ if attachments:+ workflow_run_block.attachments = attachments+ if subject:+ workflow_run_block.subject = subject+ if body:+ workflow_run_block.body = body+ if prompt:+ workflow_run_block.prompt = prompt+ if wait_sec:+ workflow_run_block.wait_sec = wait_sec+ if description:+ workflow_run_block.description = description+ if block_workflow_run_id:+ workflow_run_block.block_workflow_run_id = block_workflow_run_id+ if engine:+ workflow_run_block.engine = engine+ # HTTP request block fields+ if http_request_method:+ workflow_run_block.http_request_method = http_request_method+ if http_request_url:+ workflow_run_block.http_request_url = http_request_url+ if http_request_headers:+ workflow_run_block.http_request_headers = http_request_headers+ if http_request_body:+ workflow_run_block.http_request_body = http_request_body+ if http_request_parameters:+ workflow_run_block.http_request_parameters = http_request_parameters+ if http_request_timeout:+ workflow_run_block.http_request_timeout = http_request_timeout+ if http_request_follow_redirects is not None:+ workflow_run_block.http_request_follow_redirects = http_request_follow_redirects+ if ai_fallback_triggered is not None:+ workflow_run_block.script_run = {"ai_fallback_triggered": ai_fallback_triggered}+ if error_codes is not None:+ workflow_run_block.error_codes = error_codes+ # human interaction block fields+ if instructions:+ workflow_run_block.instructions = instructions+ if positive_descriptor:+ workflow_run_block.positive_descriptor = positive_descriptor+ if negative_descriptor:+ workflow_run_block.negative_descriptor = negative_descriptor+ # conditional block fields+ if executed_branch_id:+ workflow_run_block.executed_branch_id = executed_branch_id+ if executed_branch_expression is not None:+ workflow_run_block.executed_branch_expression = executed_branch_expression+ if executed_branch_result is not None:+ workflow_run_block.executed_branch_result = executed_branch_result+ if executed_branch_next_block is not None:+ workflow_run_block.executed_branch_next_block = executed_branch_next_block+ await session.commit()+ await session.refresh(workflow_run_block)+ else:+ raise NotFoundError(f"WorkflowRunBlock {workflow_run_block_id} not found")+ task = None+ task_id = workflow_run_block.task_id+ if task_id:+ if self._task_reader is None:+ raise RuntimeError("task_reader dependency not set")+ task = await self._task_reader.get_task(task_id, organization_id=workflow_run_block.organization_id)+ return convert_to_workflow_run_block(workflow_run_block, task=task)++ @db_operation("get_workflow_run_block")+ async def get_workflow_run_block(+ self,+ workflow_run_block_id: str,+ organization_id: str | None = None,+ ) -> WorkflowRunBlock:+ async with self.Session() as session:+ workflow_run_block = (+ await session.scalars(+ select(WorkflowRunBlockModel)+ .filter_by(workflow_run_block_id=workflow_run_block_id)+ .filter_by(organization_id=organization_id)+ )+ ).first()+ if workflow_run_block:+ task = None+ task_id = workflow_run_block.task_id+ if task_id:+ if self._task_reader is None:+ raise RuntimeError("task_reader dependency not set")+ task = await self._task_reader.get_task(task_id, organization_id=organization_id)+ return convert_to_workflow_run_block(workflow_run_block, task=task)+ raise NotFoundError(f"WorkflowRunBlock {workflow_run_block_id} not found")++ @db_operation("get_workflow_run_block_by_task_id")+ async def get_workflow_run_block_by_task_id(+ self,+ task_id: str,+ organization_id: str | None = None,+ ) -> WorkflowRunBlock:+ async with self.Session() as session:+ workflow_run_block = (+ await session.scalars(+ select(WorkflowRunBlockModel).filter_by(task_id=task_id).filter_by(organization_id=organization_id)+ )+ ).first()+ if workflow_run_block:+ task = None+ task_id = workflow_run_block.task_id+ if task_id:+ if self._task_reader is None:+ raise RuntimeError("task_reader dependency not set")+ task = await self._task_reader.get_task(task_id, organization_id=organization_id)+ return convert_to_workflow_run_block(workflow_run_block, task=task)+ raise NotFoundError(f"WorkflowRunBlock not found by {task_id}")++ @db_operation("get_workflow_run_blocks")+ async def get_workflow_run_blocks(+ self,+ workflow_run_id: str,+ organization_id: str | None = None,+ ) -> list[WorkflowRunBlock]:+ async with self.Session() as session:+ workflow_run_blocks = (+ await session.scalars(+ select(WorkflowRunBlockModel)+ .filter_by(workflow_run_id=workflow_run_id)+ .filter_by(organization_id=organization_id)+ .order_by(WorkflowRunBlockModel.created_at.desc())+ )+ ).all()+ if self._task_reader is None:+ raise RuntimeError("task_reader dependency not set")+ tasks = await self._task_reader.get_tasks_by_workflow_run_id(workflow_run_id)+ tasks_dict = {task.task_id: task for task in tasks}+ return [+ convert_to_workflow_run_block(workflow_run_block, task=tasks_dict.get(workflow_run_block.task_id))+ for workflow_run_block in workflow_run_blocks+ ]diff --git a/skyvern/forge/sdk/db/repositories/organizations.py b/skyvern/forge/sdk/db/repositories/organizations.pynew file mode 100644index 000000000..df9168599--- /dev/null+++ b/skyvern/forge/sdk/db/repositories/organizations.py@@ -0,0 +1,375 @@+from __future__ import annotations++from datetime import datetime, timedelta, timezone+from typing import Literal, overload++from sqlalchemy import select, update++from skyvern.forge.sdk.db._error_handling import db_operation+from skyvern.forge.sdk.db.base_alchemy_db import read_retry+from skyvern.forge.sdk.db.base_repository import BaseRepository+from skyvern.forge.sdk.db.enums import OrganizationAuthTokenType+from skyvern.forge.sdk.db.exceptions import NotFoundError+from skyvern.forge.sdk.db.models import (+ OrganizationAuthTokenModel,+ OrganizationModel,+ TaskModel,+ WorkflowRunModel,+)+from skyvern.forge.sdk.db.utils import (+ convert_to_organization,+ convert_to_organization_auth_token,+)+from skyvern.forge.sdk.encrypt import encryptor+from skyvern.forge.sdk.encrypt.base import EncryptMethod+from skyvern.forge.sdk.schemas.organizations import (+ AzureClientSecretCredential,+ AzureOrganizationAuthToken,+ BitwardenCredential,+ BitwardenOrganizationAuthToken,+ Organization,+ OrganizationAuthToken,+)+from skyvern.forge.sdk.schemas.tasks import TaskStatus+from skyvern.forge.sdk.workflow.models.workflow import WorkflowRunStatus+++class OrganizationsRepository(BaseRepository):+ """Database operations for organization and auth-token management."""++ @read_retry()+ @db_operation("get_active_verification_requests", log_errors=False)+ async def get_active_verification_requests(self, organization_id: str) -> list[dict]:+ """Return active 2FA verification requests for an organization.++ Queries both tasks and workflow runs where waiting_for_verification_code=True.+ Used to provide initial state when a WebSocket notification client connects.+ """+ results: list[dict] = []+ async with self.Session() as session:+ # Tasks waiting for verification (exclude finalized tasks)+ finalized_task_statuses = [s.value for s in TaskStatus if s.is_final()]+ task_rows = (+ await session.scalars(+ select(TaskModel)+ .filter_by(organization_id=organization_id)+ .filter_by(waiting_for_verification_code=True)+ .filter_by(workflow_run_id=None)+ .filter(TaskModel.status.not_in(finalized_task_statuses))+ .filter(TaskModel.created_at > datetime.now(timezone.utc) - timedelta(hours=1))+ )+ ).all()+ for t in task_rows:+ results.append(+ {+ "task_id": t.task_id,+ "workflow_run_id": None,+ "verification_code_identifier": t.verification_code_identifier,+ "verification_code_polling_started_at": (+ t.verification_code_polling_started_at.isoformat()+ if t.verification_code_polling_started_at+ else None+ ),+ }+ )+ # Workflow runs waiting for verification (exclude finalized runs)+ finalized_wr_statuses = [s.value for s in WorkflowRunStatus if s.is_final()]+ wr_rows = (+ await session.scalars(+ select(WorkflowRunModel)+ .filter_by(organization_id=organization_id)+ .filter_by(waiting_for_verification_code=True)+ .filter(WorkflowRunModel.status.not_in(finalized_wr_statuses))+ .filter(WorkflowRunModel.created_at > datetime.now(timezone.utc) - timedelta(hours=1))+ )+ ).all()+ for wr in wr_rows:+ results.append(+ {+ "task_id": None,+ "workflow_run_id": wr.workflow_run_id,+ "verification_code_identifier": wr.verification_code_identifier,+ "verification_code_polling_started_at": (+ wr.verification_code_polling_started_at.isoformat()+ if wr.verification_code_polling_started_at+ else None+ ),+ }+ )+ return results++ @db_operation("get_all_organizations")+ async def get_all_organizations(self) -> list[Organization]:+ async with self.Session() as session:+ organizations = (await session.scalars(select(OrganizationModel))).all()+ return [convert_to_organization(organization) for organization in organizations]++ @db_operation("get_organization")+ async def get_organization(self, organization_id: str) -> Organization | None:+ async with self.Session() as session:+ if organization := (+ await session.scalars(select(OrganizationModel).filter_by(organization_id=organization_id))+ ).first():+ return convert_to_organization(organization)+ else:+ return None++ @db_operation("get_organization_by_domain")+ async def get_organization_by_domain(self, domain: str) -> Organization | None:+ async with self.Session() as session:+ if organization := (await session.scalars(select(OrganizationModel).filter_by(domain=domain))).first():+ return convert_to_organization(organization)+ return None++ @db_operation("create_organization")+ async def create_organization(+ self,+ organization_name: str,+ webhook_callback_url: str | None = None,+ max_steps_per_run: int | None = None,+ max_retries_per_step: int | None = None,+ domain: str | None = None,+ ) -> Organization:+ async with self.Session() as session:+ org = OrganizationModel(+ organization_name=organization_name,+ webhook_callback_url=webhook_callback_url,+ max_steps_per_run=max_steps_per_run,+ max_retries_per_step=max_retries_per_step,+ domain=domain,+ )+ session.add(org)+ await session.commit()+ await session.refresh(org)++ return convert_to_organization(org)++ @db_operation("update_organization")+ async def update_organization(+ self,+ organization_id: str,+ organization_name: str | None = None,+ webhook_callback_url: str | None = None,+ max_steps_per_run: int | None = None,+ max_retries_per_step: int | None = None,+ ) -> Organization:+ async with self.Session() as session:+ organization = (+ await session.scalars(select(OrganizationModel).filter_by(organization_id=organization_id))+ ).first()+ if not organization:+ raise NotFoundError+ if organization_name:+ organization.organization_name = organization_name+ if webhook_callback_url:+ organization.webhook_callback_url = webhook_callback_url+ if max_steps_per_run:+ organization.max_steps_per_run = max_steps_per_run+ if max_retries_per_step:+ organization.max_retries_per_step = max_retries_per_step+ await session.commit()+ await session.refresh(organization)+ return Organization.model_validate(organization)++ @overload+ async def get_valid_org_auth_token(+ self,+ organization_id: str,+ token_type: Literal["api", "onepassword_service_account", "custom_credential_service"],+ ) -> OrganizationAuthToken | None: ...++ @overload+ async def get_valid_org_auth_token( # type: ignore+ self,+ organization_id: str,+ token_type: Literal["azure_client_secret_credential"],+ ) -> AzureOrganizationAuthToken | None: ...++ @overload+ async def get_valid_org_auth_token( # type: ignore+ self,+ organization_id: str,+ token_type: Literal["bitwarden_credential"],+ ) -> BitwardenOrganizationAuthToken | None: ...++ @db_operation("get_valid_org_auth_token")+ async def get_valid_org_auth_token(+ self,+ organization_id: str,+ token_type: Literal[+ "api",+ "onepassword_service_account",+ "azure_client_secret_credential",+ "bitwarden_credential",+ "custom_credential_service",+ ],+ ) -> OrganizationAuthToken | AzureOrganizationAuthToken | BitwardenOrganizationAuthToken | None:+ async with self.Session() as session:+ if token := (+ await session.scalars(+ select(OrganizationAuthTokenModel)+ .filter_by(organization_id=organization_id)+ .filter_by(token_type=token_type)+ .filter_by(valid=True)+ .order_by(OrganizationAuthTokenModel.created_at.desc())+ )+ ).first():+ return await convert_to_organization_auth_token(token, token_type)+ else:+ return None++ @db_operation("replace_org_auth_token")+ async def replace_org_auth_token(+ self,+ organization_id: str,+ token_type: OrganizationAuthTokenType,+ token: str | AzureClientSecretCredential | BitwardenCredential,+ encrypted_method: EncryptMethod | None = None,+ ) -> OrganizationAuthToken | AzureOrganizationAuthToken | BitwardenOrganizationAuthToken:+ """Atomically invalidate existing tokens and create a new one in a single transaction."""+ if token_type is OrganizationAuthTokenType.azure_client_secret_credential:+ if not isinstance(token, AzureClientSecretCredential):+ raise TypeError("Expected AzureClientSecretCredential for this token_type")+ plaintext_token = token.model_dump_json()+ elif token_type is OrganizationAuthTokenType.bitwarden_credential:+ if not isinstance(token, BitwardenCredential):+ raise TypeError("Expected BitwardenCredential for this token_type")+ plaintext_token = token.model_dump_json()+ else:+ if not isinstance(token, str):+ raise TypeError("Expected str token for this token_type")+ plaintext_token = token++ encrypted_token = ""+ if encrypted_method is not None:+ encrypted_token = await encryptor.encrypt(plaintext_token, encrypted_method)+ plaintext_token = ""++ async with self.Session() as session:+ # Invalidate existing tokens+ await session.execute(+ update(OrganizationAuthTokenModel)+ .filter_by(organization_id=organization_id)+ .filter_by(token_type=token_type)+ .filter_by(valid=True)+ .values(valid=False)+ )+ # Create new token+ auth_token = OrganizationAuthTokenModel(+ organization_id=organization_id,+ token_type=token_type,+ token=plaintext_token,+ encrypted_token=encrypted_token,+ encrypted_method=encrypted_method.value if encrypted_method is not None else "",+ )+ session.add(auth_token)+ await session.commit()+ await session.refresh(auth_token)++ return await convert_to_organization_auth_token(auth_token, token_type)++ @db_operation("get_valid_org_auth_tokens")+ async def get_valid_org_auth_tokens(+ self,+ organization_id: str,+ token_type: OrganizationAuthTokenType,+ ) -> list[OrganizationAuthToken]:+ async with self.Session() as session:+ tokens = (+ await session.scalars(+ select(OrganizationAuthTokenModel)+ .filter_by(organization_id=organization_id)+ .filter_by(token_type=token_type)+ .filter_by(valid=True)+ .order_by(OrganizationAuthTokenModel.created_at.desc())+ )+ ).all()+ return [await convert_to_organization_auth_token(token, token_type) for token in tokens]++ @db_operation("validate_org_auth_token")+ async def validate_org_auth_token(+ self,+ organization_id: str,+ token_type: OrganizationAuthTokenType,+ token: str,+ valid: bool | None = True,+ encrypted_method: EncryptMethod | None = None,+ ) -> OrganizationAuthToken | None:+ encrypted_token = ""+ if encrypted_method is not None:+ encrypted_token = await encryptor.encrypt(token, encrypted_method)++ async with self.Session() as session:+ query = (+ select(OrganizationAuthTokenModel)+ .filter_by(organization_id=organization_id)+ .filter_by(token_type=token_type)+ )+ if encrypted_token:+ query = query.filter_by(encrypted_token=encrypted_token)+ else:+ query = query.filter_by(token=token)+ if valid is not None:+ query = query.filter_by(valid=valid)+ if token_obj := (await session.scalars(query)).first():+ return await convert_to_organization_auth_token(token_obj, token_type)+ else:+ return None++ @db_operation("create_org_auth_token")+ async def create_org_auth_token(+ self,+ organization_id: str,+ token_type: OrganizationAuthTokenType,+ token: str | AzureClientSecretCredential | BitwardenCredential,+ encrypted_method: EncryptMethod | None = None,+ ) -> OrganizationAuthToken | AzureOrganizationAuthToken | BitwardenOrganizationAuthToken:+ if token_type is OrganizationAuthTokenType.azure_client_secret_credential:+ if not isinstance(token, AzureClientSecretCredential):+ raise TypeError("Expected AzureClientSecretCredential for this token_type")+ plaintext_token = token.model_dump_json()+ elif token_type is OrganizationAuthTokenType.bitwarden_credential:+ if not isinstance(token, BitwardenCredential):+ raise TypeError("Expected BitwardenCredential for this token_type")+ plaintext_token = token.model_dump_json()+ else:+ if not isinstance(token, str):+ raise TypeError("Expected str token for this token_type")+ plaintext_token = token++ encrypted_token = ""++ if encrypted_method is not None:+ encrypted_token = await encryptor.encrypt(plaintext_token, encrypted_method)+ plaintext_token = ""++ async with self.Session() as session:+ auth_token = OrganizationAuthTokenModel(+ organization_id=organization_id,+ token_type=token_type,+ token=plaintext_token,+ encrypted_token=encrypted_token,+ encrypted_method=encrypted_method.value if encrypted_method is not None else "",+ )+ session.add(auth_token)+ await session.commit()+ await session.refresh(auth_token)++ return await convert_to_organization_auth_token(auth_token, token_type)++ @db_operation("invalidate_org_auth_tokens")+ async def invalidate_org_auth_tokens(+ self,+ organization_id: str,+ token_type: OrganizationAuthTokenType,+ ) -> None:+ """Invalidate all existing tokens of a specific type for an organization."""+ async with self.Session() as session:+ await session.execute(+ update(OrganizationAuthTokenModel)+ .filter_by(organization_id=organization_id)+ .filter_by(token_type=token_type)+ .filter_by(valid=True)+ .values(valid=False)+ )+ await session.commit()diff --git a/skyvern/forge/sdk/db/repositories/otp.py b/skyvern/forge/sdk/db/repositories/otp.pynew file mode 100644index 000000000..1586babb6--- /dev/null+++ b/skyvern/forge/sdk/db/repositories/otp.py@@ -0,0 +1,154 @@+from __future__ import annotations++from datetime import datetime, timedelta, timezone++from sqlalchemy import and_, asc, select++from skyvern.config import settings+from skyvern.forge.sdk.db._error_handling import db_operation+from skyvern.forge.sdk.db.base_repository import BaseRepository+from skyvern.forge.sdk.db.models import TOTPCodeModel+from skyvern.forge.sdk.schemas.totp_codes import OTPType, TOTPCode+++class OTPRepository(BaseRepository):+ """Database operations for OTP/TOTP management."""++ @db_operation("get_otp_codes")+ async def get_otp_codes(+ self,+ organization_id: str,+ totp_identifier: str,+ valid_lifespan_minutes: int = settings.TOTP_LIFESPAN_MINUTES,+ otp_type: OTPType | None = None,+ workflow_run_id: str | None = None,+ limit: int | None = None,+ ) -> list[TOTPCode]:+ """+ 1. filter by:+ - organization_id+ - totp_identifier+ - workflow_run_id (optional)+ 2. make sure created_at is within the valid lifespan+ 3. sort by task_id/workflow_id/workflow_run_id nullslast and created_at desc+ 4. apply an optional limit at the DB layer+ """+ all_null = and_(+ TOTPCodeModel.task_id.is_(None),+ TOTPCodeModel.workflow_id.is_(None),+ TOTPCodeModel.workflow_run_id.is_(None),+ )+ async with self.Session() as session:+ query = (+ select(TOTPCodeModel)+ .filter_by(organization_id=organization_id)+ .filter_by(totp_identifier=totp_identifier)+ .filter(+ TOTPCodeModel.created_at > datetime.now(timezone.utc) - timedelta(minutes=valid_lifespan_minutes)+ )+ )+ if otp_type:+ query = query.filter(TOTPCodeModel.otp_type == otp_type)+ if workflow_run_id is not None:+ query = query.filter(TOTPCodeModel.workflow_run_id == workflow_run_id)+ query = query.order_by(asc(all_null), TOTPCodeModel.created_at.desc())+ if limit is not None:+ query = query.limit(limit)+ totp_codes = (await session.scalars(query)).all()+ return [TOTPCode.model_validate(code) for code in totp_codes]++ @db_operation("get_otp_codes_by_run")+ async def get_otp_codes_by_run(+ self,+ organization_id: str,+ task_id: str | None = None,+ workflow_run_id: str | None = None,+ valid_lifespan_minutes: int = settings.TOTP_LIFESPAN_MINUTES,+ limit: int = 1,+ ) -> list[TOTPCode]:+ """Get OTP codes matching a specific task or workflow run (no totp_identifier required).++ Used when the agent detects a 2FA page but no TOTP credentials are pre-configured.+ The user submits codes manually via the UI, and this method finds them by run context.+ """+ if not workflow_run_id and not task_id:+ return []+ async with self.Session() as session:+ query = (+ select(TOTPCodeModel)+ .filter_by(organization_id=organization_id)+ .filter(+ TOTPCodeModel.created_at > datetime.now(timezone.utc) - timedelta(minutes=valid_lifespan_minutes)+ )+ )+ if workflow_run_id:+ query = query.filter(TOTPCodeModel.workflow_run_id == workflow_run_id)+ elif task_id:+ query = query.filter(TOTPCodeModel.task_id == task_id)+ query = query.order_by(TOTPCodeModel.created_at.desc()).limit(limit)+ results = (await session.scalars(query)).all()+ return [TOTPCode.model_validate(r) for r in results]++ @db_operation("get_recent_otp_codes")+ async def get_recent_otp_codes(+ self,+ organization_id: str,+ limit: int = 50,+ valid_lifespan_minutes: int | None = None,+ otp_type: OTPType | None = None,+ workflow_run_id: str | None = None,+ totp_identifier: str | None = None,+ ) -> list[TOTPCode]:+ """+ Return recent otp codes for an organization ordered by newest first with optional+ workflow_run_id filtering.+ """+ async with self.Session() as session:+ query = select(TOTPCodeModel).filter_by(organization_id=organization_id)++ if valid_lifespan_minutes is not None:+ query = query.filter(+ TOTPCodeModel.created_at > datetime.now(timezone.utc) - timedelta(minutes=valid_lifespan_minutes)+ )++ if otp_type:+ query = query.filter(TOTPCodeModel.otp_type == otp_type)+ if workflow_run_id is not None:+ query = query.filter(TOTPCodeModel.workflow_run_id == workflow_run_id)+ if totp_identifier:+ query = query.filter(TOTPCodeModel.totp_identifier == totp_identifier)+ query = query.order_by(TOTPCodeModel.created_at.desc()).limit(limit)+ totp_codes = (await session.scalars(query)).all()+ return [TOTPCode.model_validate(totp_code) for totp_code in totp_codes]++ @db_operation("create_otp_code")+ async def create_otp_code(+ self,+ organization_id: str,+ totp_identifier: str,+ content: str,+ code: str,+ otp_type: OTPType,+ task_id: str | None = None,+ workflow_id: str | None = None,+ workflow_run_id: str | None = None,+ source: str | None = None,+ expired_at: datetime | None = None,+ ) -> TOTPCode:+ async with self.Session() as session:+ new_totp_code = TOTPCodeModel(+ organization_id=organization_id,+ totp_identifier=totp_identifier,+ content=content,+ code=code,+ task_id=task_id,+ workflow_id=workflow_id,+ workflow_run_id=workflow_run_id,+ source=source,+ expired_at=expired_at,+ otp_type=otp_type,+ )+ session.add(new_totp_code)+ await session.commit()+ await session.refresh(new_totp_code)+ return TOTPCode.model_validate(new_totp_code)diff --git a/skyvern/forge/sdk/db/repositories/schedules.py b/skyvern/forge/sdk/db/repositories/schedules.pynew file mode 100644index 000000000..f13d404cc--- /dev/null+++ b/skyvern/forge/sdk/db/repositories/schedules.py@@ -0,0 +1,602 @@+"""Database operations for workflow schedules."""++from __future__ import annotations++import asyncio+from datetime import UTC, datetime+from typing import TYPE_CHECKING, Any, Callable++import structlog+from sqlalchemy import exists, func, or_, select, text, update+from sqlalchemy.exc import SQLAlchemyError++from skyvern.forge.sdk.db._error_handling import db_operation, register_passthrough_exception+from skyvern.forge.sdk.db.base_repository import BaseRepository+from skyvern.forge.sdk.db.exceptions import ScheduleLimitExceededError+from skyvern.forge.sdk.db.models import WorkflowModel, WorkflowRunModel, WorkflowScheduleModel+from skyvern.forge.sdk.db.utils import convert_to_workflow_schedule+from skyvern.forge.sdk.schemas.workflow_schedules import OrganizationScheduleItem, WorkflowSchedule+from skyvern.forge.sdk.workflow.schedules import compute_next_run++if TYPE_CHECKING:+ from skyvern.forge.sdk.db.base_alchemy_db import _SessionFactory++from . import _UNSET++LOG = structlog.get_logger()++register_passthrough_exception(ScheduleLimitExceededError)+++class SchedulesRepository(BaseRepository):+ """Database operations for workflow schedules."""++ def __init__(+ self,+ session_factory: _SessionFactory,+ debug_enabled: bool = False,+ is_retryable_error_fn: Callable[[SQLAlchemyError], bool] | None = None,+ sqlite_schedule_lock: asyncio.Lock | None = None,+ ) -> None:+ super().__init__(session_factory, debug_enabled, is_retryable_error_fn)+ self._sqlite_schedule_lock = sqlite_schedule_lock++ @db_operation("create_workflow_schedule")+ async def create_workflow_schedule(+ self,+ organization_id: str,+ workflow_permanent_id: str,+ cron_expression: str,+ timezone: str,+ enabled: bool,+ parameters: dict[str, Any] | None = None,+ temporal_schedule_id: str | None = None,+ name: str | None = None,+ description: str | None = None,+ ) -> WorkflowSchedule:+ async with self.Session() as session:+ workflow_schedule = WorkflowScheduleModel(+ organization_id=organization_id,+ workflow_permanent_id=workflow_permanent_id,+ cron_expression=cron_expression,+ timezone=timezone,+ enabled=enabled,+ parameters=parameters,+ temporal_schedule_id=temporal_schedule_id,+ name=name,+ description=description,+ )+ session.add(workflow_schedule)+ await session.commit()+ await session.refresh(workflow_schedule)+ return convert_to_workflow_schedule(workflow_schedule, self.debug_enabled)++ @db_operation("create_workflow_schedule_with_limit")+ async def create_workflow_schedule_with_limit(+ self,+ organization_id: str,+ workflow_permanent_id: str,+ max_schedules: int | None,+ cron_expression: str,+ timezone: str,+ enabled: bool,+ parameters: dict[str, Any] | None = None,+ name: str | None = None,+ description: str | None = None,+ ) -> tuple[WorkflowSchedule, int]:+ """Create a schedule atomically with limit enforcement.++ On PostgreSQL, uses an advisory lock to serialize concurrent creates for+ the same workflow, preventing TOCTOU races on the schedule count.++ On SQLite, uses an asyncio.Lock (set on AgentDB.__init__) since SQLite+ is single-writer and has no advisory lock support.++ Returns (created_schedule, count_before_insert).+ Raises ScheduleLimitExceededError if count >= max_schedules.+ """+ # SQLite: serialize via Python lock (no advisory locks available).+ # The lock is held across the count-check + insert to prevent TOCTOU.+ if self._sqlite_schedule_lock is not None:+ async with self._sqlite_schedule_lock:+ return await self._create_schedule_with_limit_inner(+ organization_id,+ workflow_permanent_id,+ max_schedules,+ cron_expression,+ timezone,+ enabled,+ parameters,+ name,+ description,+ use_advisory_lock=False,+ )+ return await self._create_schedule_with_limit_inner(+ organization_id,+ workflow_permanent_id,+ max_schedules,+ cron_expression,+ timezone,+ enabled,+ parameters,+ name,+ description,+ use_advisory_lock=True,+ )++ # Intentionally not decorated with @db_operation — errors are caught by the+ # outer create_workflow_schedule_with_limit which owns the operation name.+ async def _create_schedule_with_limit_inner(+ self,+ organization_id: str,+ workflow_permanent_id: str,+ max_schedules: int | None,+ cron_expression: str,+ timezone: str,+ enabled: bool,+ parameters: dict[str, Any] | None,+ name: str | None,+ description: str | None,+ *,+ use_advisory_lock: bool,+ ) -> tuple[WorkflowSchedule, int]:+ async with self.Session() as session:+ if use_advisory_lock:+ lock_key = f"schedule:{organization_id}:{workflow_permanent_id}"+ await session.execute(+ text("SELECT pg_advisory_xact_lock(hashtext(:key))"),+ {"key": lock_key},+ )++ count = (+ await session.execute(+ select(func.count()).where(+ WorkflowScheduleModel.organization_id == organization_id,+ WorkflowScheduleModel.workflow_permanent_id == workflow_permanent_id,+ WorkflowScheduleModel.deleted_at.is_(None),+ )+ )+ ).scalar_one()++ if max_schedules is not None and count >= max_schedules:+ raise ScheduleLimitExceededError(+ organization_id=organization_id,+ workflow_permanent_id=workflow_permanent_id,+ current_count=count,+ max_allowed=max_schedules,+ )++ workflow_schedule = WorkflowScheduleModel(+ organization_id=organization_id,+ workflow_permanent_id=workflow_permanent_id,+ cron_expression=cron_expression,+ timezone=timezone,+ enabled=enabled,+ parameters=parameters,+ name=name,+ description=description,+ )+ session.add(workflow_schedule)+ await session.commit()+ await session.refresh(workflow_schedule)+ return convert_to_workflow_schedule(workflow_schedule, self.debug_enabled), count++ @db_operation("set_temporal_schedule_id")+ async def set_temporal_schedule_id(+ self,+ workflow_schedule_id: str,+ organization_id: str,+ temporal_schedule_id: str,+ ) -> WorkflowSchedule | None:+ async with self.Session() as session:+ workflow_schedule = (+ await session.scalars(+ select(WorkflowScheduleModel).filter_by(+ workflow_schedule_id=workflow_schedule_id,+ organization_id=organization_id,+ deleted_at=None,+ )+ )+ ).first()++ if not workflow_schedule:+ return None++ workflow_schedule.temporal_schedule_id = temporal_schedule_id+ workflow_schedule.modified_at = datetime.now(UTC)+ await session.commit()+ await session.refresh(workflow_schedule)+ return convert_to_workflow_schedule(workflow_schedule, self.debug_enabled)++ @db_operation("update_workflow_schedule")+ async def update_workflow_schedule(+ self,+ workflow_schedule_id: str,+ organization_id: str,+ cron_expression: str,+ timezone: str,+ enabled: bool,+ parameters: dict[str, Any] | None = None,+ temporal_schedule_id: str | None | object = _UNSET,+ name: str | None | object = _UNSET,+ description: str | None | object = _UNSET,+ ) -> WorkflowSchedule | None:+ async with self.Session() as session:+ workflow_schedule = (+ await session.scalars(+ select(WorkflowScheduleModel).filter_by(+ workflow_schedule_id=workflow_schedule_id,+ organization_id=organization_id,+ deleted_at=None,+ )+ )+ ).first()++ if not workflow_schedule:+ return None++ workflow_schedule.cron_expression = cron_expression+ workflow_schedule.timezone = timezone+ workflow_schedule.enabled = enabled+ workflow_schedule.parameters = parameters+ if temporal_schedule_id is not _UNSET:+ workflow_schedule.temporal_schedule_id = temporal_schedule_id+ if name is not _UNSET:+ workflow_schedule.name = name+ if description is not _UNSET:+ workflow_schedule.description = description+ workflow_schedule.modified_at = datetime.now(UTC)+ await session.commit()+ await session.refresh(workflow_schedule)+ return convert_to_workflow_schedule(workflow_schedule, self.debug_enabled)++ @db_operation("get_workflow_schedule_by_id")+ async def get_workflow_schedule_by_id(+ self,+ workflow_schedule_id: str,+ organization_id: str,+ ) -> WorkflowSchedule | None:+ async with self.Session() as session:+ workflow_schedule = (+ await session.scalars(+ select(WorkflowScheduleModel).filter_by(+ workflow_schedule_id=workflow_schedule_id,+ organization_id=organization_id,+ deleted_at=None,+ )+ )+ ).first()+ if not workflow_schedule:+ return None+ return convert_to_workflow_schedule(workflow_schedule, self.debug_enabled)++ @db_operation("get_workflow_schedules")+ async def get_workflow_schedules(+ self,+ workflow_permanent_id: str,+ organization_id: str,+ ) -> list[WorkflowSchedule]:+ async with self.Session() as session:+ rows = (+ await session.scalars(+ select(WorkflowScheduleModel).filter_by(+ workflow_permanent_id=workflow_permanent_id,+ organization_id=organization_id,+ deleted_at=None,+ )+ )+ ).all()+ return [convert_to_workflow_schedule(r, self.debug_enabled) for r in rows]++ @db_operation("get_all_enabled_schedules")+ async def get_all_enabled_schedules(+ self,+ organization_id: str | None = None,+ ) -> list[WorkflowSchedule]:+ """Fetch all enabled, non-deleted schedules, optionally filtered by org."""+ async with self.Session() as session:+ stmt = select(WorkflowScheduleModel).where(+ WorkflowScheduleModel.enabled.is_(True),+ WorkflowScheduleModel.deleted_at.is_(None),+ )+ if organization_id:+ stmt = stmt.where(WorkflowScheduleModel.organization_id == organization_id)+ rows = (await session.scalars(stmt)).all()+ return [convert_to_workflow_schedule(r, self.debug_enabled) for r in rows]++ @db_operation("has_schedule_fired_since")+ async def has_schedule_fired_since(+ self,+ workflow_schedule_id: str,+ since: datetime,+ ) -> bool:+ """Check if a workflow_run exists for the given schedule since a timestamp."""+ async with self.Session() as session:+ row = (+ await session.execute(+ select(+ exists().where(+ WorkflowRunModel.workflow_schedule_id == workflow_schedule_id,+ WorkflowRunModel.created_at >= since,+ )+ )+ )+ ).scalar()+ return bool(row)++ @db_operation("update_workflow_schedule_enabled")+ async def update_workflow_schedule_enabled(+ self,+ workflow_schedule_id: str,+ organization_id: str,+ enabled: bool,+ ) -> WorkflowSchedule | None:+ async with self.Session() as session:+ workflow_schedule = (+ await session.scalars(+ select(WorkflowScheduleModel).filter_by(+ workflow_schedule_id=workflow_schedule_id,+ organization_id=organization_id,+ deleted_at=None,+ )+ )+ ).first()+ if not workflow_schedule:+ return None+ workflow_schedule.enabled = enabled+ workflow_schedule.modified_at = datetime.now(UTC)+ await session.commit()+ await session.refresh(workflow_schedule)+ return convert_to_workflow_schedule(workflow_schedule, self.debug_enabled)++ @db_operation("delete_workflow_schedule")+ async def delete_workflow_schedule(+ self,+ workflow_schedule_id: str,+ organization_id: str,+ ) -> WorkflowSchedule | None:+ async with self.Session() as session:+ workflow_schedule = (+ await session.scalars(+ select(WorkflowScheduleModel).filter_by(+ workflow_schedule_id=workflow_schedule_id,+ organization_id=organization_id,+ deleted_at=None,+ )+ )+ ).first()+ if not workflow_schedule:+ return None++ workflow_schedule.deleted_at = datetime.now(UTC)+ workflow_schedule.modified_at = datetime.now(UTC)+ await session.commit()+ await session.refresh(workflow_schedule)+ return convert_to_workflow_schedule(workflow_schedule, self.debug_enabled)++ @db_operation("restore_workflow_schedule")+ async def restore_workflow_schedule(+ self,+ workflow_schedule_id: str,+ organization_id: str,+ ) -> WorkflowSchedule | None:+ async with self.Session() as session:+ workflow_schedule = (+ await session.scalars(+ select(WorkflowScheduleModel)+ .filter_by(+ workflow_schedule_id=workflow_schedule_id,+ organization_id=organization_id,+ )+ .filter(WorkflowScheduleModel.deleted_at.isnot(None))+ )+ ).first()+ if not workflow_schedule:+ return None++ workflow_schedule.deleted_at = None+ workflow_schedule.modified_at = datetime.now(UTC)+ await session.commit()+ await session.refresh(workflow_schedule)+ return convert_to_workflow_schedule(workflow_schedule, self.debug_enabled)++ @db_operation("count_workflow_schedules")+ async def count_workflow_schedules(+ self,+ organization_id: str,+ workflow_permanent_id: str,+ ) -> int:+ async with self.Session() as session:+ result = await session.execute(+ select(func.count()).where(+ WorkflowScheduleModel.organization_id == organization_id,+ WorkflowScheduleModel.workflow_permanent_id == workflow_permanent_id,+ WorkflowScheduleModel.deleted_at.is_(None),+ )+ )+ return result.scalar_one()++ @db_operation("list_organization_schedules")+ async def list_organization_schedules(+ self,+ organization_id: str,+ page: int = 1,+ page_size: int = 10,+ enabled_filter: bool | None = None,+ search: str | None = None,+ ) -> tuple[list[OrganizationScheduleItem], int]:+ """+ List all schedules for an organization, joined with workflow titles.+ Returns (schedules, total_count).+ """+ if page < 1:+ raise ValueError(f"Page must be greater than 0, got {page}")+ db_page = page - 1+ async with self.Session() as session:+ # Subquery to get the latest version title per workflow_permanent_id+ latest_version_sq = (+ select(+ WorkflowModel.workflow_permanent_id,+ func.max(WorkflowModel.version).label("max_version"),+ )+ .where(WorkflowModel.organization_id == organization_id)+ .where(WorkflowModel.deleted_at.is_(None))+ .group_by(WorkflowModel.workflow_permanent_id)+ .subquery()+ )++ workflow_title_sq = (+ select(+ WorkflowModel.workflow_permanent_id,+ WorkflowModel.title,+ )+ .join(+ latest_version_sq,+ (WorkflowModel.workflow_permanent_id == latest_version_sq.c.workflow_permanent_id)+ & (WorkflowModel.version == latest_version_sq.c.max_version),+ )+ .subquery()+ )++ # Base query: schedules joined with workflow titles+ base_filter = (+ select(WorkflowScheduleModel, workflow_title_sq.c.title.label("workflow_title"))+ .outerjoin(+ workflow_title_sq,+ WorkflowScheduleModel.workflow_permanent_id == workflow_title_sq.c.workflow_permanent_id,+ )+ .where(WorkflowScheduleModel.organization_id == organization_id)+ .where(WorkflowScheduleModel.deleted_at.is_(None))+ )++ if enabled_filter is not None:+ base_filter = base_filter.where(WorkflowScheduleModel.enabled == enabled_filter)++ if search:+ base_filter = base_filter.where(+ or_(+ workflow_title_sq.c.title.icontains(search, autoescape=True),+ WorkflowScheduleModel.name.icontains(search, autoescape=True),+ )+ )++ # Count query+ count_query = select(func.count()).select_from(base_filter.subquery())+ total_count = (await session.execute(count_query)).scalar_one()++ # Data query with pagination+ data_query = (+ base_filter.order_by(WorkflowScheduleModel.created_at.desc())+ .limit(page_size)+ .offset(db_page * page_size)+ )+ rows = (await session.execute(data_query)).all()++ # Materialize row data while session is open+ raw_schedules = []+ for row in rows:+ schedule_model = row[0]+ raw_schedules.append(+ (+ schedule_model.workflow_schedule_id,+ schedule_model.organization_id,+ schedule_model.workflow_permanent_id,+ row[1] or "Untitled Workflow",+ schedule_model.cron_expression,+ schedule_model.timezone,+ schedule_model.enabled,+ schedule_model.parameters,+ schedule_model.name,+ schedule_model.description,+ schedule_model.created_at,+ schedule_model.modified_at,+ )+ )++ # Compute next_run outside session scope (pure CPU, no DB needed)+ schedules: list[OrganizationScheduleItem] = []+ for (+ ws_id,+ org_id,+ wpid,+ title,+ cron_expr,+ tz,+ enabled,+ params,+ name,+ description,+ created,+ modified,+ ) in raw_schedules:+ next_run = None+ if enabled:+ try:+ next_run = compute_next_run(cron_expr, tz)+ except Exception:+ LOG.warning(+ "Failed to compute next_run for schedule",+ workflow_schedule_id=ws_id,+ exc_info=True,+ )++ schedules.append(+ OrganizationScheduleItem(+ workflow_schedule_id=ws_id,+ organization_id=org_id,+ workflow_permanent_id=wpid,+ workflow_title=title,+ cron_expression=cron_expr,+ timezone=tz,+ enabled=enabled,+ parameters=params,+ name=name,+ description=description,+ next_run=next_run,+ created_at=created,+ modified_at=modified,+ )+ )++ return schedules, total_count++ @db_operation("soft_delete_orphaned_schedules")+ async def soft_delete_orphaned_schedules(self, limit: int = 500) -> list[tuple[str, str]]:+ """Soft-delete orphaned schedules and return their identities.++ Uses a single UPDATE ... RETURNING statement so orphan detection and+ soft-deletion happen atomically in one DB round-trip.+ """+ async with self.Session() as session:+ active_workflow_exists = (+ select(WorkflowModel.workflow_permanent_id)+ .where(WorkflowModel.workflow_permanent_id == WorkflowScheduleModel.workflow_permanent_id)+ .where(WorkflowModel.deleted_at.is_(None))+ .correlate(WorkflowScheduleModel)+ .exists()+ )+ orphaned_schedules = (+ select(+ WorkflowScheduleModel.workflow_schedule_id.label("workflow_schedule_id"),+ WorkflowScheduleModel.workflow_permanent_id.label("workflow_permanent_id"),+ )+ .where(WorkflowScheduleModel.deleted_at.is_(None))+ .where(~active_workflow_exists)+ .limit(limit)+ .cte("orphaned_schedules")+ )+ update_query = (+ update(WorkflowScheduleModel)+ .where(+ WorkflowScheduleModel.workflow_schedule_id.in_(select(orphaned_schedules.c.workflow_schedule_id))+ )+ .where(WorkflowScheduleModel.deleted_at.is_(None))+ .values(deleted_at=datetime.now(UTC))+ .returning(+ WorkflowScheduleModel.workflow_schedule_id,+ WorkflowScheduleModel.workflow_permanent_id,+ )+ )+ result = await session.execute(update_query)+ await session.commit()+ return [(row[0], row[1]) for row in result.all()]diff --git a/skyvern/forge/sdk/db/repositories/scripts.py b/skyvern/forge/sdk/db/repositories/scripts.pynew file mode 100644index 000000000..e1673c580--- /dev/null+++ b/skyvern/forge/sdk/db/repositories/scripts.py@@ -0,0 +1,1206 @@+from __future__ import annotations++from datetime import datetime, timedelta, timezone++import structlog+from sqlalchemy import and_, delete, distinct, func, select, update+from sqlalchemy.dialects.postgresql import insert++from skyvern.forge.sdk.db._error_handling import db_operation+from skyvern.forge.sdk.db.base_repository import BaseRepository+from skyvern.forge.sdk.db.exceptions import NotFoundError+from skyvern.forge.sdk.db.models import (+ ScriptBlockModel,+ ScriptBranchHitModel,+ ScriptFallbackEpisodeModel,+ ScriptFileModel,+ ScriptModel,+ WorkflowRunModel,+ WorkflowScriptModel,+)+from skyvern.forge.sdk.db.utils import (+ convert_to_script,+ convert_to_script_block,+ convert_to_script_file,+)+from skyvern.forge.sdk.utils.sanitization import sanitize_postgres_text+from skyvern.schemas.scripts import (+ Script,+ ScriptBlock,+ ScriptBranchHit,+ ScriptFallbackEpisode,+ ScriptFile,+ ScriptStatus,+ WorkflowScript,+)++LOG = structlog.get_logger()+++class ScriptsRepository(BaseRepository):+ """Database operations for scripts, script files, script blocks, workflow scripts, and fallback episodes."""++ @db_operation("create_script")+ async def create_script(+ self,+ organization_id: str,+ run_id: str | None = None,+ script_id: str | None = None,+ version: int | None = None,+ ) -> Script:+ async with self.Session() as session:+ script = ScriptModel(+ organization_id=organization_id,+ run_id=run_id,+ )+ if script_id:+ script.script_id = script_id+ if version:+ script.version = version+ session.add(script)+ await session.commit()+ await session.refresh(script)+ return convert_to_script(script)++ @db_operation("get_scripts")+ async def get_scripts(+ self,+ organization_id: str,+ page: int = 1,+ page_size: int = 10,+ ) -> list[Script]:+ async with self.Session() as session:+ # Calculate offset for pagination+ offset = (page - 1) * page_size++ # Subquery to get the latest version of each script+ latest_versions_subquery = (+ select(ScriptModel.script_id, func.max(ScriptModel.version).label("latest_version"))+ .filter_by(organization_id=organization_id)+ .filter(ScriptModel.deleted_at.is_(None))+ .group_by(ScriptModel.script_id)+ .subquery()+ )++ # Main query to get scripts with their latest versions+ get_scripts_query = (+ select(ScriptModel)+ .join(+ latest_versions_subquery,+ and_(+ ScriptModel.script_id == latest_versions_subquery.c.script_id,+ ScriptModel.version == latest_versions_subquery.c.latest_version,+ ),+ )+ .filter_by(organization_id=organization_id)+ .filter(ScriptModel.deleted_at.is_(None))+ .order_by(ScriptModel.created_at.desc())+ .limit(page_size)+ .offset(offset)+ )+ scripts = (await session.scalars(get_scripts_query)).all()+ return [convert_to_script(script) for script in scripts]++ @db_operation("get_script")+ async def get_script(+ self,+ script_id: str,+ organization_id: str,+ version: int | None = None,+ ) -> Script | None:+ """Get a specific script by ID and optionally by version."""+ async with self.Session() as session:+ get_script_query = (+ select(ScriptModel)+ .filter_by(script_id=script_id)+ .filter_by(organization_id=organization_id)+ .filter(ScriptModel.deleted_at.is_(None))+ )++ if version is not None:+ get_script_query = get_script_query.filter_by(version=version)+ else:+ # Get the latest version+ get_script_query = get_script_query.order_by(ScriptModel.version.desc()).limit(1)++ if script := (await session.scalars(get_script_query)).first():+ return convert_to_script(script)+ return None++ @db_operation("get_script_revision")+ async def get_script_revision(self, script_revision_id: str, organization_id: str) -> Script | None:+ async with self.Session() as session:+ script = (+ await session.scalars(+ select(ScriptModel)+ .filter_by(script_revision_id=script_revision_id)+ .filter_by(organization_id=organization_id)+ )+ ).first()+ return convert_to_script(script) if script else None++ @db_operation("get_latest_script_version")+ async def get_latest_script_version(self, script_id: str, organization_id: str) -> Script | None:+ """Get the latest version of a script by script_id."""+ async with self.Session() as session:+ script = (+ await session.scalars(+ select(ScriptModel)+ .filter_by(script_id=script_id, organization_id=organization_id)+ .filter(ScriptModel.deleted_at.is_(None))+ .order_by(ScriptModel.version.desc())+ .limit(1)+ )+ ).first()+ return convert_to_script(script) if script else None++ @db_operation("get_script_versions")+ async def get_script_versions(+ self,+ script_id: str,+ organization_id: str,+ ) -> list[Script]:+ """Get all versions of a script, ordered by version DESC."""+ async with self.Session() as session:+ query = (+ select(ScriptModel)+ .filter(+ ScriptModel.script_id == script_id,+ ScriptModel.organization_id == organization_id,+ ScriptModel.deleted_at.is_(None),+ )+ .order_by(ScriptModel.version.desc())+ )+ result = await session.scalars(query)+ return [convert_to_script(row) for row in result.all()]++ @db_operation("get_script_version_stats")+ async def get_script_version_stats(+ self,+ organization_id: str,+ script_ids: list[str],+ ) -> dict[str, tuple[int, int]]:+ """Return {script_id: (latest_version, version_count)} for the given script IDs."""+ if not script_ids:+ return {}+ async with self.Session() as session:+ query = (+ select(+ ScriptModel.script_id,+ # max(version) must include soft-deleted rows so next-version+ # assignment doesn't collide with the unique constraint.+ func.max(ScriptModel.version),+ # version_count only counts live rows (for display).+ func.count(ScriptModel.script_revision_id).filter(+ ScriptModel.deleted_at.is_(None),+ ),+ )+ .filter(+ ScriptModel.organization_id == organization_id,+ ScriptModel.script_id.in_(script_ids),+ )+ .group_by(ScriptModel.script_id)+ )+ rows = (await session.execute(query)).all()+ return {row[0]: (row[1], row[2]) for row in rows}++ @db_operation("soft_delete_script_by_revision")+ async def soft_delete_script_by_revision(self, script_revision_id: str, organization_id: str) -> None:+ async with self.Session() as session:+ await session.execute(+ update(ScriptModel)+ .filter_by(script_revision_id=script_revision_id)+ .filter_by(organization_id=organization_id)+ .values(deleted_at=datetime.now(timezone.utc))+ )+ await session.commit()++ @db_operation("create_script_file")+ async def create_script_file(+ self,+ script_revision_id: str,+ script_id: str,+ organization_id: str,+ file_path: str,+ file_name: str,+ file_type: str,+ content_hash: str | None = None,+ file_size: int | None = None,+ mime_type: str | None = None,+ encoding: str = "utf-8",+ artifact_id: str | None = None,+ ) -> ScriptFile:+ """Create a script file."""+ async with self.Session() as session:+ script_file = ScriptFileModel(+ script_revision_id=script_revision_id,+ script_id=script_id,+ organization_id=organization_id,+ file_path=file_path,+ file_name=file_name,+ file_type=file_type,+ content_hash=content_hash,+ file_size=file_size,+ mime_type=mime_type,+ encoding=encoding,+ artifact_id=artifact_id,+ )+ session.add(script_file)+ await session.commit()+ await session.refresh(script_file)+ return convert_to_script_file(script_file)++ @db_operation("create_script_block")+ async def create_script_block(+ self,+ script_revision_id: str,+ script_id: str,+ organization_id: str,+ script_block_label: str,+ script_file_id: str | None = None,+ run_signature: str | None = None,+ workflow_run_id: str | None = None,+ workflow_run_block_id: str | None = None,+ input_fields: list[str] | None = None,+ requires_agent: bool = False,+ ) -> ScriptBlock:+ """Create a script block."""+ async with self.Session() as session:+ script_block = ScriptBlockModel(+ script_revision_id=script_revision_id,+ script_id=script_id,+ organization_id=organization_id,+ script_block_label=script_block_label,+ script_file_id=script_file_id,+ run_signature=run_signature,+ workflow_run_id=workflow_run_id,+ workflow_run_block_id=workflow_run_block_id,+ input_fields=input_fields,+ requires_agent=requires_agent,+ )+ session.add(script_block)+ await session.commit()+ await session.refresh(script_block)+ return convert_to_script_block(script_block)++ @db_operation("update_script_block")+ async def update_script_block(+ self,+ script_block_id: str,+ organization_id: str,+ script_file_id: str | None = None,+ run_signature: str | None = None,+ workflow_run_id: str | None = None,+ workflow_run_block_id: str | None = None,+ clear_run_signature: bool = False,+ input_fields: list[str] | None = None,+ requires_agent: bool | None = None,+ ) -> ScriptBlock:+ async with self.Session() as session:+ script_block = (+ await session.scalars(+ select(ScriptBlockModel)+ .filter_by(script_block_id=script_block_id)+ .filter_by(organization_id=organization_id)+ )+ ).first()+ if script_block:+ if script_file_id is not None:+ script_block.script_file_id = script_file_id+ if clear_run_signature:+ script_block.run_signature = None+ elif run_signature is not None:+ script_block.run_signature = run_signature+ if workflow_run_id is not None:+ script_block.workflow_run_id = workflow_run_id+ if workflow_run_block_id is not None:+ script_block.workflow_run_block_id = workflow_run_block_id+ if input_fields is not None:+ script_block.input_fields = input_fields+ if requires_agent is not None:+ script_block.requires_agent = requires_agent+ await session.commit()+ await session.refresh(script_block)+ return convert_to_script_block(script_block)+ else:+ raise NotFoundError("Script block not found")++ @db_operation("get_script_files")+ async def get_script_files(self, script_revision_id: str, organization_id: str) -> list[ScriptFile]:+ async with self.Session() as session:+ script_files = (+ await session.scalars(+ select(ScriptFileModel)+ .filter_by(script_revision_id=script_revision_id)+ .filter_by(organization_id=organization_id)+ )+ ).all()+ return [convert_to_script_file(script_file) for script_file in script_files]++ @db_operation("get_script_file_by_id")+ async def get_script_file_by_id(+ self,+ script_revision_id: str,+ file_id: str,+ organization_id: str,+ ) -> ScriptFile | None:+ async with self.Session() as session:+ script_file = (+ await session.scalars(+ select(ScriptFileModel)+ .filter_by(script_revision_id=script_revision_id)+ .filter_by(file_id=file_id)+ .filter_by(organization_id=organization_id)+ )+ ).first()++ return convert_to_script_file(script_file) if script_file else None++ @db_operation("get_script_file_by_path")+ async def get_script_file_by_path(+ self,+ script_revision_id: str,+ file_path: str,+ organization_id: str,+ ) -> ScriptFile | None:+ async with self.Session() as session:+ script_file = (+ await session.scalars(+ select(ScriptFileModel)+ .filter_by(script_revision_id=script_revision_id)+ .filter_by(file_path=file_path)+ .filter_by(organization_id=organization_id)+ )+ ).first()+ return convert_to_script_file(script_file) if script_file else None++ @db_operation("update_script_file")+ async def update_script_file(+ self,+ script_file_id: str,+ organization_id: str,+ artifact_id: str | None = None,+ ) -> ScriptFile:+ async with self.Session() as session:+ script_file = (+ await session.scalars(+ select(ScriptFileModel).filter_by(file_id=script_file_id).filter_by(organization_id=organization_id)+ )+ ).first()+ if script_file:+ if artifact_id:+ script_file.artifact_id = artifact_id+ await session.commit()+ await session.refresh(script_file)+ return convert_to_script_file(script_file)+ else:+ raise NotFoundError("Script file not found")++ @db_operation("get_script_block")+ async def get_script_block(+ self,+ script_block_id: str,+ organization_id: str,+ ) -> ScriptBlock | None:+ async with self.Session() as session:+ record = (+ await session.scalars(+ select(ScriptBlockModel)+ .filter_by(script_block_id=script_block_id)+ .filter_by(organization_id=organization_id)+ )+ ).first()+ return convert_to_script_block(record) if record else None++ @db_operation("get_script_block_by_label")+ async def get_script_block_by_label(+ self,+ organization_id: str,+ script_revision_id: str,+ script_block_label: str,+ ) -> ScriptBlock | None:+ async with self.Session() as session:+ record = (+ await session.scalars(+ select(ScriptBlockModel)+ .filter_by(script_revision_id=script_revision_id)+ .filter_by(script_block_label=script_block_label)+ .filter_by(organization_id=organization_id)+ )+ ).first()+ return convert_to_script_block(record) if record else None++ @db_operation("get_script_blocks_by_script_revision_id")+ async def get_script_blocks_by_script_revision_id(+ self,+ script_revision_id: str,+ organization_id: str,+ ) -> list[ScriptBlock]:+ async with self.Session() as session:+ records = (+ await session.scalars(+ select(ScriptBlockModel)+ .filter_by(script_revision_id=script_revision_id)+ .filter_by(organization_id=organization_id)+ .order_by(ScriptBlockModel.created_at.asc())+ )+ ).all()+ return [convert_to_script_block(record) for record in records]++ @db_operation("create_workflow_script")+ async def create_workflow_script(+ self,+ *,+ organization_id: str,+ script_id: str,+ workflow_permanent_id: str,+ cache_key: str,+ cache_key_value: str,+ workflow_id: str | None = None,+ workflow_run_id: str | None = None,+ status: ScriptStatus = ScriptStatus.published,+ ) -> None:+ """Create a workflow->script cache mapping entry."""+ async with self.Session() as session:+ record = WorkflowScriptModel(+ organization_id=organization_id,+ script_id=script_id,+ workflow_permanent_id=workflow_permanent_id,+ workflow_id=workflow_id,+ workflow_run_id=workflow_run_id,+ cache_key=cache_key,+ cache_key_value=cache_key_value,+ status=status,+ )+ session.add(record)+ await session.commit()++ @db_operation("get_workflow_script")+ async def get_workflow_script(+ self,+ organization_id: str,+ workflow_permanent_id: str,+ workflow_run_id: str,+ statuses: list[ScriptStatus] | None = None,+ ) -> WorkflowScript | None:+ async with self.Session() as session:+ query = (+ select(WorkflowScriptModel)+ .filter_by(organization_id=organization_id)+ .filter_by(workflow_permanent_id=workflow_permanent_id)+ .filter_by(workflow_run_id=workflow_run_id)+ )+ if statuses:+ query = query.filter(WorkflowScriptModel.status.in_(statuses))+ workflow_script_model = (await session.scalars(query)).first()+ return WorkflowScript.model_validate(workflow_script_model) if workflow_script_model else None++ @db_operation("get_workflow_script_by_cache_key_value")+ async def get_workflow_script_by_cache_key_value(+ self,+ *,+ organization_id: str,+ workflow_permanent_id: str,+ cache_key_value: str,+ workflow_run_id: str | None = None,+ cache_key: str | None = None,+ statuses: list[ScriptStatus] | None = None,+ ) -> Script | None:+ """Get latest script version linked to a workflow by a specific cache_key_value."""+ async with self.Session() as session:+ # Build the query: join workflow_scripts with scripts+ # Join on both script_id and organization_id to leverage uc_org_script_version index+ query = (+ select(ScriptModel)+ .join(+ WorkflowScriptModel,+ and_(+ ScriptModel.organization_id == WorkflowScriptModel.organization_id,+ ScriptModel.script_id == WorkflowScriptModel.script_id,+ ),+ )+ .where(+ WorkflowScriptModel.organization_id == organization_id,+ WorkflowScriptModel.workflow_permanent_id == workflow_permanent_id,+ WorkflowScriptModel.cache_key_value == cache_key_value,+ WorkflowScriptModel.deleted_at.is_(None),+ )+ )++ if workflow_run_id:+ query = query.where(WorkflowScriptModel.workflow_run_id == workflow_run_id)++ if cache_key is not None:+ query = query.where(WorkflowScriptModel.cache_key == cache_key)++ if statuses is not None and len(statuses) > 0:+ query = query.where(WorkflowScriptModel.status.in_(statuses))++ query = query.order_by(ScriptModel.created_at.desc(), ScriptModel.version.desc()).limit(1)++ script = (await session.scalars(query)).first()+ return convert_to_script(script) if script else None++ @db_operation("get_workflow_cache_key_count")+ async def get_workflow_cache_key_count(+ self,+ organization_id: str,+ workflow_permanent_id: str,+ cache_key: str,+ filter: str | None = None,+ ) -> int:+ async with self.Session() as session:+ query = (+ select(func.count())+ .select_from(WorkflowScriptModel)+ .filter_by(organization_id=organization_id)+ .filter_by(workflow_permanent_id=workflow_permanent_id)+ .filter_by(cache_key=cache_key)+ .filter_by(deleted_at=None)+ .filter_by(status="published")+ )++ if filter:+ query = query.filter(WorkflowScriptModel.cache_key_value.contains(filter))++ return (await session.execute(query)).scalar_one()++ @db_operation("get_workflow_cache_key_values")+ async def get_workflow_cache_key_values(+ self,+ organization_id: str,+ workflow_permanent_id: str,+ cache_key: str,+ page: int = 1,+ page_size: int = 100,+ filter: str | None = None,+ ) -> list[str]:+ async with self.Session() as session:+ query = (+ select(WorkflowScriptModel.cache_key_value)+ .order_by(WorkflowScriptModel.cache_key_value.asc())+ .filter_by(organization_id=organization_id)+ .filter_by(workflow_permanent_id=workflow_permanent_id)+ .filter_by(cache_key=cache_key)+ .filter_by(deleted_at=None)+ .filter_by(status="published")+ .offset((page - 1) * page_size)+ .limit(page_size)+ )++ if filter:+ query = query.filter(WorkflowScriptModel.cache_key_value.contains(filter))++ return (await session.scalars(query)).all()++ @db_operation("delete_workflow_cache_key_value")+ async def delete_workflow_cache_key_value(+ self,+ organization_id: str,+ workflow_permanent_id: str,+ cache_key_value: str,+ ) -> bool:+ """+ Soft delete workflow cache key values by setting deleted_at timestamp.++ Returns True if any records were deleted, False otherwise.+ """+ async with self.Session() as session:+ stmt = (+ update(WorkflowScriptModel)+ .where(+ and_(+ WorkflowScriptModel.organization_id == organization_id,+ WorkflowScriptModel.workflow_permanent_id == workflow_permanent_id,+ WorkflowScriptModel.cache_key_value == cache_key_value,+ WorkflowScriptModel.deleted_at.is_(None),+ )+ )+ .values(deleted_at=datetime.now(timezone.utc))+ )++ result = await session.execute(stmt)+ await session.commit()++ return result.rowcount > 0++ @db_operation("delete_workflow_scripts_by_permanent_id")+ async def delete_workflow_scripts_by_permanent_id(+ self,+ organization_id: str,+ workflow_permanent_id: str,+ statuses: list[ScriptStatus] | None = None,+ script_ids: list[str] | None = None,+ ) -> int:+ """+ Soft delete all published workflow scripts for a workflow permanent id by setting deleted_at timestamp.++ Returns True if any records were deleted, False otherwise.+ """+ async with self.Session() as session:+ stmt = (+ update(WorkflowScriptModel)+ .where(+ and_(+ WorkflowScriptModel.organization_id == organization_id,+ WorkflowScriptModel.workflow_permanent_id == workflow_permanent_id,+ WorkflowScriptModel.deleted_at.is_(None),+ )+ )+ .values(deleted_at=datetime.now(timezone.utc))+ )++ if statuses:+ stmt = stmt.where(WorkflowScriptModel.status.in_([s.value for s in statuses]))++ if script_ids:+ stmt = stmt.where(WorkflowScriptModel.script_id.in_(script_ids))++ result = await session.execute(stmt)+ await session.commit()++ return result.rowcount++ @db_operation("get_workflow_scripts_by_permanent_id")+ async def get_workflow_scripts_by_permanent_id(+ self,+ organization_id: str,+ workflow_permanent_id: str,+ statuses: list[ScriptStatus] | None = None,+ ) -> list[WorkflowScriptModel]:+ async with self.Session() as session:+ query = (+ select(WorkflowScriptModel)+ .filter_by(organization_id=organization_id)+ .filter_by(workflow_permanent_id=workflow_permanent_id)+ .filter_by(deleted_at=None)+ )++ if statuses:+ query = query.filter(WorkflowScriptModel.status.in_([s.value for s in statuses]))++ query = query.order_by(WorkflowScriptModel.modified_at.desc())+ return (await session.scalars(query)).all()++ # -- Script Run / Stats ------------------------------------------------++ @db_operation("get_workflow_runs_for_script")+ async def get_workflow_runs_for_script(+ self,+ organization_id: str,+ script_id: str,+ page_size: int = 50,+ created_after: datetime | None = None,+ created_before: datetime | None = None,+ ) -> tuple[list[WorkflowRunModel], int, dict[str, int]]:+ """Get workflow runs associated with a script, with total count and status counts.++ Returns (runs, total_count, status_counts) where runs is limited by page_size,+ total_count is derived from the status_counts GROUP BY, and status_counts is a+ GROUP BY aggregation of statuses across all runs.++ If created_after/created_before are provided, filters by the workflow_script+ entry's created_at (not the run's created_at), scoping to the version that+ was active in that time window.+ """+ async with self.Session() as session:+ # Subquery: distinct run IDs for this script+ run_ids_subquery = (+ select(distinct(WorkflowScriptModel.workflow_run_id))+ .filter_by(organization_id=organization_id, script_id=script_id)+ .filter(WorkflowScriptModel.deleted_at.is_(None))+ .filter(WorkflowScriptModel.workflow_run_id.isnot(None))+ )++ # Time-window filters scope by workflow_script creation time,+ # which aligns with the script version that was created/used.+ if created_after is not None:+ run_ids_subquery = run_ids_subquery.filter(+ WorkflowScriptModel.created_at >= created_after,+ )+ if created_before is not None:+ run_ids_subquery = run_ids_subquery.filter(+ WorkflowScriptModel.created_at < created_before,+ )++ # Base filter for workflow runs+ base_filters = [+ WorkflowRunModel.workflow_run_id.in_(run_ids_subquery),+ WorkflowRunModel.organization_id == organization_id,+ ]++ # Count statuses via GROUP BY (also gives us total_count)+ status_query = (+ select(WorkflowRunModel.status, func.count()).filter(*base_filters).group_by(WorkflowRunModel.status)+ )+ status_counts = {(s or "unknown"): c for s, c in (await session.execute(status_query)).all()}+ total_count = sum(status_counts.values())++ if total_count == 0:+ return [], 0, {}++ # Get the actual workflow runs (paginated)+ runs_query = (+ select(WorkflowRunModel)+ .filter(*base_filters)+ .order_by(WorkflowRunModel.created_at.desc())+ .limit(page_size)+ )+ runs = list((await session.scalars(runs_query)).all())++ return runs, total_count, status_counts++ @db_operation("get_script_run_stats")+ async def get_script_run_stats(+ self,+ organization_id: str,+ script_ids: list[str],+ ) -> dict[str, tuple[float | None, int]]:+ """Get success rate and total run count for each script_id.++ Both metrics are computed from the same population (workflow_scripts joined+ to workflow_runs), so they are always consistent.++ Returns a dict mapping script_id -> (success_rate, total_runs) where+ success_rate is 0.0-1.0 or None if no runs.+ """+ if not script_ids:+ return {}+ async with self.Session() as session:+ # Join workflow_scripts -> workflow_runs, group by script_id and status+ query = (+ select(+ WorkflowScriptModel.script_id,+ WorkflowRunModel.status,+ func.count(distinct(WorkflowRunModel.workflow_run_id)),+ )+ .join(+ WorkflowRunModel,+ WorkflowScriptModel.workflow_run_id == WorkflowRunModel.workflow_run_id,+ )+ .filter(+ WorkflowScriptModel.organization_id == organization_id,+ WorkflowScriptModel.script_id.in_(script_ids),+ WorkflowScriptModel.deleted_at.is_(None),+ WorkflowScriptModel.workflow_run_id.isnot(None),+ WorkflowRunModel.organization_id == organization_id,+ )+ .group_by(WorkflowScriptModel.script_id, WorkflowRunModel.status)+ )+ rows = (await session.execute(query)).all()++ # Aggregate per script_id+ totals: dict[str, int] = {}+ completed: dict[str, int] = {}+ for sid, status, count in rows:+ totals[sid] = totals.get(sid, 0) + count+ if status == "completed":+ completed[sid] = completed.get(sid, 0) + count++ return {+ sid: (+ (completed.get(sid, 0) / totals[sid]) if totals.get(sid) else None,+ totals.get(sid, 0),+ )+ for sid in script_ids+ }++ # -- Script Pinning ----------------------------------------------------++ @db_operation("is_script_pinned")+ async def is_script_pinned(+ self,+ organization_id: str,+ script_id: str,+ ) -> bool:+ """Check if any active workflow_script row for this script_id is pinned."""+ async with self.Session() as session:+ query = (+ select(WorkflowScriptModel.is_pinned)+ .where(+ WorkflowScriptModel.organization_id == organization_id,+ WorkflowScriptModel.script_id == script_id,+ WorkflowScriptModel.is_pinned.is_(True),+ WorkflowScriptModel.deleted_at.is_(None),+ )+ .limit(1)+ )+ result = await session.scalars(query)+ return result.first() is not None++ @db_operation("pin_workflow_script")+ async def pin_workflow_script(+ self,+ organization_id: str,+ workflow_permanent_id: str,+ cache_key_value: str,+ pinned_by: str | None = None,+ ) -> WorkflowScriptModel | None:+ """Pin all workflow scripts for a given cache key value."""+ async with self.Session() as session:+ stmt = (+ update(WorkflowScriptModel)+ .where(+ WorkflowScriptModel.organization_id == organization_id,+ WorkflowScriptModel.workflow_permanent_id == workflow_permanent_id,+ WorkflowScriptModel.cache_key_value == cache_key_value,+ WorkflowScriptModel.deleted_at.is_(None),+ )+ .values(+ is_pinned=True,+ pinned_at=datetime.now(timezone.utc),+ pinned_by=pinned_by,+ )+ )+ await session.execute(stmt)+ await session.commit()++ # Return the first updated model for the response+ query = (+ select(WorkflowScriptModel)+ .filter_by(organization_id=organization_id)+ .filter_by(workflow_permanent_id=workflow_permanent_id)+ .filter_by(cache_key_value=cache_key_value)+ .filter_by(deleted_at=None)+ .limit(1)+ )+ result = await session.scalars(query)+ return result.first()++ @db_operation("unpin_workflow_script")+ async def unpin_workflow_script(+ self,+ organization_id: str,+ workflow_permanent_id: str,+ cache_key_value: str,+ ) -> WorkflowScriptModel | None:+ """Unpin workflow scripts for a given cache key value."""+ async with self.Session() as session:+ stmt = (+ update(WorkflowScriptModel)+ .where(+ WorkflowScriptModel.organization_id == organization_id,+ WorkflowScriptModel.workflow_permanent_id == workflow_permanent_id,+ WorkflowScriptModel.cache_key_value == cache_key_value,+ WorkflowScriptModel.deleted_at.is_(None),+ )+ .values(+ is_pinned=False,+ pinned_at=None,+ pinned_by=None,+ )+ )+ await session.execute(stmt)+ await session.commit()++ # Return the first updated model for the response+ query = (+ select(WorkflowScriptModel)+ .filter_by(organization_id=organization_id)+ .filter_by(workflow_permanent_id=workflow_permanent_id)+ .filter_by(cache_key_value=cache_key_value)+ .filter_by(deleted_at=None)+ .limit(1)+ )+ result = await session.scalars(query)+ return result.first()++ # -- Script Fallback Episode CRUD --------------------------------------++ @db_operation("create_fallback_episode")+ async def create_fallback_episode(+ self,+ organization_id: str,+ workflow_permanent_id: str,+ workflow_run_id: str,+ block_label: str,+ fallback_type: str,+ script_revision_id: str | None = None,+ error_message: str | None = None,+ classify_result: str | None = None,+ agent_actions: list | dict | None = None,+ page_url: str | None = None,+ page_text_snapshot: str | None = None,+ ) -> ScriptFallbackEpisode:+ async with self.Session() as session:+ episode = ScriptFallbackEpisodeModel(+ organization_id=organization_id,+ workflow_permanent_id=workflow_permanent_id,+ workflow_run_id=workflow_run_id,+ block_label=block_label,+ fallback_type=fallback_type,+ script_revision_id=script_revision_id,+ error_message=sanitize_postgres_text(error_message) if error_message else None,+ classify_result=sanitize_postgres_text(classify_result) if classify_result else None,+ agent_actions=agent_actions,+ page_url=sanitize_postgres_text(page_url) if page_url else None,+ page_text_snapshot=sanitize_postgres_text(page_text_snapshot) if page_text_snapshot else None,+ )+ session.add(episode)+ await session.commit()+ await session.refresh(episode)+ return ScriptFallbackEpisode.model_validate(episode)++ @db_operation("get_unreviewed_episodes")+ async def get_unreviewed_episodes(+ self,+ workflow_permanent_id: str,+ organization_id: str,+ limit: int = 100,+ script_revision_id: str | None = None,+ ) -> list[ScriptFallbackEpisode]:+ async with self.Session() as session:+ query = (+ select(ScriptFallbackEpisodeModel)+ .filter_by(+ organization_id=organization_id,+ workflow_permanent_id=workflow_permanent_id,+ reviewed=False,+ )+ .order_by(ScriptFallbackEpisodeModel.created_at.asc())+ .limit(limit)+ )+ if script_revision_id:+ query = query.filter_by(script_revision_id=script_revision_id)+ episodes = (await session.scalars(query)).all()+ return [ScriptFallbackEpisode.model_validate(e) for e in episodes]++ @db_operation("update_fallback_episode")+ async def update_fallback_episode(+ self,+ episode_id: str,+ organization_id: str,+ agent_actions: list | dict | None = None,+ fallback_succeeded: bool | None = None,+ ) -> None:+ values: dict = {}+ if agent_actions is not None:+ values["agent_actions"] = agent_actions+ if fallback_succeeded is not None:+ values["fallback_succeeded"] = fallback_succeeded+ if not values:+ return+ values["modified_at"] = datetime.now(timezone.utc)+ async with self.Session() as session:+ await session.execute(+ update(ScriptFallbackEpisodeModel)+ .where(ScriptFallbackEpisodeModel.episode_id == episode_id)+ .where(ScriptFallbackEpisodeModel.organization_id == organization_id)+ .values(**values)+ )+ await session.commit()++ @db_operation("delete_fallback_episode")+ async def delete_fallback_episode(+ self,+ episode_id: str,+ organization_id: str,+ ) -> None:+ async with self.Session() as session:+ await session.execute(+ delete(ScriptFallbackEpisodeModel)+ .where(ScriptFallbackEpisodeModel.episode_id == episode_id)+ .where(ScriptFallbackEpisodeModel.organization_id == organization_id)+ )+ await session.commit()++ @db_operation("get_fallback_episodes")+ async def get_fallback_episodes(+ self,+ organization_id: str,+ workflow_permanent_id: str,+ page: int = 1,+ page_size: int = 20,+ workflow_run_id: str | None = None,+ block_label: str | None = None,+ reviewed: bool | None = None,+ fallback_type: str | None = None,+ ) -> list[ScriptFallbackEpisode]:+ async with self.Session() as session:+ query = select(ScriptFallbackEpisodeModel).filter(+ ScriptFallbackEpisodeModel.organization_id == organization_id,+ ScriptFallbackEpisodeModel.workflow_permanent_id == workflow_permanent_id,+ )+ if workflow_run_id is not None:+ query = query.filter(ScriptFallbackEpisodeModel.workflow_run_id == workflow_run_id)+ if block_label is not None:+ query = query.filter(ScriptFallbackEpisodeModel.block_label == block_label)+ if reviewed is not None:+ query = query.filter(ScriptFallbackEpisodeModel.reviewed == reviewed)+ if fallback_type is not None:+ query = query.filter(ScriptFallbackEpisodeModel.fallback_type == fallback_type)++ offset = (page - 1) * page_size+ query = query.order_by(ScriptFallbackEpisodeModel.created_at.desc()).limit(page_size).offset(offset)++ result = await session.scalars(query)+ return [ScriptFallbackEpisode.model_validate(row) for row in result.all()]++ @db_operation("get_fallback_episodes_count")+ async def get_fallback_episodes_count(+ self,+ organization_id: str,+ workflow_permanent_id: str | None = None,+ workflow_run_id: str | None = None,+ block_label: str | None = None,+ reviewed: bool | None = None,+ fallback_type: str | None = None,+ script_revision_id: str | None = None,+ ) -> int:+ """Count fallback episodes matching the given filters.++ At least one scoping filter (workflow_permanent_id, workflow_run_id,+ or script_revision_id) should be provided. Without any, this returns+ the total count for the entire organization which is rarely intended.+ """+ if workflow_permanent_id is None and workflow_run_id is None and script_revision_id is None:+ LOG.warning(+ "get_fallback_episodes_count called without any scoping filter",+ organization_id=organization_id,+ )+ async with self.Session() as session:+ query = (+ select(func.count())+ .select_from(ScriptFallbackEpisodeModel)+ .filter(+ ScriptFallbackEpisodeModel.organization_id == organization_id,+ )+ )+ if workflow_permanent_id is not None:+ query = query.filter(ScriptFallbackEpisodeModel.workflow_permanent_id == workflow_permanent_id)+ if workflow_run_id is not None:+ query = query.filter(ScriptFallbackEpisodeModel.workflow_run_id == workflow_run_id)+ if block_label is not None:+ query = query.filter(ScriptFallbackEpisodeModel.block_label == block_label)+ if reviewed is not None:+ query = query.filter(ScriptFallbackEpisodeModel.reviewed == reviewed)+ if fallback_type is not None:+ query = query.filter(ScriptFallbackEpisodeModel.fallback_type == fallback_type)+ if script_revision_id is not None:+ query = query.filter(ScriptFallbackEpisodeModel.script_revision_id == script_revision_id)++ result = await session.scalar(query)+ return result or 0++ @db_operation("get_fallback_episode")+ async def get_fallback_episode(+ self,+ episode_id: str,+ organization_id: str,+ ) -> ScriptFallbackEpisode | None:+ async with self.Session() as session:+ query = select(ScriptFallbackEpisodeModel).filter(+ ScriptFallbackEpisodeModel.episode_id == episode_id,+ ScriptFallbackEpisodeModel.organization_id == organization_id,+ )+ result = await session.scalar(query)+ if result:+ return ScriptFallbackEpisode.model_validate(result)+ return None++ @db_operation("mark_episode_reviewed")+ async def mark_episode_reviewed(+ self,+ episode_id: str,+ organization_id: str,+ reviewer_output: str | None = None,+ new_script_revision_id: str | None = None,+ ) -> None:+ async with self.Session() as session:+ await session.execute(+ update(ScriptFallbackEpisodeModel)+ .where(ScriptFallbackEpisodeModel.episode_id == episode_id)+ .where(ScriptFallbackEpisodeModel.organization_id == organization_id)+ .values(+ reviewed=True,+ reviewer_output=sanitize_postgres_text(reviewer_output) if reviewer_output else None,+ new_script_revision_id=new_script_revision_id,+ modified_at=datetime.now(timezone.utc),+ )+ )+ await session.commit()++ @db_operation("get_recent_reviewed_episodes")+ async def get_recent_reviewed_episodes(+ self,+ workflow_permanent_id: str,+ organization_id: str,+ limit: int = 20,+ ) -> list[ScriptFallbackEpisode]:+ """Return recently reviewed episodes for cross-run historical context.++ These give the reviewer visibility into past failures and fixes so it can+ avoid repeating the same mistakes.+ """+ async with self.Session() as session:+ query = (+ select(ScriptFallbackEpisodeModel)+ .filter_by(+ organization_id=organization_id,+ workflow_permanent_id=workflow_permanent_id,+ reviewed=True,+ )+ .order_by(ScriptFallbackEpisodeModel.created_at.desc())+ .limit(limit)+ )+ episodes = (await session.scalars(query)).all()+ return [ScriptFallbackEpisode.model_validate(e) for e in episodes]++ @db_operation("record_branch_hit")+ async def record_branch_hit(+ self,+ organization_id: str,+ workflow_permanent_id: str,+ block_label: str,+ branch_key: str,+ ) -> None:+ """Record a classify branch hit, upserting the hit count and last_hit_at."""+ now = datetime.now(timezone.utc)+ async with self.Session() as session:+ stmt = insert(ScriptBranchHitModel).values(+ organization_id=organization_id,+ workflow_permanent_id=workflow_permanent_id,+ block_label=block_label,+ branch_key=branch_key,+ hit_count=1,+ first_hit_at=now,+ last_hit_at=now,+ )+ stmt = stmt.on_conflict_do_update(+ index_elements=[+ "organization_id",+ "workflow_permanent_id",+ "block_label",+ "branch_key",+ ],+ set_={+ "hit_count": ScriptBranchHitModel.hit_count + 1,+ "last_hit_at": now,+ },+ )+ await session.execute(stmt)+ await session.commit()++ @db_operation("get_stale_branches")+ async def get_stale_branches(+ self,+ organization_id: str,+ workflow_permanent_id: str,+ stale_days: int = 90,+ limit: int = 200,+ ) -> list[ScriptBranchHit]:+ """Get branches that haven't been accessed in stale_days days."""+ cutoff = datetime.now(timezone.utc) - timedelta(days=stale_days)+ async with self.Session() as session:+ query = (+ select(ScriptBranchHitModel)+ .filter_by(+ organization_id=organization_id,+ workflow_permanent_id=workflow_permanent_id,+ )+ .filter(ScriptBranchHitModel.last_hit_at < cutoff)+ .order_by(ScriptBranchHitModel.last_hit_at.asc())+ .limit(limit)+ )+ results = (await session.scalars(query)).all()+ return [ScriptBranchHit.model_validate(r) for r in results]diff --git a/skyvern/forge/sdk/db/repositories/tasks.py b/skyvern/forge/sdk/db/repositories/tasks.pynew file mode 100644index 000000000..4493bcc42--- /dev/null+++ b/skyvern/forge/sdk/db/repositories/tasks.py@@ -0,0 +1,727 @@+from __future__ import annotations++from datetime import datetime, timedelta, timezone+from typing import Any, Sequence++import structlog+from sqlalchemy import and_, delete, distinct, func, select, tuple_, update++from skyvern.forge.sdk.db._error_handling import db_operation+from skyvern.forge.sdk.db.base_alchemy_db import read_retry+from skyvern.forge.sdk.db.base_repository import BaseRepository+from skyvern.forge.sdk.db.enums import TaskType+from skyvern.forge.sdk.db.exceptions import NotFoundError+from skyvern.forge.sdk.db.models import (+ ActionModel,+ StepModel,+ TaskModel,+ WorkflowRunModel,+)+from skyvern.forge.sdk.db.utils import convert_to_step, convert_to_task, hydrate_action, serialize_proxy_location+from skyvern.forge.sdk.models import Step, StepStatus+from skyvern.forge.sdk.schemas.tasks import OrderBy, SortDirection, Task, TaskStatus+from skyvern.forge.sdk.utils.sanitization import sanitize_postgres_text+from skyvern.schemas.runs import ProxyLocationInput+from skyvern.schemas.steps import AgentStepOutput+from skyvern.webeye.actions.actions import Action++LOG = structlog.get_logger()+++class TasksRepository(BaseRepository):+ @db_operation("create_task")+ async def create_task(+ self,+ url: str,+ title: str | None,+ navigation_goal: str | None,+ data_extraction_goal: str | None,+ navigation_payload: dict[str, Any] | list | str | None,+ status: str = "created",+ complete_criterion: str | None = None,+ terminate_criterion: str | None = None,+ webhook_callback_url: str | None = None,+ totp_verification_url: str | None = None,+ totp_identifier: str | None = None,+ organization_id: str | None = None,+ proxy_location: ProxyLocationInput = None,+ extracted_information_schema: dict[str, Any] | list | str | None = None,+ workflow_run_id: str | None = None,+ order: int | None = None,+ retry: int | None = None,+ max_steps_per_run: int | None = None,+ error_code_mapping: dict[str, str] | None = None,+ task_type: str = TaskType.general,+ application: str | None = None,+ include_action_history_in_verification: bool | None = None,+ model: dict[str, Any] | None = None,+ max_screenshot_scrolling_times: int | None = None,+ extra_http_headers: dict[str, str] | None = None,+ browser_session_id: str | None = None,+ browser_address: str | None = None,+ download_timeout: float | None = None,+ ) -> Task:+ # Sanitize text fields to remove NUL bytes and control characters+ # that PostgreSQL cannot store in text columns+ def _sanitize(v: str | None) -> str | None:+ return sanitize_postgres_text(v) if isinstance(v, str) else v++ navigation_goal = _sanitize(navigation_goal)+ data_extraction_goal = _sanitize(data_extraction_goal)+ title = _sanitize(title)+ url = sanitize_postgres_text(url)+ complete_criterion = _sanitize(complete_criterion)+ terminate_criterion = _sanitize(terminate_criterion)++ async with self.Session() as session:+ new_task = TaskModel(+ status=status,+ task_type=task_type,+ url=url,+ title=title,+ webhook_callback_url=webhook_callback_url,+ totp_verification_url=totp_verification_url,+ totp_identifier=totp_identifier,+ navigation_goal=navigation_goal,+ complete_criterion=complete_criterion,+ terminate_criterion=terminate_criterion,+ data_extraction_goal=data_extraction_goal,+ navigation_payload=navigation_payload,+ organization_id=organization_id,+ proxy_location=serialize_proxy_location(proxy_location),+ extracted_information_schema=extracted_information_schema,+ workflow_run_id=workflow_run_id,+ order=order,+ retry=retry,+ max_steps_per_run=max_steps_per_run,+ error_code_mapping=error_code_mapping,+ application=application,+ include_action_history_in_verification=include_action_history_in_verification,+ model=model,+ max_screenshot_scrolling_times=max_screenshot_scrolling_times,+ extra_http_headers=extra_http_headers,+ browser_session_id=browser_session_id,+ browser_address=browser_address,+ download_timeout=download_timeout,+ )+ session.add(new_task)+ await session.commit()+ await session.refresh(new_task)+ return convert_to_task(new_task, self.debug_enabled)++ @db_operation("create_step")+ async def create_step(+ self,+ task_id: str,+ order: int,+ retry_index: int,+ organization_id: str | None = None,+ status: StepStatus = StepStatus.created,+ created_by: str | None = None,+ ) -> Step:+ async with self.Session() as session:+ new_step = StepModel(+ task_id=task_id,+ order=order,+ retry_index=retry_index,+ status=status,+ organization_id=organization_id,+ created_by=created_by,+ )+ session.add(new_step)+ await session.commit()+ await session.refresh(new_step)+ return convert_to_step(new_step, debug_enabled=self.debug_enabled)++ @read_retry()+ @db_operation("get_task", log_errors=False)+ async def get_task(self, task_id: str, organization_id: str | None = None) -> Task | None:+ """Get a task by its id"""+ async with self.Session() as session:+ query = select(TaskModel).filter_by(task_id=task_id)+ if organization_id is not None:+ query = query.filter_by(organization_id=organization_id)+ if task_obj := (await session.scalars(query)).first():+ return convert_to_task(task_obj, self.debug_enabled)+ else:+ LOG.info(+ "Task not found",+ task_id=task_id,+ organization_id=organization_id,+ )+ return None++ @db_operation("get_tasks_by_ids")+ async def get_tasks_by_ids(+ self,+ task_ids: list[str],+ organization_id: str,+ ) -> list[Task]:+ async with self.Session() as session:+ tasks = (+ await session.scalars(+ select(TaskModel).filter(TaskModel.task_id.in_(task_ids)).filter_by(organization_id=organization_id)+ )+ ).all()+ return [convert_to_task(task, debug_enabled=self.debug_enabled) for task in tasks]++ @db_operation("get_step")+ async def get_step(self, step_id: str, organization_id: str | None = None) -> Step | None:+ async with self.Session() as session:+ if step := (+ await session.scalars(+ select(StepModel).filter_by(step_id=step_id).filter_by(organization_id=organization_id)+ )+ ).first():+ return convert_to_step(step, debug_enabled=self.debug_enabled)++ else:+ return None++ @db_operation("get_task_steps")+ async def get_task_steps(self, task_id: str, organization_id: str) -> list[Step]:+ async with self.Session() as session:+ if steps := (+ await session.scalars(+ select(StepModel)+ .filter_by(task_id=task_id)+ .filter_by(organization_id=organization_id)+ .order_by(StepModel.order)+ .order_by(StepModel.retry_index)+ )+ ).all():+ return [convert_to_step(step, debug_enabled=self.debug_enabled) for step in steps]+ else:+ return []++ @db_operation("get_steps_by_task_ids")+ async def get_steps_by_task_ids(self, task_ids: list[str], organization_id: str | None = None) -> list[Step]:+ async with self.Session() as session:+ steps = (+ await session.scalars(+ select(StepModel).filter(StepModel.task_id.in_(task_ids)).filter_by(organization_id=organization_id)+ )+ ).all()+ return [convert_to_step(step, debug_enabled=self.debug_enabled) for step in steps]++ @db_operation("get_total_unique_step_order_count_by_task_ids")+ async def get_total_unique_step_order_count_by_task_ids(+ self,+ *,+ task_ids: list[str],+ organization_id: str,+ ) -> int:+ """+ Get the total count of unique (step.task_id, step.order) pairs of StepModel for the given task ids+ Basically translate this sql query into a SQLAlchemy query: select count(distinct(s.task_id, s.order)) from steps s+ where s.task_id in task_ids+ """+ async with self.Session() as session:+ query = (+ select(func.count(distinct(tuple_(StepModel.task_id, StepModel.order))))+ .where(StepModel.task_id.in_(task_ids))+ .where(StepModel.organization_id == organization_id)+ )+ return (await session.execute(query)).scalar()++ @db_operation("get_task_step_models")+ async def get_task_step_models(self, task_id: str, organization_id: str | None = None) -> Sequence[StepModel]:+ async with self.Session() as session:+ return (+ await session.scalars(+ select(StepModel)+ .filter_by(task_id=task_id)+ .filter_by(organization_id=organization_id)+ .order_by(StepModel.order)+ .order_by(StepModel.retry_index)+ )+ ).all()++ @db_operation("get_task_step_count")+ async def get_task_step_count(self, task_id: str, organization_id: str | None = None) -> int:+ async with self.Session() as session:+ result = await session.scalar(+ select(func.count(StepModel.step_id))+ .filter_by(task_id=task_id)+ .filter_by(organization_id=organization_id)+ )+ return result or 0++ @db_operation("get_task_actions")+ async def get_task_actions(self, task_id: str, organization_id: str | None = None) -> list[Action]:+ async with self.Session() as session:+ query = (+ select(ActionModel)+ .filter(ActionModel.organization_id == organization_id)+ .filter(ActionModel.task_id == task_id)+ .order_by(ActionModel.created_at)+ )++ actions = (await session.scalars(query)).all()+ return [Action.model_validate(action) for action in actions]++ @db_operation("get_task_actions_hydrated")+ async def get_task_actions_hydrated(self, task_id: str, organization_id: str | None = None) -> list[Action]:+ async with self.Session() as session:+ query = (+ select(ActionModel)+ .filter(ActionModel.organization_id == organization_id)+ .filter(ActionModel.task_id == task_id)+ .order_by(ActionModel.created_at)+ )++ actions = (await session.scalars(query)).all()+ return [hydrate_action(action) for action in actions]++ @db_operation("get_tasks_actions")+ async def get_tasks_actions(self, task_ids: list[str], organization_id: str | None = None) -> list[Action]:+ async with self.Session() as session:+ query = (+ select(ActionModel)+ .filter(ActionModel.organization_id == organization_id)+ .filter(ActionModel.task_id.in_(task_ids))+ .order_by(ActionModel.created_at.desc())+ )+ actions = (await session.scalars(query)).all()+ return [hydrate_action(action) for action in actions]++ @db_operation("get_action_count_for_step")+ async def get_action_count_for_step(self, step_id: str, task_id: str, organization_id: str) -> int:+ """Get count of actions for a step. Uses composite index for efficiency."""+ async with self.Session() as session:+ query = (+ select(func.count())+ .select_from(ActionModel)+ .where(ActionModel.organization_id == organization_id)+ .where(ActionModel.task_id == task_id)+ .where(ActionModel.step_id == step_id)+ )+ result = await session.scalar(query)+ return result or 0++ @db_operation("get_first_step")+ async def get_first_step(self, task_id: str, organization_id: str | None = None) -> Step | None:+ async with self.Session() as session:+ if step := (+ await session.scalars(+ select(StepModel)+ .filter_by(task_id=task_id)+ .filter_by(organization_id=organization_id)+ .order_by(StepModel.order.asc())+ .order_by(StepModel.retry_index.asc())+ )+ ).first():+ return convert_to_step(step, debug_enabled=self.debug_enabled)+ else:+ LOG.info(+ "Latest step not found",+ task_id=task_id,+ organization_id=organization_id,+ )+ return None++ @db_operation("get_latest_step")+ async def get_latest_step(self, task_id: str, organization_id: str | None = None) -> Step | None:+ async with self.Session() as session:+ if step := (+ await session.scalars(+ select(StepModel)+ .filter_by(task_id=task_id)+ .filter_by(organization_id=organization_id)+ .filter(StepModel.status != StepStatus.canceled)+ .order_by(StepModel.order.desc())+ .order_by(StepModel.retry_index.desc())+ )+ ).first():+ return convert_to_step(step, debug_enabled=self.debug_enabled)+ else:+ LOG.info(+ "Latest step not found",+ task_id=task_id,+ organization_id=organization_id,+ )+ return None++ @db_operation("update_step")+ async def update_step(+ self,+ task_id: str,+ step_id: str,+ status: StepStatus | None = None,+ output: AgentStepOutput | None = None,+ is_last: bool | None = None,+ retry_index: int | None = None,+ organization_id: str | None = None,+ incremental_cost: float | None = None,+ incremental_input_tokens: int | None = None,+ incremental_output_tokens: int | None = None,+ incremental_reasoning_tokens: int | None = None,+ incremental_cached_tokens: int | None = None,+ created_by: str | None = None,+ ) -> Step:+ async with self.Session() as session:+ if step := (+ await session.scalars(+ select(StepModel)+ .filter_by(task_id=task_id)+ .filter_by(step_id=step_id)+ .filter_by(organization_id=organization_id)+ )+ ).first():+ if status is not None:+ step.status = status++ if status.is_terminal() and step.finished_at is None:+ step.finished_at = datetime.now(timezone.utc)+ if output is not None:+ step.output = output.model_dump(exclude_none=True)+ if is_last is not None:+ step.is_last = is_last+ if retry_index is not None:+ step.retry_index = retry_index+ if incremental_cost is not None:+ step.step_cost = incremental_cost + float(step.step_cost or 0)+ if incremental_input_tokens is not None:+ step.input_token_count = incremental_input_tokens + (step.input_token_count or 0)+ if incremental_output_tokens is not None:+ step.output_token_count = incremental_output_tokens + (step.output_token_count or 0)+ if incremental_reasoning_tokens is not None:+ step.reasoning_token_count = incremental_reasoning_tokens + (step.reasoning_token_count or 0)+ if incremental_cached_tokens is not None:+ step.cached_token_count = incremental_cached_tokens + (step.cached_token_count or 0)+ if created_by is not None:+ step.created_by = created_by++ await session.commit()+ updated_step = await self.get_step(step_id, organization_id)+ if not updated_step:+ raise NotFoundError("Step not found")+ return updated_step+ else:+ raise NotFoundError("Step not found")++ @db_operation("clear_task_failure_reason")+ async def clear_task_failure_reason(self, organization_id: str, task_id: str) -> Task:+ async with self.Session() as session:+ if task := (+ await session.scalars(+ select(TaskModel).filter_by(task_id=task_id).filter_by(organization_id=organization_id)+ )+ ).first():+ task.failure_reason = None+ await session.commit()+ await session.refresh(task)+ return convert_to_task(task, debug_enabled=self.debug_enabled)+ else:+ raise NotFoundError("Task not found")++ @db_operation("update_task")+ async def update_task(+ self,+ task_id: str,+ status: TaskStatus | None = None,+ extracted_information: dict[str, Any] | list | str | None = None,+ webhook_failure_reason: str | None = None,+ failure_reason: str | None = None,+ errors: list[dict[str, Any]] | None = None,+ max_steps_per_run: int | None = None,+ organization_id: str | None = None,+ ) -> Task:+ if (+ status is None+ and extracted_information is None+ and failure_reason is None+ and errors is None+ and max_steps_per_run is None+ and webhook_failure_reason is None+ ):+ raise ValueError(+ "At least one of status, extracted_information, or failure_reason must be provided to update the task"+ )+ async with self.Session() as session:+ if task := (+ await session.scalars(+ select(TaskModel).filter_by(task_id=task_id).filter_by(organization_id=organization_id)+ )+ ).first():+ if status is not None:+ task.status = status+ if status == TaskStatus.queued and task.queued_at is None:+ task.queued_at = datetime.now(timezone.utc)+ if status == TaskStatus.running and task.started_at is None:+ task.started_at = datetime.now(timezone.utc)+ if status.is_final() and task.finished_at is None:+ task.finished_at = datetime.now(timezone.utc)+ if extracted_information is not None:+ task.extracted_information = extracted_information+ if failure_reason is not None:+ task.failure_reason = failure_reason+ if errors is not None:+ task.errors = (task.errors or []) + errors+ if max_steps_per_run is not None:+ task.max_steps_per_run = max_steps_per_run+ if webhook_failure_reason is not None:+ task.webhook_failure_reason = webhook_failure_reason+ await session.commit()+ updated_task = await self.get_task(task_id, organization_id=organization_id)+ if not updated_task:+ raise NotFoundError("Task not found")+ return updated_task+ else:+ raise NotFoundError("Task not found")++ @db_operation("update_task_2fa_state")+ async def update_task_2fa_state(+ self,+ task_id: str,+ organization_id: str,+ waiting_for_verification_code: bool,+ verification_code_identifier: str | None = None,+ verification_code_polling_started_at: datetime | None = None,+ ) -> Task:+ """Update task 2FA verification code waiting state."""+ async with self.Session() as session:+ if task := (+ await session.scalars(+ select(TaskModel).filter_by(task_id=task_id).filter_by(organization_id=organization_id)+ )+ ).first():+ task.waiting_for_verification_code = waiting_for_verification_code+ if verification_code_identifier is not None:+ task.verification_code_identifier = verification_code_identifier+ if verification_code_polling_started_at is not None:+ task.verification_code_polling_started_at = verification_code_polling_started_at+ if not waiting_for_verification_code:+ # Clear identifiers when no longer waiting+ task.verification_code_identifier = None+ task.verification_code_polling_started_at = None+ await session.commit()+ updated_task = await self.get_task(task_id, organization_id=organization_id)+ if not updated_task:+ raise NotFoundError("Task not found")+ return updated_task+ else:+ raise NotFoundError("Task not found")++ @db_operation("bulk_update_tasks")+ async def bulk_update_tasks(+ self,+ task_ids: list[str],+ status: TaskStatus | None = None,+ failure_reason: str | None = None,+ ) -> None:+ """Bulk update tasks by their IDs.++ Args:+ task_ids: List of task IDs to update+ status: Optional status to set for all tasks+ failure_reason: Optional failure reason to set for all tasks+ """+ if not task_ids:+ return++ async with self.Session() as session:+ update_values = {}+ if status:+ update_values["status"] = status.value+ if failure_reason:+ update_values["failure_reason"] = failure_reason++ if update_values:+ update_stmt = update(TaskModel).where(TaskModel.task_id.in_(task_ids)).values(**update_values)+ await session.execute(update_stmt)+ await session.commit()++ @db_operation("get_tasks")+ async def get_tasks(+ self,+ page: int = 1,+ page_size: int = 10,+ task_status: list[TaskStatus] | None = None,+ workflow_run_id: str | None = None,+ organization_id: str | None = None,+ only_standalone_tasks: bool = False,+ application: str | None = None,+ order_by_column: OrderBy = OrderBy.created_at,+ order: SortDirection = SortDirection.desc,+ ) -> list[Task]:+ """+ Get all tasks.+ :param page: Starts at 1+ :param page_size:+ :param task_status:+ :param workflow_run_id:+ :param only_standalone_tasks:+ :param order_by_column:+ :param order:+ :return:+ """+ if page < 1:+ raise ValueError(f"Page must be greater than 0, got {page}")++ async with self.Session() as session:+ db_page = page - 1 # offset logic is 0 based+ query = (+ select(TaskModel, WorkflowRunModel.workflow_permanent_id)+ .join(WorkflowRunModel, TaskModel.workflow_run_id == WorkflowRunModel.workflow_run_id, isouter=True)+ .filter(TaskModel.organization_id == organization_id)+ )+ if task_status:+ query = query.filter(TaskModel.status.in_(task_status))+ if workflow_run_id:+ query = query.filter(TaskModel.workflow_run_id == workflow_run_id)+ if only_standalone_tasks:+ query = query.filter(TaskModel.workflow_run_id.is_(None))+ if application:+ query = query.filter(TaskModel.application == application)+ order_by_col = getattr(TaskModel, order_by_column)+ query = (+ query.order_by(order_by_col.desc() if order == SortDirection.desc else order_by_col.asc())+ .limit(page_size)+ .offset(db_page * page_size)+ )++ results = (await session.execute(query)).all()++ return [+ convert_to_task(task, debug_enabled=self.debug_enabled, workflow_permanent_id=workflow_permanent_id)+ for task, workflow_permanent_id in results+ ]++ @db_operation("get_tasks_count")+ async def get_tasks_count(+ self,+ organization_id: str,+ task_status: list[TaskStatus] | None = None,+ workflow_run_id: str | None = None,+ only_standalone_tasks: bool = False,+ application: str | None = None,+ ) -> int:+ async with self.Session() as session:+ count_query = (+ select(func.count()).select_from(TaskModel).filter(TaskModel.organization_id == organization_id)+ )+ if task_status:+ count_query = count_query.filter(TaskModel.status.in_(task_status))+ if workflow_run_id:+ count_query = count_query.filter(TaskModel.workflow_run_id == workflow_run_id)+ if only_standalone_tasks:+ count_query = count_query.filter(TaskModel.workflow_run_id.is_(None))+ if application:+ count_query = count_query.filter(TaskModel.application == application)+ return (await session.execute(count_query)).scalar_one()++ @db_operation("get_running_tasks_info_globally")+ async def get_running_tasks_info_globally(+ self,+ stale_threshold_hours: int = 24,+ ) -> tuple[int, int]:+ """+ Get information about running tasks across all organizations.+ Used by cleanup service to determine if cleanup should be skipped.++ Args:+ stale_threshold_hours: Tasks not updated for this many hours are considered stale.++ Returns:+ Tuple of (active_task_count, stale_task_count).+ Active tasks are those updated within the threshold.+ Stale tasks are those not updated within the threshold but still in running status.+ """+ async with self.Session() as session:+ running_statuses = [TaskStatus.created, TaskStatus.queued, TaskStatus.running]+ stale_cutoff = datetime.now(timezone.utc) - timedelta(hours=stale_threshold_hours)++ # Count active tasks (recently updated)+ active_query = (+ select(func.count())+ .select_from(TaskModel)+ .filter(TaskModel.status.in_(running_statuses))+ .filter(TaskModel.modified_at >= stale_cutoff)+ )+ active_count = (await session.execute(active_query)).scalar_one()++ # Count stale tasks (not updated for a long time)+ stale_query = (+ select(func.count())+ .select_from(TaskModel)+ .filter(TaskModel.status.in_(running_statuses))+ .filter(TaskModel.modified_at < stale_cutoff)+ )+ stale_count = (await session.execute(stale_query)).scalar_one()++ return (active_count, stale_count)++ @db_operation("get_latest_task_by_workflow_id")+ async def get_latest_task_by_workflow_id(+ self,+ organization_id: str,+ workflow_id: str,+ before: datetime | None = None,+ ) -> Task | None:+ async with self.Session() as session:+ query = select(TaskModel).filter_by(organization_id=organization_id).filter_by(workflow_id=workflow_id)+ if before:+ query = query.filter(TaskModel.created_at < before)+ task = (await session.scalars(query.order_by(TaskModel.created_at.desc()))).first()+ if task:+ return convert_to_task(task, debug_enabled=self.debug_enabled)+ return None++ @db_operation("get_last_task_for_workflow_run")+ async def get_last_task_for_workflow_run(self, workflow_run_id: str) -> Task | None:+ async with self.Session() as session:+ if task := (+ await session.scalars(+ select(TaskModel).filter_by(workflow_run_id=workflow_run_id).order_by(TaskModel.created_at.desc())+ )+ ).first():+ return convert_to_task(task, debug_enabled=self.debug_enabled)+ return None++ @db_operation("get_tasks_by_workflow_run_id")+ async def get_tasks_by_workflow_run_id(self, workflow_run_id: str) -> list[Task]:+ async with self.Session() as session:+ tasks = (+ await session.scalars(+ select(TaskModel).filter_by(workflow_run_id=workflow_run_id).order_by(TaskModel.created_at)+ )+ ).all()+ return [convert_to_task(task, debug_enabled=self.debug_enabled) for task in tasks]++ @db_operation("delete_task_steps")+ async def delete_task_steps(self, organization_id: str, task_id: str) -> None:+ async with self.Session() as session:+ # delete artifacts by filtering organization_id and task_id+ stmt = delete(StepModel).where(+ and_(+ StepModel.organization_id == organization_id,+ StepModel.task_id == task_id,+ )+ )+ await session.execute(stmt)+ await session.commit()++ @db_operation("get_previous_actions_for_task")+ async def get_previous_actions_for_task(self, task_id: str) -> list[Action]:+ async with self.Session() as session:+ query = (+ select(ActionModel)+ .filter_by(task_id=task_id)+ .order_by(ActionModel.step_order, ActionModel.action_order, ActionModel.created_at)+ )+ actions = (await session.scalars(query)).all()+ return [Action.model_validate(action) for action in actions]++ @db_operation("delete_task_actions")+ async def delete_task_actions(self, organization_id: str, task_id: str) -> None:+ async with self.Session() as session:+ # delete actions by filtering organization_id and task_id+ stmt = delete(ActionModel).where(+ and_(+ ActionModel.organization_id == organization_id,+ ActionModel.task_id == task_id,+ )+ )+ await session.execute(stmt)+ await session.commit()diff --git a/skyvern/forge/sdk/db/repositories/workflow_parameters.py b/skyvern/forge/sdk/db/repositories/workflow_parameters.pynew file mode 100644index 000000000..004ffef5a--- /dev/null+++ b/skyvern/forge/sdk/db/repositories/workflow_parameters.py@@ -0,0 +1,699 @@+from __future__ import annotations++import json+from datetime import datetime, timedelta, timezone+from typing import Any++import structlog+from sqlalchemy import select++from skyvern.config import settings+from skyvern.forge.sdk.db._error_handling import db_operation+from skyvern.forge.sdk.db.base_repository import BaseRepository+from skyvern.forge.sdk.db.exceptions import NotFoundError+from skyvern.forge.sdk.db.models import (+ ActionModel,+ AISuggestionModel,+ AWSSecretParameterModel,+ AzureVaultCredentialParameterModel,+ Base,+ BitwardenCreditCardDataParameterModel,+ BitwardenLoginCredentialParameterModel,+ BitwardenSensitiveInformationParameterModel,+ CredentialParameterModel,+ OnePasswordCredentialParameterModel,+ OutputParameterModel,+ TaskGenerationModel,+ TaskModel,+ TaskRunModel,+ WorkflowCopilotChatMessageModel,+ WorkflowCopilotChatModel,+ WorkflowParameterModel,+)+from skyvern.forge.sdk.db.utils import (+ convert_to_aws_secret_parameter,+ convert_to_output_parameter,+ convert_to_workflow_copilot_chat_message,+ convert_to_workflow_parameter,+ hydrate_action,+)+from skyvern.forge.sdk.schemas.ai_suggestions import AISuggestion+from skyvern.forge.sdk.schemas.runs import Run+from skyvern.forge.sdk.schemas.task_generations import TaskGeneration+from skyvern.forge.sdk.schemas.tasks import Task, TaskStatus+from skyvern.forge.sdk.schemas.workflow_copilot import (+ WorkflowCopilotChat,+ WorkflowCopilotChatMessage,+ WorkflowCopilotChatSender,+)+from skyvern.forge.sdk.workflow.models.parameter import (+ PARAMETER_TYPE,+ AWSSecretParameter,+ AzureVaultCredentialParameter,+ BitwardenCreditCardDataParameter,+ BitwardenLoginCredentialParameter,+ BitwardenSensitiveInformationParameter,+ ContextParameter,+ CredentialParameter,+ OnePasswordCredentialParameter,+ OutputParameter,+ WorkflowParameter,+ WorkflowParameterType,+)+from skyvern.schemas.runs import RunType+from skyvern.webeye.actions.actions import Action++from . import _UNSET++LOG = structlog.get_logger()+++class WorkflowParametersRepository(BaseRepository):+ """Database operations for workflow parameters, copilot chat, task generation, actions, and runs."""++ @db_operation("create_workflow_parameter")+ async def create_workflow_parameter(+ self,+ workflow_id: str,+ workflow_parameter_type: WorkflowParameterType,+ key: str,+ default_value: Any,+ description: str | None = None,+ ) -> WorkflowParameter:+ async with self.Session() as session:+ if default_value is None:+ pass+ elif workflow_parameter_type == WorkflowParameterType.JSON:+ default_value = json.dumps(default_value)+ else:+ default_value = str(default_value)+ workflow_parameter = WorkflowParameterModel(+ workflow_id=workflow_id,+ workflow_parameter_type=workflow_parameter_type,+ key=key,+ default_value=default_value,+ description=description,+ )+ session.add(workflow_parameter)+ await session.commit()+ await session.refresh(workflow_parameter)+ return convert_to_workflow_parameter(workflow_parameter, self.debug_enabled)++ @db_operation("create_aws_secret_parameter")+ async def create_aws_secret_parameter(+ self,+ workflow_id: str,+ key: str,+ aws_key: str,+ description: str | None = None,+ ) -> AWSSecretParameter:+ async with self.Session() as session:+ aws_secret_parameter = AWSSecretParameterModel(+ workflow_id=workflow_id,+ key=key,+ aws_key=aws_key,+ description=description,+ )+ session.add(aws_secret_parameter)+ await session.commit()+ await session.refresh(aws_secret_parameter)+ return convert_to_aws_secret_parameter(aws_secret_parameter)++ @db_operation("create_output_parameter")+ async def create_output_parameter(+ self,+ workflow_id: str,+ key: str,+ description: str | None = None,+ ) -> OutputParameter:+ async with self.Session() as session:+ output_parameter = OutputParameterModel(+ key=key,+ description=description,+ workflow_id=workflow_id,+ )+ session.add(output_parameter)+ await session.commit()+ await session.refresh(output_parameter)+ return convert_to_output_parameter(output_parameter)++ @staticmethod+ def _convert_parameter_to_model(parameter: PARAMETER_TYPE) -> Base:+ """Convert a parameter object to its corresponding SQLAlchemy model."""+ if isinstance(parameter, WorkflowParameter):+ if parameter.default_value is None:+ default_value = None+ elif parameter.workflow_parameter_type == WorkflowParameterType.JSON:+ default_value = json.dumps(parameter.default_value)+ else:+ default_value = str(parameter.default_value)+ return WorkflowParameterModel(+ workflow_parameter_id=parameter.workflow_parameter_id,+ workflow_parameter_type=parameter.workflow_parameter_type.value,+ key=parameter.key,+ description=parameter.description,+ workflow_id=parameter.workflow_id,+ default_value=default_value,+ deleted_at=parameter.deleted_at,+ )+ elif isinstance(parameter, OutputParameter):+ return OutputParameterModel(+ output_parameter_id=parameter.output_parameter_id,+ key=parameter.key,+ description=parameter.description,+ workflow_id=parameter.workflow_id,+ deleted_at=parameter.deleted_at,+ )+ elif isinstance(parameter, AWSSecretParameter):+ return AWSSecretParameterModel(+ aws_secret_parameter_id=parameter.aws_secret_parameter_id,+ workflow_id=parameter.workflow_id,+ key=parameter.key,+ description=parameter.description,+ aws_key=parameter.aws_key,+ deleted_at=parameter.deleted_at,+ )+ elif isinstance(parameter, BitwardenLoginCredentialParameter):+ return BitwardenLoginCredentialParameterModel(+ bitwarden_login_credential_parameter_id=parameter.bitwarden_login_credential_parameter_id,+ workflow_id=parameter.workflow_id,+ key=parameter.key,+ description=parameter.description,+ bitwarden_client_id_aws_secret_key=parameter.bitwarden_client_id_aws_secret_key,+ bitwarden_client_secret_aws_secret_key=parameter.bitwarden_client_secret_aws_secret_key,+ bitwarden_master_password_aws_secret_key=parameter.bitwarden_master_password_aws_secret_key,+ bitwarden_collection_id=parameter.bitwarden_collection_id,+ bitwarden_item_id=parameter.bitwarden_item_id,+ url_parameter_key=parameter.url_parameter_key,+ deleted_at=parameter.deleted_at,+ )+ elif isinstance(parameter, BitwardenSensitiveInformationParameter):+ return BitwardenSensitiveInformationParameterModel(+ bitwarden_sensitive_information_parameter_id=parameter.bitwarden_sensitive_information_parameter_id,+ workflow_id=parameter.workflow_id,+ key=parameter.key,+ description=parameter.description,+ bitwarden_client_id_aws_secret_key=parameter.bitwarden_client_id_aws_secret_key,+ bitwarden_client_secret_aws_secret_key=parameter.bitwarden_client_secret_aws_secret_key,+ bitwarden_master_password_aws_secret_key=parameter.bitwarden_master_password_aws_secret_key,+ bitwarden_collection_id=parameter.bitwarden_collection_id,+ bitwarden_identity_key=parameter.bitwarden_identity_key,+ bitwarden_identity_fields=parameter.bitwarden_identity_fields,+ deleted_at=parameter.deleted_at,+ )+ elif isinstance(parameter, BitwardenCreditCardDataParameter):+ return BitwardenCreditCardDataParameterModel(+ bitwarden_credit_card_data_parameter_id=parameter.bitwarden_credit_card_data_parameter_id,+ workflow_id=parameter.workflow_id,+ key=parameter.key,+ description=parameter.description,+ bitwarden_client_id_aws_secret_key=parameter.bitwarden_client_id_aws_secret_key,+ bitwarden_client_secret_aws_secret_key=parameter.bitwarden_client_secret_aws_secret_key,+ bitwarden_master_password_aws_secret_key=parameter.bitwarden_master_password_aws_secret_key,+ bitwarden_collection_id=parameter.bitwarden_collection_id,+ bitwarden_item_id=parameter.bitwarden_item_id,+ deleted_at=parameter.deleted_at,+ )+ elif isinstance(parameter, CredentialParameter):+ return CredentialParameterModel(+ credential_parameter_id=parameter.credential_parameter_id,+ workflow_id=parameter.workflow_id,+ key=parameter.key,+ description=parameter.description,+ credential_id=parameter.credential_id,+ deleted_at=parameter.deleted_at,+ )+ elif isinstance(parameter, OnePasswordCredentialParameter):+ return OnePasswordCredentialParameterModel(+ onepassword_credential_parameter_id=parameter.onepassword_credential_parameter_id,+ workflow_id=parameter.workflow_id,+ key=parameter.key,+ description=parameter.description,+ vault_id=parameter.vault_id,+ item_id=parameter.item_id,+ deleted_at=parameter.deleted_at,+ )+ elif isinstance(parameter, AzureVaultCredentialParameter):+ return AzureVaultCredentialParameterModel(+ azure_vault_credential_parameter_id=parameter.azure_vault_credential_parameter_id,+ workflow_id=parameter.workflow_id,+ key=parameter.key,+ description=parameter.description,+ vault_name=parameter.vault_name,+ username_key=parameter.username_key,+ password_key=parameter.password_key,+ totp_secret_key=parameter.totp_secret_key,+ deleted_at=parameter.deleted_at,+ )+ else:+ raise ValueError(f"Unsupported workflow definition parameter type: {type(parameter).__name__}")++ @db_operation("save_workflow_definition_parameters")+ async def save_workflow_definition_parameters(self, parameters: list[PARAMETER_TYPE]) -> None:+ """Save multiple workflow definition parameters in a single transaction."""++ # ContextParameter is not persisted+ parameters_to_save = [p for p in parameters if not isinstance(p, ContextParameter)]+ if not parameters_to_save:+ return++ async with self.Session() as session:+ for parameter in parameters_to_save:+ model = self._convert_parameter_to_model(parameter)+ session.add(model)+ await session.commit()++ @db_operation("get_workflow_output_parameters")+ async def get_workflow_output_parameters(self, workflow_id: str) -> list[OutputParameter]:+ async with self.Session() as session:+ output_parameters = (+ await session.scalars(select(OutputParameterModel).filter_by(workflow_id=workflow_id))+ ).all()+ return [convert_to_output_parameter(parameter) for parameter in output_parameters]++ @db_operation("get_workflow_output_parameters_by_ids")+ async def get_workflow_output_parameters_by_ids(self, output_parameter_ids: list[str]) -> list[OutputParameter]:+ async with self.Session() as session:+ output_parameters = (+ await session.scalars(+ select(OutputParameterModel).filter(+ OutputParameterModel.output_parameter_id.in_(output_parameter_ids)+ )+ )+ ).all()+ return [convert_to_output_parameter(parameter) for parameter in output_parameters]++ @db_operation("get_workflow_parameters")+ async def get_workflow_parameters(self, workflow_id: str) -> list[WorkflowParameter]:+ async with self.Session() as session:+ workflow_parameters = (+ await session.scalars(select(WorkflowParameterModel).filter_by(workflow_id=workflow_id))+ ).all()+ return [convert_to_workflow_parameter(parameter) for parameter in workflow_parameters]++ @db_operation("get_workflow_parameter")+ async def get_workflow_parameter(+ self, workflow_parameter_id: str, organization_id: str | None = None+ ) -> WorkflowParameter | None:+ async with self.Session() as session:+ if workflow_parameter := (+ await session.scalars(+ select(WorkflowParameterModel).filter_by(workflow_parameter_id=workflow_parameter_id)+ )+ ).first():+ return convert_to_workflow_parameter(workflow_parameter, self.debug_enabled)+ return None++ @db_operation("create_task_generation")+ async def create_task_generation(+ self,+ organization_id: str,+ user_prompt: str,+ user_prompt_hash: str,+ url: str | None = None,+ navigation_goal: str | None = None,+ navigation_payload: dict[str, Any] | None = None,+ data_extraction_goal: str | None = None,+ extracted_information_schema: dict[str, Any] | None = None,+ suggested_title: str | None = None,+ llm: str | None = None,+ llm_prompt: str | None = None,+ llm_response: str | None = None,+ source_task_generation_id: str | None = None,+ ) -> TaskGeneration:+ async with self.Session() as session:+ new_task_generation = TaskGenerationModel(+ organization_id=organization_id,+ user_prompt=user_prompt,+ user_prompt_hash=user_prompt_hash,+ url=url,+ navigation_goal=navigation_goal,+ navigation_payload=navigation_payload,+ data_extraction_goal=data_extraction_goal,+ extracted_information_schema=extracted_information_schema,+ llm=llm,+ llm_prompt=llm_prompt,+ llm_response=llm_response,+ suggested_title=suggested_title,+ source_task_generation_id=source_task_generation_id,+ )+ session.add(new_task_generation)+ await session.commit()+ await session.refresh(new_task_generation)+ return TaskGeneration.model_validate(new_task_generation)++ @db_operation("create_ai_suggestion")+ async def create_ai_suggestion(+ self,+ organization_id: str,+ ai_suggestion_type: str,+ ) -> AISuggestion:+ async with self.Session() as session:+ new_ai_suggestion = AISuggestionModel(+ organization_id=organization_id,+ ai_suggestion_type=ai_suggestion_type,+ )+ session.add(new_ai_suggestion)+ await session.commit()+ await session.refresh(new_ai_suggestion)+ return AISuggestion.model_validate(new_ai_suggestion)++ @db_operation("create_workflow_copilot_chat")+ async def create_workflow_copilot_chat(+ self,+ organization_id: str,+ workflow_permanent_id: str,+ ) -> WorkflowCopilotChat:+ async with self.Session() as session:+ new_chat = WorkflowCopilotChatModel(+ organization_id=organization_id,+ workflow_permanent_id=workflow_permanent_id,+ )+ session.add(new_chat)+ await session.commit()+ await session.refresh(new_chat)+ return WorkflowCopilotChat.model_validate(new_chat)++ @db_operation("update_workflow_copilot_chat")+ async def update_workflow_copilot_chat(+ self,+ organization_id: str,+ workflow_copilot_chat_id: str,+ proposed_workflow: dict | None | object = _UNSET,+ auto_accept: bool | None = None,+ ) -> WorkflowCopilotChat | None:+ async with self.Session() as session:+ chat = (+ await session.scalars(+ select(WorkflowCopilotChatModel)+ .where(WorkflowCopilotChatModel.organization_id == organization_id)+ .where(WorkflowCopilotChatModel.workflow_copilot_chat_id == workflow_copilot_chat_id)+ )+ ).first()+ if not chat:+ return None++ if proposed_workflow is not _UNSET:+ chat.proposed_workflow = proposed_workflow+ if auto_accept is not None:+ chat.auto_accept = auto_accept++ await session.commit()+ await session.refresh(chat)+ return WorkflowCopilotChat.model_validate(chat)++ @db_operation("create_workflow_copilot_chat_message")+ async def create_workflow_copilot_chat_message(+ self,+ organization_id: str,+ workflow_copilot_chat_id: str,+ sender: WorkflowCopilotChatSender,+ content: str,+ global_llm_context: str | None = None,+ ) -> WorkflowCopilotChatMessage:+ async with self.Session() as session:+ new_message = WorkflowCopilotChatMessageModel(+ workflow_copilot_chat_id=workflow_copilot_chat_id,+ organization_id=organization_id,+ sender=sender,+ content=content,+ global_llm_context=global_llm_context,+ )+ session.add(new_message)+ await session.commit()+ await session.refresh(new_message)+ return convert_to_workflow_copilot_chat_message(new_message, self.debug_enabled)++ @db_operation("get_workflow_copilot_chat_messages")+ async def get_workflow_copilot_chat_messages(+ self,+ workflow_copilot_chat_id: str,+ ) -> list[WorkflowCopilotChatMessage]:+ async with self.Session() as session:+ query = (+ select(WorkflowCopilotChatMessageModel)+ .filter(WorkflowCopilotChatMessageModel.workflow_copilot_chat_id == workflow_copilot_chat_id)+ .order_by(WorkflowCopilotChatMessageModel.workflow_copilot_chat_message_id.asc())+ )+ messages = (await session.scalars(query)).all()+ return [convert_to_workflow_copilot_chat_message(message, self.debug_enabled) for message in messages]++ @db_operation("get_workflow_copilot_chat_by_id")+ async def get_workflow_copilot_chat_by_id(+ self,+ organization_id: str,+ workflow_copilot_chat_id: str,+ ) -> WorkflowCopilotChat | None:+ async with self.Session() as session:+ query = (+ select(WorkflowCopilotChatModel)+ .filter(WorkflowCopilotChatModel.organization_id == organization_id)+ .filter(WorkflowCopilotChatModel.workflow_copilot_chat_id == workflow_copilot_chat_id)+ .order_by(WorkflowCopilotChatModel.created_at.desc())+ .limit(1)+ )+ chat = (await session.scalars(query)).first()+ if not chat:+ return None+ return WorkflowCopilotChat.model_validate(chat)++ @db_operation("get_latest_workflow_copilot_chat")+ async def get_latest_workflow_copilot_chat(+ self,+ organization_id: str,+ workflow_permanent_id: str,+ ) -> WorkflowCopilotChat | None:+ async with self.Session() as session:+ query = (+ select(WorkflowCopilotChatModel)+ .filter(WorkflowCopilotChatModel.organization_id == organization_id)+ .filter(WorkflowCopilotChatModel.workflow_permanent_id == workflow_permanent_id)+ .order_by(WorkflowCopilotChatModel.created_at.desc())+ .limit(1)+ )+ chat = (await session.scalars(query)).first()+ if not chat:+ return None+ return WorkflowCopilotChat.model_validate(chat)++ @db_operation("get_task_generation_by_prompt_hash")+ async def get_task_generation_by_prompt_hash(+ self,+ user_prompt_hash: str,+ query_window_hours: int = settings.PROMPT_CACHE_WINDOW_HOURS,+ ) -> TaskGeneration | None:+ before_time = datetime.now(timezone.utc) - timedelta(hours=query_window_hours)+ async with self.Session() as session:+ query = (+ select(TaskGenerationModel)+ .filter_by(user_prompt_hash=user_prompt_hash)+ .filter(TaskGenerationModel.llm.is_not(None))+ .filter(TaskGenerationModel.created_at > before_time)+ )+ task_generation = (await session.scalars(query)).first()+ if not task_generation:+ return None+ return TaskGeneration.model_validate(task_generation)++ @db_operation("create_action")+ async def create_action(self, action: Action) -> Action:+ async with self.Session() as session:+ new_action = ActionModel(+ action_type=action.action_type,+ source_action_id=action.source_action_id,+ organization_id=action.organization_id,+ workflow_run_id=action.workflow_run_id,+ task_id=action.task_id,+ step_id=action.step_id,+ step_order=action.step_order,+ action_order=action.action_order,+ status=action.status,+ reasoning=action.reasoning,+ intention=action.intention,+ response=action.response,+ element_id=action.element_id,+ skyvern_element_hash=action.skyvern_element_hash,+ skyvern_element_data=action.skyvern_element_data,+ screenshot_artifact_id=action.screenshot_artifact_id,+ action_json=action.model_dump(),+ confidence_float=action.confidence_float,+ created_by=action.created_by,+ )+ session.add(new_action)+ await session.commit()+ await session.refresh(new_action)+ return hydrate_action(new_action)++ @db_operation("update_action_reasoning")+ async def update_action_reasoning(+ self,+ organization_id: str,+ action_id: str,+ reasoning: str,+ ) -> Action:+ async with self.Session() as session:+ action = (+ await session.scalars(+ select(ActionModel).filter_by(action_id=action_id).filter_by(organization_id=organization_id)+ )+ ).first()+ if action:+ action.reasoning = reasoning+ await session.commit()+ await session.refresh(action)+ return Action.model_validate(action)+ raise NotFoundError(f"Action {action_id}")++ @db_operation("retrieve_action_plan")+ async def retrieve_action_plan(self, task: Task) -> list[Action]:+ async with self.Session() as session:+ subquery = (+ select(TaskModel.task_id)+ .filter(TaskModel.url == task.url)+ .filter(TaskModel.navigation_goal == task.navigation_goal)+ .filter(TaskModel.status == TaskStatus.completed)+ .order_by(TaskModel.created_at.desc())+ .limit(1)+ .subquery()+ )++ query = (+ select(ActionModel)+ .filter(ActionModel.task_id == subquery.c.task_id)+ .order_by(ActionModel.step_order, ActionModel.action_order, ActionModel.created_at)+ )++ actions = (await session.scalars(query)).all()+ return [Action.model_validate(action) for action in actions]++ @db_operation("create_task_run")+ async def create_task_run(+ self,+ task_run_type: RunType,+ organization_id: str,+ run_id: str,+ title: str | None = None,+ url: str | None = None,+ url_hash: str | None = None,+ ) -> Run:+ async with self.Session() as session:+ task_run = TaskRunModel(+ task_run_type=task_run_type,+ organization_id=organization_id,+ run_id=run_id,+ title=title,+ url=url,+ url_hash=url_hash,+ )+ session.add(task_run)+ await session.commit()+ await session.refresh(task_run)+ return Run.model_validate(task_run)++ @db_operation("update_task_run")+ async def update_task_run(+ self,+ organization_id: str,+ run_id: str,+ title: str | None = None,+ url: str | None = None,+ url_hash: str | None = None,+ ) -> None:+ async with self.Session() as session:+ task_run = (+ await session.scalars(+ select(TaskRunModel).filter_by(run_id=run_id).filter_by(organization_id=organization_id)+ )+ ).first()+ if not task_run:+ raise NotFoundError(f"TaskRun {run_id} not found")++ if title:+ task_run.title = title+ if url:+ task_run.url = url+ if url_hash:+ task_run.url_hash = url_hash+ await session.commit()++ @db_operation("update_job_run_compute_cost")+ async def update_job_run_compute_cost(+ self,+ organization_id: str,+ run_id: str,+ instance_type: str | None = None,+ vcpu_millicores: int | None = None,+ memory_mb: int | None = None,+ duration_ms: int | None = None,+ compute_cost: float | None = None,+ ) -> None:+ """Update compute cost metrics for a job run."""+ async with self.Session() as session:+ task_run = (+ await session.scalars(+ select(TaskRunModel).filter_by(run_id=run_id).filter_by(organization_id=organization_id)+ )+ ).first()+ if not task_run:+ LOG.warning(+ "TaskRun not found for compute cost update",+ run_id=run_id,+ organization_id=organization_id,+ )+ return++ if instance_type is not None:+ task_run.instance_type = instance_type+ if vcpu_millicores is not None:+ task_run.vcpu_millicores = vcpu_millicores+ if memory_mb is not None:+ task_run.memory_mb = memory_mb+ if duration_ms is not None:+ task_run.duration_ms = duration_ms+ if compute_cost is not None:+ task_run.compute_cost = compute_cost+ await session.commit()++ @db_operation("cache_task_run")+ async def cache_task_run(self, run_id: str, organization_id: str | None = None) -> Run:+ async with self.Session() as session:+ task_run = (+ await session.scalars(+ select(TaskRunModel).filter_by(organization_id=organization_id).filter_by(run_id=run_id)+ )+ ).first()+ if task_run:+ task_run.cached = True+ await session.commit()+ await session.refresh(task_run)+ return Run.model_validate(task_run)+ raise NotFoundError(f"Run {run_id} not found")++ @db_operation("get_cached_task_run")+ async def get_cached_task_run(+ self, task_run_type: RunType, url_hash: str | None = None, organization_id: str | None = None+ ) -> Run | None:+ async with self.Session() as session:+ query = select(TaskRunModel)+ if task_run_type:+ query = query.filter_by(task_run_type=task_run_type)+ if url_hash:+ query = query.filter_by(url_hash=url_hash)+ if organization_id:+ query = query.filter_by(organization_id=organization_id)+ query = query.filter_by(cached=True).order_by(TaskRunModel.created_at.desc())+ task_run = (await session.scalars(query)).first()+ return Run.model_validate(task_run) if task_run else None++ @db_operation("get_run")+ async def get_run(+ self,+ run_id: str,+ organization_id: str | None = None,+ ) -> Run | None:+ async with self.Session() as session:+ query = select(TaskRunModel).filter_by(run_id=run_id)+ if organization_id:+ query = query.filter_by(organization_id=organization_id)+ task_run = (await session.scalars(query)).first()+ return Run.model_validate(task_run) if task_run else Nonediff --git a/skyvern/forge/sdk/db/repositories/workflow_runs.py b/skyvern/forge/sdk/db/repositories/workflow_runs.pynew file mode 100644index 000000000..e38076fe3--- /dev/null+++ b/skyvern/forge/sdk/db/repositories/workflow_runs.py@@ -0,0 +1,903 @@+from __future__ import annotations++from datetime import datetime, timedelta, timezone+from typing import TYPE_CHECKING, Any, Callable++import structlog+from sqlalchemy import Text, and_, cast, exists, func, literal, literal_column, or_, select, update+from sqlalchemy.dialects.postgresql import JSONB+from sqlalchemy.exc import SQLAlchemyError++from skyvern.exceptions import WorkflowParameterNotFound, WorkflowRunNotFound+from skyvern.forge.sdk.db._error_handling import db_operation+from skyvern.forge.sdk.db.base_alchemy_db import read_retry+from skyvern.forge.sdk.db.base_repository import BaseRepository+from skyvern.forge.sdk.db.enums import WorkflowRunTriggerType+from skyvern.forge.sdk.db.exceptions import NotFoundError++if TYPE_CHECKING:+ from skyvern.forge.sdk.db.base_alchemy_db import _SessionFactory++from skyvern.forge.sdk.db.models import (+ TaskModel,+ WorkflowModel,+ WorkflowParameterModel,+ WorkflowRunBlockModel,+ WorkflowRunModel,+ WorkflowRunOutputParameterModel,+ WorkflowRunParameterModel,+)+from skyvern.forge.sdk.db.protocols import WorkflowParameterReader+from skyvern.forge.sdk.db.utils import (+ convert_to_task,+ convert_to_workflow_run,+ convert_to_workflow_run_output_parameter,+ convert_to_workflow_run_parameter,+ serialize_proxy_location,+)+from skyvern.forge.sdk.log_artifacts import save_workflow_run_logs+from skyvern.forge.sdk.schemas.tasks import Task+from skyvern.forge.sdk.workflow.models.parameter import WorkflowParameter+from skyvern.forge.sdk.workflow.models.workflow import (+ WorkflowRun,+ WorkflowRunOutputParameter,+ WorkflowRunParameter,+ WorkflowRunStatus,+)+from skyvern.schemas.runs import ProxyLocationInput++from . import _UNSET++LOG = structlog.get_logger()+++class WorkflowRunsRepository(BaseRepository):+ """Database operations for workflow runs."""++ def __init__(+ self,+ session_factory: _SessionFactory,+ debug_enabled: bool = False,+ is_retryable_error_fn: Callable[[SQLAlchemyError], bool] | None = None,+ workflow_parameter_reader: WorkflowParameterReader | None = None,+ dialect_name: str = "postgresql",+ ) -> None:+ super().__init__(session_factory, debug_enabled, is_retryable_error_fn)+ self._workflow_parameter_reader = workflow_parameter_reader+ self._dialect_name = dialect_name++ @db_operation("get_running_workflow_runs_info_globally")+ async def get_running_workflow_runs_info_globally(+ self,+ stale_threshold_hours: int = 24,+ ) -> tuple[int, int]:+ """+ Get information about running workflow runs across all organizations.+ Used by cleanup service to determine if cleanup should be skipped.++ Args:+ stale_threshold_hours: Workflow runs not updated for this many hours are considered stale.++ Returns:+ Tuple of (active_workflow_count, stale_workflow_count).+ Active workflows are those updated within the threshold.+ Stale workflows are those not updated within the threshold but still in running status.+ """+ async with self.Session() as session:+ running_statuses = [+ WorkflowRunStatus.created,+ WorkflowRunStatus.queued,+ WorkflowRunStatus.running,+ WorkflowRunStatus.paused,+ ]+ stale_cutoff = datetime.now(timezone.utc) - timedelta(hours=stale_threshold_hours)++ # Count active workflow runs (recently updated)+ active_query = (+ select(func.count())+ .select_from(WorkflowRunModel)+ .filter(WorkflowRunModel.status.in_(running_statuses))+ .filter(WorkflowRunModel.modified_at >= stale_cutoff)+ )+ active_count = (await session.execute(active_query)).scalar_one()++ # Count stale workflow runs (not updated for a long time)+ stale_query = (+ select(func.count())+ .select_from(WorkflowRunModel)+ .filter(WorkflowRunModel.status.in_(running_statuses))+ .filter(WorkflowRunModel.modified_at < stale_cutoff)+ )+ stale_count = (await session.execute(stale_query)).scalar_one()++ return (active_count, stale_count)++ @db_operation("create_workflow_run")+ async def create_workflow_run(+ self,+ workflow_permanent_id: str,+ workflow_id: str,+ organization_id: str,+ browser_session_id: str | None = None,+ browser_profile_id: str | None = None,+ proxy_location: ProxyLocationInput = None,+ webhook_callback_url: str | None = None,+ totp_verification_url: str | None = None,+ totp_identifier: str | None = None,+ parent_workflow_run_id: str | None = None,+ max_screenshot_scrolling_times: int | None = None,+ extra_http_headers: dict[str, str] | None = None,+ browser_address: str | None = None,+ sequential_key: str | None = None,+ run_with: str | None = None,+ debug_session_id: str | None = None,+ ai_fallback: bool | None = None,+ code_gen: bool | None = None,+ workflow_run_id: str | None = None,+ trigger_type: WorkflowRunTriggerType | None = None,+ workflow_schedule_id: str | None = None,+ ) -> WorkflowRun:+ async with self.Session() as session:+ kwargs: dict[str, Any] = {}+ if workflow_run_id is not None:+ kwargs["workflow_run_id"] = workflow_run_id+ workflow_run = WorkflowRunModel(+ workflow_permanent_id=workflow_permanent_id,+ workflow_id=workflow_id,+ organization_id=organization_id,+ browser_session_id=browser_session_id,+ browser_profile_id=browser_profile_id,+ proxy_location=serialize_proxy_location(proxy_location),+ status="created",+ webhook_callback_url=webhook_callback_url,+ totp_verification_url=totp_verification_url,+ totp_identifier=totp_identifier,+ parent_workflow_run_id=parent_workflow_run_id,+ max_screenshot_scrolling_times=max_screenshot_scrolling_times,+ extra_http_headers=extra_http_headers,+ browser_address=browser_address,+ sequential_key=sequential_key,+ run_with=run_with,+ debug_session_id=debug_session_id,+ ai_fallback=ai_fallback,+ code_gen=code_gen,+ trigger_type=trigger_type.value if trigger_type else None,+ workflow_schedule_id=workflow_schedule_id,+ **kwargs,+ )+ session.add(workflow_run)+ await session.commit()+ await session.refresh(workflow_run)+ return convert_to_workflow_run(workflow_run)++ @db_operation("update_workflow_run")+ async def update_workflow_run(+ self,+ workflow_run_id: str,+ status: WorkflowRunStatus | None = None,+ failure_reason: str | None = None,+ webhook_failure_reason: str | None = None,+ ai_fallback_triggered: bool | None = None,+ job_id: str | None = None,+ run_with: str | None = None,+ sequential_key: str | None = None,+ ai_fallback: bool | None = None,+ depends_on_workflow_run_id: str | None = None,+ browser_session_id: str | None = None,+ waiting_for_verification_code: bool | None = None,+ verification_code_identifier: str | None = None,+ verification_code_polling_started_at: datetime | None = None,+ browser_profile_id: str | None | object = _UNSET,+ ) -> WorkflowRun:+ async with self.Session() as session:+ workflow_run = (+ await session.scalars(select(WorkflowRunModel).filter_by(workflow_run_id=workflow_run_id))+ ).first()+ if workflow_run:+ if status:+ workflow_run.status = status+ if status and status == WorkflowRunStatus.queued and workflow_run.queued_at is None:+ workflow_run.queued_at = datetime.now(timezone.utc)+ if status and status == WorkflowRunStatus.running and workflow_run.started_at is None:+ workflow_run.started_at = datetime.now(timezone.utc)+ if status and status.is_final() and workflow_run.finished_at is None:+ workflow_run.finished_at = datetime.now(timezone.utc)+ if failure_reason:+ workflow_run.failure_reason = failure_reason+ if webhook_failure_reason is not None:+ workflow_run.webhook_failure_reason = webhook_failure_reason+ if ai_fallback_triggered is not None:+ workflow_run.script_run = {"ai_fallback_triggered": ai_fallback_triggered}+ if job_id:+ workflow_run.job_id = job_id+ if run_with:+ workflow_run.run_with = run_with+ if sequential_key:+ workflow_run.sequential_key = sequential_key+ if ai_fallback is not None:+ workflow_run.ai_fallback = ai_fallback+ if depends_on_workflow_run_id:+ workflow_run.depends_on_workflow_run_id = depends_on_workflow_run_id+ if browser_session_id:+ workflow_run.browser_session_id = browser_session_id+ # 2FA verification code waiting state updates+ if waiting_for_verification_code is not None:+ workflow_run.waiting_for_verification_code = waiting_for_verification_code+ if verification_code_identifier is not None:+ workflow_run.verification_code_identifier = verification_code_identifier+ if verification_code_polling_started_at is not None:+ workflow_run.verification_code_polling_started_at = verification_code_polling_started_at+ if waiting_for_verification_code is not None and not waiting_for_verification_code:+ # Clear related fields when waiting is set to False+ workflow_run.verification_code_identifier = None+ workflow_run.verification_code_polling_started_at = None+ if browser_profile_id is not _UNSET:+ workflow_run.browser_profile_id = browser_profile_id+ await session.commit()+ await save_workflow_run_logs(workflow_run_id)+ await session.refresh(workflow_run)+ return convert_to_workflow_run(workflow_run)+ else:+ raise WorkflowRunNotFound(workflow_run_id)++ @db_operation("bulk_update_workflow_runs")+ async def bulk_update_workflow_runs(+ self,+ workflow_run_ids: list[str],+ status: WorkflowRunStatus | None = None,+ failure_reason: str | None = None,+ ) -> None:+ """Bulk update workflow runs by their IDs.++ Args:+ workflow_run_ids: List of workflow run IDs to update+ status: Optional status to set for all workflow runs+ failure_reason: Optional failure reason to set for all workflow runs+ """+ if not workflow_run_ids:+ return++ async with self.Session() as session:+ update_values = {}+ if status:+ update_values["status"] = status.value+ if failure_reason:+ update_values["failure_reason"] = failure_reason++ if update_values:+ update_stmt = (+ update(WorkflowRunModel)+ .where(WorkflowRunModel.workflow_run_id.in_(workflow_run_ids))+ .values(**update_values)+ )+ await session.execute(update_stmt)+ await session.commit()++ @db_operation("clear_workflow_run_failure_reason")+ async def clear_workflow_run_failure_reason(self, workflow_run_id: str, organization_id: str) -> WorkflowRun:+ async with self.Session() as session:+ workflow_run = (+ await session.scalars(+ select(WorkflowRunModel)+ .filter_by(workflow_run_id=workflow_run_id)+ .filter_by(organization_id=organization_id)+ )+ ).first()+ if workflow_run:+ workflow_run.failure_reason = None+ await session.commit()+ await session.refresh(workflow_run)+ return convert_to_workflow_run(workflow_run)+ else:+ raise NotFoundError("Workflow run not found")++ @db_operation("get_all_runs")+ async def get_all_runs(+ self,+ organization_id: str,+ page: int = 1,+ page_size: int = 10,+ status: list[WorkflowRunStatus] | None = None,+ include_debugger_runs: bool = False,+ search_key: str | None = None,+ ) -> list[WorkflowRun | Task]:+ async with self.Session() as session:+ # temporary limit to 10 pages+ if page > 10:+ return []++ limit = page * page_size++ workflow_run_query = (+ select(WorkflowRunModel, WorkflowModel.title)+ .join(WorkflowModel, WorkflowModel.workflow_id == WorkflowRunModel.workflow_id)+ .filter(WorkflowRunModel.organization_id == organization_id)+ .filter(WorkflowRunModel.parent_workflow_run_id.is_(None))+ )++ if not include_debugger_runs:+ workflow_run_query = workflow_run_query.filter(WorkflowRunModel.debug_session_id.is_(None))++ if search_key:+ key_like = f"%{search_key}%"+ # Match workflow_run_id directly+ id_matches = WorkflowRunModel.workflow_run_id.ilike(key_like)+ # Match parameter key or description (only for non-deleted parameter definitions)+ param_key_desc_exists = exists(+ select(1)+ .select_from(WorkflowRunParameterModel)+ .join(+ WorkflowParameterModel,+ WorkflowParameterModel.workflow_parameter_id == WorkflowRunParameterModel.workflow_parameter_id,+ )+ .where(WorkflowRunParameterModel.workflow_run_id == WorkflowRunModel.workflow_run_id)+ .where(WorkflowParameterModel.deleted_at.is_(None))+ .where(+ or_(+ WorkflowParameterModel.key.ilike(key_like),+ WorkflowParameterModel.description.ilike(key_like),+ )+ )+ )+ # Match run parameter value directly (searches all values regardless of parameter definition status)+ param_value_exists = exists(+ select(1)+ .select_from(WorkflowRunParameterModel)+ .where(WorkflowRunParameterModel.workflow_run_id == WorkflowRunModel.workflow_run_id)+ .where(WorkflowRunParameterModel.value.ilike(key_like))+ )+ # Match extra HTTP headers (cast JSON to text for search, skip NULLs)+ extra_headers_match = and_(+ WorkflowRunModel.extra_http_headers.isnot(None),+ func.cast(WorkflowRunModel.extra_http_headers, Text()).ilike(key_like),+ )+ workflow_run_query = workflow_run_query.where(+ or_(id_matches, param_key_desc_exists, param_value_exists, extra_headers_match)+ )++ if status:+ workflow_run_query = workflow_run_query.filter(WorkflowRunModel.status.in_(status))+ workflow_run_query = workflow_run_query.order_by(WorkflowRunModel.created_at.desc()).limit(limit)+ workflow_run_query_result = (await session.execute(workflow_run_query)).all()+ workflow_runs = [+ convert_to_workflow_run(run, workflow_title=title, debug_enabled=self.debug_enabled)+ for run, title in workflow_run_query_result+ ]++ task_query = (+ select(TaskModel)+ .filter(TaskModel.organization_id == organization_id)+ .filter(TaskModel.workflow_run_id.is_(None))+ )+ if status:+ task_query = task_query.filter(TaskModel.status.in_(status))+ task_query = task_query.order_by(TaskModel.created_at.desc()).limit(limit)+ task_query_result = (await session.scalars(task_query)).all()+ tasks = [convert_to_task(task, debug_enabled=self.debug_enabled) for task in task_query_result]++ runs = workflow_runs + tasks++ runs.sort(key=lambda x: x.created_at, reverse=True)++ lower = (page - 1) * page_size+ upper = page * page_size++ return runs[lower:upper]++ @read_retry()+ @db_operation("get_workflow_run", log_errors=False)+ async def get_workflow_run(+ self,+ workflow_run_id: str,+ organization_id: str | None = None,+ job_id: str | None = None,+ status: WorkflowRunStatus | None = None,+ ) -> WorkflowRun | None:+ async with self.Session() as session:+ get_workflow_run_query = select(WorkflowRunModel).filter_by(workflow_run_id=workflow_run_id)+ if organization_id:+ get_workflow_run_query = get_workflow_run_query.filter_by(organization_id=organization_id)+ if job_id:+ get_workflow_run_query = get_workflow_run_query.filter_by(job_id=job_id)+ if status:+ get_workflow_run_query = get_workflow_run_query.filter_by(status=status.value)+ if workflow_run := (await session.scalars(get_workflow_run_query)).first():+ return convert_to_workflow_run(workflow_run)+ return None++ async def get_run(self, run_id: str, organization_id: str | None = None) -> WorkflowRun | None:+ """Alias satisfying the RunReader protocol."""+ return await self.get_workflow_run(run_id, organization_id=organization_id)++ @db_operation("get_last_queued_workflow_run")+ async def get_last_queued_workflow_run(+ self,+ workflow_permanent_id: str,+ organization_id: str | None = None,+ sequential_key: str | None = None,+ ) -> WorkflowRun | None:+ async with self.Session() as session:+ query = select(WorkflowRunModel).filter_by(workflow_permanent_id=workflow_permanent_id)+ query = query.filter(WorkflowRunModel.browser_session_id.is_(None))+ if organization_id:+ query = query.filter_by(organization_id=organization_id)+ query = query.filter_by(status=WorkflowRunStatus.queued)+ if sequential_key:+ query = query.filter_by(sequential_key=sequential_key)+ query = query.order_by(WorkflowRunModel.modified_at.desc())+ workflow_run = (await session.scalars(query)).first()+ return convert_to_workflow_run(workflow_run) if workflow_run else None++ @db_operation("get_workflow_runs_by_ids")+ async def get_workflow_runs_by_ids(+ self,+ workflow_run_ids: list[str],+ workflow_permanent_id: str | None = None,+ organization_id: str | None = None,+ ) -> list[WorkflowRun]:+ async with self.Session() as session:+ query = select(WorkflowRunModel).filter(WorkflowRunModel.workflow_run_id.in_(workflow_run_ids))+ if workflow_permanent_id:+ query = query.filter_by(workflow_permanent_id=workflow_permanent_id)+ if organization_id:+ query = query.filter_by(organization_id=organization_id)+ workflow_runs = (await session.scalars(query)).all()+ return [convert_to_workflow_run(workflow_run) for workflow_run in workflow_runs]++ @db_operation("get_last_running_workflow_run")+ async def get_last_running_workflow_run(+ self,+ workflow_permanent_id: str,+ organization_id: str | None = None,+ sequential_key: str | None = None,+ ) -> WorkflowRun | None:+ async with self.Session() as session:+ query = select(WorkflowRunModel).filter_by(workflow_permanent_id=workflow_permanent_id)+ query = query.filter(WorkflowRunModel.browser_session_id.is_(None))+ if organization_id:+ query = query.filter_by(organization_id=organization_id)+ query = query.filter_by(status=WorkflowRunStatus.running)+ if sequential_key:+ query = query.filter_by(sequential_key=sequential_key)+ query = query.filter(+ WorkflowRunModel.started_at.isnot(None)+ ) # filter out workflow runs that does not have a started_at timestamp+ query = query.order_by(WorkflowRunModel.started_at.desc())+ workflow_run = (await session.scalars(query)).first()+ return convert_to_workflow_run(workflow_run) if workflow_run else None++ async def _get_last_workflow_run_by_filter(+ self,+ organization_id: str | None = None,+ **filters: str,+ ) -> WorkflowRun | None:+ """Get the last queued or running workflow run matching the given column filters.++ Used for browser_session_id and browser_address sequential execution.+ """+ async with self.Session() as session:+ query = select(WorkflowRunModel).filter_by(**filters)+ if organization_id:+ query = query.filter_by(organization_id=organization_id)++ # check if there's a queued run+ queue_query = query.filter_by(status=WorkflowRunStatus.queued)+ queue_query = queue_query.order_by(WorkflowRunModel.modified_at.desc())+ workflow_run = (await session.scalars(queue_query)).first()+ if workflow_run:+ return convert_to_workflow_run(workflow_run)++ # check if there's a running run+ running_query = query.filter_by(status=WorkflowRunStatus.running)+ running_query = running_query.filter(WorkflowRunModel.started_at.isnot(None))+ running_query = running_query.order_by(WorkflowRunModel.started_at.desc())+ workflow_run = (await session.scalars(running_query)).first()+ if workflow_run:+ return convert_to_workflow_run(workflow_run)+ return None++ async def get_last_workflow_run_for_browser_session(+ self,+ browser_session_id: str,+ organization_id: str | None = None,+ ) -> WorkflowRun | None:+ return await self._get_last_workflow_run_by_filter(+ organization_id=organization_id,+ browser_session_id=browser_session_id,+ )++ async def get_last_workflow_run_for_browser_address(+ self,+ browser_address: str,+ organization_id: str | None = None,+ ) -> WorkflowRun | None:+ return await self._get_last_workflow_run_by_filter(+ organization_id=organization_id,+ browser_address=browser_address,+ )++ @db_operation("get_workflows_depending_on")+ async def get_workflows_depending_on(+ self,+ workflow_run_id: str,+ ) -> list[WorkflowRun]:+ """+ Get all workflow runs that depend on the given workflow_run_id.++ Used to find workflows that should be signaled when a workflow completes,+ for sequential workflow dependency handling.++ Args:+ workflow_run_id: The workflow_run_id to find dependents for++ Returns:+ List of WorkflowRun objects that have depends_on_workflow_run_id set to workflow_run_id+ """+ async with self.Session() as session:+ query = select(WorkflowRunModel).filter_by(depends_on_workflow_run_id=workflow_run_id)+ workflow_runs = (await session.scalars(query)).all()+ return [convert_to_workflow_run(workflow_run) for workflow_run in workflow_runs]++ @staticmethod+ def _apply_search_key_filter(query, search_key: str | None): # type: ignore[no-untyped-def]+ if not search_key:+ return query+ key_like = f"%{search_key}%"+ # Match workflow_run_id directly+ id_matches = WorkflowRunModel.workflow_run_id.ilike(key_like)+ # Match parameter key or description (only for non-deleted parameter definitions)+ # Use EXISTS to avoid duplicate rows and to keep pagination correct+ param_key_desc_exists = exists(+ select(1)+ .select_from(WorkflowRunParameterModel)+ .join(+ WorkflowParameterModel,+ WorkflowParameterModel.workflow_parameter_id == WorkflowRunParameterModel.workflow_parameter_id,+ )+ .where(WorkflowRunParameterModel.workflow_run_id == WorkflowRunModel.workflow_run_id)+ .where(WorkflowParameterModel.deleted_at.is_(None))+ .where(+ or_(+ WorkflowParameterModel.key.ilike(key_like),+ WorkflowParameterModel.description.ilike(key_like),+ )+ )+ )+ # Match run parameter value directly (searches all values regardless of parameter definition status)+ param_value_exists = exists(+ select(1)+ .select_from(WorkflowRunParameterModel)+ .where(WorkflowRunParameterModel.workflow_run_id == WorkflowRunModel.workflow_run_id)+ .where(WorkflowRunParameterModel.value.ilike(key_like))+ )+ # Match extra HTTP headers (cast JSON to text for search, skip NULLs)+ extra_headers_match = and_(+ WorkflowRunModel.extra_http_headers.isnot(None),+ func.cast(WorkflowRunModel.extra_http_headers, Text()).ilike(key_like),+ )+ return query.where(or_(id_matches, param_key_desc_exists, param_value_exists, extra_headers_match))++ def _apply_error_code_filter(self, query, error_code: str | None): # type: ignore[no-untyped-def]+ if not error_code:+ return query++ if self._dialect_name == "sqlite":+ # Task errors: array of objects like [{"error_code": "timeout", ...}]+ # Use json_each to iterate + json_extract to match the error_code field+ error_code_in_tasks = exists(+ select(1)+ .select_from(TaskModel)+ .where(TaskModel.workflow_run_id == WorkflowRunModel.workflow_run_id)+ .where(+ exists(+ select(1)+ .select_from(func.json_each(TaskModel.errors))+ .where(func.json_extract(literal_column("json_each.value"), "$.error_code") == error_code)+ )+ )+ )+ # Block errors: flat array of strings like ["timeout", "network_error"]+ error_code_in_blocks = exists(+ select(1)+ .select_from(WorkflowRunBlockModel)+ .where(WorkflowRunBlockModel.workflow_run_id == WorkflowRunModel.workflow_run_id)+ .where(+ exists(+ select(1)+ .select_from(func.json_each(WorkflowRunBlockModel.error_codes))+ .where(literal_column("json_each.value") == error_code)+ )+ )+ )+ else:+ # PostgreSQL: native JSONB containment+ error_code_in_tasks = exists(+ select(1)+ .select_from(TaskModel)+ .where(TaskModel.workflow_run_id == WorkflowRunModel.workflow_run_id)+ .where(cast(TaskModel.errors, JSONB).contains(literal([{"error_code": error_code}], type_=JSONB)))+ )+ error_code_in_blocks = exists(+ select(1)+ .select_from(WorkflowRunBlockModel)+ .where(WorkflowRunBlockModel.workflow_run_id == WorkflowRunModel.workflow_run_id)+ .where(cast(WorkflowRunBlockModel.error_codes, JSONB).contains(literal([error_code], type_=JSONB)))+ )+ return query.where(or_(error_code_in_tasks, error_code_in_blocks))++ @db_operation("get_workflow_runs")+ async def get_workflow_runs(+ self,+ organization_id: str,+ page: int = 1,+ page_size: int = 10,+ status: list[WorkflowRunStatus] | None = None,+ ordering: tuple[str, str] | None = None,+ search_key: str | None = None,+ error_code: str | None = None,+ ) -> list[WorkflowRun]:+ async with self.Session() as session:+ db_page = page - 1 # offset logic is 0 based++ query = (+ select(WorkflowRunModel, WorkflowModel.title)+ .join(WorkflowModel, WorkflowModel.workflow_id == WorkflowRunModel.workflow_id)+ .filter(WorkflowRunModel.organization_id == organization_id)+ .filter(WorkflowRunModel.parent_workflow_run_id.is_(None))+ )++ query = self._apply_search_key_filter(query, search_key)+ query = self._apply_error_code_filter(query, error_code)++ if status:+ query = query.filter(WorkflowRunModel.status.in_(status))++ allowed_ordering_fields = {+ "created_at": WorkflowRunModel.created_at,+ "status": WorkflowRunModel.status,+ }++ field, direction = ("created_at", "desc")++ if ordering and isinstance(ordering, tuple) and len(ordering) == 2:+ req_field, req_direction = ordering+ if req_field in allowed_ordering_fields and req_direction in ("asc", "desc"):+ field, direction = req_field, req_direction++ order_column = allowed_ordering_fields[field]++ if direction == "asc":+ query = query.order_by(order_column.asc())+ else:+ query = query.order_by(order_column.desc())++ query = query.limit(page_size).offset(db_page * page_size)++ workflow_runs = (await session.execute(query)).all()++ return [+ convert_to_workflow_run(run, workflow_title=title, debug_enabled=self.debug_enabled)+ for run, title in workflow_runs+ ]++ @db_operation("get_workflow_runs_count")+ async def get_workflow_runs_count(+ self,+ organization_id: str,+ status: list[WorkflowRunStatus] | None = None,+ ) -> int:+ async with self.Session() as session:+ count_query = (+ select(func.count())+ .select_from(WorkflowRunModel)+ .filter(WorkflowRunModel.organization_id == organization_id)+ )+ if status:+ count_query = count_query.filter(WorkflowRunModel.status.in_(status))+ return (await session.execute(count_query)).scalar_one()++ @db_operation("get_workflow_runs_for_workflow_permanent_id")+ async def get_workflow_runs_for_workflow_permanent_id(+ self,+ workflow_permanent_id: str,+ organization_id: str,+ page: int = 1,+ page_size: int = 10,+ status: list[WorkflowRunStatus] | None = None,+ search_key: str | None = None,+ error_code: str | None = None,+ ) -> list[WorkflowRun]:+ """+ Get runs for a workflow, with optional `search_key` on run ID, parameter key/description/value,+ or extra HTTP headers.+ """+ async with self.Session() as session:+ db_page = page - 1 # offset logic is 0 based+ query = (+ select(WorkflowRunModel, WorkflowModel.title)+ .join(WorkflowModel, WorkflowModel.workflow_id == WorkflowRunModel.workflow_id)+ .filter(WorkflowRunModel.workflow_permanent_id == workflow_permanent_id)+ .filter(WorkflowRunModel.organization_id == organization_id)+ )+ query = self._apply_search_key_filter(query, search_key)+ query = self._apply_error_code_filter(query, error_code)+ if status:+ query = query.filter(WorkflowRunModel.status.in_(status))+ query = query.order_by(WorkflowRunModel.created_at.desc()).limit(page_size).offset(db_page * page_size)+ workflow_runs_and_titles_tuples = (await session.execute(query)).all()+ workflow_runs = [+ convert_to_workflow_run(run, workflow_title=title, debug_enabled=self.debug_enabled)+ for run, title in workflow_runs_and_titles_tuples+ ]+ return workflow_runs++ @db_operation("get_workflow_runs_by_parent_workflow_run_id")+ async def get_workflow_runs_by_parent_workflow_run_id(+ self,+ parent_workflow_run_id: str,+ organization_id: str | None = None,+ ) -> list[WorkflowRun]:+ async with self.Session() as session:+ query = select(WorkflowRunModel).filter(WorkflowRunModel.parent_workflow_run_id == parent_workflow_run_id)+ if organization_id is not None:+ query = query.filter(WorkflowRunModel.organization_id == organization_id)+ workflow_runs = (await session.scalars(query)).all()+ return [convert_to_workflow_run(run) for run in workflow_runs]++ @db_operation("get_workflow_run_output_parameters")+ async def get_workflow_run_output_parameters(self, workflow_run_id: str) -> list[WorkflowRunOutputParameter]:+ async with self.Session() as session:+ workflow_run_output_parameters = (+ await session.scalars(+ select(WorkflowRunOutputParameterModel)+ .filter_by(workflow_run_id=workflow_run_id)+ .order_by(WorkflowRunOutputParameterModel.created_at)+ )+ ).all()+ return [+ convert_to_workflow_run_output_parameter(parameter, self.debug_enabled)+ for parameter in workflow_run_output_parameters+ ]++ @db_operation("get_workflow_run_output_parameter_by_id")+ async def get_workflow_run_output_parameter_by_id(+ self, workflow_run_id: str, output_parameter_id: str+ ) -> WorkflowRunOutputParameter | None:+ async with self.Session() as session:+ parameter = (+ await session.scalars(+ select(WorkflowRunOutputParameterModel)+ .filter_by(workflow_run_id=workflow_run_id)+ .filter_by(output_parameter_id=output_parameter_id)+ .order_by(WorkflowRunOutputParameterModel.created_at)+ )+ ).first()++ if parameter:+ return convert_to_workflow_run_output_parameter(parameter, self.debug_enabled)++ return None++ @db_operation("create_or_update_workflow_run_output_parameter")+ async def create_or_update_workflow_run_output_parameter(+ self,+ workflow_run_id: str,+ output_parameter_id: str,+ value: dict[str, Any] | list | str | None,+ ) -> WorkflowRunOutputParameter:+ async with self.Session() as session:+ # check if the workflow run output parameter already exists+ # if it does, update the value+ if workflow_run_output_parameter := (+ await session.scalars(+ select(WorkflowRunOutputParameterModel)+ .filter_by(workflow_run_id=workflow_run_id)+ .filter_by(output_parameter_id=output_parameter_id)+ )+ ).first():+ LOG.info(+ "Updating existing workflow run output parameter",+ workflow_run_id=workflow_run_output_parameter.workflow_run_id,+ output_parameter_id=workflow_run_output_parameter.output_parameter_id,+ )+ workflow_run_output_parameter.value = value+ await session.commit()+ await session.refresh(workflow_run_output_parameter)+ return convert_to_workflow_run_output_parameter(workflow_run_output_parameter, self.debug_enabled)++ # if it does not exist, create a new one+ workflow_run_output_parameter = WorkflowRunOutputParameterModel(+ workflow_run_id=workflow_run_id,+ output_parameter_id=output_parameter_id,+ value=value,+ )+ session.add(workflow_run_output_parameter)+ await session.commit()+ await session.refresh(workflow_run_output_parameter)+ return convert_to_workflow_run_output_parameter(workflow_run_output_parameter, self.debug_enabled)++ @db_operation("update_workflow_run_output_parameter")+ async def update_workflow_run_output_parameter(+ self,+ workflow_run_id: str,+ output_parameter_id: str,+ value: dict[str, Any] | list | str | None,+ ) -> WorkflowRunOutputParameter:+ async with self.Session() as session:+ workflow_run_output_parameter = (+ await session.scalars(+ select(WorkflowRunOutputParameterModel)+ .filter_by(workflow_run_id=workflow_run_id)+ .filter_by(output_parameter_id=output_parameter_id)+ )+ ).first()+ if not workflow_run_output_parameter:+ raise NotFoundError(+ f"WorkflowRunOutputParameter not found for {workflow_run_id} and {output_parameter_id}"+ )+ workflow_run_output_parameter.value = value+ await session.commit()+ await session.refresh(workflow_run_output_parameter)+ return convert_to_workflow_run_output_parameter(workflow_run_output_parameter, self.debug_enabled)++ @db_operation("create_workflow_run_parameter")+ async def create_workflow_run_parameter(+ self, workflow_run_id: str, workflow_parameter: WorkflowParameter, value: Any+ ) -> WorkflowRunParameter:+ workflow_parameter_id = workflow_parameter.workflow_parameter_id+ async with self.Session() as session:+ workflow_run_parameter = WorkflowRunParameterModel(+ workflow_run_id=workflow_run_id,+ workflow_parameter_id=workflow_parameter_id,+ value=value,+ )+ session.add(workflow_run_parameter)+ await session.commit()+ await session.refresh(workflow_run_parameter)+ return convert_to_workflow_run_parameter(workflow_run_parameter, workflow_parameter, self.debug_enabled)++ @db_operation("get_workflow_run_parameters")+ async def get_workflow_run_parameters(+ self, workflow_run_id: str+ ) -> list[tuple[WorkflowParameter, WorkflowRunParameter]]:+ async with self.Session() as session:+ workflow_run_parameters = (+ await session.scalars(select(WorkflowRunParameterModel).filter_by(workflow_run_id=workflow_run_id))+ ).all()+ results = []+ for workflow_run_parameter in workflow_run_parameters:+ if self._workflow_parameter_reader is None:+ raise RuntimeError("workflow_parameter_reader dependency not set")+ workflow_parameter = await self._workflow_parameter_reader.get_workflow_parameter(+ workflow_run_parameter.workflow_parameter_id+ )+ if not workflow_parameter:+ raise WorkflowParameterNotFound(workflow_parameter_id=workflow_run_parameter.workflow_parameter_id)+ results.append(+ (+ workflow_parameter,+ convert_to_workflow_run_parameter(+ workflow_run_parameter,+ workflow_parameter,+ self.debug_enabled,+ ),+ )+ )+ return results++ @db_operation("get_workflow_run_block_errors")+ async def get_workflow_run_block_errors(+ self,+ workflow_run_id: str,+ organization_id: str | None = None,+ ) -> list[tuple[list[str], str | None]]:+ """Return (error_codes, failure_reason) tuples for blocks with non-null error_codes."""+ async with self.Session() as session:+ query = select(WorkflowRunBlockModel.error_codes, WorkflowRunBlockModel.failure_reason).filter_by(+ workflow_run_id=workflow_run_id+ )+ if organization_id is not None:+ query = query.filter_by(organization_id=organization_id)+ query = query.where(WorkflowRunBlockModel.error_codes.isnot(None))+ rows = (await session.execute(query)).all()+ return [(row.error_codes, row.failure_reason) for row in rows]diff --git a/skyvern/forge/sdk/db/repositories/workflows.py b/skyvern/forge/sdk/db/repositories/workflows.pynew file mode 100644index 000000000..fd9cfb9cd--- /dev/null+++ b/skyvern/forge/sdk/db/repositories/workflows.py@@ -0,0 +1,705 @@+from __future__ import annotations++from datetime import datetime, timezone+from typing import Any++import structlog+from sqlalchemy import exists, func, or_, select, update++from skyvern.constants import DEFAULT_SCRIPT_RUN_ID+from skyvern.forge.sdk.db._error_handling import db_operation+from skyvern.forge.sdk.db._soft_delete import exclude_deleted+from skyvern.forge.sdk.db.base_repository import BaseRepository+from skyvern.forge.sdk.db.exceptions import NotFoundError+from skyvern.forge.sdk.db.models import (+ AWSSecretParameterModel,+ AzureVaultCredentialParameterModel,+ BitwardenCreditCardDataParameterModel,+ BitwardenLoginCredentialParameterModel,+ BitwardenSensitiveInformationParameterModel,+ CredentialParameterModel,+ FolderModel,+ OnePasswordCredentialParameterModel,+ OutputParameterModel,+ WorkflowModel,+ WorkflowParameterModel,+ WorkflowRunModel,+ WorkflowScheduleModel,+ WorkflowTemplateModel,+)+from skyvern.forge.sdk.db.utils import convert_to_workflow, serialize_proxy_location+from skyvern.forge.sdk.workflow.models.workflow import Workflow+from skyvern.schemas.runs import ProxyLocationInput+from skyvern.schemas.workflows import WorkflowStatus++LOG = structlog.get_logger()+++class WorkflowsRepository(BaseRepository):+ """Database operations for workflow management."""++ @db_operation("create_workflow")+ async def create_workflow(+ self,+ title: str,+ workflow_definition: dict[str, Any],+ organization_id: str | None = None,+ description: str | None = None,+ proxy_location: ProxyLocationInput = None,+ webhook_callback_url: str | None = None,+ max_screenshot_scrolling_times: int | None = None,+ extra_http_headers: dict[str, str] | None = None,+ totp_verification_url: str | None = None,+ totp_identifier: str | None = None,+ persist_browser_session: bool = False,+ model: dict[str, Any] | None = None,+ workflow_permanent_id: str | None = None,+ version: int | None = None,+ is_saved_task: bool = False,+ status: WorkflowStatus = WorkflowStatus.published,+ run_with: str | None = None,+ ai_fallback: bool = True,+ cache_key: str | None = None,+ adaptive_caching: bool = False,+ code_version: int | None = None,+ generate_script_on_terminal: bool = False,+ run_sequentially: bool = False,+ sequential_key: str | None = None,+ folder_id: str | None = None,+ ) -> Workflow:+ async with self.Session() as session:+ workflow = WorkflowModel(+ organization_id=organization_id,+ title=title,+ description=description,+ workflow_definition=workflow_definition,+ proxy_location=serialize_proxy_location(proxy_location),+ webhook_callback_url=webhook_callback_url,+ totp_verification_url=totp_verification_url,+ totp_identifier=totp_identifier,+ max_screenshot_scrolling_times=max_screenshot_scrolling_times,+ extra_http_headers=extra_http_headers,+ persist_browser_session=persist_browser_session,+ model=model,+ is_saved_task=is_saved_task,+ status=status,+ run_with=run_with,+ ai_fallback=ai_fallback,+ cache_key=cache_key or DEFAULT_SCRIPT_RUN_ID,+ adaptive_caching=adaptive_caching,+ code_version=code_version,+ generate_script_on_terminal=generate_script_on_terminal,+ run_sequentially=run_sequentially,+ sequential_key=sequential_key,+ folder_id=folder_id,+ )+ if workflow_permanent_id:+ workflow.workflow_permanent_id = workflow_permanent_id+ if version:+ workflow.version = version+ session.add(workflow)++ # Update folder's modified_at if folder_id is provided+ if folder_id:+ # Validate folder exists and belongs to the same organization+ folder_stmt = (+ select(FolderModel)+ .where(FolderModel.folder_id == folder_id)+ .where(FolderModel.organization_id == organization_id)+ .where(FolderModel.deleted_at.is_(None))+ )+ folder_model = await session.scalar(folder_stmt)+ if not folder_model:+ raise ValueError(+ f"Folder {folder_id} not found or does not belong to organization {organization_id}"+ )+ folder_model.modified_at = datetime.now(timezone.utc)++ await session.commit()+ await session.refresh(workflow)+ return convert_to_workflow(workflow, self.debug_enabled)++ @db_operation("soft_delete_workflow_by_id")+ async def soft_delete_workflow_by_id(self, workflow_id: str, organization_id: str) -> None:+ async with self.Session() as session:+ # soft delete the workflow by setting the deleted_at field to the current time+ update_deleted_at_query = (+ update(WorkflowModel)+ .where(WorkflowModel.workflow_id == workflow_id)+ .where(WorkflowModel.organization_id == organization_id)+ .where(WorkflowModel.deleted_at.is_(None))+ .values(deleted_at=datetime.now(timezone.utc))+ )+ await session.execute(update_deleted_at_query)+ await session.commit()++ @db_operation("get_workflow")+ async def get_workflow(self, workflow_id: str, organization_id: str | None = None) -> Workflow | None:+ async with self.Session() as session:+ get_workflow_query = exclude_deleted(+ select(WorkflowModel).filter_by(workflow_id=workflow_id), WorkflowModel+ )+ if organization_id:+ get_workflow_query = get_workflow_query.filter_by(organization_id=organization_id)+ if workflow := (await session.scalars(get_workflow_query)).first():+ is_template = (+ await self.is_workflow_template(+ workflow_permanent_id=workflow.workflow_permanent_id,+ organization_id=workflow.organization_id,+ )+ if organization_id+ else False+ )+ return convert_to_workflow(+ workflow,+ self.debug_enabled,+ is_template=is_template,+ )+ return None++ @db_operation("get_workflow_by_permanent_id")+ async def get_workflow_by_permanent_id(+ self,+ workflow_permanent_id: str,+ organization_id: str | None = None,+ version: int | None = None,+ ignore_version: int | None = None,+ filter_deleted: bool = True,+ ) -> Workflow | None:+ get_workflow_query = select(WorkflowModel).filter_by(workflow_permanent_id=workflow_permanent_id)+ if filter_deleted:+ get_workflow_query = get_workflow_query.filter(WorkflowModel.deleted_at.is_(None))+ if organization_id:+ get_workflow_query = get_workflow_query.filter_by(organization_id=organization_id)+ if version:+ get_workflow_query = get_workflow_query.filter_by(version=version)+ if ignore_version:+ get_workflow_query = get_workflow_query.filter(WorkflowModel.version != ignore_version)+ get_workflow_query = get_workflow_query.order_by(WorkflowModel.version.desc())+ async with self.Session() as session:+ if workflow := (await session.scalars(get_workflow_query)).first():+ is_template = (+ await self.is_workflow_template(+ workflow_permanent_id=workflow.workflow_permanent_id,+ organization_id=workflow.organization_id,+ )+ if organization_id+ else False+ )+ return convert_to_workflow(+ workflow,+ self.debug_enabled,+ is_template=is_template,+ )+ return None++ @db_operation("get_workflow_for_workflow_run")+ async def get_workflow_for_workflow_run(+ self,+ workflow_run_id: str,+ organization_id: str | None = None,+ filter_deleted: bool = True,+ ) -> Workflow | None:+ get_workflow_query = select(WorkflowModel)++ if filter_deleted:+ get_workflow_query = get_workflow_query.filter(WorkflowModel.deleted_at.is_(None))++ get_workflow_query = get_workflow_query.join(+ WorkflowRunModel,+ WorkflowRunModel.workflow_id == WorkflowModel.workflow_id,+ )++ if organization_id:+ get_workflow_query = get_workflow_query.filter(WorkflowRunModel.organization_id == organization_id)++ get_workflow_query = get_workflow_query.filter(WorkflowRunModel.workflow_run_id == workflow_run_id)+ async with self.Session() as session:+ if workflow := (await session.scalars(get_workflow_query)).first():+ is_template = (+ await self.is_workflow_template(+ workflow_permanent_id=workflow.workflow_permanent_id,+ organization_id=workflow.organization_id,+ )+ if organization_id+ else False+ )+ return convert_to_workflow(+ workflow,+ self.debug_enabled,+ is_template=is_template,+ )+ return None++ @db_operation("get_workflow_versions_by_permanent_id")+ async def get_workflow_versions_by_permanent_id(+ self,+ workflow_permanent_id: str,+ organization_id: str | None = None,+ filter_deleted: bool = True,+ ) -> list[Workflow]:+ """+ Get all versions of a workflow by its permanent ID, ordered by version descending (newest first).+ """+ get_workflows_query = select(WorkflowModel).filter_by(workflow_permanent_id=workflow_permanent_id)+ if filter_deleted:+ get_workflows_query = get_workflows_query.filter(WorkflowModel.deleted_at.is_(None))+ if organization_id:+ get_workflows_query = get_workflows_query.filter_by(organization_id=organization_id)+ get_workflows_query = get_workflows_query.order_by(WorkflowModel.version.desc())++ async with self.Session() as session:+ workflows = (await session.scalars(get_workflows_query)).all()+ template_permanent_ids: set[str] = set()+ if workflows and organization_id:+ template_permanent_ids = await self.get_org_template_permanent_ids(organization_id)++ return [+ convert_to_workflow(+ workflow,+ self.debug_enabled,+ is_template=workflow.workflow_permanent_id in template_permanent_ids,+ )+ for workflow in workflows+ ]++ @db_operation("get_workflows_by_permanent_ids")+ async def get_workflows_by_permanent_ids(+ self,+ workflow_permanent_ids: list[str],+ organization_id: str | None = None,+ page: int = 1,+ page_size: int = 10,+ title: str = "",+ statuses: list[WorkflowStatus] | None = None,+ ) -> list[Workflow]:+ """+ Get all workflows with the latest version for the organization.+ """+ if page < 1:+ raise ValueError(f"Page must be greater than 0, got {page}")+ db_page = page - 1+ async with self.Session() as session:+ subquery = (+ select(+ WorkflowModel.workflow_permanent_id,+ func.max(WorkflowModel.version).label("max_version"),+ )+ .where(WorkflowModel.workflow_permanent_id.in_(workflow_permanent_ids))+ .where(WorkflowModel.deleted_at.is_(None))+ .group_by(+ WorkflowModel.workflow_permanent_id,+ )+ .subquery()+ )+ main_query = select(WorkflowModel).join(+ subquery,+ (WorkflowModel.workflow_permanent_id == subquery.c.workflow_permanent_id)+ & (WorkflowModel.version == subquery.c.max_version),+ )+ if organization_id:+ main_query = main_query.where(WorkflowModel.organization_id == organization_id)+ if title:+ main_query = main_query.where(WorkflowModel.title.ilike(f"%{title}%"))+ if statuses:+ main_query = main_query.where(WorkflowModel.status.in_(statuses))+ main_query = (+ main_query.order_by(WorkflowModel.created_at.desc()).limit(page_size).offset(db_page * page_size)+ )+ workflows = (await session.scalars(main_query)).all()++ # Map template status by permanent_id so API responses surface is_template+ template_permanent_ids: set[str] = set()+ if workflows and organization_id:+ template_permanent_ids = await self.get_org_template_permanent_ids(organization_id)++ return [+ convert_to_workflow(+ workflow,+ self.debug_enabled,+ is_template=workflow.workflow_permanent_id in template_permanent_ids,+ )+ for workflow in workflows+ ]++ @db_operation("get_workflows_by_organization_id")+ async def get_workflows_by_organization_id(+ self,+ organization_id: str,+ page: int = 1,+ page_size: int = 10,+ only_saved_tasks: bool = False,+ only_workflows: bool = False,+ only_templates: bool = False,+ search_key: str | None = None,+ folder_id: str | None = None,+ statuses: list[WorkflowStatus] | None = None,+ ) -> list[Workflow]:+ """+ Get all workflows with the latest version for the organization.++ Search semantics:+ - If `search_key` is provided, its value is used as a unified search term for+ `workflows.title`, `folders.title`, and workflow parameter metadata (key, description, and default_value).+ - If `search_key` is not provided, no search filtering is applied.+ - Parameter metadata search excludes soft-deleted parameter rows across parameter tables.+ """+ if page < 1:+ raise ValueError(f"Page must be greater than 0, got {page}")+ db_page = page - 1+ async with self.Session() as session:+ subquery = (+ select(+ WorkflowModel.organization_id,+ WorkflowModel.workflow_permanent_id,+ func.max(WorkflowModel.version).label("max_version"),+ )+ .where(WorkflowModel.organization_id == organization_id)+ .where(WorkflowModel.deleted_at.is_(None))+ .group_by(+ WorkflowModel.organization_id,+ WorkflowModel.workflow_permanent_id,+ )+ .subquery()+ )+ main_query = (+ select(WorkflowModel)+ .join(+ subquery,+ (WorkflowModel.organization_id == subquery.c.organization_id)+ & (WorkflowModel.workflow_permanent_id == subquery.c.workflow_permanent_id)+ & (WorkflowModel.version == subquery.c.max_version),+ )+ .outerjoin(+ FolderModel,+ (WorkflowModel.folder_id == FolderModel.folder_id)+ & (FolderModel.organization_id == WorkflowModel.organization_id),+ )+ )+ if only_saved_tasks:+ main_query = main_query.where(WorkflowModel.is_saved_task.is_(True))+ elif only_workflows:+ main_query = main_query.where(WorkflowModel.is_saved_task.is_(False))+ if only_templates:+ # Filter by workflow_templates table (templates at permanent_id level)+ template_subquery = select(WorkflowTemplateModel.workflow_permanent_id).where(+ WorkflowTemplateModel.organization_id == organization_id,+ WorkflowTemplateModel.deleted_at.is_(None),+ )+ main_query = main_query.where(WorkflowModel.workflow_permanent_id.in_(template_subquery))+ if statuses:+ main_query = main_query.where(WorkflowModel.status.in_(statuses))+ if folder_id:+ main_query = main_query.where(WorkflowModel.folder_id == folder_id)+ if search_key:+ search_like = f"%{search_key}%"+ title_like = WorkflowModel.title.ilike(search_like)+ folder_title_like = FolderModel.title.ilike(search_like)++ parameter_filters = [+ # WorkflowParameterModel+ exists(+ select(1)+ .select_from(WorkflowParameterModel)+ .where(WorkflowParameterModel.workflow_id == WorkflowModel.workflow_id)+ .where(WorkflowParameterModel.deleted_at.is_(None))+ .where(+ or_(+ WorkflowParameterModel.key.ilike(search_like),+ WorkflowParameterModel.description.ilike(search_like),+ WorkflowParameterModel.default_value.ilike(search_like),+ )+ )+ ),+ # OutputParameterModel+ exists(+ select(1)+ .select_from(OutputParameterModel)+ .where(OutputParameterModel.workflow_id == WorkflowModel.workflow_id)+ .where(OutputParameterModel.deleted_at.is_(None))+ .where(+ or_(+ OutputParameterModel.key.ilike(search_like),+ OutputParameterModel.description.ilike(search_like),+ )+ )+ ),+ # AWSSecretParameterModel+ exists(+ select(1)+ .select_from(AWSSecretParameterModel)+ .where(AWSSecretParameterModel.workflow_id == WorkflowModel.workflow_id)+ .where(AWSSecretParameterModel.deleted_at.is_(None))+ .where(+ or_(+ AWSSecretParameterModel.key.ilike(search_like),+ AWSSecretParameterModel.description.ilike(search_like),+ )+ )+ ),+ # BitwardenLoginCredentialParameterModel+ exists(+ select(1)+ .select_from(BitwardenLoginCredentialParameterModel)+ .where(BitwardenLoginCredentialParameterModel.workflow_id == WorkflowModel.workflow_id)+ .where(BitwardenLoginCredentialParameterModel.deleted_at.is_(None))+ .where(+ or_(+ BitwardenLoginCredentialParameterModel.key.ilike(search_like),+ BitwardenLoginCredentialParameterModel.description.ilike(search_like),+ )+ )+ ),+ # BitwardenSensitiveInformationParameterModel+ exists(+ select(1)+ .select_from(BitwardenSensitiveInformationParameterModel)+ .where(BitwardenSensitiveInformationParameterModel.workflow_id == WorkflowModel.workflow_id)+ .where(BitwardenSensitiveInformationParameterModel.deleted_at.is_(None))+ .where(+ or_(+ BitwardenSensitiveInformationParameterModel.key.ilike(search_like),+ BitwardenSensitiveInformationParameterModel.description.ilike(search_like),+ )+ )+ ),+ # BitwardenCreditCardDataParameterModel+ exists(+ select(1)+ .select_from(BitwardenCreditCardDataParameterModel)+ .where(BitwardenCreditCardDataParameterModel.workflow_id == WorkflowModel.workflow_id)+ .where(BitwardenCreditCardDataParameterModel.deleted_at.is_(None))+ .where(+ or_(+ BitwardenCreditCardDataParameterModel.key.ilike(search_like),+ BitwardenCreditCardDataParameterModel.description.ilike(search_like),+ )+ )+ ),+ # OnePasswordCredentialParameterModel+ exists(+ select(1)+ .select_from(OnePasswordCredentialParameterModel)+ .where(OnePasswordCredentialParameterModel.workflow_id == WorkflowModel.workflow_id)+ .where(OnePasswordCredentialParameterModel.deleted_at.is_(None))+ .where(+ or_(+ OnePasswordCredentialParameterModel.key.ilike(search_like),+ OnePasswordCredentialParameterModel.description.ilike(search_like),+ )+ )+ ),+ # AzureVaultCredentialParameterModel+ exists(+ select(1)+ .select_from(AzureVaultCredentialParameterModel)+ .where(AzureVaultCredentialParameterModel.workflow_id == WorkflowModel.workflow_id)+ .where(AzureVaultCredentialParameterModel.deleted_at.is_(None))+ .where(+ or_(+ AzureVaultCredentialParameterModel.key.ilike(search_like),+ AzureVaultCredentialParameterModel.description.ilike(search_like),+ )+ )+ ),+ # CredentialParameterModel+ exists(+ select(1)+ .select_from(CredentialParameterModel)+ .where(CredentialParameterModel.workflow_id == WorkflowModel.workflow_id)+ .where(CredentialParameterModel.deleted_at.is_(None))+ .where(+ or_(+ CredentialParameterModel.key.ilike(search_like),+ CredentialParameterModel.description.ilike(search_like),+ )+ )+ ),+ ]+ main_query = main_query.where(or_(title_like, folder_title_like, or_(*parameter_filters)))+ main_query = (+ main_query.order_by(WorkflowModel.created_at.desc()).limit(page_size).offset(db_page * page_size)+ )+ workflows = (await session.scalars(main_query)).all()+ template_permanent_ids: set[str] = set()+ if workflows and organization_id:+ template_permanent_ids = await self.get_org_template_permanent_ids(organization_id)++ return [+ convert_to_workflow(+ workflow,+ self.debug_enabled,+ is_template=workflow.workflow_permanent_id in template_permanent_ids,+ )+ for workflow in workflows+ ]++ @db_operation("update_workflow")+ async def update_workflow(+ self,+ workflow_id: str,+ organization_id: str | None = None,+ title: str | None = None,+ description: str | None = None,+ workflow_definition: dict[str, Any] | None = None,+ version: int | None = None,+ run_with: str | None = None,+ cache_key: str | None = None,+ status: str | None = None,+ import_error: str | None = None,+ ) -> Workflow:+ async with self.Session() as session:+ get_workflow_query = exclude_deleted(+ select(WorkflowModel).filter_by(workflow_id=workflow_id), WorkflowModel+ )+ if organization_id:+ get_workflow_query = get_workflow_query.filter_by(organization_id=organization_id)+ if workflow := (await session.scalars(get_workflow_query)).first():+ if title is not None:+ workflow.title = title+ if description is not None:+ workflow.description = description+ if workflow_definition is not None:+ workflow.workflow_definition = workflow_definition+ if version is not None:+ workflow.version = version+ if run_with is not None:+ workflow.run_with = run_with+ if cache_key is not None:+ workflow.cache_key = cache_key+ if status is not None:+ workflow.status = status+ if import_error is not None:+ workflow.import_error = import_error+ await session.commit()+ await session.refresh(workflow)+ is_template = (+ await self.is_workflow_template(+ workflow_permanent_id=workflow.workflow_permanent_id,+ organization_id=workflow.organization_id,+ )+ if organization_id+ else False+ )+ return convert_to_workflow(+ workflow,+ self.debug_enabled,+ is_template=is_template,+ )+ else:+ raise NotFoundError("Workflow not found")++ @db_operation("soft_delete_workflow_and_schedules_by_permanent_id")+ async def soft_delete_workflow_and_schedules_by_permanent_id(+ self,+ workflow_permanent_id: str,+ organization_id: str | None = None,+ ) -> list[str]:+ """Soft-delete a workflow and its active schedules in a single DB transaction."""+ async with self.Session() as session:+ select_query = (+ select(WorkflowScheduleModel.workflow_schedule_id)+ .where(WorkflowScheduleModel.workflow_permanent_id == workflow_permanent_id)+ .where(WorkflowScheduleModel.deleted_at.is_(None))+ )+ if organization_id is not None:+ select_query = select_query.where(WorkflowScheduleModel.organization_id == organization_id)+ result = await session.execute(select_query)+ schedule_ids = list(result.scalars().all())++ deleted_at = datetime.now(timezone.utc)+ if schedule_ids:+ update_schedules_query = (+ update(WorkflowScheduleModel)+ .where(WorkflowScheduleModel.workflow_schedule_id.in_(schedule_ids))+ .values(deleted_at=deleted_at)+ )+ await session.execute(update_schedules_query)++ update_workflow_query = (+ update(WorkflowModel)+ .where(WorkflowModel.workflow_permanent_id == workflow_permanent_id)+ .where(WorkflowModel.deleted_at.is_(None))+ )+ if organization_id is not None:+ update_workflow_query = update_workflow_query.filter_by(organization_id=organization_id)+ await session.execute(update_workflow_query.values(deleted_at=deleted_at))+ await session.commit()+ return schedule_ids++ @db_operation("add_workflow_template")+ async def add_workflow_template(+ self,+ workflow_permanent_id: str,+ organization_id: str,+ ) -> None:+ """Add a workflow to the templates table."""+ async with self.Session() as session:+ existing = (+ await session.scalars(+ select(WorkflowTemplateModel)+ .where(WorkflowTemplateModel.workflow_permanent_id == workflow_permanent_id)+ .where(WorkflowTemplateModel.organization_id == organization_id)+ )+ ).first()+ if existing:+ if existing.deleted_at is not None:+ existing.deleted_at = None+ await session.commit()+ return+ template = WorkflowTemplateModel(+ workflow_permanent_id=workflow_permanent_id,+ organization_id=organization_id,+ )+ session.add(template)+ await session.commit()++ @db_operation("remove_workflow_template")+ async def remove_workflow_template(+ self,+ workflow_permanent_id: str,+ organization_id: str,+ ) -> None:+ """Soft delete a workflow from the templates table."""+ async with self.Session() as session:+ update_deleted_at_query = (+ update(WorkflowTemplateModel)+ .where(WorkflowTemplateModel.workflow_permanent_id == workflow_permanent_id)+ .where(WorkflowTemplateModel.organization_id == organization_id)+ .where(WorkflowTemplateModel.deleted_at.is_(None))+ .values(deleted_at=datetime.now(timezone.utc))+ )+ await session.execute(update_deleted_at_query)+ await session.commit()++ @db_operation("get_org_template_permanent_ids")+ async def get_org_template_permanent_ids(+ self,+ organization_id: str,+ ) -> set[str]:+ """Get all workflow_permanent_ids that are templates for an organization."""+ async with self.Session() as session:+ result = await session.scalars(+ select(WorkflowTemplateModel.workflow_permanent_id)+ .where(WorkflowTemplateModel.organization_id == organization_id)+ .where(WorkflowTemplateModel.deleted_at.is_(None))+ )+ return set(result.all())++ @db_operation("is_workflow_template")+ async def is_workflow_template(+ self,+ workflow_permanent_id: str,+ organization_id: str,+ ) -> bool:+ """Check if a workflow is marked as a template."""+ async with self.Session() as session:+ result = (+ await session.scalars(+ select(WorkflowTemplateModel)+ .where(WorkflowTemplateModel.workflow_permanent_id == workflow_permanent_id)+ .where(WorkflowTemplateModel.organization_id == organization_id)+ .where(WorkflowTemplateModel.deleted_at.is_(None))+ )+ ).first()+ return result is not Nonediff --git a/tests/unit/forge/__init__.py b/tests/unit/forge/__init__.pynew file mode 100644index 000000000..e69de29bbdiff --git a/tests/unit/forge/sdk/__init__.py b/tests/unit/forge/sdk/__init__.pynew file mode 100644index 000000000..e69de29bbdiff --git a/tests/unit/forge/sdk/db/__init__.py b/tests/unit/forge/sdk/db/__init__.pynew file mode 100644index 000000000..e69de29bbdiff --git a/tests/unit/forge/sdk/db/test_base_repository.py b/tests/unit/forge/sdk/db/test_base_repository.pynew file mode 100644index 000000000..c7eaef2e8--- /dev/null+++ b/tests/unit/forge/sdk/db/test_base_repository.py@@ -0,0 +1,56 @@+from unittest.mock import MagicMock++from sqlalchemy.exc import OperationalError++from skyvern.forge.sdk.db.base_repository import BaseRepository+from skyvern.forge.sdk.db.protocols import RunReader, TaskReader, WorkflowParameterReader, WorkflowReader+from skyvern.forge.sdk.db.utils import serialize_proxy_location+from skyvern.schemas.runs import GeoTarget, ProxyLocation+++class TestSerializeProxyLocation:+ def test_none(self):+ assert serialize_proxy_location(None) is None++ def test_geo_target(self):+ geo = GeoTarget(country="US", state="CA")+ result = serialize_proxy_location(geo)+ assert result is not None+ assert "US" in result++ def test_enum(self):+ result = serialize_proxy_location(ProxyLocation.RESIDENTIAL)+ assert result == "RESIDENTIAL"+++class TestBaseRepository:+ def test_init_with_defaults(self):+ mock_session = MagicMock()+ repo = BaseRepository(session_factory=mock_session, debug_enabled=True)+ assert repo.Session is mock_session+ assert repo.debug_enabled is True++ def test_is_retryable_error_default(self):+ mock_session = MagicMock()+ repo = BaseRepository(session_factory=mock_session)+ error = OperationalError("statement", {}, Exception("server closed the connection unexpectedly"))+ assert repo.is_retryable_error(error) is False # default returns False++ def test_is_retryable_error_custom(self):+ mock_session = MagicMock()++ def custom_fn(e):+ return "closed" in str(e).lower()++ repo = BaseRepository(session_factory=mock_session, is_retryable_error_fn=custom_fn)+ error = OperationalError("statement", {}, Exception("server closed the connection"))+ assert repo.is_retryable_error(error) is True+++class TestProtocols:+ def test_protocols_importable(self):+ """Protocols should be importable and runtime-checkable."""+ assert TaskReader is not None+ assert WorkflowReader is not None+ assert WorkflowParameterReader is not None+ assert RunReader is not Nonediff --git a/tests/unit/forge/sdk/db/test_repositories.py b/tests/unit/forge/sdk/db/test_repositories.pynew file mode 100644index 000000000..840f881e4--- /dev/null+++ b/tests/unit/forge/sdk/db/test_repositories.py@@ -0,0 +1,238 @@+"""Tests for all 14 OSS repository instantiations + dependency injection."""++from unittest.mock import MagicMock, patch+++def test_credential_repository_instantiation():+ from skyvern.forge.sdk.db.repositories.credentials import CredentialRepository++ mock_session = MagicMock()+ repo = CredentialRepository(session_factory=mock_session, debug_enabled=False)+ assert repo.Session is mock_session+ assert hasattr(repo, "create_credential")+ assert hasattr(repo, "get_credential")+ assert hasattr(repo, "get_credentials")+ assert hasattr(repo, "update_credential")+ assert hasattr(repo, "delete_credential")+ assert hasattr(repo, "create_organization_bitwarden_collection")+ assert hasattr(repo, "get_organization_bitwarden_collection")+++def test_otp_repository_instantiation():+ from skyvern.forge.sdk.db.repositories.otp import OTPRepository++ mock_session = MagicMock()+ repo = OTPRepository(session_factory=mock_session, debug_enabled=False)+ assert repo.Session is mock_session+ assert hasattr(repo, "get_otp_codes")+ assert hasattr(repo, "create_otp_code")+++def test_debug_repository_instantiation():+ from skyvern.forge.sdk.db.repositories.debug import DebugRepository++ mock_session = MagicMock()+ repo = DebugRepository(session_factory=mock_session, debug_enabled=False)+ assert repo.Session is mock_session+ assert hasattr(repo, "get_debug_session")+ assert hasattr(repo, "create_debug_session")+ assert hasattr(repo, "create_block_run")+++def test_organizations_repository_instantiation():+ from skyvern.forge.sdk.db.repositories.organizations import OrganizationsRepository++ mock_session = MagicMock()+ repo = OrganizationsRepository(session_factory=mock_session, debug_enabled=False)+ assert repo.Session is mock_session+ assert hasattr(repo, "get_organization")+ assert hasattr(repo, "create_organization")+ assert hasattr(repo, "create_org_auth_token")+ assert hasattr(repo, "validate_org_auth_token")+++def test_schedules_repository_instantiation():+ from skyvern.forge.sdk.db.repositories.schedules import SchedulesRepository++ mock_session = MagicMock()+ repo = SchedulesRepository(session_factory=mock_session, debug_enabled=False)+ assert repo.Session is mock_session+ assert hasattr(repo, "create_workflow_schedule")+ assert hasattr(repo, "get_workflow_schedules")+++def test_scripts_repository_instantiation():+ from skyvern.forge.sdk.db.repositories.scripts import ScriptsRepository++ mock_session = MagicMock()+ repo = ScriptsRepository(session_factory=mock_session, debug_enabled=False)+ assert repo.Session is mock_session+ assert hasattr(repo, "create_script")+ assert hasattr(repo, "get_scripts")+++def test_workflow_parameters_repository_instantiation():+ from skyvern.forge.sdk.db.repositories.workflow_parameters import WorkflowParametersRepository++ mock_session = MagicMock()+ repo = WorkflowParametersRepository(session_factory=mock_session, debug_enabled=False)+ assert repo.Session is mock_session+ assert hasattr(repo, "get_workflow_parameter")+ assert hasattr(repo, "create_workflow_parameter")+++def test_tasks_repository_instantiation():+ from skyvern.forge.sdk.db.repositories.tasks import TasksRepository++ mock_session = MagicMock()+ repo = TasksRepository(session_factory=mock_session, debug_enabled=False)+ assert repo.Session is mock_session+ assert hasattr(repo, "create_task")+ assert hasattr(repo, "get_task")+ assert hasattr(repo, "create_step")+++def test_workflows_repository_instantiation():+ from skyvern.forge.sdk.db.repositories.workflows import WorkflowsRepository++ mock_session = MagicMock()+ repo = WorkflowsRepository(session_factory=mock_session, debug_enabled=False)+ assert repo.Session is mock_session+ assert hasattr(repo, "get_workflow")+ assert hasattr(repo, "create_workflow")+ assert hasattr(repo, "get_workflow_by_permanent_id")+++def test_browser_sessions_repository_instantiation():+ from skyvern.forge.sdk.db.repositories.browser_sessions import BrowserSessionsRepository++ mock_session = MagicMock()+ repo = BrowserSessionsRepository(session_factory=mock_session, debug_enabled=False)+ assert repo.Session is mock_session+ assert hasattr(repo, "create_browser_profile")+ assert hasattr(repo, "get_browser_profile")+++# ── Cross-dependency repositories ──+++def test_workflow_runs_repository_with_dependency():+ from skyvern.forge.sdk.db.repositories.workflow_runs import WorkflowRunsRepository++ mock_session = MagicMock()+ mock_param_reader = MagicMock()+ repo = WorkflowRunsRepository(+ session_factory=mock_session,+ debug_enabled=False,+ workflow_parameter_reader=mock_param_reader,+ )+ assert repo.Session is mock_session+ assert repo._workflow_parameter_reader is mock_param_reader+ assert hasattr(repo, "get_workflow_run_parameters")+ assert hasattr(repo, "create_workflow_run")+ assert hasattr(repo, "get_workflow_run")+++def test_artifacts_repository_with_dependency():+ from skyvern.forge.sdk.db.repositories.artifacts import ArtifactsRepository++ mock_session = MagicMock()+ mock_run_reader = MagicMock()+ repo = ArtifactsRepository(+ session_factory=mock_session,+ debug_enabled=False,+ run_reader=mock_run_reader,+ )+ assert repo.Session is mock_session+ assert repo._run_reader is mock_run_reader+ assert hasattr(repo, "create_artifact")+ assert hasattr(repo, "get_artifact")+++def test_folders_repository_with_dependency():+ from skyvern.forge.sdk.db.repositories.folders import FoldersRepository++ mock_session = MagicMock()+ mock_workflow_reader = MagicMock()+ repo = FoldersRepository(+ session_factory=mock_session,+ debug_enabled=False,+ workflow_reader=mock_workflow_reader,+ )+ assert repo.Session is mock_session+ assert repo._workflow_reader is mock_workflow_reader+ assert hasattr(repo, "create_folder")+ assert hasattr(repo, "update_workflow_folder")+++def test_observer_repository_with_dependency():+ from skyvern.forge.sdk.db.repositories.observer import ObserverRepository++ mock_session = MagicMock()+ mock_task_reader = MagicMock()+ repo = ObserverRepository(+ session_factory=mock_session,+ debug_enabled=False,+ task_reader=mock_task_reader,+ )+ assert repo.Session is mock_session+ assert repo._task_reader is mock_task_reader+ assert hasattr(repo, "create_workflow_run_block")+ assert hasattr(repo, "get_workflow_run_blocks")+++# ── AgentDB composition test ──+++def test_agent_db_has_typed_repo_attributes():+ """After refactoring, AgentDB should expose typed repository attributes."""+ from skyvern.forge.sdk.db.repositories.credentials import CredentialRepository+ from skyvern.forge.sdk.db.repositories.tasks import TasksRepository++ with patch("skyvern.forge.sdk.db.agent_db.create_async_engine"):+ from skyvern.forge.sdk.db.agent_db import AgentDB++ db = AgentDB("postgresql+asyncpg://test", debug_enabled=True)+ assert isinstance(db.tasks, TasksRepository)+ assert isinstance(db.credentials, CredentialRepository)+ assert hasattr(db, "get_task") # backward compat delegate+ assert hasattr(db, "create_workflow")+++def test_agent_db_delegates_route_to_repositories():+ """Verify delegate methods actually forward to the correct repository."""+ from unittest.mock import AsyncMock+ from unittest.mock import patch as mock_patch++ with mock_patch("skyvern.forge.sdk.db.agent_db.create_async_engine"):+ from skyvern.forge.sdk.db.agent_db import AgentDB++ db = AgentDB("postgresql+asyncpg://test", debug_enabled=False)++ # Patch a method on each major repository and verify the delegate calls it+ delegates_to_check = [+ ("get_task", "tasks"),+ ("create_workflow", "workflows"),+ ("create_artifact", "artifacts"),+ ("get_organization", "organizations"),+ ("get_credential", "credentials"),+ ("create_workflow_run", "workflow_runs"),+ ]++ import asyncio++ loop = asyncio.new_event_loop()+ try:+ for delegate_name, repo_attr in delegates_to_check:+ repo = getattr(db, repo_attr)+ mock_method = AsyncMock(return_value="sentinel")+ original = getattr(repo, delegate_name)+ setattr(repo, delegate_name, mock_method)+ try:+ result = loop.run_until_complete(getattr(db, delegate_name)("arg1", key="val"))+ mock_method.assert_called_once_with("arg1", key="val")+ assert result == "sentinel", f"Delegate {delegate_name} did not return repository result"+ finally:+ setattr(repo, delegate_name, original)+ finally:+ loop.close()diff --git a/tests/unit/test_agent_db_imports.py b/tests/unit/test_agent_db_imports.pyindex 653b830a8..f4256c38b 100644--- a/tests/unit/test_agent_db_imports.py+++ b/tests/unit/test_agent_db_imports.py@@ -5,13 +5,15 @@ Guards against:- Re-export contracts breaking (ScheduleLimitExceededError used by cloud/routes/)"""+from skyvern.forge.sdk.db.base_repository import BaseRepository+def test_agent_db_exports_schedule_limit_exceeded_error() -> None:"""ScheduleLimitExceededError must be importable from agent_db (re-export contract)."""from skyvern.forge.sdk.db.agent_db import ScheduleLimitExceededError- # Verify it's the canonical class, not a shadow- from skyvern.forge.sdk.db.mixins.schedules import ScheduleLimitExceededError as Original+ # Verify it's the canonical class from exceptions.py, not a shadow+ from skyvern.forge.sdk.db.exceptions import ScheduleLimitExceededError as Originalassert ScheduleLimitExceededError is Original@@ -23,30 +25,35 @@ def test_agent_db_exports_agent_db_class() -> None:assert AgentDB is not None-def test_all_mixins_in_agent_db_mro() -> None:- """All 14 domain mixins must appear in AgentDB's MRO.+def test_all_repositories_on_agent_db() -> None:+ """All 14 domain repositories must be present as typed attributes on AgentDB.- If someone re-introduces a late import for any mixin, this test- catches it because the mixin won't be in the class hierarchy.+ After the mixin-to-repository refactor, AgentDB uses composition instead+ of inheritance. This test verifies every domain repository is wired up+ by checking that __init__ assigns BaseRepository instances to each expected name."""from skyvern.forge.sdk.db.agent_db import AgentDB- mro_names = {cls.__name__ for cls in AgentDB.__mro__}- expected_mixins = [- "TasksMixin",- "WorkflowsMixin",- "WorkflowRunsMixin",- "WorkflowParametersMixin",- "SchedulesMixin",- "ArtifactsMixin",- "BrowserSessionsMixin",- "ScriptsMixin",- "OTPMixin",- "CredentialsMixin",- "FoldersMixin",- "OrganizationsMixin",- "ObserverMixin",- "DebugMixin",+ expected_repos = [+ "tasks",+ "workflows",+ "workflow_runs",+ "workflow_params",+ "schedules",+ "artifacts",+ "browser_sessions",+ "scripts",+ "otp",+ "credentials",+ "folders",+ "organizations",+ "observer",+ "debug",]- for name in expected_mixins:- assert name in mro_names, f"{name} missing from AgentDB MRO"+ # Instantiate with a dummy database string (sqlite in-memory)+ db = AgentDB("sqlite+aiosqlite:///", debug_enabled=False)+ for repo in expected_repos:+ assert hasattr(db, repo), f"Repository '{repo}' missing from AgentDB instance"+ assert isinstance(getattr(db, repo), BaseRepository), (+ f"AgentDB.{repo} should be a BaseRepository, got {type(getattr(db, repo))}"+ )diff --git a/tests/unit/test_db_operation_decorator.py b/tests/unit/test_db_operation_decorator.pyindex d571b6961..e039d80ff 100644--- a/tests/unit/test_db_operation_decorator.py+++ b/tests/unit/test_db_operation_decorator.py@@ -177,7 +177,7 @@ async def test_db_operation_log_errors_false_suppresses_logging() -> None:@pytest.mark.asyncioasync def test_db_operation_schedule_limit_exceeded_is_passthrough() -> None:"""ScheduleLimitExceededError should be treated as business logic, not unexpected."""- from skyvern.forge.sdk.db.mixins.schedules import ScheduleLimitExceededError+ from skyvern.forge.sdk.db.exceptions import ScheduleLimitExceededErrorclass ScheduleDB:@db_operation("create_schedule")