daytona-use-computer 0.0.48__tar.gz

daytona_use_computer-0.0.48/.env.example

@@ -0,0 +1,6 @@
+# SDK runtime
+USE_COMPUTER_API_KEY=uc_live_...
+USE_COMPUTER_BASE_URL=https://api.use.computer
+
+# Local PyPI publish only. Prefer CI Trusted Publishing when possible.
+PYPI_API_TOKEN=pypi-...

daytona_use_computer-0.0.48/.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.pyc
+results/
+dist/
+*.egg-info/
+.env
+.env.*
+!.env.example
+.venv/

daytona_use_computer-0.0.48/.pre-commit-config.yaml

@@ -0,0 +1,15 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.15.12
+    hooks:
+      - id: ruff-format
+      - id: ruff-check
+        args: [--fix]
+
+  - repo: local
+    hooks:
+      - id: ty-check
+        name: ty check
+        entry: uv run --group dev ty check .
+        language: system
+        pass_filenames: false

daytona_use_computer-0.0.48/PKG-INFO

@@ -0,0 +1,197 @@
+Metadata-Version: 2.5
+Name: daytona-use-computer
+Version: 0.0.48
+Summary: Python SDK for use.computer macOS sandboxes
+Project-URL: Homepage, https://use.computer
+Project-URL: Documentation, https://api.use.computer/docs
+Project-URL: Repository, https://github.com/daytona/use-computer-sdk
+Author: use.computer
+Keywords: automation,computer-use,macos,sandbox,vnc
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Provides-Extra: agents
+Requires-Dist: anthropic>=0.86; extra == 'agents'
+Requires-Dist: google-genai>=1; extra == 'agents'
+Requires-Dist: litellm>=1; extra == 'agents'
+Requires-Dist: openai>=1; extra == 'agents'
+Requires-Dist: pillow>=10; extra == 'agents'
+Requires-Dist: tinker-cookbook>=0.1.0; (python_full_version >= '3.11') and extra == 'agents'
+Requires-Dist: tinker>=0.14.0; (python_full_version >= '3.11') and extra == 'agents'
+Description-Content-Type: text/markdown
+
+# use-computer Python SDK (`daytona-use-computer`)
+
+use.computer gives you macOS sandboxes: VMs on dedicated Apple M4 Mac minis that you reserve for 24 hours or more, up to 2 VMs at a time per Mac.
+
+```bash
+pip install daytona-use-computer
+export USE_COMPUTER_API_KEY=uc_live_...
+```
+
+Optional agent integrations are installed explicitly:
+
+```bash
+pip install "daytona-use-computer[agents]"        # computer-use agents and provider SDKs
+```
+
+Base installs only the SDK client and `httpx`. The `agents` extra installs the agent runtime plus model-provider dependencies (Anthropic, OpenAI, Gemini, LiteLLM).
+
+## Quickstart
+
+Flow: sign up → $100 starter credit → reserve a Mac mini (dashboard, or `client.reserve(hours=24)` in the SDK) → `create()` a macOS sandbox → drive it (mouse, keyboard, screenshot, exec, files, recording, UI tree, VNC) → `delete()`. Reservations cost $1.91/hour per Mac; the starter credit pays for them.
+
+```python
+from use_computer import Computer
+
+client = Computer()
+
+# 1. Reserve one M4 Mac Mini for 24 hours
+reservation = client.reserve(hours=24, mac_model="m4")
+
+# 2. Launch a macOS sandbox on the reserved Mac
+with client.create(reservation_id=reservation.id) as mac:
+    # 3. Drive the macOS sandbox
+    mac.exec("open -a Safari")
+    mac.keyboard.type("hello from use.computer")
+    mac.mouse.click(500, 500)
+    png = mac.screenshot.take_full_screen()
+    print("Sandbox:", mac.sandbox_id)
+    # Open this sandbox's viewer from the use.computer dashboard.
+```
+
+Never print or share `vnc_url`: it contains your account API key. Open the viewer from the dashboard instead.
+
+The optional `mac_model` picks the Mac: `"m4"` (the default; 10 vCPU and 16 GiB RAM) or `"m4-pro"` (12 or more vCPU and 24 GiB RAM). `reservation.mac_model` reports it.
+
+Each `create()` can set `cpu`, `memory_gib`, and `disk_gib`. Omitted fields use the Mac's warm VM size, which is 5 vCPU and 8 GiB RAM today and starts right away. Any other size boots a new VM, which can take up to 5 minutes, so `create()` waits up to 10 minutes when you set any of them. A Mac runs at most 2 sandboxes at a time, and their sizes must fit in the Mac. The sandbox reports `cpu`, `memory_gib`, `disk_gib`, and `boot` (`"warm"` or `"cold"`):
+
+```python
+with client.create(reservation_id=reservation.id, cpu=8, memory_gib=12) as mac:
+    print(mac.cpu, mac.memory_gib, mac.boot)
+```
+
+If the size does not fit, `create()` raises `SandboxResourcesError`. Its `code` is `invalid_resources`, `resources_exceed_mac`, `sandbox_limit_reached`, or `insufficient_capacity`, and its `message` explains the refusal. `AsyncComputer` accepts the same options. Check `Computer().platforms(reservation_id=...)["macos"]["capacity"]` for the selected reservation's `max` and `used` counts.
+
+The older `vm_layout` reservation option still works but is deprecated; the SDK sends it only when you pass it. `"split"` (the server default) allows two sandboxes, and `"whole"` allows one sandbox at a time.
+
+When `ephemeral` is omitted, the server default is the reservation lifetime. Explicit `ephemeral=True` opts into destruction after 2 idle minutes; call `sandbox.start_keepalive(interval=30)` during long model-think periods. Explicit `ephemeral=False` disables idle destruction. Context managers still delete their sandbox on exit.
+
+This default applies to the source release documented here. Published Python 0.0.46
+still defaults to `ephemeral=True`; pass `ephemeral=False` explicitly on that
+version. The next tagged release includes the omitted-field default above.
+
+## Computer actions
+
+Coordinates use screenshot pixels. `mouse.click(x, y, button="middle")` selects the
+middle button; `click_count=3` sends one native triple-click sequence.
+`mouse.down()` / `mouse.up()` hold and release the left button at the current
+cursor, with optional `button`, `x`, and `y`. `keyboard.hold("shift", 0.5)` holds
+keys for seconds. `mouse.drag(..., path=[{"x": 10, "y": 20}, ...])` preserves all
+path points. `mouse.scroll(x, y, scroll_x=40, scroll_y=-80)` sends both pixel
+deltas (positive right/down); the direction/amount form remains available.
+The async methods have the same arguments.
+
+Provider mappings are recorded in
+[`action_manifest.json`](use_computer/agents/action_manifest.json).
+Anthropic tool pixels are scaled to sandbox pixels; Gemini uses normalized
+0..999 coordinates. Control and Command remain distinct. Invalid actions and
+gateway errors are not reported as executed.
+
+Agent logs separate action execution from `settle+screenshot`: the latter
+includes a deliberate two-second settle, screenshot requests, and any recovery.
+These are not model inference timings or raw screenshot latency.
+
+`exec(command, timeout=120)` uses the gateway's non-login `/bin/zsh -c`;
+`exec_ax` uses `/bin/sh` through the desktop server. The timeout is seconds
+and is sent to the gateway and used as the HTTP timeout. For a 200-second
+command, use `timeout=300`. Results retain separate stdout, stderr, and
+`return_code`; a nonzero process exit is not an HTTP transport failure.
+
+## Application automation permissions
+
+macOS asks for consent when a process sends Apple events to another application
+through AppleScript or `osascript`. That consent dialog cannot be answered inside
+the sandbox. The gateway approves every installed application when creating a
+sandbox or restoring a snapshot. After installing another app, call
+`sandbox.permissions.allow_automation()` to approve it before scripting it:
+
+```python
+# Inside an async macOS sandbox session:
+result = await sandbox.exec("brew install --cask firefox")
+if result.return_code != 0:
+    raise RuntimeError(result.stderr)
+approval = await sandbox.permissions.allow_automation(
+    bundle_ids=["org.mozilla.firefox"]
+)
+print(approval.success, approval.targets, approval.changed)
+
+# Alternatively, approve all currently installed applications:
+approval = await sandbox.permissions.allow_automation(installed=True)
+```
+
+The synchronous `MacOSSandbox` exposes the same method without `await`.
+Approvals cover Apple events sent through `osascript`, SSH sessions, `exec`, and
+Terminal.
+
+`allow_automation(bundle_ids=None, installed=False)` sends
+`POST /v1/sandboxes/{sandboxID}/permissions/automation`. Supply specific
+`bundle_ids`, `installed=True` for all installed applications, or both in one
+call. Omitted bundle IDs and the default `installed=False` are not sent.
+The 200 response is decoded as the exported `AutomationApproval` dataclass:
+`success: bool`, `targets: int` (applications considered), and `changed: int`
+(approvals added or flipped from denied).
+
+The gateway validates bundle IDs against
+`^[A-Za-z0-9][A-Za-z0-9._-]{0,254}$`. Malformed IDs or an empty request receive
+HTTP 400 with `{"error": ...}`. The SDK does not validate them locally; it raises
+the standard `httpx.HTTPStatusError`, whose `response` retains the status and
+error body.
+
+## Runtime Snapshots
+
+macOS snapshots let you seed a VM once, snapshot it, then create new sandboxes from that snapshot version. macOS snapshots preserve disk state, so installed apps, accounts, and seeded files are available immediately:
+
+```python
+from use_computer import Computer
+
+client = Computer()
+
+# Configure the macOS desktop by hand over VNC, then snapshot it.
+with client.create(type="macos") as mac:
+    print("Configure sandbox in the dashboard viewer:", mac.sandbox_id)
+    input("Press Enter once the desktop is ready to snapshot...")
+    snapshot = mac.snapshot("chrome-seeded-macos")
+
+# New sandboxes boot from that saved disk state, no setup needed.
+with client.create(type="macos", snapshot=snapshot.version) as seeded:
+    print("Seeded sandbox ready:", seeded.sandbox_id)
+```
+
+Use `client.snapshots()` to list saved snapshot versions.
+
+## Examples
+
+| File | What it shows |
+| --- | --- |
+| [`examples/_1_hello_macos.py`](../examples/python/_1_hello_macos.py) | reserve → create → exec → keyboard → screenshot |
+| [`examples/_2_recording.py`](../examples/python/_2_recording.py) | start / stop / download a screen recording |
+| [`examples/_3_file_transfer.py`](../examples/python/_3_file_transfer.py) | upload bytes, download a file back |
+| [`examples/_4_keepalive.py`](../examples/python/_4_keepalive.py) | heartbeat for ephemeral sessions idle > 2 min |
+| [`examples/_5_snapshots.py`](../examples/python/_5_snapshots.py) | snapshot seeded macOS state |
+
+## HTTP API
+
+Every SDK method wraps `https://api.use.computer/v1/...` with `Authorization: Bearer uc_live_...`. Swagger: [api.use.computer/docs](https://api.use.computer/docs). OpenAPI spec: [api.use.computer/openapi.yaml](https://api.use.computer/openapi.yaml).
+
+Gateway URLs, whether passed explicitly or via `USE_COMPUTER_BASE_URL`, must use HTTPS except for loopback HTTP. The SDK does not load `.env` files by default; load one explicitly in your application if needed. Authenticated requests, including keepalive and agent reference screenshots, do not follow redirects.
+
+Lifecycle calls (`reserve`, `create`, and `snapshot`, including restores via `create(snapshot=...)`) send a fresh UUID v4 `Idempotency-Key` per call. Idempotent HTTP methods and keyed lifecycle mutations retry transient failures using the same key and body; unkeyed mutations are not retried. A new lifecycle method invocation is a new intent with a new key.

daytona_use_computer-0.0.48/README.md

@@ -0,0 +1,167 @@
+# use-computer Python SDK (`daytona-use-computer`)
+
+use.computer gives you macOS sandboxes: VMs on dedicated Apple M4 Mac minis that you reserve for 24 hours or more, up to 2 VMs at a time per Mac.
+
+```bash
+pip install daytona-use-computer
+export USE_COMPUTER_API_KEY=uc_live_...
+```
+
+Optional agent integrations are installed explicitly:
+
+```bash
+pip install "daytona-use-computer[agents]"        # computer-use agents and provider SDKs
+```
+
+Base installs only the SDK client and `httpx`. The `agents` extra installs the agent runtime plus model-provider dependencies (Anthropic, OpenAI, Gemini, LiteLLM).
+
+## Quickstart
+
+Flow: sign up → $100 starter credit → reserve a Mac mini (dashboard, or `client.reserve(hours=24)` in the SDK) → `create()` a macOS sandbox → drive it (mouse, keyboard, screenshot, exec, files, recording, UI tree, VNC) → `delete()`. Reservations cost $1.91/hour per Mac; the starter credit pays for them.
+
+```python
+from use_computer import Computer
+
+client = Computer()
+
+# 1. Reserve one M4 Mac Mini for 24 hours
+reservation = client.reserve(hours=24, mac_model="m4")
+
+# 2. Launch a macOS sandbox on the reserved Mac
+with client.create(reservation_id=reservation.id) as mac:
+    # 3. Drive the macOS sandbox
+    mac.exec("open -a Safari")
+    mac.keyboard.type("hello from use.computer")
+    mac.mouse.click(500, 500)
+    png = mac.screenshot.take_full_screen()
+    print("Sandbox:", mac.sandbox_id)
+    # Open this sandbox's viewer from the use.computer dashboard.
+```
+
+Never print or share `vnc_url`: it contains your account API key. Open the viewer from the dashboard instead.
+
+The optional `mac_model` picks the Mac: `"m4"` (the default; 10 vCPU and 16 GiB RAM) or `"m4-pro"` (12 or more vCPU and 24 GiB RAM). `reservation.mac_model` reports it.
+
+Each `create()` can set `cpu`, `memory_gib`, and `disk_gib`. Omitted fields use the Mac's warm VM size, which is 5 vCPU and 8 GiB RAM today and starts right away. Any other size boots a new VM, which can take up to 5 minutes, so `create()` waits up to 10 minutes when you set any of them. A Mac runs at most 2 sandboxes at a time, and their sizes must fit in the Mac. The sandbox reports `cpu`, `memory_gib`, `disk_gib`, and `boot` (`"warm"` or `"cold"`):
+
+```python
+with client.create(reservation_id=reservation.id, cpu=8, memory_gib=12) as mac:
+    print(mac.cpu, mac.memory_gib, mac.boot)
+```
+
+If the size does not fit, `create()` raises `SandboxResourcesError`. Its `code` is `invalid_resources`, `resources_exceed_mac`, `sandbox_limit_reached`, or `insufficient_capacity`, and its `message` explains the refusal. `AsyncComputer` accepts the same options. Check `Computer().platforms(reservation_id=...)["macos"]["capacity"]` for the selected reservation's `max` and `used` counts.
+
+The older `vm_layout` reservation option still works but is deprecated; the SDK sends it only when you pass it. `"split"` (the server default) allows two sandboxes, and `"whole"` allows one sandbox at a time.
+
+When `ephemeral` is omitted, the server default is the reservation lifetime. Explicit `ephemeral=True` opts into destruction after 2 idle minutes; call `sandbox.start_keepalive(interval=30)` during long model-think periods. Explicit `ephemeral=False` disables idle destruction. Context managers still delete their sandbox on exit.
+
+This default applies to the source release documented here. Published Python 0.0.46
+still defaults to `ephemeral=True`; pass `ephemeral=False` explicitly on that
+version. The next tagged release includes the omitted-field default above.
+
+## Computer actions
+
+Coordinates use screenshot pixels. `mouse.click(x, y, button="middle")` selects the
+middle button; `click_count=3` sends one native triple-click sequence.
+`mouse.down()` / `mouse.up()` hold and release the left button at the current
+cursor, with optional `button`, `x`, and `y`. `keyboard.hold("shift", 0.5)` holds
+keys for seconds. `mouse.drag(..., path=[{"x": 10, "y": 20}, ...])` preserves all
+path points. `mouse.scroll(x, y, scroll_x=40, scroll_y=-80)` sends both pixel
+deltas (positive right/down); the direction/amount form remains available.
+The async methods have the same arguments.
+
+Provider mappings are recorded in
+[`action_manifest.json`](use_computer/agents/action_manifest.json).
+Anthropic tool pixels are scaled to sandbox pixels; Gemini uses normalized
+0..999 coordinates. Control and Command remain distinct. Invalid actions and
+gateway errors are not reported as executed.
+
+Agent logs separate action execution from `settle+screenshot`: the latter
+includes a deliberate two-second settle, screenshot requests, and any recovery.
+These are not model inference timings or raw screenshot latency.
+
+`exec(command, timeout=120)` uses the gateway's non-login `/bin/zsh -c`;
+`exec_ax` uses `/bin/sh` through the desktop server. The timeout is seconds
+and is sent to the gateway and used as the HTTP timeout. For a 200-second
+command, use `timeout=300`. Results retain separate stdout, stderr, and
+`return_code`; a nonzero process exit is not an HTTP transport failure.
+
+## Application automation permissions
+
+macOS asks for consent when a process sends Apple events to another application
+through AppleScript or `osascript`. That consent dialog cannot be answered inside
+the sandbox. The gateway approves every installed application when creating a
+sandbox or restoring a snapshot. After installing another app, call
+`sandbox.permissions.allow_automation()` to approve it before scripting it:
+
+```python
+# Inside an async macOS sandbox session:
+result = await sandbox.exec("brew install --cask firefox")
+if result.return_code != 0:
+    raise RuntimeError(result.stderr)
+approval = await sandbox.permissions.allow_automation(
+    bundle_ids=["org.mozilla.firefox"]
+)
+print(approval.success, approval.targets, approval.changed)
+
+# Alternatively, approve all currently installed applications:
+approval = await sandbox.permissions.allow_automation(installed=True)
+```
+
+The synchronous `MacOSSandbox` exposes the same method without `await`.
+Approvals cover Apple events sent through `osascript`, SSH sessions, `exec`, and
+Terminal.
+
+`allow_automation(bundle_ids=None, installed=False)` sends
+`POST /v1/sandboxes/{sandboxID}/permissions/automation`. Supply specific
+`bundle_ids`, `installed=True` for all installed applications, or both in one
+call. Omitted bundle IDs and the default `installed=False` are not sent.
+The 200 response is decoded as the exported `AutomationApproval` dataclass:
+`success: bool`, `targets: int` (applications considered), and `changed: int`
+(approvals added or flipped from denied).
+
+The gateway validates bundle IDs against
+`^[A-Za-z0-9][A-Za-z0-9._-]{0,254}$`. Malformed IDs or an empty request receive
+HTTP 400 with `{"error": ...}`. The SDK does not validate them locally; it raises
+the standard `httpx.HTTPStatusError`, whose `response` retains the status and
+error body.
+
+## Runtime Snapshots
+
+macOS snapshots let you seed a VM once, snapshot it, then create new sandboxes from that snapshot version. macOS snapshots preserve disk state, so installed apps, accounts, and seeded files are available immediately:
+
+```python
+from use_computer import Computer
+
+client = Computer()
+
+# Configure the macOS desktop by hand over VNC, then snapshot it.
+with client.create(type="macos") as mac:
+    print("Configure sandbox in the dashboard viewer:", mac.sandbox_id)
+    input("Press Enter once the desktop is ready to snapshot...")
+    snapshot = mac.snapshot("chrome-seeded-macos")
+
+# New sandboxes boot from that saved disk state, no setup needed.
+with client.create(type="macos", snapshot=snapshot.version) as seeded:
+    print("Seeded sandbox ready:", seeded.sandbox_id)
+```
+
+Use `client.snapshots()` to list saved snapshot versions.
+
+## Examples
+
+| File | What it shows |
+| --- | --- |
+| [`examples/_1_hello_macos.py`](../examples/python/_1_hello_macos.py) | reserve → create → exec → keyboard → screenshot |
+| [`examples/_2_recording.py`](../examples/python/_2_recording.py) | start / stop / download a screen recording |
+| [`examples/_3_file_transfer.py`](../examples/python/_3_file_transfer.py) | upload bytes, download a file back |
+| [`examples/_4_keepalive.py`](../examples/python/_4_keepalive.py) | heartbeat for ephemeral sessions idle > 2 min |
+| [`examples/_5_snapshots.py`](../examples/python/_5_snapshots.py) | snapshot seeded macOS state |
+
+## HTTP API
+
+Every SDK method wraps `https://api.use.computer/v1/...` with `Authorization: Bearer uc_live_...`. Swagger: [api.use.computer/docs](https://api.use.computer/docs). OpenAPI spec: [api.use.computer/openapi.yaml](https://api.use.computer/openapi.yaml).
+
+Gateway URLs, whether passed explicitly or via `USE_COMPUTER_BASE_URL`, must use HTTPS except for loopback HTTP. The SDK does not load `.env` files by default; load one explicitly in your application if needed. Authenticated requests, including keepalive and agent reference screenshots, do not follow redirects.
+
+Lifecycle calls (`reserve`, `create`, and `snapshot`, including restores via `create(snapshot=...)`) send a fresh UUID v4 `Idempotency-Key` per call. Idempotent HTTP methods and keyed lifecycle mutations retry transient failures using the same key and body; unkeyed mutations are not retried. A new lifecycle method invocation is a new intent with a new key.

daytona_use_computer-0.0.48/pyproject.toml

@@ -0,0 +1,82 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "daytona-use-computer"
+version = "0.0.48"
+description = "Python SDK for use.computer macOS sandboxes"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "use.computer" }]
+dependencies = ["httpx>=0.27"]
+keywords = ["computer-use", "macos", "automation", "sandbox", "vnc"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Typing :: Typed",
+]
+
+[project.optional-dependencies]
+agents = [
+    "Pillow>=10",
+    "openai>=1",
+    "anthropic>=0.86",
+    "litellm>=1",
+    "google-genai>=1",
+    "tinker>=0.14.0 ; python_full_version >= '3.11'",
+    "tinker-cookbook>=0.1.0 ; python_full_version >= '3.11'",
+]
+
+
+[dependency-groups]
+dev = [
+    "anthropic>=0.86",
+    "google-genai>=1",
+    "harbor @ git+https://github.com/josancamon19/harbor.git@b0203845795be95f86b149dbc73ab0fd56cf9192 ; python_version >= '3.12'",
+    "litellm>=1",
+    "openai>=1",
+    "pre-commit>=4",
+    "pytest>=9",
+    "ruff>=0.15",
+    "Pillow>=10",
+    "PyYAML>=6",
+    "tomli>=2",
+    "twine>=6",
+    "ty>=0.0.34",
+]
+
+[project.urls]
+Homepage = "https://use.computer"
+Documentation = "https://api.use.computer/docs"
+Repository = "https://github.com/daytona/use-computer-sdk"
+
+[tool.hatch.build.targets.wheel]
+packages = ["use_computer"]
+
+[tool.hatch.build]
+exclude = [
+    "/.github",
+    "/.pytest_cache",
+    "/.ruff_cache",
+    "/.venv",
+    "/dist",
+    "/results",
+    "/tests",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP"]

daytona_use_computer-0.0.48/scripts/smoke_wheel.py

@@ -0,0 +1,193 @@
+"""Smoke-test the built wheel in clean environments."""
+
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+import tempfile
+import zipfile
+from pathlib import Path
+
+BASE_SMOKE = r"""
+import importlib.util
+import use_computer
+
+def has(name):
+    try:
+        return importlib.util.find_spec(name) is not None
+    except ModuleNotFoundError:
+        return False
+
+assert "site-packages" in (use_computer.__file__ or ""), use_computer.__file__
+for name in ["PIL", "openai", "anthropic", "google.genai", "litellm"]:
+    assert not has(name), name
+"""
+
+AGENTS_SMOKE = r"""
+import asyncio
+import importlib
+import importlib.util
+import tempfile
+from pathlib import Path
+
+assert importlib.util.find_spec("PIL") is not None
+for name in ["openai", "anthropic", "google.genai", "litellm"]:
+    assert importlib.util.find_spec(name) is not None, name
+for path in ["use_computer.agents", "use_computer.agents.debug"]:
+    importlib.import_module(path)
+
+from use_computer.agents import (
+    AnthropicComputerAgent,
+    GeminiComputerAgent,
+    GenericComputerAgent,
+
+    OpenAIComputerAgent,
+)
+from use_computer.agents.debug import DebugComputerAgent
+from use_computer.core.models import ExecResult
+
+PNG_BYTES = (
+    b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01"
+    b"\x08\x02\x00\x00\x00\x90wS\xde\x00\x00\x00\x0cIDAT\x08\xd7c\xf8\xff"
+    b"\xff?\x00\x05\xfe\x02\xfeA\xe2`\\\x00\x00\x00\x00IEND\xaeB`\x82"
+)
+
+class Recording:
+    async def start(self, name="trial"):
+        raise RuntimeError("recording disabled")
+
+class Screenshot:
+    async def take_full_screen(self):
+        return PNG_BYTES
+
+class Display:
+    async def get_windows(self):
+        return [{"role": "window", "title": "Fake"}]
+
+class Mouse:
+    def __init__(self):
+        self.clicks = []
+
+    async def click(self, x, y, button="left", double=False):
+        self.clicks.append((x, y, button, double))
+
+class Sandbox:
+    def __init__(self):
+        self.sandbox_id = "fake"
+        self.screenshot = Screenshot()
+        self.recording = Recording()
+        self.display = Display()
+        self.mouse = Mouse()
+        self.commands = []
+
+    async def exec_ssh(self, command, timeout=120):
+        self.commands.append(command)
+        return ExecResult(return_code=0, stdout="ok", stderr="")
+
+with tempfile.TemporaryDirectory() as tmp:
+    root = Path(tmp)
+    sandbox = Sandbox()
+    result = asyncio.run(
+        DebugComputerAgent(max_steps=1).run(
+            "smoke",
+            sandbox=sandbox,
+            logs_dir=root / "agent",
+            task_dir=root / "task",
+        )
+    )
+    assert sandbox.mouse.clicks == [(960, 540, "left", False)]
+    assert sandbox.commands == ["echo hello world"]
+    assert result.final_message == "smoke"
+
+for agent_cls, model_name in [
+    (AnthropicComputerAgent, "anthropic/claude-sonnet-4-6"),
+    (OpenAIComputerAgent, "openai/gpt-5.5"),
+    (GeminiComputerAgent, "gemini/gemini-2.5-computer-use-preview-10-2025"),
+    (GenericComputerAgent, "openai/gpt-4o"),
+
+]:
+    assert agent_cls(model_name=model_name, max_steps=1).max_steps == 1
+"""
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("wheel", type=Path)
+    args = parser.parse_args()
+
+    wheel = args.wheel.resolve()
+    if not wheel.name.endswith(".whl"):
+        raise SystemExit(f"expected a wheel path, got {wheel}")
+
+    _check_wheel_contents(wheel)
+    _check_metadata(wheel)
+    _smoke_install(wheel, None, BASE_SMOKE)
+    _smoke_install(wheel, "agents", AGENTS_SMOKE)
+
+
+def _check_wheel_contents(wheel: Path) -> None:
+    with zipfile.ZipFile(wheel) as archive:
+        names = set(archive.namelist())
+
+    required = {
+        "use_computer/py.typed",
+        "use_computer/agents/prompts/anthropic.txt",
+        "use_computer/agents/prompts/gemini.txt",
+        "use_computer/agents/prompts/openai.txt",
+        "use_computer/agents/prompts/pyautogui.txt",
+    }
+    missing = sorted(required - names)
+    if missing:
+        raise SystemExit(f"wheel is missing files: {missing}")
+
+    forbidden = [name for name in names if "__pycache__" in name or name.startswith("tests/")]
+    if forbidden:
+        raise SystemExit(f"wheel contains generated/test files: {sorted(forbidden)[:10]}")
+
+
+def _check_metadata(wheel: Path) -> None:
+    with zipfile.ZipFile(wheel) as archive:
+        metadata_name = next(
+            name for name in archive.namelist() if name.endswith(".dist-info/METADATA")
+        )
+        metadata = archive.read(metadata_name).decode()
+
+    required = [
+        "Provides-Extra: agents",
+        "Requires-Dist: pillow>=10; extra == 'agents'",
+        "Requires-Dist: openai>=1; extra == 'agents'",
+        "Requires-Dist: anthropic>=0.86; extra == 'agents'",
+        "Requires-Dist: litellm>=1; extra == 'agents'",
+        "Requires-Dist: google-genai>=1; extra == 'agents'",
+    ]
+    missing = [line for line in required if line not in metadata]
+    if missing:
+        raise SystemExit(f"wheel metadata is missing: {missing}")
+
+    forbidden = [
+        f"Provides-Extra: agents-{name}"
+        for name in ("openai", "anthropic", "litellm", "gemini", "all")
+    ]
+    present = [line for line in forbidden if line in metadata]
+    if present:
+        raise SystemExit(f"wheel metadata still has provider-specific extras: {present}")
+
+
+def _smoke_install(wheel: Path, extra: str | None, code: str) -> None:
+    with tempfile.TemporaryDirectory(prefix="use-computer-wheel-") as tmp:
+        tmp_path = Path(tmp)
+        venv = tmp_path / "venv"
+        _run(["uv", "venv", "--python", sys.executable, str(venv)], cwd=tmp_path)
+        python = venv / ("Scripts/python.exe" if sys.platform == "win32" else "bin/python")
+        requirement = f"{wheel}[{extra}]" if extra else str(wheel)
+        _run(["uv", "pip", "install", "--python", str(python), requirement], cwd=tmp_path)
+        _run([str(python), "-c", code], cwd=tmp_path)
+
+
+def _run(cmd: list[str], *, cwd: Path) -> None:
+    subprocess.run(cmd, cwd=cwd, check=True)
+
+
+if __name__ == "__main__":
+    main()