Skip to content

Automate browser based workflows with AI

SKY-13202 Let the copilot see connected Google and Microsoft accounts (#7871)

Andrew Neilsone197cc97a2a1
diff --git a/pyproject.toml b/pyproject.toml
index 2158107cd..f65e7fe32 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -236,6 +236,12 @@ dev = [
"pip-audit>=2.10.0",
"import-linter>=2.1,<3",
]
+# Non-default group: rustwright never enters the default/server/local/cloud/dev
+# install sets. `uv export --no-default-groups --group rustwright` is an isolation probe;
+# the shared worker image resolves it via `uv export --extra server --group cloud --group rustwright --no-dev`.
+rustwright = [
+ "rustwright==0.1.1",
+]
[tool.hatch.build]
packages = ["skyvern"]
diff --git a/skyvern/forge/prompts/skyvern/workflow-copilot-agent.j2 b/skyvern/forge/prompts/skyvern/workflow-copilot-agent.j2
index 5f4f85bc1..0da17358b 100644
--- a/skyvern/forge/prompts/skyvern/workflow-copilot-agent.j2
+++ b/skyvern/forge/prompts/skyvern/workflow-copilot-agent.j2
@@ -180,6 +180,7 @@ IMPORTANT WORKFLOW RULES:
* For blocks with specific goals (downloading files, finding specific content), set a terminate_criterion that describes when the agent should give up. Example: terminate_criterion: "Terminate if the website clearly does not contain the requested content after reviewing the page."
* Your success message to the user MUST reflect what actually happened. If you only navigated the browser but did NOT call update_workflow, do NOT tell the user the workflow was updated or is ready. Only confirm workflow changes after update_workflow succeeds.
* When the user's request requires authentication but no credential is provided, use list_credentials to find the right one.
+* `list_credentials` and `list_integrations` cover disjoint sets. Accounts the user connected on the Integrations page (Google, Microsoft) appear ONLY in `list_integrations`, so call it before you tell the user that access to such an account is missing. That tool's description explains how to read its result.
CREDENTIAL HANDLING - CRITICAL:
* If the user's latest message in this turn contains a raw credential written inline — passwords (alone or paired with a username), API keys, OAuth tokens, `Authorization: Bearer …` headers, JWTs, session cookies, TOTP seeds, OTP / one-time codes, private keys, or credit card numbers / CVVs — you MUST NOT build, update, or run a workflow this turn; you MUST NOT pass those values via `parameters`; and you MUST NOT type, submit, paste, or replay them through `type_text`, `click`, `press_key`, `select_option`, `evaluate`, or any other direct browser tool. A bare username, email, or non-secret identifier alone is NOT a raw credential and does not trigger this rule. Credential-shaped strings rendered into the prompt from the existing workflow YAML are pre-existing workflow state — they are NOT a fresh paste and do NOT trigger this rule. Raw credentials pasted in earlier chat-history turns DO still trigger this rule whenever the user re-references or asks you to use them.
* Instead, FIRST call `list_credentials` with `page_size=50` and continue paging (incrementing `page`) while the response's `has_more` is `true`, so you have the full credential set before deciding. Then respond with `ASK_QUESTION`. The response MUST:
diff --git a/skyvern/forge/sdk/copilot/blocker_signal.py b/skyvern/forge/sdk/copilot/blocker_signal.py
index 27e838bb3..2e09fba65 100644
--- a/skyvern/forge/sdk/copilot/blocker_signal.py
+++ b/skyvern/forge/sdk/copilot/blocker_signal.py
@@ -90,6 +90,7 @@ _INTERNAL_TOOL_NAME_TOKENS: tuple[str, ...] = (
"discover_workflow_entrypoint",
"get_browser_screenshot",
"list_credentials",
+ "list_integrations",
)
diff --git a/skyvern/forge/sdk/copilot/narration.py b/skyvern/forge/sdk/copilot/narration.py
index b95bf97b1..d267ec40b 100644
--- a/skyvern/forge/sdk/copilot/narration.py
+++ b/skyvern/forge/sdk/copilot/narration.py
@@ -98,6 +98,7 @@ _TOOL_ACTIVITY_DISPLAY_LABELS = {
"press_key": "Interacting with page",
"navigate_browser": "Opening page",
"get_block_schema": "Checking workflow block options",
+ "list_integrations": "Checking connected integrations",
"inspect_current_workflow": "Inspecting workflow",
"discover_workflow_entrypoint": "Finding the entry page",
"inspect_page_for_composition": "Inspecting the page",
@@ -632,6 +633,7 @@ _USER_FACING_TOOL_LABELS: dict[str, str] = {
"evaluate": "inspecting the page",
"console_messages": "checking the browser console",
"list_credentials": "checking saved credentials",
+ "list_integrations": "checking connected integrations",
"get_block_schema": "looking up workflow block options",
"validate_block": "checking workflow block configuration",
"get_run_results": "checking results of a prior run",
diff --git a/skyvern/forge/sdk/copilot/output_utils.py b/skyvern/forge/sdk/copilot/output_utils.py
index 6cf9dc33f..f2881df7e 100644
--- a/skyvern/forge/sdk/copilot/output_utils.py
+++ b/skyvern/forge/sdk/copilot/output_utils.py
@@ -554,6 +554,8 @@ def summarize_tool_result(tool_name: str, result: dict[str, Any], *, for_display
return "Updated the workflow and ran it"
if tool_name == "list_credentials":
return f"Found {data.get('count', 0)} credential(s)"
+ if tool_name == "list_integrations":
+ return f"Found {data.get('count', 0)} connected integration(s)"
if tool_name == "get_block_schema":
if "block_types" in data:
return f"Listed {data.get('count', '?')} block types"
diff --git a/skyvern/forge/sdk/copilot/tools/__init__.py b/skyvern/forge/sdk/copilot/tools/__init__.py
index 21553d5b4..f7bf879f9 100644
--- a/skyvern/forge/sdk/copilot/tools/__init__.py
+++ b/skyvern/forge/sdk/copilot/tools/__init__.py
@@ -154,6 +154,9 @@ from .guardrails import (
_request_policy_allows_update_and_skip_run,
)
from .guardrails import _turn_intent_tool_error as _turn_intent_tool_error
+from .integrations import (
+ _list_integrations,
+)
from .mcp_hooks import _build_skyvern_mcp_overlays as _build_skyvern_mcp_overlays
from .mcp_hooks import _click_post_hook as _click_post_hook
from .mcp_hooks import _click_pre_hook as _click_pre_hook
@@ -515,6 +518,42 @@ async def list_credentials_tool(
return json.dumps(sanitized)
+@function_tool(name_override="list_integrations")
+async def list_integrations_tool(ctx: RunContextWrapper) -> str:
+ """List the organization's connected Google and Microsoft accounts (metadata only —
+ never tokens). Each entry has `connection_id`, `provider`, `name`, `state`, and
+ `scopes_granted`.
+
+ These are OAuth connections made on the Integrations page, NOT the stored
+ login credentials returned by `list_credentials` — the two lists are disjoint,
+ so check this one before concluding the user has no Google or Microsoft access.
+ Blocks such as `google_sheets_write` take a `connection_id` from here directly
+ as their credential field. Not paginated; one call returns every connection.
+
+ Match on `scopes_granted`, not on `provider` alone: connections are granted per
+ product, so a Sheets connection cannot read Gmail and binding it to a mail block
+ fails at run time. Only a connection whose `state` is `active` can be used — an
+ expired grant stays listed so you can ask the user to reconnect that account
+ rather than tell them nothing is connected.
+ """
+ copilot_ctx = ctx.context
+ arguments: dict[str, Any] = {}
+ loop_error = _tool_loop_error(copilot_ctx, "list_integrations", arguments)
+ if loop_error:
+ return json.dumps({"ok": False, "error": loop_error})
+
+ authority_error = _authority_tool_error(copilot_ctx, "list_integrations")
+ if authority_error:
+ result = {"ok": False, "error": authority_error}
+ record_tool_step_result_for_ctx(copilot_ctx, "list_integrations", arguments, result)
+ return json.dumps(result)
+
+ result = await _list_integrations(arguments, copilot_ctx)
+ record_tool_step_result_for_ctx(copilot_ctx, "list_integrations", arguments, result)
+ sanitized = sanitize_tool_result_for_llm("list_integrations", result)
+ return json.dumps(sanitized)
+
+
@function_tool(
name_override="run_blocks_and_collect_debug",
timeout=RUN_BLOCKS_SAFETY_CEILING_SECONDS,
@@ -1014,6 +1053,7 @@ NATIVE_TOOLS = [
delete_block_tool,
synthesize_demonstrated_block_tool,
list_credentials_tool,
+ list_integrations_tool,
run_blocks_tool,
get_run_results_tool,
update_and_run_blocks_tool,
diff --git a/skyvern/forge/sdk/copilot/tools/integrations.py b/skyvern/forge/sdk/copilot/tools/integrations.py
new file mode 100644
index 000000000..35d570939
--- /dev/null
+++ b/skyvern/forge/sdk/copilot/tools/integrations.py
@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import Any
+
+from skyvern.forge.sdk.copilot.runtime import AgentContext
+from skyvern.forge.sdk.schemas.google_oauth import GoogleOAuthCredentialBase
+from skyvern.forge.sdk.schemas.microsoft_oauth import MicrosoftOAuthCredentialBase
+from skyvern.forge.sdk.services import google_oauth_service, microsoft_oauth_service
+
+
+def _serialize(
+ credential: GoogleOAuthCredentialBase | MicrosoftOAuthCredentialBase,
+ provider: str,
+) -> dict[str, Any]:
+ # Allowlist rather than a model dump: both source models are token-free today,
+ # so a dump would start leaking the day either one gains a token field.
+ return {
+ "connection_id": credential.id,
+ "provider": provider,
+ "name": credential.credential_name,
+ "state": credential.state,
+ "scopes_granted": list(credential.scopes_granted),
+ }
+
+
+async def _list_integrations(params: dict[str, Any], ctx: AgentContext) -> dict[str, Any]:
+ # Each provider is read through whatever its own Integrations page shows, so a connection the
+ # user can see is never reported as absent. Google surfaces expired grants as state=error;
+ # Microsoft has no such listing, so active is all it can offer.
+ google_credentials = await google_oauth_service.get_visible_credentials_for_org(ctx.organization_id)
+ microsoft_credentials = await microsoft_oauth_service.get_credentials_for_org(ctx.organization_id)
+ integrations = [_serialize(credential, "google") for credential in google_credentials] + [
+ _serialize(credential, "microsoft") for credential in microsoft_credentials
+ ]
+ return {
+ "ok": True,
+ "data": {
+ "integrations": integrations,
+ "count": len(integrations),
+ },
+ }
diff --git a/tests/unit/test_browser_engine.py b/tests/unit/test_browser_engine.py
index b7b08fa4a..938075518 100644
--- a/tests/unit/test_browser_engine.py
+++ b/tests/unit/test_browser_engine.py
@@ -2,16 +2,21 @@
These tests stay driver-agnostic: they exercise the registry, per-run selection, capability gate,
and exception-identity classification with fake engine specs, so they hold on an image that ships
-only stock Playwright. Cloud-only concerns (the cloud-private engine, the multivariate flag) are
-left to the cloud wiring slice that introduces them.
+only stock Playwright. The rustwright cases simulate the driver package's presence or absence
+explicitly, so they assert behaviour and capability, never whether the optional group is installed.
+Cloud-only concerns (the cloud-private engine, the multivariate flag) are left to the cloud wiring
+slice that introduces them.
"""
from __future__ import annotations
import asyncio
+import contextlib
import dataclasses
import re
+import subprocess
import sys
+import types
from pathlib import Path
import pytest
@@ -95,6 +100,74 @@ def _restore_resolver():
browser_engine.reset_browser_engine_resolver()
+_RUSTWRIGHT_DRIVER_MODULES = ("rustwright", "rustwright.async_api")
+
+
+class _RustwrightImportBlocker:
+ """Meta-path finder that fails every ``rustwright`` import with the same ModuleNotFoundError an
+ image without the wheel raises, so the fail-closed-when-absent contract is verified deterministically
+ instead of relying on the ambient environment lacking the package."""
+
+ def find_spec(self, fullname, path=None, target=None):
+ if fullname == "rustwright" or fullname.startswith("rustwright."):
+ raise ModuleNotFoundError(f"No module named {fullname!r}", name="rustwright")
+ return None
+
+
+def _rustwright_driver_absent():
+ saved = {name: sys.modules.get(name) for name in _RUSTWRIGHT_DRIVER_MODULES}
+ for name in _RUSTWRIGHT_DRIVER_MODULES:
+ sys.modules.pop(name, None)
+ blocker = _RustwrightImportBlocker()
+ sys.meta_path.insert(0, blocker)
+ try:
+ yield
+ finally:
+ sys.meta_path.remove(blocker)
+ for name, module in saved.items():
+ if module is not None:
+ sys.modules[name] = module
+
+
+def _rustwright_driver_present():
+ """Make ``rustwright.async_api`` importable with the exact public surface the OSS module binds
+ (``Error`` / ``TimeoutError`` / ``TargetClosedError`` in the hierarchy the real wheel documents), so
+ the group-installed behaviour is exercised without depending on a real install of the PyO3 wheel."""
+ saved = {name: sys.modules.get(name) for name in _RUSTWRIGHT_DRIVER_MODULES}
+ package = types.ModuleType("rustwright")
+ async_api = types.ModuleType("rustwright.async_api")
+
+ class Error(Exception):
+ pass
+
+ class TimeoutError(Error):
+ pass
+
+ class TargetClosedError(Error):
+ pass
+
+ async def async_playwright(): # pragma: no cover - a selection never starts the driver here
+ raise AssertionError("the rustwright driver must not be started in these tests")
+
+ async_api.Error = Error
+ async_api.TimeoutError = TimeoutError
+ async_api.TargetClosedError = TargetClosedError
+ async_api.async_playwright = async_playwright
+ package.async_api = async_api
+ sys.modules["rustwright"] = package
+ sys.modules["rustwright.async_api"] = async_api
+ try:
+ yield
+ finally:
+ for name, module in saved.items():
+ if module is None:
+ sys.modules.pop(name, None)
+ else:
+ sys.modules[name] = module
+
+
def test_registry_has_stock_and_rustwright_and_rejects_unknown():
names = browser_engine.REGISTRY.names()
assert STOCK_ENGINE_NAME in names
@@ -129,31 +202,61 @@ def test_stock_spec_selects_with_playwright_identity():
def test_rustwright_spec_fails_closed_when_driver_absent():
- # rustwright is not installed in the OSS test image: selecting it must fail closed, never fall back.
+ # With the driver package absent, selecting rustwright must fail closed, never fall back. Absence is
+ # forced here rather than read from the environment, so the contract holds even where the optional
+ # group is installed.
spec = browser_engine.REGISTRY.get(browser_engine.RUSTWRIGHT_ENGINE_NAME)
- assert spec.is_installed() is False
- with pytest.raises(browser_engine.BrowserEngineUnavailable):
- spec.select(selection_reason="explicit-rustwright")
+ with _rustwright_driver_absent():
+ assert spec.is_installed() is False
+ with pytest.raises(browser_engine.BrowserEngineUnavailable):
+ spec.select(selection_reason="explicit-rustwright")
-def test_rustwright_spec_has_rich_error_loader_wired_and_lazy():
- # Every candidate engine (not just stock) binds the richer families: the rustwright spec carries a
- # rich loader. It must stay lazy — importing this module registered the spec without importing the
- # (absent) rustwright package, so the loader is only invoked at select().
+def test_rustwright_spec_has_rich_error_loader_wired_and_stays_lazy():
+ # The rustwright spec carries the rich loader by reference, and registering it never imports the
+ # driver. Laziness is probed in a fresh subprocess so it holds whether or not the wheel is installed,
+ # instead of asserting about this process's already-populated sys.modules.
spec = browser_engine.REGISTRY.get(browser_engine.RUSTWRIGHT_ENGINE_NAME)
assert spec._load_rich_error_types is browser_engine._rustwright_rich_error_types
- assert "rustwright" not in sys.modules # registering the spec never imported the driver
+ probe = subprocess.run(
+ [
+ sys.executable,
+ "-c",
+ "import sys, skyvern.webeye.browser_engine; "
+ "print(any(m == 'rustwright' or m.startswith('rustwright.') for m in sys.modules))",
+ ],
+ capture_output=True,
+ text=True,
+ check=True,
+ )
+ assert probe.stdout.strip() == "False", probe.stdout + probe.stderr
def test_rustwright_rich_loader_imports_the_real_driver_and_fails_closed_when_absent():
# The rich loader binds the REAL native identity (a lazy ``from rustwright.async_api import
# TargetClosedError``), not a stub: with the package absent it raises ModuleNotFoundError naming
# the driver, and select() surfaces that as BrowserEngineUnavailable (never silent empty families).
- with pytest.raises(ModuleNotFoundError) as excinfo:
- browser_engine._rustwright_rich_error_types()
- assert excinfo.value.name == "rustwright"
- with pytest.raises(browser_engine.BrowserEngineUnavailable):
- browser_engine.RUSTWRIGHT_SPEC.select(selection_reason="explicit-rustwright")
+ with _rustwright_driver_absent():
+ with pytest.raises(ModuleNotFoundError) as excinfo:
+ browser_engine._rustwright_rich_error_types()
+ assert excinfo.value.name == "rustwright"
+ with pytest.raises(browser_engine.BrowserEngineUnavailable):
+ browser_engine.RUSTWRIGHT_SPEC.select(selection_reason="explicit-rustwright")
+
+
+def test_installing_rustwright_group_keeps_it_deny_all_not_selectable():
+ # The blocker this guards: merely installing the optional rustwright group must not make the engine
+ # selectable. With the driver importable, select() succeeds (no BrowserEngineUnavailable), but the
+ # selection stays deny-all — every source, attributed or not, is rejected before any provisioning —
+ # so installing the wheel never turns rustwright into a routable engine.
+ spec = browser_engine.REGISTRY.get(browser_engine.RUSTWRIGHT_ENGINE_NAME)
+ with _rustwright_driver_present():
+ assert spec.is_installed() is True
+ selection = spec.select(selection_reason="explicit-rustwright")
+ assert selection.metadata.allowed_browser_sources == frozenset()
+ for source in ("chromium-headful", "cdp-connect", None):
+ with pytest.raises(BrowserSourceNotSupportedByEngine):
+ selection.ensure_supports(source)
# Representative neutral source strings (not a canonical source registry — that belongs to the cloud
@@ -254,6 +357,14 @@ async def test_default_resolver_is_stock_playwright():
assert sel.name == STOCK_ENGINE_NAME
+async def test_default_resolver_stays_stock_even_when_rustwright_installed():
+ # Installing the optional group must not shift the OSS default runtime selection.
+ with _rustwright_driver_present():
+ sel = await resolve_browser_engine(BrowserEngineContext(browser_source="local-browser"))
+ assert sel.name == STOCK_ENGINE_NAME
+
+
@pytest.mark.asyncio
async def test_unknown_engine_selection_fails_closed():
browser_engine.set_browser_engine_resolver(
diff --git a/tests/unit/test_copilot_tools_list_integrations.py b/tests/unit/test_copilot_tools_list_integrations.py
new file mode 100644
index 000000000..8e0c81e99
--- /dev/null
+++ b/tests/unit/test_copilot_tools_list_integrations.py
@@ -0,0 +1,142 @@
+from datetime import datetime
+from types import SimpleNamespace
+
+import pytest
+
+from skyvern.forge.sdk.copilot.tools.integrations import _list_integrations, _serialize
+from skyvern.forge.sdk.schemas.google_oauth import GoogleOAuthCredentialBase
+from skyvern.forge.sdk.schemas.microsoft_oauth import MicrosoftOAuthCredentialBase
+from tests.unit.conftest import render_agent_prompt
+
+ORGANIZATION_ID = "o_test_org"
+
+TOKEN_FIELD_NAMES = (
+ "access_token",
+ "refresh_token",
+ "token",
+ "client_secret",
+ "secret",
+ "id_token",
+ "encrypted_refresh_token",
+)
+
+
+def _google(**overrides: object) -> GoogleOAuthCredentialBase:
+ defaults = {
+ "id": "goac_1",
+ "organization_id": ORGANIZATION_ID,
+ "credential_name": "Sheets account",
+ "state": "active",
+ "scopes_requested": ["https://www.googleapis.com/auth/spreadsheets"],
+ "scopes_granted": ["https://www.googleapis.com/auth/spreadsheets"],
+ "created_at": datetime(2026, 6, 19),
+ "modified_at": datetime(2026, 6, 19),
+ }
+ return GoogleOAuthCredentialBase(**{**defaults, **overrides})
+
+
+def _microsoft(**overrides: object) -> MicrosoftOAuthCredentialBase:
+ defaults = {
+ "id": "msoac_1",
+ "organization_id": ORGANIZATION_ID,
+ "credential_name": "Outlook account",
+ "state": "active",
+ "scopes_requested": ["Mail.Send"],
+ "scopes_granted": ["Mail.Send"],
+ "created_at": datetime(2026, 6, 19),
+ "modified_at": datetime(2026, 6, 19),
+ }
+ return MicrosoftOAuthCredentialBase(**{**defaults, **overrides})
+
+
+def patched_services(monkeypatch: pytest.MonkeyPatch):
+ def _apply(google: list[GoogleOAuthCredentialBase], microsoft: list[MicrosoftOAuthCredentialBase]) -> None:
+ async def fake_google(organization_id: str) -> list[GoogleOAuthCredentialBase]:
+ assert organization_id == ORGANIZATION_ID
+ return google
+
+ async def fake_microsoft(organization_id: str) -> list[MicrosoftOAuthCredentialBase]:
+ assert organization_id == ORGANIZATION_ID
+ return microsoft
+
+ monkeypatch.setattr(
+ "skyvern.forge.sdk.copilot.tools.integrations.google_oauth_service.get_visible_credentials_for_org",
+ fake_google,
+ )
+ monkeypatch.setattr(
+ "skyvern.forge.sdk.copilot.tools.integrations.microsoft_oauth_service.get_credentials_for_org",
+ fake_microsoft,
+ )
+
+ return _apply
+
+
+async def test_lists_both_providers_with_the_fields_the_agent_needs(patched_services) -> None:
+ patched_services([_google()], [_microsoft()])
+ ctx = SimpleNamespace(organization_id=ORGANIZATION_ID)
+
+ result = await _list_integrations({}, ctx)
+
+ assert result["ok"] is True
+ assert result["data"]["count"] == 2
+ google_entry, microsoft_entry = result["data"]["integrations"]
+ assert google_entry == {
+ "connection_id": "goac_1",
+ "provider": "google",
+ "name": "Sheets account",
+ "state": "active",
+ "scopes_granted": ["https://www.googleapis.com/auth/spreadsheets"],
+ }
+ assert microsoft_entry == {
+ "connection_id": "msoac_1",
+ "provider": "microsoft",
+ "name": "Outlook account",
+ "state": "active",
+ "scopes_granted": ["Mail.Send"],
+ }
+
+
+async def test_reports_no_integrations_without_erroring(patched_services) -> None:
+ patched_services([], [])
+ ctx = SimpleNamespace(organization_id=ORGANIZATION_ID)
+
+ result = await _list_integrations({}, ctx)
+
+ assert result["ok"] is True
+ assert result["data"] == {"integrations": [], "count": 0}
+
+
+def test_serializer_is_an_allowlist_so_a_new_token_field_cannot_leak() -> None:
+ leaky_google = SimpleNamespace(
+ id="goac_1",
+ credential_name="Sheets account",
+ state="active",
+ scopes_granted=["https://www.googleapis.com/auth/spreadsheets"],
+ **{name: f"SECRET_{name}" for name in TOKEN_FIELD_NAMES},
+ )
+
+ entry = _serialize(leaky_google, "google")
+
+ assert set(entry) == {"connection_id", "provider", "name", "state", "scopes_granted"}
+ for name in TOKEN_FIELD_NAMES:
+ assert name not in entry
+ assert not any("SECRET_" in str(value) for value in entry.values())
+
+
+def test_prompt_routes_oauth_accounts_to_the_right_lookup() -> None:
+ rendered = render_agent_prompt()
+ assert "appear ONLY in `list_integrations`" in rendered
+
+
+async def test_lists_a_google_connection_whose_grant_expired(patched_services) -> None:
+ patched_services([_google(state="error")], [])
+ ctx = SimpleNamespace(organization_id=ORGANIZATION_ID)
+
+ result = await _list_integrations({}, ctx)
+
+ assert result["data"]["count"] == 1
+ assert result["data"]["integrations"][0]["state"] == "error"
diff --git a/uv.lock b/uv.lock
index 3b735c505..452f7e14f 100644
--- a/uv.lock
+++ b/uv.lock
@@ -5801,6 +5801,19 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/c0/98/6beb4b351e472e5f4c4613f7c35a5290b8be2497e183825310c4c3a3984b/ruff-0.15.12-py3-none-win_arm64.whl", hash = "sha256:a538f7a82d061cee7be55542aca1d86d1393d55d81d4fcc314370f4340930d4f", size = 11120821, upload-time = "2026-04-24T18:16:57.979Z" },
]
+[[package]]
+name = "rustwright"
+version = "0.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/51/80/c4b1fe7f942b8fbbf0420295cb265413bb6ad874d2064a53e95782c7d8c5/rustwright-0.1.1.tar.gz", hash = "sha256:9a42264eaa7c7aa1a11eaa81a34699e8b8c83a504bd6eb3c61a444c242a5b98d", size = 3831062, upload-time = "2026-07-15T16:13:00.029Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/b3/ea/878236a78cd0da88a629471501b01b5aef92eecce438b0e6ab8de670199f/rustwright-0.1.1-cp38-abi3-macosx_10_12_x86_64.whl", hash = "sha256:fcfb8afc5ec10146727d7d57b66528022a37fd9bc2408c25dcdc72868521e131", size = 4302856, upload-time = "2026-07-15T16:12:51.297Z" },
+ { url = "https://files.pythonhosted.org/packages/b9/52/3ccddd9f1e5436e543149b16c5f50bf9fd5fab27fcf7be7a7f8e9b795931/rustwright-0.1.1-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:01f969f691acb2b61f830c32e2b23c97c59a108b661086bde58652d84821841f", size = 4126466, upload-time = "2026-07-15T16:12:53.138Z" },
+ { url = "https://files.pythonhosted.org/packages/f4/cb/4d8714e27ba6ea0a430f96a1baf3b09c56a75d2920a467bb44d03cf95bca/rustwright-0.1.1-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ddc60409aa12478c9617b742356be7f5baae81b17e77dabfbe040fc43864fa4e", size = 3877892, upload-time = "2026-07-15T16:12:54.721Z" },
+ { url = "https://files.pythonhosted.org/packages/ff/a1/9e1b3224e9a2c82e7b44d9abbb00a0e65e6b7ff40a5cfa6832f783330051/rustwright-0.1.1-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4c9bd1a72db79fbfaf20ba829a74564e8a82088ae8a939daff1cf3c9c3e7f8cd", size = 4500875, upload-time = "2026-07-15T16:12:56.668Z" },
+ { url = "https://files.pythonhosted.org/packages/60/74/47ee2c9f924fa25b522826a5761a1b0e362789d9f668f51f09cab784a03c/rustwright-0.1.1-cp38-abi3-win_amd64.whl", hash = "sha256:fc44f2be7918c98fd444522848d506786cb35b4e2e02a9efc722734f4e700458", size = 4235069, upload-time = "2026-07-15T16:12:58.353Z" },
+]
+
[[package]]
name = "s3transfer"
version = "0.11.3"
@@ -6074,6 +6087,9 @@ dev = [
{ name = "twine" },
{ name = "types-requests" },
]
+rustwright = [
+ { name = "rustwright" },
+]
[package.metadata]
requires-dist = [
@@ -6280,6 +6296,7 @@ dev = [
{ name = "twine", specifier = ">=6.1.0,<7" },
{ name = "types-requests", specifier = ">=2.31.0.2,<3" },
]
+rustwright = [{ name = "rustwright", specifier = "==0.1.1" }]
[[package]]
name = "sniffio"