Skip to content

Automate browser based workflows with AI

fix(SKY-9294): clarify failure_reason for 1Password upstream failures (#5747)

Shuchang Zheng54ede67d745b
diff --git a/skyvern/exceptions.py b/skyvern/exceptions.py
index a0593eb05..fdacb613e 100644
--- a/skyvern/exceptions.py
+++ b/skyvern/exceptions.py
@@ -557,6 +557,36 @@ class BitwardenAccessDeniedError(BitwardenBaseError):
)
+class OnePasswordBaseError(SkyvernException):
+ def __init__(self, message: str) -> None:
+ super().__init__(f"1Password error: {message}")
+
+
+class OnePasswordServiceUnavailableError(OnePasswordBaseError):
+ def __init__(self, status_code: int | None = None) -> None:
+ suffix = f" (HTTP {status_code})" if status_code else ""
+ super().__init__(
+ f"1Password is currently unavailable{suffix}. "
+ "This is an upstream outage on 1Password's side, not a Skyvern issue. "
+ "Please retry in a few minutes."
+ )
+
+
+class OnePasswordRateLimitError(OnePasswordBaseError):
+ def __init__(self, message: str) -> None:
+ super().__init__(f"1Password rate limit exceeded: {message}. Please retry in a few minutes.")
+
+
+class OnePasswordSessionExpiredError(OnePasswordBaseError):
+ def __init__(self, message: str) -> None:
+ super().__init__(f"1Password service account session expired: {message}.")
+
+
+class OnePasswordGetItemError(OnePasswordBaseError):
+ def __init__(self, message: str) -> None:
+ super().__init__(f"Error getting item from 1Password: {message}")
+
+
class CredentialParameterParsingError(SkyvernException):
def __init__(self, message: str) -> None:
super().__init__(f"Error parsing credential parameter: {message}")
diff --git a/skyvern/forge/sdk/workflow/context_manager.py b/skyvern/forge/sdk/workflow/context_manager.py
index e7d735944..a1b55bbc9 100644
--- a/skyvern/forge/sdk/workflow/context_manager.py
+++ b/skyvern/forge/sdk/workflow/context_manager.py
@@ -1,4 +1,5 @@
import copy
+import re
from datetime import datetime, timezone
from typing import TYPE_CHECKING, Any, Awaitable, Callable, Self
@@ -6,6 +7,7 @@ import structlog
from jinja2.sandbox import SandboxedEnvironment
from onepassword import ItemFieldType
from onepassword.client import Client as OnePasswordClient
+from onepassword.errors import DesktopSessionExpiredException, RateLimitExceededException
from skyvern.config import settings
from skyvern.exceptions import (
@@ -14,6 +16,10 @@ from skyvern.exceptions import (
CredentialParameterNotFoundError,
CredentialVaultNotConfiguredError,
ImaginarySecretValue,
+ OnePasswordGetItemError,
+ OnePasswordRateLimitError,
+ OnePasswordServiceUnavailableError,
+ OnePasswordSessionExpiredError,
SkyvernException,
WorkflowRunContextNotInitialized,
sanitize_credential_for_error,
@@ -60,6 +66,15 @@ jinja_sandbox_env = SandboxedEnvironment()
RANDOM_SECRET_ID_PREFIX = "placeholder_"
+# 1Password's Python SDK forwards generic 5xx upstream failures as plain Exceptions
+# whose stringified message embeds the HTTP status.
+_ONEPASSWORD_5XX_PATTERN = re.compile(
+ r"(?i)"
+ r"(?:\b(?:HTTP|status(?:\s+code)?|code|response)\s*[:=]?\s*(5\d{2})\b)"
+ r"|"
+ r"(?:\b(5\d{2})\s+(?:service\s+unavailable|bad\s+gateway|gateway\s+timeout|internal\s+server\s+error)\b)"
+)
+
class WorkflowRunContext:
@classmethod
@@ -667,14 +682,26 @@ class WorkflowRunContext:
"OP_SERVICE_ACCOUNT_TOKEN environment variable not set and no valid 1Password service account token found. Please go to the settings and add your 1Password service account token."
)
- client = await OnePasswordClient.authenticate(
- auth=token,
- integration_name="Skyvern",
- integration_version="v1.0.0",
- )
item_id = self._resolve_required_parameter_value(parameter.item_id, "OnePassword Item ID")
vault_id = self._resolve_required_parameter_value(parameter.vault_id, "OnePassword Vault ID")
- item = await client.items.get(vault_id, item_id)
+ try:
+ client = await OnePasswordClient.authenticate(
+ auth=token,
+ integration_name="Skyvern",
+ integration_version="v1.0.0",
+ )
+ item = await client.items.get(vault_id, item_id)
+ except RateLimitExceededException as e:
+ raise OnePasswordRateLimitError(str(e)) from e
+ except DesktopSessionExpiredException as e:
+ raise OnePasswordSessionExpiredError(str(e)) from e
+ except Exception as e:
+ raw = str(e)
+ match = _ONEPASSWORD_5XX_PATTERN.search(raw)
+ if match:
+ status_digits = match.group(1) or match.group(2)
+ raise OnePasswordServiceUnavailableError(status_code=int(status_digits)) from e
+ raise OnePasswordGetItemError(raw) from e
# Check if item is None
if item is None:
diff --git a/tests/unit/test_workflow_onepassword_errors.py b/tests/unit/test_workflow_onepassword_errors.py
new file mode 100644
index 000000000..86bab61f8
--- /dev/null
+++ b/tests/unit/test_workflow_onepassword_errors.py
@@ -0,0 +1,184 @@
+"""Tests for SKY-9294: 1Password failures must surface a clear, user-facing failure_reason
+that names 1Password as the failing dependency rather than leaking the raw SDK error.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from onepassword.errors import DesktopSessionExpiredException, RateLimitExceededException
+
+from skyvern.exceptions import (
+ OnePasswordGetItemError,
+ OnePasswordRateLimitError,
+ OnePasswordServiceUnavailableError,
+ OnePasswordSessionExpiredError,
+)
+from skyvern.forge import app as forge_app
+from skyvern.forge.sdk.workflow.context_manager import WorkflowRunContext
+from skyvern.forge.sdk.workflow.models.parameter import OnePasswordCredentialParameter
+
+
+def _make_context() -> WorkflowRunContext:
+ return WorkflowRunContext(
+ workflow_title="wf-title",
+ workflow_id="wf-id",
+ workflow_permanent_id="wf-perm-id",
+ workflow_run_id="wf-run-id",
+ aws_client=MagicMock(),
+ )
+
+
+def _make_parameter() -> OnePasswordCredentialParameter:
+ now = datetime.now(timezone.utc)
+ return OnePasswordCredentialParameter(
+ key="op_cred",
+ onepassword_credential_parameter_id="opcp_test",
+ workflow_id="wf-id",
+ vault_id="vault123",
+ item_id="item123",
+ created_at=now,
+ modified_at=now,
+ )
+
+
+def _make_organization() -> MagicMock:
+ org = MagicMock()
+ org.organization_id = "o_test"
+ return org
+
+
+def mocked_app_database():
+ """Patch app.DATABASE so org-auth-token lookup returns None (forcing fallback to settings token)."""
+ original = getattr(forge_app, "DATABASE", None)
+ forge_app.DATABASE = MagicMock()
+ forge_app.DATABASE.organizations.get_valid_org_auth_token = AsyncMock(return_value=None)
+ yield forge_app.DATABASE
+ if original is None:
+ del forge_app.DATABASE
+ else:
+ forge_app.DATABASE = original
+
+
+def patched_settings_token(monkeypatch):
+ monkeypatch.setattr("skyvern.forge.sdk.workflow.context_manager.settings.OP_SERVICE_ACCOUNT_TOKEN", "fake-token")
+
+
+async def test_onepassword_503_surfaces_service_unavailable_error(mocked_app_database, patched_settings_token):
+ ctx = _make_context()
+ with patch(
+ "skyvern.forge.sdk.workflow.context_manager.OnePasswordClient.authenticate",
+ new_callable=AsyncMock,
+ side_effect=Exception("Server error: 503 Service Unavailable"),
+ ):
+ with pytest.raises(OnePasswordServiceUnavailableError) as exc_info:
+ await ctx.register_onepassword_credential_parameter_value(_make_parameter(), _make_organization())
+
+ message = exc_info.value.message
+ assert "1Password is currently unavailable" in message
+ assert "503" in message
+ assert "upstream outage" in message
+
+
+async def test_onepassword_503_from_items_get_surfaces_service_unavailable_error(
+ mocked_app_database, patched_settings_token
+):
+ ctx = _make_context()
+ fake_client = MagicMock()
+ fake_client.items.get = AsyncMock(side_effect=Exception("upstream returned 502 bad gateway"))
+ with patch(
+ "skyvern.forge.sdk.workflow.context_manager.OnePasswordClient.authenticate",
+ new_callable=AsyncMock,
+ return_value=fake_client,
+ ):
+ with pytest.raises(OnePasswordServiceUnavailableError) as exc_info:
+ await ctx.register_onepassword_credential_parameter_value(_make_parameter(), _make_organization())
+
+ assert "502" in exc_info.value.message
+
+
+async def test_onepassword_rate_limit_maps_to_typed_error(mocked_app_database, patched_settings_token):
+ ctx = _make_context()
+ with patch(
+ "skyvern.forge.sdk.workflow.context_manager.OnePasswordClient.authenticate",
+ new_callable=AsyncMock,
+ side_effect=RateLimitExceededException("rate limit hit"),
+ ):
+ with pytest.raises(OnePasswordRateLimitError) as exc_info:
+ await ctx.register_onepassword_credential_parameter_value(_make_parameter(), _make_organization())
+
+ assert "rate limit" in exc_info.value.message.lower()
+ assert "rate limit hit" in exc_info.value.message
+
+
+async def test_onepassword_session_expired_maps_to_typed_error(mocked_app_database, patched_settings_token):
+ ctx = _make_context()
+ with patch(
+ "skyvern.forge.sdk.workflow.context_manager.OnePasswordClient.authenticate",
+ new_callable=AsyncMock,
+ side_effect=DesktopSessionExpiredException("session expired"),
+ ):
+ with pytest.raises(OnePasswordSessionExpiredError) as exc_info:
+ await ctx.register_onepassword_credential_parameter_value(_make_parameter(), _make_organization())
+
+ assert "session expired" in exc_info.value.message
+ assert "1Password" in exc_info.value.message
+
+
+async def test_onepassword_generic_error_falls_back_to_get_item_error(mocked_app_database, patched_settings_token):
+ ctx = _make_context()
+ with patch(
+ "skyvern.forge.sdk.workflow.context_manager.OnePasswordClient.authenticate",
+ new_callable=AsyncMock,
+ side_effect=Exception("something weird happened"),
+ ):
+ with pytest.raises(OnePasswordGetItemError) as exc_info:
+ await ctx.register_onepassword_credential_parameter_value(_make_parameter(), _make_organization())
+
+ assert "something weird happened" in exc_info.value.message
+ assert "1Password" in exc_info.value.message
+
+
+async def test_onepassword_incidental_5xx_digits_do_not_trigger_service_unavailable(
+ mocked_app_database, patched_settings_token
+):
+ """Numbers like '500' that appear in error messages without HTTP/status context must not be
+ misclassified as service-unavailable. False-positives would mislead users into retrying a
+ permanent failure as if it were a transient outage."""
+ ctx = _make_context()
+ with patch(
+ "skyvern.forge.sdk.workflow.context_manager.OnePasswordClient.authenticate",
+ new_callable=AsyncMock,
+ side_effect=Exception("vault has 500 items, exceeded soft limit"),
+ ):
+ with pytest.raises(OnePasswordGetItemError) as exc_info:
+ await ctx.register_onepassword_credential_parameter_value(_make_parameter(), _make_organization())
+
+ assert "exceeded soft limit" in exc_info.value.message
+
+
+async def test_onepassword_status_keyword_5xx_classified_as_service_unavailable(
+ mocked_app_database, patched_settings_token
+):
+ """A 5xx digit paired with a status keyword (HTTP/status/code) must be classified."""
+ ctx = _make_context()
+ with patch(
+ "skyvern.forge.sdk.workflow.context_manager.OnePasswordClient.authenticate",
+ new_callable=AsyncMock,
+ side_effect=Exception("request failed with status: 504"),
+ ):
+ with pytest.raises(OnePasswordServiceUnavailableError) as exc_info:
+ await ctx.register_onepassword_credential_parameter_value(_make_parameter(), _make_organization())
+
+ assert "504" in exc_info.value.message