sprites-adk 0.1.0__tar.gz

sprites_adk-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,44 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - 'v[0-9]+.[0-9]+.[0-9]+'
+      - 'v[0-9]+.[0-9]+.[0-9]+-*'
+
+jobs:
+  publish:
+    name: Build and publish to PyPI
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Update version
+        run: |
+          # Strip 'v' prefix from tag
+          VERSION="${GITHUB_REF_NAME#v}"
+          echo "Publishing version: ${VERSION}"
+          # Update pyproject.toml
+          sed -i "s/^version = \".*\"/version = \"${VERSION}\"/" pyproject.toml
+          # Update __version__ in the package
+          sed -i "s/__version__ = \".*\"/__version__ = \"${VERSION}\"/" sprites_adk/__init__.py
+
+      - name: Install and test
+        run: |
+          python -m pip install --upgrade pip
+          pip install '.[dev]' build
+          pytest -q
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

sprites_adk-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+.venv/
+__pycache__/
+*.pyc
+*.egg-info/
+dist/
+build/
+.pytest_cache/

sprites_adk-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fly.io
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sprites_adk-0.1.0/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: sprites-adk
+Version: 0.1.0
+Summary: Google ADK plugin for Sprites: persistent, stateful Linux sandboxes with checkpoint/restore for AI agents.
+Project-URL: Homepage, https://sprites.dev
+Project-URL: Documentation, https://docs.sprites.dev
+Project-URL: Repository, https://github.com/superfly/sprites-adk
+Author: Fly.io
+License: MIT
+License-File: LICENSE
+Keywords: adk,agents,code-execution,fly.io,google-adk,sandbox,sprites
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+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: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: google-adk>=1.0.0
+Requires-Dist: sprites-py>=0.2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# sprites-adk
+
+Google [ADK](https://google.github.io/adk-docs/) integration for [Sprites](https://sprites.dev) — persistent, stateful Linux sandboxes for AI agents, with checkpoint/restore, from [Fly.io](https://fly.io).
+
+Most agent sandboxes are ephemeral: the environment vanishes when the session ends. A Sprite is a **stateful Linux microVM** that suspends when idle and keeps everything — files, packages, databases, running services — so your agent can resume yesterday's environment today. And because Sprites support **checkpoints**, your agent can snapshot the whole environment before a risky change and roll back if it goes wrong.
+
+## Installation
+
+```sh
+pip install sprites-adk
+```
+
+You'll need a Sprites API token ([get started](https://docs.sprites.dev/quickstart/)):
+
+```sh
+export SPRITES_TOKEN=...
+```
+
+## Quickstart
+
+```python
+from google.adk.agents import Agent
+from sprites_adk import SpritesPlugin
+
+plugin = SpritesPlugin()  # or SpritesPlugin(sprite_name="my-project") for a persistent env
+
+root_agent = Agent(
+    model="gemini-flash-latest",
+    name="sprite_agent",
+    instruction="Run code and commands in the Sprite sandbox, not locally.",
+    tools=plugin.get_tools(),
+)
+```
+
+Pass the plugin to your runner to get lifecycle callbacks and error handling:
+
+```python
+runner = InMemoryRunner(agent=root_agent, plugins=[plugin])
+```
+
+## Two modes
+
+| | `SpritesPlugin()` | `SpritesPlugin(sprite_name="my-project")` |
+|---|---|---|
+| Sprite name | auto-generated `adk-…` | yours |
+| Reused across sessions | no | **yes — full state persists** |
+| Destroyed on `plugin.close()` | yes | no |
+
+The Sprite is created lazily on first tool use; constructing the agent needs no network. Sprites suspend automatically when idle — a parked environment costs (almost) nothing.
+
+## Tools
+
+| Tool | Description |
+|---|---|
+| `execute_command_in_sprite` | Run a shell command (cwd, timeout supported) |
+| `execute_code_in_sprite` | Run a Python / JavaScript / bash snippet |
+| `write_file_to_sprite` | Write a text file (parents auto-created) |
+| `read_file_from_sprite` | Read a text file |
+| `create_sprite_checkpoint` | Snapshot the entire environment |
+| `list_sprite_checkpoints` | List checkpoints, newest first |
+| `restore_sprite_checkpoint` | Roll back to a checkpoint (**destructive**, requires `confirm=true`) |
+
+All tools return structured dicts (`success`, `stdout`/`stderr`/`exit_code`, …); failures come back as `{"success": false, "error": ...}` so the agent can adapt instead of crashing the run.
+
+File reads and writes run as commands inside the Sprite (via `base64`, so quotes/newlines/unicode survive) rather than through a separate filesystem API. That keeps them consistent with everything else the agent does — in particular, files written this way are correctly reverted by `restore_sprite_checkpoint`. `write_file_to_sprite` is capped at 256 KB; generate larger files with a command inside the Sprite. `/tmp` is tmpfs and is not captured by checkpoints.
+
+### A note on restore
+
+`restore_sprite_checkpoint` rewinds the **whole environment** and permanently discards anything newer than the checkpoint. The tool refuses to run unless `confirm=true` is passed, and its description instructs the model to get explicit user confirmation first.
+
+## Configuration
+
+```python
+SpritesPlugin(
+    token=None,                # default: $SPRITES_TOKEN
+    sprite_name=None,          # default: auto-generated "adk-…"
+    plugin_name="sprites_plugin",
+    base_url="https://api.sprites.dev",
+    destroy_on_close=None,     # default: True if unnamed, False if named
+    client_timeout=600.0,      # HTTP timeout for Sprites API calls
+)
+```
+
+## Examples
+
+- [`examples/quickstart.py`](examples/quickstart.py) — minimal agent
+- [`examples/persistent_environment.py`](examples/persistent_environment.py) — a named dev environment that survives across sessions
+- [`examples/checkpoint_rollback.py`](examples/checkpoint_rollback.py) — snapshot, break things, roll back
+
+## Development
+
+```sh
+python -m venv .venv && .venv/bin/pip install -e '.[dev]'
+.venv/bin/pytest
+```
+
+### Releasing
+
+Publishing to PyPI is automated via [`.github/workflows/publish.yml`](.github/workflows/publish.yml). Push a `vX.Y.Z` tag and the workflow stamps that version into `pyproject.toml` and `sprites_adk/__init__.py`, runs the tests, builds, and publishes via PyPI trusted publishing (OIDC — no API tokens):
+
+```sh
+git tag v0.1.0
+git push origin v0.1.0
+```
+
+This requires a one-time [PyPI trusted publisher](https://docs.pypi.org/trusted-publishers/) configured for the `sprites-adk` project pointing at `superfly/sprites-adk` and workflow `publish.yml`.
+
+## Resources
+
+- [Sprites docs](https://docs.sprites.dev)
+- [Sprites Python SDK](https://github.com/superfly/sprites-py)
+- [Google ADK docs](https://google.github.io/adk-docs/)
+
+## License
+
+MIT

sprites_adk-0.1.0/README.md

@@ -0,0 +1,116 @@
+# sprites-adk
+
+Google [ADK](https://google.github.io/adk-docs/) integration for [Sprites](https://sprites.dev) — persistent, stateful Linux sandboxes for AI agents, with checkpoint/restore, from [Fly.io](https://fly.io).
+
+Most agent sandboxes are ephemeral: the environment vanishes when the session ends. A Sprite is a **stateful Linux microVM** that suspends when idle and keeps everything — files, packages, databases, running services — so your agent can resume yesterday's environment today. And because Sprites support **checkpoints**, your agent can snapshot the whole environment before a risky change and roll back if it goes wrong.
+
+## Installation
+
+```sh
+pip install sprites-adk
+```
+
+You'll need a Sprites API token ([get started](https://docs.sprites.dev/quickstart/)):
+
+```sh
+export SPRITES_TOKEN=...
+```
+
+## Quickstart
+
+```python
+from google.adk.agents import Agent
+from sprites_adk import SpritesPlugin
+
+plugin = SpritesPlugin()  # or SpritesPlugin(sprite_name="my-project") for a persistent env
+
+root_agent = Agent(
+    model="gemini-flash-latest",
+    name="sprite_agent",
+    instruction="Run code and commands in the Sprite sandbox, not locally.",
+    tools=plugin.get_tools(),
+)
+```
+
+Pass the plugin to your runner to get lifecycle callbacks and error handling:
+
+```python
+runner = InMemoryRunner(agent=root_agent, plugins=[plugin])
+```
+
+## Two modes
+
+| | `SpritesPlugin()` | `SpritesPlugin(sprite_name="my-project")` |
+|---|---|---|
+| Sprite name | auto-generated `adk-…` | yours |
+| Reused across sessions | no | **yes — full state persists** |
+| Destroyed on `plugin.close()` | yes | no |
+
+The Sprite is created lazily on first tool use; constructing the agent needs no network. Sprites suspend automatically when idle — a parked environment costs (almost) nothing.
+
+## Tools
+
+| Tool | Description |
+|---|---|
+| `execute_command_in_sprite` | Run a shell command (cwd, timeout supported) |
+| `execute_code_in_sprite` | Run a Python / JavaScript / bash snippet |
+| `write_file_to_sprite` | Write a text file (parents auto-created) |
+| `read_file_from_sprite` | Read a text file |
+| `create_sprite_checkpoint` | Snapshot the entire environment |
+| `list_sprite_checkpoints` | List checkpoints, newest first |
+| `restore_sprite_checkpoint` | Roll back to a checkpoint (**destructive**, requires `confirm=true`) |
+
+All tools return structured dicts (`success`, `stdout`/`stderr`/`exit_code`, …); failures come back as `{"success": false, "error": ...}` so the agent can adapt instead of crashing the run.
+
+File reads and writes run as commands inside the Sprite (via `base64`, so quotes/newlines/unicode survive) rather than through a separate filesystem API. That keeps them consistent with everything else the agent does — in particular, files written this way are correctly reverted by `restore_sprite_checkpoint`. `write_file_to_sprite` is capped at 256 KB; generate larger files with a command inside the Sprite. `/tmp` is tmpfs and is not captured by checkpoints.
+
+### A note on restore
+
+`restore_sprite_checkpoint` rewinds the **whole environment** and permanently discards anything newer than the checkpoint. The tool refuses to run unless `confirm=true` is passed, and its description instructs the model to get explicit user confirmation first.
+
+## Configuration
+
+```python
+SpritesPlugin(
+    token=None,                # default: $SPRITES_TOKEN
+    sprite_name=None,          # default: auto-generated "adk-…"
+    plugin_name="sprites_plugin",
+    base_url="https://api.sprites.dev",
+    destroy_on_close=None,     # default: True if unnamed, False if named
+    client_timeout=600.0,      # HTTP timeout for Sprites API calls
+)
+```
+
+## Examples
+
+- [`examples/quickstart.py`](examples/quickstart.py) — minimal agent
+- [`examples/persistent_environment.py`](examples/persistent_environment.py) — a named dev environment that survives across sessions
+- [`examples/checkpoint_rollback.py`](examples/checkpoint_rollback.py) — snapshot, break things, roll back
+
+## Development
+
+```sh
+python -m venv .venv && .venv/bin/pip install -e '.[dev]'
+.venv/bin/pytest
+```
+
+### Releasing
+
+Publishing to PyPI is automated via [`.github/workflows/publish.yml`](.github/workflows/publish.yml). Push a `vX.Y.Z` tag and the workflow stamps that version into `pyproject.toml` and `sprites_adk/__init__.py`, runs the tests, builds, and publishes via PyPI trusted publishing (OIDC — no API tokens):
+
+```sh
+git tag v0.1.0
+git push origin v0.1.0
+```
+
+This requires a one-time [PyPI trusted publisher](https://docs.pypi.org/trusted-publishers/) configured for the `sprites-adk` project pointing at `superfly/sprites-adk` and workflow `publish.yml`.
+
+## Resources
+
+- [Sprites docs](https://docs.sprites.dev)
+- [Sprites Python SDK](https://github.com/superfly/sprites-py)
+- [Google ADK docs](https://google.github.io/adk-docs/)
+
+## License
+
+MIT

sprites_adk-0.1.0/docs/adk-docs-page/README.md

@@ -0,0 +1,16 @@
+# ADK docs catalog submission
+
+This directory holds the draft page for the `google/adk-docs` integrations
+catalog, per their [contributing guide](https://github.com/google/adk-docs/blob/main/CONTRIBUTING.md#integrations).
+
+To submit, open a PR against `google/adk-docs` that adds:
+
+1. `docs/integrations/sprites.md` — the page in this directory.
+2. `docs/integrations/assets/sprites.png` — a square, card-sized Sprites
+   logo (not included here; export one from the sprites.dev brand assets).
+3. Optional but encouraged: screenshots of an agent session using the
+   integration, also under `docs/integrations/assets/`.
+
+Their review criteria: working/testable code examples, clear value for ADK
+developers, and terms-of-service compliance. Publish `sprites-adk` to PyPI
+before opening the PR so the installation instructions work.

sprites_adk-0.1.0/docs/adk-docs-page/sprites.md

@@ -0,0 +1,79 @@
+---
+catalog_title: Sprites
+catalog_description: Persistent, stateful Linux sandboxes with checkpoint/restore for agent code execution, by Fly.io
+catalog_icon: /integrations/assets/sprites.png
+---
+
+# Sprites
+
+[Sprites](https://sprites.dev) are persistent, stateful Linux sandboxes from [Fly.io](https://fly.io). Unlike ephemeral sandboxes, a Sprite keeps its filesystem, installed packages, and services between sessions — it suspends when idle and resumes in milliseconds. The `sprites-adk` plugin gives ADK agents a full Linux environment with a capability most sandboxes don't have: **checkpoint and restore**, so an agent can snapshot the environment before a risky change and roll back if it goes wrong.
+
+Supported in ADK Python.
+
+## Use cases
+
+- **Persistent development environments**: a named Sprite is reused across agent sessions — packages installed yesterday are still there today, so long-running projects don't rebuild the world every session.
+- **Secure code execution**: run Python, JavaScript, or bash produced by the model in an isolated microVM instead of the host machine.
+- **Fearless experimentation**: checkpoint the entire environment before package upgrades, migrations, or bulk edits; restore if the experiment breaks it.
+- **File workflows**: write scripts and data into the sandbox, run them, and read results back.
+
+## Prerequisites
+
+- A [Sprites account and API token](https://docs.sprites.dev/quickstart/) (`sprite tokens create`), exported as `SPRITES_TOKEN`.
+- A Google API key for the Gemini model used by your agent.
+
+## Installation
+
+```sh
+pip install sprites-adk
+```
+
+## Use with agent
+
+```python
+from google.adk.agents import Agent
+from sprites_adk import SpritesPlugin
+
+# SpritesPlugin() creates an ephemeral sandbox, destroyed on plugin.close().
+# SpritesPlugin(sprite_name="my-project") attaches to a persistent environment
+# that keeps all state between sessions and is never destroyed automatically.
+plugin = SpritesPlugin()
+
+root_agent = Agent(
+    model="gemini-flash-latest",
+    name="sprite_agent",
+    instruction=(
+        "Run code and commands inside the Sprite sandbox, not locally. "
+        "Create a checkpoint before risky operations."
+    ),
+    tools=plugin.get_tools(),
+)
+```
+
+For lifecycle callbacks and structured tool-error handling, also register the plugin with your runner:
+
+```python
+from google.adk.runners import InMemoryRunner
+
+runner = InMemoryRunner(agent=root_agent, plugins=[plugin])
+```
+
+The Sprite is created lazily on first tool use. Named Sprites are get-or-create: if a Sprite with that name already exists, the agent attaches to it with all of its state intact.
+
+## Available tools
+
+| Tool | Description |
+| --- | --- |
+| `execute_command_in_sprite` | Run a shell command with optional working directory and timeout. |
+| `execute_code_in_sprite` | Run a Python, JavaScript, or bash snippet. |
+| `write_file_to_sprite` | Write a text file (parent directories auto-created). |
+| `read_file_from_sprite` | Read a text file from the sandbox. |
+| `create_sprite_checkpoint` | Snapshot the entire environment (filesystem, packages, processes). |
+| `list_sprite_checkpoints` | List checkpoints, newest first. |
+| `restore_sprite_checkpoint` | Roll back to a checkpoint. Destructive — discards newer state and requires explicit `confirm=true`. |
+
+## Resources
+
+- [sprites-adk on PyPI](https://pypi.org/project/sprites-adk/)
+- [Source code and examples](https://github.com/superfly/sprites-adk)
+- [Sprites documentation](https://docs.sprites.dev)

sprites_adk-0.1.0/examples/checkpoint_rollback.py

@@ -0,0 +1,62 @@
+"""Checkpoint / rollback: let an agent experiment fearlessly.
+
+The agent snapshots the Sprite before a risky change; if the change breaks
+the environment, it rolls back to the checkpoint instead of trying to
+hand-undo the damage. Restore is destructive (it discards state newer than
+the checkpoint), so the restore tool requires explicit confirmation.
+
+    export SPRITES_TOKEN=...
+    export GOOGLE_API_KEY=...
+    python examples/checkpoint_rollback.py
+"""
+
+import asyncio
+
+from google.adk.agents import Agent
+from google.adk.runners import InMemoryRunner
+from google.genai import types
+
+from sprites_adk import SpritesPlugin
+
+PROMPT = """
+Set up a marker file /work/state.txt containing "v1".
+Then create a checkpoint with the comment "before-experiment".
+Then simulate a failed experiment: overwrite /work/state.txt with "broken".
+Finally, restore the checkpoint (I confirm the restore - discarding the
+"broken" state is exactly what I want) and read /work/state.txt to prove
+the environment was rolled back.
+"""
+
+
+async def main() -> None:
+    plugin = SpritesPlugin()  # ephemeral sprite, destroyed on close
+
+    agent = Agent(
+        model="gemini-flash-latest",
+        name="rollback_agent",
+        instruction=(
+            "You operate a Sprite sandbox with checkpoint/restore. Before "
+            "risky changes, create a checkpoint. Restoring discards newer "
+            "state, so only pass confirm=true when the user has clearly "
+            "agreed."
+        ),
+        tools=plugin.get_tools(),
+    )
+
+    runner = InMemoryRunner(agent=agent, plugins=[plugin])
+    session = await runner.session_service.create_session(
+        app_name=runner.app_name, user_id="demo"
+    )
+    async for event in runner.run_async(
+        user_id="demo",
+        session_id=session.id,
+        new_message=types.Content(role="user", parts=[types.Part(text=PROMPT)]),
+    ):
+        if event.content and event.content.parts and event.content.parts[0].text:
+            print(event.content.parts[0].text)
+
+    await plugin.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

sprites_adk-0.1.0/examples/persistent_environment.py

@@ -0,0 +1,61 @@
+"""A persistent development environment that survives across sessions.
+
+Because the Sprite is named, every run of this script attaches to the SAME
+Linux environment: packages installed yesterday are still installed today,
+files are still there, and the agent picks up where it left off. Sprites
+suspend automatically when idle, so a parked environment costs (almost)
+nothing.
+
+    export SPRITES_TOKEN=...
+    export GOOGLE_API_KEY=...
+    python examples/persistent_environment.py "install uv and create a fastapi project in /app"
+    # ...later, a new process, same environment:
+    python examples/persistent_environment.py "add a /health endpoint to the project in /app"
+"""
+
+import asyncio
+import sys
+
+from google.adk.agents import Agent
+from google.adk.runners import InMemoryRunner
+from google.genai import types
+
+from sprites_adk import SpritesPlugin
+
+
+async def main() -> None:
+    prompt = " ".join(sys.argv[1:]) or "What is in /app? Summarize the project state."
+
+    # Named sprite: reused across sessions, never auto-destroyed.
+    plugin = SpritesPlugin(sprite_name="my-dev-environment")
+
+    agent = Agent(
+        model="gemini-flash-latest",
+        name="dev_env_agent",
+        instruction=(
+            "You maintain a long-lived development environment inside a "
+            "Sprite. All commands, code, and files run inside the Sprite. "
+            "It persists between sessions, so check existing state before "
+            "assuming a fresh machine. Create a checkpoint before risky "
+            "changes."
+        ),
+        tools=plugin.get_tools(),
+    )
+
+    runner = InMemoryRunner(agent=agent, plugins=[plugin])
+    session = await runner.session_service.create_session(
+        app_name=runner.app_name, user_id="demo"
+    )
+    async for event in runner.run_async(
+        user_id="demo",
+        session_id=session.id,
+        new_message=types.Content(role="user", parts=[types.Part(text=prompt)]),
+    ):
+        if event.content and event.content.parts and event.content.parts[0].text:
+            print(event.content.parts[0].text)
+
+    await plugin.close()  # named sprite is preserved
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

sprites_adk-0.1.0/examples/quickstart.py

@@ -0,0 +1,31 @@
+"""Quickstart: an ADK agent with a Sprites sandbox.
+
+Prerequisites:
+    pip install sprites-adk
+    export SPRITES_TOKEN=...   # `sprite tokens create`
+    export GOOGLE_API_KEY=...  # for the Gemini model
+
+Run with the ADK CLI from the directory above this file:
+    adk run examples
+or programmatically via Runner (see persistent_environment.py).
+"""
+
+from google.adk.agents import Agent
+
+from sprites_adk import SpritesPlugin
+
+# No sprite_name: an ephemeral `adk-` prefixed Sprite is created on first
+# tool use and destroyed when the plugin is closed.
+plugin = SpritesPlugin()
+
+root_agent = Agent(
+    model="gemini-flash-latest",
+    name="sprite_agent",
+    instruction=(
+        "You help users build and test code inside a persistent Linux "
+        "sandbox (a Sprite). Run commands and code in the sandbox, not "
+        "locally. Create a checkpoint before risky operations such as "
+        "package installs or migrations."
+    ),
+    tools=plugin.get_tools(),
+)

sprites_adk-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "sprites-adk"
+version = "0.1.0"
+description = "Google ADK plugin for Sprites: persistent, stateful Linux sandboxes with checkpoint/restore for AI agents."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.9"
+authors = [{ name = "Fly.io" }]
+keywords = ["adk", "google-adk", "agents", "sandbox", "sprites", "fly.io", "code-execution"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "google-adk>=1.0.0",
+    "sprites-py>=0.2.0",
+]
+
+[project.urls]
+Homepage = "https://sprites.dev"
+Documentation = "https://docs.sprites.dev"
+Repository = "https://github.com/superfly/sprites-adk"
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["sprites_adk"]

sprites_adk-0.1.0/sprites_adk/__init__.py

@@ -0,0 +1,30 @@
+"""Google ADK integration for Sprites (https://sprites.dev).
+
+Gives ADK agents a persistent, stateful Linux sandbox with checkpoint and
+restore, backed by Fly.io's Sprites.
+"""
+
+from .plugin import SpritesPlugin
+from .tools import (
+    CreateCheckpointTool,
+    ExecuteCodeTool,
+    ExecuteCommandTool,
+    ListCheckpointsTool,
+    ReadFileTool,
+    RestoreCheckpointTool,
+    WriteFileTool,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "SpritesPlugin",
+    "ExecuteCommandTool",
+    "ExecuteCodeTool",
+    "WriteFileTool",
+    "ReadFileTool",
+    "CreateCheckpointTool",
+    "ListCheckpointsTool",
+    "RestoreCheckpointTool",
+    "__version__",
+]