Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
SKY-13202 Let the copilot see connected Google and Microsoft accounts (#7871)
Andrew Neilsone197cc97a2a1
diff --git a/pyproject.toml b/pyproject.tomlindex 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.j2index 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.pyindex 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.pyindex 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.pyindex 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_displayreturn "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__.pyindex 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_overlaysfrom .mcp_hooks import _click_post_hook as _click_post_hookfrom .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.pynew file mode 100644index 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.pyindex 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 annotationsimport asyncio+import contextlibimport dataclassesimport re+import subprocessimport sys+import typesfrom pathlib import Pathimport 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.stderrdef 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.asyncioasync 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.pynew file mode 100644index 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.lockindex 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"