space: clean sync from chief-engineer root incl. screenshots and latest README

.agents/skills/hf-cli/.hf-skill-manifest.json

@@ -1,4 +0,0 @@
-{
-  "installed_revision": "7bf59b7f85b79c74207b10d5e425934514e8b089",
-  "schema_version": 1
-}

.agents/skills/hf-cli/SKILL.md

@@ -1,218 +0,0 @@
----
-name: hf-cli
-description: "Hugging Face Hub CLI (`hf`) for downloading, uploading, and managing models, datasets, spaces, buckets, repos, papers, jobs, and more on the Hugging Face Hub. Use when: handling authentication; managing local cache; managing Hugging Face Buckets; running or scheduling jobs on Hugging Face infrastructure; managing Hugging Face repos; discussions and pull requests; browsing models, datasets and spaces; reading, searching, or browsing academic papers; managing collections; querying datasets; configuring spaces; setting up webhooks; or deploying and managing HF Inference Endpoints. Make sure to use this skill whenever the user mentions 'hf', 'huggingface', 'Hugging Face', 'huggingface-cli', or 'hugging face cli', or wants to do anything related to the Hugging Face ecosystem and to AI and ML in general. Also use for cloud storage needs like training checkpoints, data pipelines, or agent traces. Use even if the user doesn't explicitly ask for a CLI command. Replaces the deprecated `huggingface-cli`."
----
-
-Install: `curl -LsSf https://hf.co/cli/install.sh | bash -s`.
-
-The Hugging Face Hub CLI tool `hf` is available. IMPORTANT: The `hf` command replaces the deprecated `huggingface-cli` command.
-
-Use `hf --help` to view available functions. Note that auth commands are now all under `hf auth` e.g. `hf auth whoami`.
-
-Generated with `huggingface_hub v1.19.0`. Run `hf skills add --force` to regenerate.
-
-## Commands
-
-- `hf cp SRC` — Copy files between local paths, repositories, and buckets. `[--format [auto|human|agent|json|quiet]]`
-- `hf download REPO_ID` — Download files from the Hub. `[--type [model|dataset|space] --revision TEXT --include TEXT --exclude TEXT --cache-dir TEXT --local-dir TEXT --force-download --dry-run --max-workers INTEGER --format [auto|human|agent|json|quiet]]`
-- `hf env` — Print information about the environment. `[--format [auto|human|agent|json|quiet]]`
-- `hf sync` — Sync files between local directory and a bucket. `[--delete --ignore-times --ignore-sizes --plan TEXT --apply TEXT --dry-run --include TEXT --exclude TEXT --filter-from TEXT --existing --ignore-existing --verbose --format [auto|human|agent|json|quiet]]`
-- `hf update` — Update the `hf` CLI to the latest version. `[--format [auto|human|agent|json|quiet]]`
-- `hf upload REPO_ID` — Upload a file or a folder to the Hub. Recommended for single-commit uploads. `[--type [model|dataset|space] --revision TEXT --private --include TEXT --exclude TEXT --delete TEXT --commit-message TEXT --commit-description TEXT --create-pr --every FLOAT --format [auto|human|agent|json|quiet]]`
-- `hf upload-large-folder REPO_ID LOCAL_PATH` — Upload a large folder to the Hub. Recommended for resumable uploads. `[--type [model|dataset|space] --revision TEXT --private --include TEXT --exclude TEXT --num-workers INTEGER --no-report --no-bars --format [auto|human|agent|json|quiet]]`
-- `hf version` — Print information about the hf version. `[--format [auto|human|agent|json|quiet]]`
-
-### `hf auth` — Manage authentication (login, logout, etc.).
-
-- `hf auth list` — List all stored access tokens. `[--format [auto|human|agent|json|quiet]]`
-- `hf auth login` — Login using a token from huggingface.co/settings/tokens. `[--add-to-git-credential --force --format [auto|human|agent|json|quiet]]`
-- `hf auth logout` — Logout from a specific token. `[--token-name TEXT --format [auto|human|agent|json|quiet]]`
-- `hf auth switch` — Switch between access tokens. `[--token-name TEXT --add-to-git-credential --format [auto|human|agent|json|quiet]]`
-- `hf auth token` — Print the current access token to stdout. `[--format [auto|human|agent|json|quiet]]`
-- `hf auth whoami` — Find out which huggingface.co account you are logged in as. `[--format [auto|human|agent|json|quiet]]`
-
-### `hf buckets` — Commands to interact with buckets.
-
-- `hf buckets cp SRC` — Copy files between local paths, repositories, and buckets. `[--format [auto|human|agent|json|quiet]]`
-- `hf buckets create BUCKET_ID` — Create a new bucket. `[--private --region [us|eu] --exist-ok --format [auto|human|agent|json|quiet]]`
-- `hf buckets delete BUCKET_ID` — Delete a bucket. `[--yes --missing-ok --format [auto|human|agent|json|quiet]]`
-- `hf buckets info BUCKET_ID` — Get info about a bucket. `[--format [auto|human|agent|json|quiet]]`
-- `hf buckets list` — List buckets or files in a bucket. `[--human-readable --tree --recursive --search TEXT --format [auto|human|agent|json|quiet]]`
-- `hf buckets move FROM_ID TO_ID` — Move (rename) a bucket to a new name or namespace. `[--format [auto|human|agent|json|quiet]]`
-- `hf buckets remove ARGUMENT` — Remove files from a bucket. `[--recursive --yes --dry-run --include TEXT --exclude TEXT --format [auto|human|agent|json|quiet]]`
-- `hf buckets sync` — Sync files between local directory and a bucket. `[--delete --ignore-times --ignore-sizes --plan TEXT --apply TEXT --dry-run --include TEXT --exclude TEXT --filter-from TEXT --existing --ignore-existing --verbose --format [auto|human|agent|json|quiet]]`
-
-### `hf cache` — Manage local cache directory.
-
-- `hf cache list` — List cached repositories or revisions. `[--cache-dir TEXT --revisions --filter TEXT --sort [accessed|accessed:asc|accessed:desc|modified|modified:asc|modified:desc|name|name:asc|name:desc|size|size:asc|size:desc] --limit INTEGER --format [auto|human|agent|json|quiet]]`
-- `hf cache prune` — Remove detached revisions from the cache. `[--cache-dir TEXT --yes --dry-run --format [auto|human|agent|json|quiet]]`
-- `hf cache rm TARGETS` — Remove cached repositories or revisions. `[--cache-dir TEXT --yes --dry-run --format [auto|human|agent|json|quiet]]`
-- `hf cache verify REPO_ID` — Verify checksums for a single repo revision from cache or a local directory. `[--type [model|dataset|space] --revision TEXT --cache-dir TEXT --local-dir TEXT --fail-on-missing-files --fail-on-extra-files --format [auto|human|agent|json|quiet]]`
-
-### `hf collections` — Interact with collections on the Hub.
-
-- `hf collections add-item COLLECTION_SLUG ITEM_ID ITEM_TYPE` — Add an item to a collection. `[--note TEXT --exists-ok --format [auto|human|agent|json|quiet]]`
-- `hf collections create TITLE` — Create a new collection on the Hub. `[--namespace TEXT --description TEXT --private --exists-ok --format [auto|human|agent|json|quiet]]`
-- `hf collections delete COLLECTION_SLUG` — Delete a collection from the Hub. `[--missing-ok --format [auto|human|agent|json|quiet]]`
-- `hf collections delete-item COLLECTION_SLUG ITEM_OBJECT_ID` — Delete an item from a collection. `[--missing-ok --format [auto|human|agent|json|quiet]]`
-- `hf collections info COLLECTION_SLUG` — Get info about a collection on the Hub. `[--format [auto|human|agent|json|quiet]]`
-- `hf collections list` — List collections on the Hub. `[--owner TEXT --item TEXT --sort [lastModified|trending|upvotes] --limit INTEGER --format [auto|human|agent|json|quiet]]`
-- `hf collections update COLLECTION_SLUG` — Update a collection's metadata on the Hub. `[--title TEXT --description TEXT --position INTEGER --private --theme TEXT --format [auto|human|agent|json|quiet]]`
-- `hf collections update-item COLLECTION_SLUG ITEM_OBJECT_ID` — Update an item in a collection. `[--note TEXT --position INTEGER --format [auto|human|agent|json|quiet]]`
-
-### `hf datasets` — Interact with datasets on the Hub.
-
-- `hf datasets card DATASET_ID` — Get the dataset card (README) for a dataset on the Hub. `[--metadata --text --format [auto|human|agent|json|quiet]]`
-- `hf datasets info DATASET_ID` — Get info about a dataset on the Hub. `[--revision TEXT --expand TEXT --format [auto|human|agent|json|quiet]]`
-- `hf datasets leaderboard DATASET_ID` — List model scores from a dataset leaderboard. This command helps find the best models for a task or compare models by benchmark scores. Use 'hf datasets ls --filter benchmark:official' to list available leaderboards. `[--limit INTEGER --format [auto|human|agent|json|quiet]]`
-- `hf datasets list` — List datasets on the Hub, or files in a dataset repo. `[--search TEXT --author TEXT --filter TEXT --sort [created_at|downloads|last_modified|likes|trending_score] --limit INTEGER --expand TEXT --human-readable --tree --recursive --revision TEXT --format [auto|human|agent|json|quiet]]`
-- `hf datasets parquet DATASET_ID` — List parquet file URLs available for a dataset. `[--subset TEXT --split TEXT --format [auto|human|agent|json|quiet]]`
-- `hf datasets sql SQL` — Execute a raw SQL query with DuckDB against dataset parquet URLs. `[--format [auto|human|agent|json|quiet]]`
-
-### `hf discussions` — Manage discussions and pull requests on the Hub.
-
-- `hf discussions close REPO_ID NUM` — Close a discussion or pull request. `[--comment TEXT --yes --type [model|dataset|space] --format [auto|human|agent|json|quiet]]`
-- `hf discussions comment REPO_ID NUM` — Comment on a discussion or pull request. `[--body TEXT --body-file PATH --type [model|dataset|space] --format [auto|human|agent|json|quiet]]`
-- `hf discussions create REPO_ID --title TEXT` — Create a new discussion or pull request on a repo. `[--body TEXT --body-file PATH --pull-request --type [model|dataset|space] --format [auto|human|agent|json|quiet]]`
-- `hf discussions diff REPO_ID NUM` — Show the diff of a pull request. `[--type [model|dataset|space] --format [auto|human|agent|json|quiet]]`
-- `hf discussions info REPO_ID NUM` — Get info about a discussion or pull request. `[--type [model|dataset|space] --format [auto|human|agent|json|quiet]]`
-- `hf discussions list REPO_ID` — List discussions and pull requests on a repo. `[--status [open|closed|merged|draft|all] --kind [all|discussion|pull_request] --author TEXT --limit INTEGER --type [model|dataset|space] --format [auto|human|agent|json|quiet]]`
-- `hf discussions merge REPO_ID NUM` — Merge a pull request. `[--comment TEXT --yes --type [model|dataset|space] --format [auto|human|agent|json|quiet]]`
-- `hf discussions rename REPO_ID NUM NEW_TITLE` — Rename a discussion or pull request. `[--type [model|dataset|space] --format [auto|human|agent|json|quiet]]`
-- `hf discussions reopen REPO_ID NUM` — Reopen a closed discussion or pull request. `[--comment TEXT --yes --type [model|dataset|space] --format [auto|human|agent|json|quiet]]`
-
-### `hf endpoints` — Manage Hugging Face Inference Endpoints.
-
-- `hf endpoints catalog deploy --repo TEXT` — Deploy an Inference Endpoint from the Model Catalog. `[--name TEXT --accelerator TEXT --namespace TEXT --format [auto|human|agent|json|quiet]]`
-- `hf endpoints catalog list` — List available Catalog models. `[--format [auto|human|agent|json|quiet]]`
-- `hf endpoints delete NAME` — Delete an Inference Endpoint permanently. `[--namespace TEXT --yes --format [auto|human|agent|json|quiet]]`
-- `hf endpoints deploy NAME --repo TEXT --framework TEXT --accelerator TEXT --instance-size TEXT --instance-type TEXT --region TEXT --vendor TEXT` — Deploy an Inference Endpoint from a Hub repository. `[--namespace TEXT --task TEXT --min-replica INTEGER --max-replica INTEGER --scale-to-zero-timeout INTEGER --scaling-metric [pendingRequests|hardwareUsage] --scaling-threshold FLOAT --format [auto|human|agent|json|quiet]]`
-- `hf endpoints describe NAME` — Get information about an existing endpoint. `[--namespace TEXT --format [auto|human|agent|json|quiet]]`
-- `hf endpoints list` — Lists all Inference Endpoints for the given namespace. `[--namespace TEXT --format [auto|human|agent|json|quiet]]`
-- `hf endpoints pause NAME` — Pause an Inference Endpoint. `[--namespace TEXT --format [auto|human|agent|json|quiet]]`
-- `hf endpoints resume NAME` — Resume an Inference Endpoint. `[--namespace TEXT --fail-if-already-running --format [auto|human|agent|json|quiet]]`
-- `hf endpoints scale-to-zero NAME` — Scale an Inference Endpoint to zero. `[--namespace TEXT --format [auto|human|agent|json|quiet]]`
-- `hf endpoints update NAME` — Update an existing endpoint. `[--namespace TEXT --repo TEXT --accelerator TEXT --instance-size TEXT --instance-type TEXT --framework TEXT --revision TEXT --task TEXT --min-replica INTEGER --max-replica INTEGER --scale-to-zero-timeout INTEGER --scaling-metric [pendingRequests|hardwareUsage] --scaling-threshold FLOAT --format [auto|human|agent|json|quiet]]`
-
-### `hf extensions` — Manage hf CLI extensions.
-
-- `hf extensions exec NAME` — Execute an installed extension.
-- `hf extensions install REPO_ID` — Install an extension from a public GitHub repository. `[--force --format [auto|human|agent|json|quiet]]`
-- `hf extensions list` — List installed extension commands. `[--format [auto|human|agent|json|quiet]]`
-- `hf extensions remove NAME` — Remove an installed extension. `[--format [auto|human|agent|json|quiet]]`
-- `hf extensions search` — Search extensions available on GitHub (tagged with 'hf-extension' topic). `[--format [auto|human|agent|json|quiet]]`
-
-### `hf jobs` — Run and manage Jobs on the Hub.
-
-- `hf jobs cancel JOB_ID` — Cancel a Job `[--namespace TEXT --format [auto|human|agent|json|quiet]]`
-- `hf jobs hardware` — List available hardware options for Jobs `[--format [auto|human|agent|json|quiet]]`
-- `hf jobs inspect JOB_IDS` — Display detailed information on one or more Jobs `[--namespace TEXT --format [auto|human|agent|json|quiet]]`
-- `hf jobs labels JOB_ID` — Update labels on a Job. Replaces all existing labels. `[--label TEXT --clear --namespace TEXT --format [auto|human|agent|json|quiet]]`
-- `hf jobs logs JOB_ID` — Fetch the logs of a Job. `[--follow --tail INTEGER --namespace TEXT --format [auto|human|agent|json|quiet]]`
-- `hf jobs ps` — List Jobs. `[--all --namespace TEXT --filter TEXT --format [auto|human|agent|json|quiet]]`
-- `hf jobs run IMAGE COMMAND` — Run a Job. `[--env TEXT --secrets TEXT --label TEXT --volume TEXT --env-file TEXT --secrets-file TEXT --flavor [cpu-basic|cpu-upgrade|cpu-performance|cpu-xl|t4-small|t4-medium|l4x1|l4x4|l40sx1|l40sx4|l40sx8|a10g-small|a10g-large|a10g-largex2|a10g-largex4|a100-large|a100x4|a100x8|h200|h200x2|h200x4|h200x8|rtx-pro-6000|rtx-pro-6000x2|rtx-pro-6000x4|rtx-pro-6000x8] --timeout TEXT --detach --expose INTEGER --namespace TEXT]`
-- `hf jobs scheduled delete SCHEDULED_JOB_ID` — Delete a scheduled Job. `[--namespace TEXT --format [auto|human|agent|json|quiet]]`
-- `hf jobs scheduled inspect SCHEDULED_JOB_IDS` — Display detailed information on one or more scheduled Jobs `[--namespace TEXT --format [auto|human|agent|json|quiet]]`
-- `hf jobs scheduled labels SCHEDULED_JOB_ID` — Update labels on a scheduled Job. Replaces all existing labels. `[--label TEXT --clear --namespace TEXT --format [auto|human|agent|json|quiet]]`
-- `hf jobs scheduled ps` — List scheduled Jobs `[--all --namespace TEXT --filter TEXT --format [auto|human|agent|json|quiet]]`
-- `hf jobs scheduled resume SCHEDULED_JOB_ID` — Resume (unpause) a scheduled Job. `[--namespace TEXT --format [auto|human|agent|json|quiet]]`
-- `hf jobs scheduled run SCHEDULE IMAGE COMMAND` — Schedule a Job. `[--suspend --concurrency --env TEXT --secrets TEXT --label TEXT --volume TEXT --env-file TEXT --secrets-file TEXT --flavor [cpu-basic|cpu-upgrade|cpu-performance|cpu-xl|t4-small|t4-medium|l4x1|l4x4|l40sx1|l40sx4|l40sx8|a10g-small|a10g-large|a10g-largex2|a10g-largex4|a100-large|a100x4|a100x8|h200|h200x2|h200x4|h200x8|rtx-pro-6000|rtx-pro-6000x2|rtx-pro-6000x4|rtx-pro-6000x8] --timeout TEXT --expose INTEGER --namespace TEXT]`
-- `hf jobs scheduled suspend SCHEDULED_JOB_ID` — Suspend (pause) a scheduled Job. `[--namespace TEXT --format [auto|human|agent|json|quiet]]`
-- `hf jobs scheduled uv run SCHEDULE SCRIPT` — Run a UV script (local file or URL) on HF infrastructure `[--suspend --concurrency --image TEXT --flavor [cpu-basic|cpu-upgrade|cpu-performance|cpu-xl|t4-small|t4-medium|l4x1|l4x4|l40sx1|l40sx4|l40sx8|a10g-small|a10g-large|a10g-largex2|a10g-largex4|a100-large|a100x4|a100x8|h200|h200x2|h200x4|h200x8|rtx-pro-6000|rtx-pro-6000x2|rtx-pro-6000x4|rtx-pro-6000x8] --env TEXT --secrets TEXT --label TEXT --volume TEXT --env-file TEXT --secrets-file TEXT --timeout TEXT --expose INTEGER --namespace TEXT --with TEXT --python TEXT]`
-- `hf jobs stats` — Fetch the resource usage statistics and metrics of Jobs `[--namespace TEXT --format [auto|human|agent|json|quiet]]`
-- `hf jobs uv run SCRIPT` — Run a UV script (local file or URL) on HF infrastructure `[--image TEXT --flavor [cpu-basic|cpu-upgrade|cpu-performance|cpu-xl|t4-small|t4-medium|l4x1|l4x4|l40sx1|l40sx4|l40sx8|a10g-small|a10g-large|a10g-largex2|a10g-largex4|a100-large|a100x4|a100x8|h200|h200x2|h200x4|h200x8|rtx-pro-6000|rtx-pro-6000x2|rtx-pro-6000x4|rtx-pro-6000x8] --env TEXT --secrets TEXT --label TEXT --volume TEXT --env-file TEXT --secrets-file TEXT --timeout TEXT --detach --expose INTEGER --namespace TEXT --with TEXT --python TEXT]`
-
-### `hf models` — Interact with models on the Hub.
-
-- `hf models card MODEL_ID` — Get the model card (README) for a model on the Hub. `[--metadata --text --format [auto|human|agent|json|quiet]]`
-- `hf models info MODEL_ID` — Get info about a model on the Hub. `[--revision TEXT --expand TEXT --format [auto|human|agent|json|quiet]]`
-- `hf models list` — List models on the Hub, or files in a model repo. `[--search TEXT --author TEXT --filter TEXT --num-parameters TEXT --sort [created_at|downloads|last_modified|likes|trending_score] --limit INTEGER --expand TEXT --human-readable --tree --recursive --revision TEXT --format [auto|human|agent|json|quiet]]`
-
-### `hf papers` — Interact with papers on the Hub.
-
-- `hf papers info PAPER_ID` — Get info about a paper on the Hub. `[--format [auto|human|agent|json|quiet]]`
-- `hf papers list` — List daily papers on the Hub. `[--date TEXT --week TEXT --month TEXT --submitter TEXT --sort [publishedAt|trending] --limit INTEGER --format [auto|human|agent|json|quiet]]`
-- `hf papers read PAPER_ID` — Read a paper as markdown. `[--format [auto|human|agent|json|quiet]]`
-- `hf papers search QUERY` — Search papers on the Hub. `[--limit INTEGER --format [auto|human|agent|json|quiet]]`
-
-### `hf repos` — Manage repos on the Hub.
-
-- `hf repos branch create REPO_ID BRANCH` — Create a new branch for a repo on the Hub. `[--revision TEXT --type [model|dataset|space] --exist-ok --format [auto|human|agent|json|quiet]]`
-- `hf repos branch delete REPO_ID BRANCH` — Delete a branch from a repo on the Hub. `[--type [model|dataset|space] --format [auto|human|agent|json|quiet]]`
-- `hf repos cp SRC` — Copy files between local paths, repositories, and buckets. `[--format [auto|human|agent|json|quiet]]`
-- `hf repos create REPO_ID` — Create a new repo on the Hub. `[--type [model|dataset|space] --space-sdk TEXT --private --public --protected --exist-ok --resource-group-id TEXT --region [us|eu] --flavor [cpu-basic|cpu-upgrade|zero-a10g|t4-small|t4-medium|l4x1|l4x4|l40sx1|l40sx4|l40sx8|a10g-small|a10g-large|a10g-largex2|a10g-largex4|a100-large|a100x4|a100x8] --storage [small|medium|large] --sleep-time INTEGER --secrets TEXT --secrets-file TEXT --env TEXT --env-file TEXT --volume TEXT --format [auto|human|agent|json|quiet]]`
-- `hf repos delete REPO_ID` — Delete a repo from the Hub. This is an irreversible operation. `[--type [model|dataset|space] --missing-ok --yes --format [auto|human|agent|json|quiet]]`
-- `hf repos delete-files REPO_ID PATTERNS` — Delete files from a repo on the Hub. `[--type [model|dataset|space] --revision TEXT --commit-message TEXT --commit-description TEXT --create-pr --format [auto|human|agent|json|quiet]]`
-- `hf repos duplicate FROM_ID` — Duplicate a repo on the Hub (model, dataset, or Space). `[--type [model|dataset|space] --private --public --protected --exist-ok --flavor [cpu-basic|cpu-upgrade|zero-a10g|t4-small|t4-medium|l4x1|l4x4|l40sx1|l40sx4|l40sx8|a10g-small|a10g-large|a10g-largex2|a10g-largex4|a100-large|a100x4|a100x8] --storage [small|medium|large] --sleep-time INTEGER --secrets TEXT --secrets-file TEXT --env TEXT --env-file TEXT --volume TEXT --format [auto|human|agent|json|quiet]]`
-- `hf repos list` — List all repos (models, datasets, spaces, buckets) with storage info. `[--namespace TEXT --type [model|dataset|space|bucket] --search TEXT --limit INTEGER --explore --format [auto|human|agent|json|quiet]]`
-- `hf repos move FROM_ID TO_ID` — Move a repository from a namespace to another namespace. `[--type [model|dataset|space] --format [auto|human|agent|json|quiet]]`
-- `hf repos settings REPO_ID` — Update the settings of a repository. `[--gated [auto|manual|false] --private --public --protected --type [model|dataset|space] --format [auto|human|agent|json|quiet]]`
-- `hf repos tag create REPO_ID TAG` — Create a tag for a repo. `[--message TEXT --revision TEXT --type [model|dataset|space] --format [auto|human|agent|json|quiet]]`
-- `hf repos tag delete REPO_ID TAG` — Delete a tag for a repo. `[--yes --type [model|dataset|space] --format [auto|human|agent|json|quiet]]`
-- `hf repos tag list REPO_ID` — List tags for a repo. `[--type [model|dataset|space] --format [auto|human|agent|json|quiet]]`
-
-### `hf skills` — Manage skills for AI assistants.
-
-- `hf skills add` — Download a Hugging Face skill and install it for an AI assistant. `[--claude --global --dest PATH --force --format [auto|human|agent|json|quiet]]`
-- `hf skills list` — List available skills from the Hugging Face marketplace. `[--format [auto|human|agent|json|quiet]]`
-- `hf skills preview` — Print the generated `hf-cli` SKILL.md to stdout. `[--format [auto|human|agent|json|quiet]]`
-- `hf skills update` — Update installed Hugging Face marketplace skills. `[--claude --global --dest PATH --format [auto|human|agent|json|quiet]]`
-
-### `hf spaces` — Interact with spaces on the Hub.
-
-- `hf spaces card SPACE_ID` — Get the Space card (README) for a Space on the Hub. `[--metadata --text --format [auto|human|agent|json|quiet]]`
-- `hf spaces dev-mode SPACE_ID` — Enable or disable dev mode on a Space. `[--stop --format [auto|human|agent|json|quiet]]`
-- `hf spaces hardware` — List available hardware options for Spaces. `[--format [auto|human|agent|json|quiet]]`
-- `hf spaces hot-reload SPACE_ID` — Hot-reload any Python file of a Space without a full rebuild + restart. `[--local-file PATH --skip-checks --skip-summary --format [auto|human|agent|json|quiet]]`
-- `hf spaces info SPACE_ID` — Get info about a space on the Hub. `[--revision TEXT --expand TEXT --format [auto|human|agent|json|quiet]]`
-- `hf spaces list` — List spaces on the Hub, or files in a space repo. `[--search TEXT --author TEXT --filter TEXT --sort [created_at|last_modified|likes|trending_score] --limit INTEGER --expand TEXT --human-readable --tree --recursive --revision TEXT --format [auto|human|agent|json|quiet]]`
-- `hf spaces logs SPACE_ID` — Fetch the run or build logs of a Space. `[--build --follow --tail INTEGER --format [auto|human|agent|json|quiet]]`
-- `hf spaces pause SPACE_ID` — Pause a Space. `[--format [auto|human|agent|json|quiet]]`
-- `hf spaces restart SPACE_ID` — Restart a Space. `[--factory-reboot --format [auto|human|agent|json|quiet]]`
-- `hf spaces search QUERY` — Search spaces on the Hub using semantic search. `[--filter TEXT --sdk TEXT --include-non-running --description --limit INTEGER --format [auto|human|agent|json|quiet]]`
-- `hf spaces secrets add SPACE_ID` — Add or update secrets for a Space. `[--secrets TEXT --secrets-file TEXT --format [auto|human|agent|json|quiet]]`
-- `hf spaces secrets delete SPACE_ID KEY` — Remove a secret from a Space. `[--yes --format [auto|human|agent|json|quiet]]`
-- `hf spaces secrets list SPACE_ID` — List secrets for a Space. Secret values are write-only and not returned. `[--format [auto|human|agent|json|quiet]]`
-- `hf spaces settings SPACE_ID` — Update the settings of a Space. `[--sleep-time INTEGER --hardware [cpu-basic|cpu-upgrade|zero-a10g|t4-small|t4-medium|l4x1|l4x4|l40sx1|l40sx4|l40sx8|a10g-small|a10g-large|a10g-largex2|a10g-largex4|a100-large|a100x4|a100x8] --format [auto|human|agent|json|quiet]]`
-- `hf spaces ssh SPACE_ID` — SSH into a Space's Dev Mode container. `[--identity-file PATH --dry-run --auto --format [auto|human|agent|json|quiet]]`
-- `hf spaces variables add SPACE_ID` — Add or update environment variables for a Space. `[--env TEXT --env-file TEXT --format [auto|human|agent|json|quiet]]`
-- `hf spaces variables delete SPACE_ID KEY` — Remove an environment variable from a Space. `[--yes --format [auto|human|agent|json|quiet]]`
-- `hf spaces variables list SPACE_ID` — List environment variables for a Space. `[--format [auto|human|agent|json|quiet]]`
-- `hf spaces volumes delete SPACE_ID` — Remove all volumes from a Space. `[--yes --format [auto|human|agent|json|quiet]]`
-- `hf spaces volumes list SPACE_ID` — List volumes mounted in a Space. `[--format [auto|human|agent|json|quiet]]`
-- `hf spaces volumes set SPACE_ID` — Set (replace) volumes for a Space. `[--volume TEXT --format [auto|human|agent|json|quiet]]`
-
-### `hf webhooks` — Manage webhooks on the Hub.
-
-- `hf webhooks create --watch TEXT` — Create a new webhook. `[--url TEXT --job-id TEXT --domain [repo|discussions] --secret TEXT --format [auto|human|agent|json|quiet]]`
-- `hf webhooks delete WEBHOOK_ID` — Delete a webhook permanently. `[--yes --format [auto|human|agent|json|quiet]]`
-- `hf webhooks disable WEBHOOK_ID` — Disable an active webhook. `[--format [auto|human|agent|json|quiet]]`
-- `hf webhooks enable WEBHOOK_ID` — Enable a disabled webhook. `[--format [auto|human|agent|json|quiet]]`
-- `hf webhooks info WEBHOOK_ID` — Show full details for a single webhook. `[--format [auto|human|agent|json|quiet]]`
-- `hf webhooks list` — List all webhooks for the current user. `[--format [auto|human|agent|json|quiet]]`
-- `hf webhooks update WEBHOOK_ID` — Update an existing webhook. Only provided options are changed. `[--url TEXT --watch TEXT --domain [repo|discussions] --secret TEXT --format [auto|human|agent|json|quiet]]`
-
-## Common options
-
-- `--format` — Output format: `--format json` (or `--json`) or `--format table` (default).
-- `-q / --quiet` — Quiet output (one ID per line).
-- `--revision` — Git revision id which can be a branch name, a tag, or a commit hash.
-- `--token` — Use a User Access Token. Prefer setting `HF_TOKEN` env var instead of passing `--token`.
-- `--type` — The type of repository (model, dataset, or space).
-
-## Mounting repos as local filesystems
-
-To mount Hub repositories or buckets as local filesystems — no download, no copy, no waiting — use `hf-mount`. Files are fetched on demand. GitHub: https://github.com/huggingface/hf-mount
-
-Install: `curl -fsSL https://raw.githubusercontent.com/huggingface/hf-mount/main/install.sh | sh`
-
-Some command examples:
-- `hf-mount start repo openai-community/gpt2 /tmp/gpt2` — mount a repo (read-only)
-- `hf-mount start --hf-token $HF_TOKEN bucket myuser/my-bucket /tmp/data` — mount a bucket (read-write)
-- `hf-mount status` / `hf-mount stop /tmp/data` — list or unmount
-
-## Tips
-
-- Use `hf <command> --help` for full options, descriptions, usage, and real-world examples
-- Authenticate with `HF_TOKEN` env var (recommended) or with `--token`
-- Update the CLI with `hf update` (uses the correct command for the detected install method)

.agents/skills/modal/SKILL.md

@@ -1,88 +0,0 @@
----
-name: modal
-description: >
-  This skill provides guidance for working with the Modal cloud platform. Use
-  this skill whenever the user mentions Modal or has code that imports the
-  `modal` SDK in Python, Go, or JavaScript. This skill should also trigger when
-  the user needs to run Python code with vertical or horizontal scalability
-  (e.g. batch jobs), needs access to GPUs (e.g. AI workloads including training
-  and inference) or needs to run untrusted processes in a sandbox, since Modal
-  serves these use cases well.
-metadata:
-  version: "1.5.0"
----
-
-# Overview
-
-This is a foundational skill for working with the Modal cloud platform.
-
-Modal is a platform for AI workloads. It offers highly scalable serverless compute (including GPUs) with minimal configuration.
-
-# Documentation
-
-The official docs are the best source for up-to-date information on the platform. Make use of them when planning, debugging, or answering questions!
-
-Modal's documentation is outlined at https://modal.com/llms.txt. This file contains titles and URLs for all public docs; reading it directly will guide you to specific content.
-
-The docs are divided into three sections:
-
-- _Guide_ pages have explanations of Modal features, primitives, and workflows
-- _API Reference_ pages have detailed information about each component of the SDK
-- _Examples_ pages contain didactic examples of various AI applications on Modal
-
-Fetch the docs using a `.md` extension to get plain text.
-
-If this skill has been installed via the `modal` CLI, the docs are also bundled locally under `references/`.
-
-You can also refer to https://modal.com/llms-full.txt, which aggregates all docs in a single very large file. Do *not* read this into your main context, but it may be useful for searching.
-
-# Using the CLI
-
-The `modal` CLI can be used to run or deploy code, manage resources, and observe running Apps. It is a key tool for interacting with Modal throughout all stages of development.
-
-Run `modal --help` to see all available CLI commands.
-
-You can see more detailed information about each command by running `modal [command] --help`. Rely on the `--help` to discover functionality: new features are added in every release! Always check the `--help` if you encounter a usage error.
-
-Tip: many CLI commands accept a `--json` flag to make their output more easily parseable, e.g. with `jq`.
-
-The `modal` CLI is part of the Python SDK and executes in a Python runtime. Depending on the user's preferred Python development workflow, you may need to prefix `modal` CLI invocations with, e.g., `uv run` to ensure a consistent Python environment. The CLI can also be used via `uvx` as a standalone tool, but only do this when working outside of a Python project.
-
-# Getting up to date
-
-You have significant knowledge about Modal from your training data but may not be aware of new features or recent changes to the API. Modal is continuously adding new features. Reading relevant docs while planning or debugging can help you discover the most up-to-date way to accomplish a task on Modal.
-
-The Modal CLI provides a `modal changelog` command for learning about recent changes. Useful invocation patterns:
-
-- `modal changelog --since [DATE]` to see changes added since your knowledge cutoff
-- `modal changelog --since [VERSION]` when migrating a codebase to a newer version
-- `modal changelog --newer` to discover features that would be available on update
-
-Note: `modal changelog` requires network access.
-
-Run `modal --version` to see the SDK version that is in use.
-
-If your code exercises deprecated APIs, Modal will issue warnings. Use the warning message and related documentation to migrate your code to stable API.
-
-This skill will also be improved over time. Its version should correspond to the version of the Modal SDK that you are using. If the skill is out of date, it can be updated by running `modal skills update`.
-
-# Auth
-
-Modal is a cloud platform. Using the CLI or running code that depends on the `modal` library requires internet access and an authorization token. There is no "local development mode" with Modal.
-
-You can use the `modal token` CLI to create a new token (note: this workflow requires human user involvement) or to debug authorization issues. Token setup only needs to happen once, so assume it is configured unless you encounter issues.
-
-# Async Python
-
-When writing async Python, use Modal's `.aio()` interface (e.g. `await modal.Sandbox.create.aio(...)`, `await modal.Function.remote.aio(...)`) so that Modal runs its I/O operations via asynchronous coroutines.
-
-# Other languages
-
-Python is currently the only runtime language for Modal Functions, but there are Modal SDKs in both JavaScript (TypeScript) and Go:
-
-- JavaScript SDK: https://github.com/modal-labs/modal-client/blob/main/js/README.md
-- Go SDK: https://github.com/modal-labs/modal-client/blob/main/go/README.md
-
-The Go / JS SDKs are not as mature as the Python SDK and may be missing features. The current scope for the Go / JS SDKs includes (1) creating and interacting with Sandboxes and (2) calling into deployed Modal Functions (i.e., Functions defined in Python).
-
-They are primarily documented through examples hosted on GitHub rather than through the main Modal docs. You likely have much less knowledge of these SDKs from your training, so rely on these examples.

.agents/skills/modal/references/api/modal.App.md

@@ -1,514 +0,0 @@
-# modal.App
-
-
-```python
-class App(object)
-```
-
-A Modal App is a group of functions and classes that are deployed together.
-
-The app serves at least three purposes:
-
-* A unit of deployment for functions and classes.
-* Syncing of identities of (primarily) functions and classes across processes
-  (your local Python interpreter and every Modal container active in your application).
-* Manage log collection for everything that happens inside your code.
-
-**Registering functions with an app**
-
-The most common way to explicitly register an Object with an app is through the
-`@app.function()` decorator. It both registers the annotated function itself and
-other passed objects, like schedules and secrets, with the app:
-
-```python
-import modal
-
-app = modal.App()
-
-@app.function(
-    secrets=[modal.Secret.from_name("some_secret")],
-    schedule=modal.Period(days=1),
-)
-def foo():
-    pass
-```
-
-In this example, the secret and schedule are registered with the app.
-
-```python
-__init__(self, name=None, *, tags=None, image=None, secrets=[], volumes={},
-    include_source=True)
-```
-Construct a new app, optionally with default image, mounts, secrets, or volumes.
-
-**Parameters**
-
-<Parameter name="name" type="str | None" defaultValue="None" description="Optional app name used for registration and lookup." />
-<Parameter name="tags" type="dict[str, str] | None" defaultValue="None" description="Additional metadata to set on the App." />
-<Parameter name="image" type="_Image | None" defaultValue="None" description="Default image for the App (otherwise defaults to `modal.Image.debian_slim()`)." />
-<Parameter name="secrets" type="Sequence[_Secret]" defaultValue="[]" description="Secrets to add for all Functions in the App." />
-<Parameter name="volumes" type="dict[str | PurePosixPath, _Volume]" defaultValue="&#123;&#125;" description="Volume mounts to use for all Functions." />
-<Parameter name="include_source" type="bool" defaultValue="True" description="Default for whether Function source files are added to the Modal container (per-function override possible)." />
-
-**Usage**
-
-```python notest
-image = modal.Image.debian_slim().pip_install(...)
-secret = modal.Secret.from_name("my-secret")
-volume = modal.Volume.from_name("my-data")
-app = modal.App(image=image, secrets=[secret], volumes={"/mnt/data": volume})
-```
-
-## name
-
-```python
-name(self)
-```
-The user-provided name of the App.
-
-**Returns**
-
-The configured app name, if any.
-
-## app_id
-
-```python
-app_id(self)
-```
-Return the app_id of a running or stopped app.
-
-**Returns**
-
-The app ID when the app has been deployed or run, otherwise None.
-
-## description
-
-```python
-description(self)
-```
-The App's `name`, if available, or a fallback descriptive identifier.
-
-**Returns**
-
-Human-readable description string for the app.
-
-## lookup
-
-```python
-lookup(name, *, client=None, environment_name=None, create_if_missing=False)
-```
-Look up an App with a given name, creating a new App if necessary.
-
-Note that Apps created through this method will be in a deployed state,
-but they will not have any associated Functions or Classes. This method
-is mainly useful for creating an App to associate with a Sandbox.
-
-**Parameters**
-
-<Parameter name="name" type="str" description="App name to resolve or create." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use; defaults to `Client.from_env()` when omitted." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="Optional environment name; defaults to the configured environment." />
-<Parameter name="create_if_missing" type="bool" defaultValue="False" description="If True, create the app when it does not already exist." />
-
-**Returns**
-
-An `App` handle tied to the deployed app record.
-
-**Usage**
-
-```python
-app = modal.App.lookup("my-app", create_if_missing=True)
-modal.Sandbox.create("echo", "hi", app=app)
-```
-
-## get_dashboard_url
-
-```python
-get_dashboard_url(self)
-```
-Get the dashboard URL for the App.
-
-**Returns**
-
-The dashboard URL for the App.
-
-**Usage**
-
-```python
-app = modal.App.lookup("my-app")
-print(app.get_dashboard_url())
-```
-
-## run
-
-```python
-run(self, *, name=None, client=None, detach=False, interactive=False,
-    environment_name=None)
-```
-Context manager that runs an ephemeral app on Modal.
-
-Use this as the main entry point for your Modal application. All calls
-to Modal Functions should be made within the scope of this context
-manager, and they will correspond to the current App.
-
-Note that you should not invoke this in global scope of a file where you have
-Modal Functions or Classes defined, since that would run the block when the Function
-or Cls is imported in your containers as well. If you want to run it as your entrypoint,
-consider protecting it with ``if __name__ == "__main__"``.
-
-**Parameters**
-
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use for the run session." />
-<Parameter name="detach" type="bool" defaultValue="False" description="Whether to detach after starting the app." />
-<Parameter name="interactive" type="bool" defaultValue="False" description="Whether to run in interactive mode." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="Optional environment name; defaults to the configured environment." />
-
-**Returns**
-
-Async context manager yielding this `App` while it is running.
-
-**Usage**
-
-```python notest
-with app.run():
-    some_modal_function.remote()
-```
-
-To enable output printing (i.e., to see App logs), use `modal.enable_output()`:
-
-```python notest
-with modal.enable_output():
-    with app.run():
-        some_modal_function.remote()
-```
-
-Note that you should not invoke this in global scope of a file where you have Modal
-Functions or Classes defined, since that would run the block when the Function or Cls
-is imported in your containers as well. If you want to run it as your entrypoint,
-consider protecting it:
-
-```python
-if __name__ == "__main__":
-    with app.run():
-        some_modal_function.remote()
-```
-
-You can then run your script with:
-
-```shell
-python app_module.py
-```
-
-## deploy
-
-```python
-deploy(self, *, name=None, environment_name=None, tag="", client=None,
-    strategy="rolling")
-```
-Deploy the App so that it is available persistently.
-
-Deployed Apps will be available for lookup or web-based invocations until they are stopped.
-Unlike with `App.run`, this method will return as soon as the deployment completes.
-
-This method is a programmatic alternative to the `modal deploy` CLI command.
-
-Unlike with `App.run`, Function logs will not stream back to the local client after the
-App is deployed.
-
-Note that you should not invoke this method in global scope, as that would redeploy
-the App every time the file is imported. If you want to write a programmatic deployment
-script, protect this call so that it only runs when the file is executed directly.
-
-**Parameters**
-
-<Parameter name="name" type="str | None" defaultValue="None" description="Name for the deployment, overriding any set on the App." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="Environment to deploy the App in." />
-<Parameter name="tag" type="str" defaultValue="&quot;&quot;" description="Optional metadata that is specific to this deployment." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Alternate client to use for communication with the server." />
-<Parameter name="strategy" type="str" defaultValue="&quot;rolling&quot;" description="Deployment strategy. ``rolling`` (default) shifts traffic gradually to new containers while old ones drain. ``recreate`` terminates all running containers as part of the deployment before new work starts." />
-
-**Returns**
-
-This app instance after deployment completes.
-
-**Usage**
-
-```python notest
-app = App("my-app")
-app.deploy()
-```
-
-To enable output printing (i.e., to see build logs), use `modal.enable_output()`:
-
-```python notest
-app = App("my-app")
-with modal.enable_output():
-    app.deploy()
-```
-
-Unlike with `App.run`, Function logs will not stream back to the local client after the App is deployed.
-
-Note that you should not invoke this method in global scope, as that would redeploy the App every time
-the file is imported. If you want to write a programmatic deployment script, protect this call so that it
-only runs when the file is executed directly. You can then run your script with:
-
-```python notest
-if __name__ == "__main__":
-    with modal.enable_output():
-        app.deploy()
-```
-
-Then you can deploy your app with:
-
-```shell
-python app_module.py
-```
-
-## local_entrypoint
-
-```python
-local_entrypoint(self, _warn_parentheses_missing=None, *, name=None)
-```
-Decorate a function to be used as a CLI entrypoint for a Modal App.
-
-These functions can be used to define code that runs locally to set up the app,
-and act as an entrypoint to start Modal functions from. Note that regular
-Modal functions can also be used as CLI entrypoints, but unlike `local_entrypoint`,
-those functions are executed remotely directly.
-
-Note that an explicit [`app.run()`](https://modal.com/docs/reference/modal.App#run) is not needed, as an
-[app](https://modal.com/docs/guide/apps) is automatically created for you.
-
-**Parameters**
-
-<Parameter name="name" type="str | None" defaultValue="None" description="Optional name for the entrypoint; defaults to the function&#x27;s qualified name." />
-
-**Returns**
-
-A decorator that registers the wrapped callable as a local CLI entrypoint.
-
-**Usage**
-
-```python
-@app.local_entrypoint()
-def main():
-    some_modal_function.remote()
-```
-
-You can call the function using `modal run` directly from the CLI:
-
-```shell
-modal run app_module.py
-```
-
-Note that an explicit `app.run()` is not needed, as an app is automatically created for you.
-
-**Multiple entrypoints**
-
-If you have multiple `local_entrypoint` functions, qualify the name:
-
-```shell
-modal run app_module.py::app.some_other_function
-```
-
-**Parsing arguments**
-
-If your entrypoint function take arguments with primitive types, `modal run` automatically
-parses them as CLI options. For example, the following function can be called with
-`modal run app_module.py --foo 1 --bar "hello"`:
-
-```python
-@app.local_entrypoint()
-def main(foo: int, bar: str):
-    some_modal_function.call(foo, bar)
-```
-
-Currently, `str`, `int`, `float`, `bool`, and `datetime.datetime` are supported.
-Use `modal run app_module.py --help` for more information on usage.
-
-## function
-
-```python
-function(self, *, image=None, schedule=None, env=None, secrets=None, gpu=None,
-    serialized=False, network_file_systems={}, volumes={}, cpu=None,
-    memory=None, ephemeral_disk=None, min_containers=None, max_containers=None,
-    buffer_containers=None, scaledown_window=None, proxy=None, retries=None,
-    timeout=300, startup_timeout=None, name=None, is_generator=None, cloud=None,
-    region=None, routing_region=None, nonpreemptible=False,
-    enable_memory_snapshot=False, block_network=False,
-    restrict_modal_access=False, single_use_containers=False, i6pn=None,
-    include_source=None, experimental_options=None,
-    _experimental_restrict_output=False, max_inputs=None)
-```
-Decorator to register a new Modal Function with this App.
-
-**Parameters**
-
-<Parameter name="image" type="_Image | None" defaultValue="None" description="The image to run as the container for the function." />
-<Parameter name="schedule" type="Schedule | None" defaultValue="None" description="An optional Modal Schedule for the function." />
-<Parameter name="env" type="dict[str, str | None] | None" defaultValue="None" description="Environment variables to set in the container." />
-<Parameter name="secrets" type="Collection[_Secret] | None" defaultValue="None" description="Secrets to inject into the container as environment variables." />
-<Parameter name="gpu" type="str | list[str] | None" defaultValue="None" description="GPU request; either a single GPU type or a list of types." />
-<Parameter name="serialized" type="bool" defaultValue="False" description="Whether to send the function over using cloudpickle." />
-<Parameter name="network_file_systems" type="dict[str | PurePosixPath, _NetworkFileSystem]" defaultValue="&#123;&#125;" description="Mountpoints for Modal NetworkFileSystems." />
-<Parameter name="volumes" type="dict[str | PurePosixPath, _Volume | _CloudBucketMount]" defaultValue="&#123;&#125;" description="Mount points for Modal Volumes &amp; CloudBucketMounts." />
-<Parameter name="cpu" type="float | tuple[float, float] | None" defaultValue="None" description="Specify, in fractional CPU cores, how many CPU cores to request. Or, pass (request, limit) to additionally specify a hard limit in fractional CPU cores. CPU throttling will prevent a container from exceeding its specified limit." />
-<Parameter name="memory" type="int | tuple[int, int] | None" defaultValue="None" description="Specify, in MiB, a memory request which is the minimum memory required. Or, pass (request, limit) to additionally specify a hard limit in MiB." />
-<Parameter name="ephemeral_disk" type="int | None" defaultValue="None" description="Specify, in MiB, the ephemeral disk size for the Function." />
-<Parameter name="min_containers" type="int | None" defaultValue="None" description="Minimum number of containers to keep warm, even when Function is idle." />
-<Parameter name="max_containers" type="int | None" defaultValue="None" description="Limit on the number of containers that can be concurrently running." />
-<Parameter name="buffer_containers" type="int | None" defaultValue="None" description="Number of additional idle containers to maintain under active load." />
-<Parameter name="scaledown_window" type="int | None" defaultValue="None" description="Max time (in seconds) a container can remain idle while scaling down." />
-<Parameter name="proxy" type="_Proxy | None" defaultValue="None" description="Reference to a Modal Proxy to use in front of this function." />
-<Parameter name="retries" type="int | Retries | None" defaultValue="None" description="Number of times to retry each input in case of failure." />
-<Parameter name="timeout" type="int" defaultValue="300" description="Maximum execution time for inputs and startup time in seconds." />
-<Parameter name="startup_timeout" type="int | None" defaultValue="None" description="Maximum startup time in seconds with higher precedence than `timeout`." />
-<Parameter name="name" type="str | None" defaultValue="None" description="Sets the Modal name of the function within the app." />
-<Parameter name="is_generator" type="None | bool" defaultValue="None" description="Set this to True if it&#x27;s a non-generator function returning a sync or async generator object." />
-<Parameter name="cloud" type="str | None" defaultValue="None" description="Cloud provider to run the function on. Possible values are aws, gcp, oci, auto." />
-<Parameter name="region" type="str | Sequence[str] | None" defaultValue="None" description="Region or regions to run the function on." />
-<Parameter name="routing_region" type="str | None" defaultValue="None" description="Region to route inputs to the function through." />
-<Parameter name="nonpreemptible" type="bool" defaultValue="False" description="Whether to run the function on a nonpreemptible instance." />
-<Parameter name="enable_memory_snapshot" type="bool" defaultValue="False" description="Enable memory checkpointing for faster cold starts." />
-<Parameter name="block_network" type="bool" defaultValue="False" description="Whether to block network access." />
-<Parameter name="restrict_modal_access" type="bool" defaultValue="False" description="Whether to allow this function access to other Modal resources." />
-<Parameter name="single_use_containers" type="bool" defaultValue="False" description="When True, containers will shut down after handling a single input." />
-<Parameter name="i6pn" type="bool | None" defaultValue="None" description="Whether to enable IPv6 container networking within the region." />
-<Parameter name="include_source" type="bool | None" defaultValue="None" description="Whether the file or directory containing the Function&#x27;s source should automatically be included in the container. When unset, falls back to the App-level configuration, or is otherwise True by default." />
-<Parameter name="experimental_options" type="dict[str, Any] | None" defaultValue="None" description="Experimental options for the function." />
-<Parameter name="_experimental_restrict_output" type="bool" defaultValue="False" description="Experimental; do not use pickle for return values." />
-<Parameter name="max_inputs" type="int | None" defaultValue="None" description="Deprecated; replaced with `single_use_containers`." />
-
-**Returns**
-
-A decorator that registers the wrapped callable or partial as a Modal `Function`.
-
-## cls
-
-```python
-cls(self, *, image=None, env=None, secrets=None, gpu=None, serialized=False,
-    network_file_systems={}, volumes={}, cpu=None, memory=None,
-    ephemeral_disk=None, min_containers=None, max_containers=None,
-    buffer_containers=None, scaledown_window=None, proxy=None, retries=None,
-    timeout=300, startup_timeout=None, cloud=None, region=None,
-    routing_region=None, nonpreemptible=False, enable_memory_snapshot=False,
-    block_network=False, restrict_modal_access=False,
-    single_use_containers=False, i6pn=None, include_source=None,
-    experimental_options=None, _experimental_restrict_output=False,
-    max_inputs=None)
-```
-Decorator to register a new Modal [Cls](https://modal.com/docs/reference/modal.Cls) with this App.
-
-**Parameters**
-
-<Parameter name="image" type="_Image | None" defaultValue="None" description="The image to run as the container for the class service." />
-<Parameter name="env" type="dict[str, str | None] | None" defaultValue="None" description="Environment variables to set in the container." />
-<Parameter name="secrets" type="Collection[_Secret] | None" defaultValue="None" description="Secrets to inject into the container as environment variables." />
-<Parameter name="gpu" type="str | list[str] | None" defaultValue="None" description="GPU request; either a single GPU type or a list of types." />
-<Parameter name="serialized" type="bool" defaultValue="False" description="Whether to send the class over using cloudpickle." />
-<Parameter name="network_file_systems" type="dict[str | PurePosixPath, _NetworkFileSystem]" defaultValue="&#123;&#125;" description="Mountpoints for Modal NetworkFileSystems." />
-<Parameter name="volumes" type="dict[str | PurePosixPath, _Volume | _CloudBucketMount]" defaultValue="&#123;&#125;" description="Mount points for Modal Volumes &amp; CloudBucketMounts." />
-<Parameter name="cpu" type="float | tuple[float, float] | None" defaultValue="None" description="Specify, in fractional CPU cores, how many CPU cores to request. Or, pass (request, limit) to additionally specify a hard limit in fractional CPU cores. CPU throttling will prevent a container from exceeding its specified limit." />
-<Parameter name="memory" type="int | tuple[int, int] | None" defaultValue="None" description="Specify, in MiB, a memory request which is the minimum memory required. Or, pass (request, limit) to additionally specify a hard limit in MiB." />
-<Parameter name="ephemeral_disk" type="int | None" defaultValue="None" description="Specify, in MiB, the ephemeral disk size for the Function." />
-<Parameter name="min_containers" type="int | None" defaultValue="None" description="Minimum number of containers to keep warm, even when Function is idle." />
-<Parameter name="max_containers" type="int | None" defaultValue="None" description="Limit on the number of containers that can be concurrently running." />
-<Parameter name="buffer_containers" type="int | None" defaultValue="None" description="Number of additional idle containers to maintain under active load." />
-<Parameter name="scaledown_window" type="int | None" defaultValue="None" description="Max time (in seconds) a container can remain idle while scaling down." />
-<Parameter name="proxy" type="_Proxy | None" defaultValue="None" description="Reference to a Modal Proxy to use in front of this function." />
-<Parameter name="retries" type="int | Retries | None" defaultValue="None" description="Number of times to retry each input in case of failure." />
-<Parameter name="timeout" type="int" defaultValue="300" description="Maximum execution time for inputs and startup time in seconds." />
-<Parameter name="startup_timeout" type="int | None" defaultValue="None" description="Maximum startup time in seconds with higher precedence than `timeout`." />
-<Parameter name="cloud" type="str | None" defaultValue="None" description="Cloud provider to run the function on. Possible values are aws, gcp, oci, auto." />
-<Parameter name="region" type="str | Sequence[str] | None" defaultValue="None" description="Region or regions to run the function on." />
-<Parameter name="routing_region" type="str | None" defaultValue="None" description="Region to route inputs to the function through." />
-<Parameter name="nonpreemptible" type="bool" defaultValue="False" description="Whether to run the function on a non-preemptible instance." />
-<Parameter name="enable_memory_snapshot" type="bool" defaultValue="False" description="Enable memory checkpointing for faster cold starts." />
-<Parameter name="block_network" type="bool" defaultValue="False" description="Whether to block network access." />
-<Parameter name="restrict_modal_access" type="bool" defaultValue="False" description="Whether to allow this class access to other Modal resources." />
-<Parameter name="single_use_containers" type="bool" defaultValue="False" description="When True, containers will shut down after handling a single input." />
-<Parameter name="i6pn" type="bool | None" defaultValue="None" description="Whether to enable IPv6 container networking within the region." />
-<Parameter name="include_source" type="bool | None" defaultValue="None" description="When ``False``, don&#x27;t automatically add the App source to the container." />
-<Parameter name="experimental_options" type="dict[str, Any] | None" defaultValue="None" description="Experimental options for the class service." />
-<Parameter name="_experimental_restrict_output" type="bool" defaultValue="False" description="Experimental; do not use pickle for return values." />
-<Parameter name="max_inputs" type="int | None" defaultValue="None" description="Deprecated; replaced with `single_use_containers`." />
-
-**Returns**
-
-A decorator that registers the wrapped class or partial as a Modal `Cls`.
-
-## include
-
-```python
-include(self, /, other_app, inherit_tags=True)
-```
-Include another App's objects in this one.
-
-Useful for splitting up Modal Apps across different self-contained files.
-
-When `inherit_tags=True` any tags set on the other App will be inherited by this App
-(with this App's tags taking precedence in the case of conflicts).
-
-**Parameters**
-
-<Parameter name="other_app" type="&quot;_App&quot;" description="App whose registered functions and classes are merged into this app." />
-<Parameter name="inherit_tags" type="bool" defaultValue="True" description="If True, merge tags from `other_app` into this app (this app wins on conflicts)." />
-
-**Returns**
-
-This app instance for chaining.
-
-**Usage**
-
-```python
-app_a = modal.App("a")
-@app_a.function()
-def foo():
-    ...
-
-app_b = modal.App("b")
-@app_b.function()
-def bar():
-    ...
-
-app_a.include(app_b)
-
-@app_a.local_entrypoint()
-def main():
-    # use function declared on the included app
-    bar.remote()
-```
-
-## set_tags
-
-```python
-set_tags(self, tags, *, client=None)
-```
-Attach key-value metadata to the App.
-
-Tag metadata can be used to add organization-specific context to the App and can be
-included in billing reports and other informational APIs. Tags can also be set in
-the App constructor.
-
-Any tags set on the App before calling this method will be removed if they are not
-included in the argument (i.e., this method does not have `.update()` semantics).
-
-**Parameters**
-
-<Parameter name="tags" type="Mapping[str, str]" description="Complete tag set to store on the app (replaces previous tags)." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use for the RPC." />
-
-## get_tags
-
-```python
-get_tags(self, *, client=None)
-```
-Get the tags that are currently attached to the App.
-
-**Parameters**
-
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use for the RPC." />
-
-**Returns**
-
-Tags as a map from key to value.

.agents/skills/modal/references/api/modal.Client.md

@@ -1,75 +0,0 @@
-# modal.Client
-
-
-```python
-class Client(object)
-```
-
-
-## is_closed
-
-```python
-is_closed(self)
-```
-Check if the client is closed.
-
-**Returns**
-
-True if the client is closed, False otherwise.
-
-## hello
-
-```python
-hello(self)
-```
-Connect to server and retrieve version information; raise appropriate error for various failures.
-
-**Usage**
-
-```python
-client = modal.Client.from_env()
-client.hello()
-```
-
-## from_credentials
-
-```python
-from_credentials(cls, token_id, token_secret)
-```
-Constructor based on token credentials; useful for managing Modal on behalf of third-party users.
-
-Also useful when it's necessary to explicitly manage the lifecycle of the client
-(e.g. when running Modal in a forked subprocess) — see
-[troubleshooting](/docs/guide/troubleshooting#connection-issues-in-forked-processes).
-
-**Parameters**
-
-<Parameter name="token_id" type="str" description="API token ID." />
-<Parameter name="token_secret" type="str" description="API token secret." />
-
-**Returns**
-
-An authenticated `Client` with its connection opened.
-
-**Usage**
-
-```python notest
-client = modal.Client.from_credentials("my_token_id", "my_token_secret")
-
-modal.Sandbox.create("echo", "hi", client=client, app=app)
-```
-
-## get_input_plane_metadata
-
-```python
-get_input_plane_metadata(self, input_plane_region)
-```
-Get the metadata for the input plane.
-
-**Parameters**
-
-<Parameter name="input_plane_region" type="str" description="The region of the input plane." />
-
-**Returns**
-
-The metadata for the input plane as a list of header/value tuples.

.agents/skills/modal/references/api/modal.CloudBucketMount.md

@@ -1,103 +0,0 @@
-# modal.CloudBucketMount
-
-
-```python
-class CloudBucketMount(object)
-```
-
-Mounts a cloud bucket to your container. Currently supports AWS S3 buckets.
-
-S3 buckets are mounted using [AWS S3 Mountpoint](https://github.com/awslabs/mountpoint-s3).
-S3 mounts are optimized for reading large files sequentially. It does not support every file operation; consult
-[the AWS S3 Mountpoint documentation](https://github.com/awslabs/mountpoint-s3/blob/main/doc/SEMANTICS.md)
-for more information.
-
-**Usage**
-
-S3:
-
-```python
-import subprocess
-
-app = modal.App()
-secret = modal.Secret.from_name(
-    "aws-secret",
-    required_keys=["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"]
-    # Note: providing AWS_REGION can help when automatic detection of the bucket region fails.
-)
-
-@app.function(
-    volumes={
-        "/my-mount": modal.CloudBucketMount(
-            bucket_name="s3-bucket-name",
-            secret=secret,
-            read_only=True
-        )
-    }
-)
-def f():
-    subprocess.run(["ls", "/my-mount"], check=True)
-```
-
-R2:
-
-Cloudflare R2 is [S3-compatible](https://developers.cloudflare.com/r2/api/s3/api/) so its setup looks
-very similar to S3. But additionally the `bucket_endpoint_url` argument must be passed.
-
-```python
-import subprocess
-
-app = modal.App()
-secret = modal.Secret.from_name(
-    "r2-secret",
-    required_keys=["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"]
-)
-
-@app.function(
-    volumes={
-        "/my-mount": modal.CloudBucketMount(
-            bucket_name="my-r2-bucket",
-            bucket_endpoint_url="https://<ACCOUNT ID>.r2.cloudflarestorage.com",
-            secret=secret,
-            read_only=True
-        )
-    }
-)
-def f():
-    subprocess.run(["ls", "/my-mount"], check=True)
-```
-
-GCS:
-
-Google Cloud Storage (GCS) is [S3-compatible](https://cloud.google.com/storage/docs/interoperability).
-GCS Buckets also require a secret with Google-specific key names (see below) populated with
-a [HMAC key](https://cloud.google.com/storage/docs/authentication/managing-hmackeys#create).
-
-```python
-import subprocess
-
-app = modal.App()
-gcp_hmac_secret = modal.Secret.from_name(
-    "gcp-secret",
-    required_keys=["GOOGLE_ACCESS_KEY_ID", "GOOGLE_ACCESS_KEY_SECRET"]
-)
-
-@app.function(
-    volumes={
-        "/my-mount": modal.CloudBucketMount(
-            bucket_name="my-gcs-bucket",
-            bucket_endpoint_url="https://storage.googleapis.com",
-            secret=gcp_hmac_secret,
-        )
-    }
-)
-def f():
-    subprocess.run(["ls", "/my-mount"], check=True)
-```
-
-```python
-__init__(self, bucket_name, bucket_endpoint_url=None, key_prefix=None,
-    secret=None, oidc_auth_role_arn=None, read_only=False, requester_pays=False,
-    force_path_style=False)
-```
-

.agents/skills/modal/references/api/modal.Cls.md

@@ -1,163 +0,0 @@
-# modal.Cls
-
-
-```python
-class Cls(modal.object.Object)
-```
-
-Cls adds method pooling and [lifecycle hook](https://modal.com/docs/guide/lifecycle-functions) behavior
-to [modal.Function](https://modal.com/docs/reference/modal.Function).
-
-Generally, you will not construct a Cls directly.
-Instead, use the [`@app.cls()`](https://modal.com/docs/reference/modal.App#cls) decorator on the App object.
-
-
-## hydrate
-
-```python
-hydrate(self, client=None)
-```
-Synchronize the local object with its identity on the Modal server.
-
-It is rarely necessary to call this method explicitly, as most operations
-will lazily hydrate when needed. The main use case is when you need to
-access object metadata, such as its ID.
-
-*Added in v0.72.39*: This method replaces the deprecated `.resolve()` method.
-
-## from_name
-
-```python
-from_name(cls, app_name, name, *, version=None, environment_name=None,
-    client=None)
-```
-Reference a Cls from a deployed App by its name.
-
-This is a lazy method that defers hydrating the local
-object with metadata from Modal servers until the first
-time it is actually used.
-
-**Parameters**
-
-<Parameter name="app_name" type="str" description="Name of the deployed App that defines this class." />
-<Parameter name="name" type="str" description="Object tag of the Cls within that App." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="Workspace environment for the lookup; defaults to the active environment." />
-<Parameter name="client" type="&quot;_Client | None&quot;" defaultValue="None" description="Optional Modal client; defaults to the process client." />
-
-**Returns**
-
-A ``Cls`` reference that hydrates on first use.
-
-**Usage**
-
-```python
-Model = modal.Cls.from_name("other-app", "Model")
-```
-
-The `version` parameter constructs a version-pinned Cls:
-
-```python
-Modelv3 = modal.Cls.from_name("other-app", "Model", version=3)
-```
-
-## with_options
-
-```python
-with_options(self, *, cpu=None, memory=None, gpu=None, env=None, secrets=None,
-    volumes={}, retries=None, max_containers=None, buffer_containers=None,
-    scaledown_window=None, timeout=None, region=None, cloud=None)
-```
-Override the static Cls configuration with invocation-specific values.
-
-This method will return a new variant of the Cls that will autoscale independently of the
-base configuration.
-
-Note that options cannot be "unset" with this method (i.e., if a GPU is configured in the
-`@app.cls()` decorator, passing `gpu=None` here will not create a CPU-only instance).
-
-Container arguments (``volumes`` and ``secrets``) from later calls replace earlier values; they are not merged.
-
-**Parameters**
-
-<Parameter name="cpu" type="float | tuple[float, float] | None" defaultValue="None" description="CPU cores for instances created from this Cls (see ``@app.function`` / ``@app.cls`` resource options)." />
-<Parameter name="memory" type="int | tuple[int, int] | None" defaultValue="None" description="Memory in MiB, or min/max pair, for those instances." />
-<Parameter name="gpu" type="str | None" defaultValue="None" description="GPU type string, for example ``A100``." />
-<Parameter name="env" type="dict[str, str | None] | None" defaultValue="None" description="Environment variables merged into a temporary secret for this configuration." />
-<Parameter name="secrets" type="Collection[_Secret] | None" defaultValue="None" description="Additional secrets attached to the service function." />
-<Parameter name="volumes" type="dict[str | PurePosixPath, _Volume | _CloudBucketMount]" defaultValue="&#123;&#125;" description="Volume and cloud-bucket mounts (paths to ``Volume`` or ``CloudBucketMount``)." />
-<Parameter name="retries" type="int | Retries | None" defaultValue="None" description="Retry policy or count for invocations." />
-<Parameter name="max_containers" type="int | None" defaultValue="None" description="Cap on concurrently running containers for this Cls configuration." />
-<Parameter name="buffer_containers" type="int | None" defaultValue="None" description="Extra idle containers kept warm while the Function is active." />
-<Parameter name="scaledown_window" type="int | None" defaultValue="None" description="Seconds a container may stay idle before scaling down." />
-<Parameter name="timeout" type="int | None" defaultValue="None" description="Function timeout in seconds." />
-<Parameter name="region" type="str | Sequence[str] | None" defaultValue="None" description="One region or a list of regions to schedule on." />
-<Parameter name="cloud" type="str | None" defaultValue="None" description="Cloud provider (for example ``aws``, ``gcp``, ``oci``, or ``auto``)." />
-
-**Returns**
-
-A new ``Cls`` with the merged options.
-
-**Usage**
-
-You can use this method after looking up the Cls from a deployed App or if you have a
-direct reference to a Cls from another Function or local entrypoint on its App:
-
-```python notest
-Model = modal.Cls.from_name("my_app", "Model")
-ModelUsingGPU = Model.with_options(gpu="A100")
-ModelUsingGPU().generate.remote(input_prompt)  # Run with an A100 GPU
-```
-
-The method can be called multiple times to "stack" updates:
-
-```python notest
-Model.with_options(gpu="A100").with_options(scaledown_window=300)  # Use an A100 with slow scaledown
-```
-
-## with_concurrency
-
-```python
-with_concurrency(self, *, max_inputs, target_inputs=None)
-```
-Override the static Cls configuration with invocation-specific input concurrency settings.
-
-**Parameters**
-
-<Parameter name="max_inputs" type="int" description="Maximum number of inputs processed concurrently per container." />
-<Parameter name="target_inputs" type="int | None" defaultValue="None" description="Optional target concurrency; see ``@app.cls`` / Function concurrency docs." />
-
-**Returns**
-
-A new ``Cls`` with the merged concurrency settings.
-
-**Usage**
-
-```python notest
-Model = modal.Cls.from_name("my_app", "Model")
-ModelUsingGPU = Model.with_options(gpu="A100").with_concurrency(max_inputs=100)
-ModelUsingGPU().generate.remote(42)  # will run on an A100 GPU with input concurrency enabled
-```
-
-## with_batching
-
-```python
-with_batching(self, *, max_batch_size, wait_ms)
-```
-Override the static Cls configuration with invocation-specific dynamic batching settings.
-
-**Parameters**
-
-<Parameter name="max_batch_size" type="int" description="Maximum batch size for dynamic batching." />
-<Parameter name="wait_ms" type="int" description="Maximum time to wait to fill a batch, in milliseconds." />
-
-**Returns**
-
-A new ``Cls`` with the merged batching settings.
-
-**Usage**
-
-```python notest
-Model = modal.Cls.from_name("my_app", "Model")
-ModelUsingGPU = Model.with_options(gpu="A100").with_batching(max_batch_size=100, wait_ms=1000)
-ModelUsingGPU().generate.remote(42)  # A100 with dynamic batching
-```

.agents/skills/modal/references/api/modal.Cron.md

@@ -1,48 +0,0 @@
-# modal.Cron
-
-
-```python
-class Cron(modal.schedule.Schedule)
-```
-
-Cron jobs are a type of schedule, specified using the
-[Unix cron tab](https://crontab.guru/) syntax.
-
-The alternative schedule type is the [`modal.Period`](https://modal.com/docs/reference/modal.Period).
-
-```python
-__init__(self, cron_string, timezone="UTC")
-```
-Construct a schedule that runs according to a cron expression string.
-
-**Parameters**
-
-<Parameter name="cron_string" type="str" description="Cron expression (see crontab.guru)." />
-<Parameter name="timezone" type="str" defaultValue="&quot;UTC&quot;" description="IANA timezone name; defaults to UTC." />
-
-**Usage**
-
-```python
-import modal
-app = modal.App()
-
-
-@app.function(schedule=modal.Cron("* * * * *"))
-def f():
-    print("This function will run every minute")
-```
-
-We can specify different schedules with cron strings, for example:
-
-```python
-modal.Cron("5 4 * * *")  # run at 4:05am UTC every night
-modal.Cron("0 9 * * 4")  # runs every Thursday at 9am UTC
-```
-
-We can also optionally specify a timezone, for example:
-
-```python
-modal.Cron("0 6 * * *", timezone="America/New_York")
-```
-
-If no timezone is specified, the default is UTC.

.agents/skills/modal/references/api/modal.Dict.md

@@ -1,379 +0,0 @@
-# modal.Dict
-
-
-```python
-class Dict(modal.object.Object)
-```
-
-Distributed dictionary for storage in Modal apps.
-
-Dict contents can be essentially any object so long as they can be serialized by
-`cloudpickle`. This includes other Modal objects. If writing and reading in different
-environments (eg., writing locally and reading remotely), it's necessary to have the
-library defining the data type installed, with compatible versions, on both sides.
-Additionally, cloudpickle serialization is not guaranteed to be deterministic, so it is
-generally recommended to use primitive types for keys.
-
-**Lifetime of a Dict and its items**
-
-An individual Dict entry will expire after 7 days of inactivity (no reads or writes). The
-Dict entries are written to durable storage.
-
-Legacy Dicts (created before 2025-05-20) will still have entries expire 30 days after being
-last added. Additionally, contents are stored in memory on the Modal server and could be lost
-due to unexpected server restarts. Eventually, these Dicts will be fully sunset.
-
-**Usage**
-
-```python
-from modal import Dict
-
-my_dict = Dict.from_name("my-persisted_dict", create_if_missing=True)
-
-my_dict["some key"] = "some value"
-my_dict[123] = 456
-
-assert my_dict["some key"] == "some value"
-assert my_dict[123] == 456
-```
-
-The `Dict` class offers a few methods for operations that are usually accomplished
-in Python with operators, such as `Dict.put` and `Dict.contains`. The advantage of
-these methods is that they can be safely called in an asynchronous context by using
-the `.aio` suffix on the method, whereas their operator-based analogues will always
-run synchronously and block the event loop.
-
-For more examples, see the [guide](https://modal.com/docs/guide/dicts-and-queues#modal-dicts).
-
-
-## hydrate
-
-```python
-hydrate(self, client=None)
-```
-Synchronize the local object with its identity on the Modal server.
-
-It is rarely necessary to call this method explicitly, as most operations
-will lazily hydrate when needed. The main use case is when you need to
-access object metadata, such as its ID.
-
-*Added in v0.72.39*: This method replaces the deprecated `.resolve()` method.
-
-## objects
-
-
-```python
-objects: DictManager
-```
-
-Namespace with methods for managing named Dict objects.
-
-
-### objects.create
-
-```python
-create(self, name, *, allow_existing=False, environment_name=None, client=None)
-```
-Create a new named Dict in the workspace environment.
-
-This does not return a local handle; use `modal.Dict.from_name` to look up the Dict after creation.
-
-Added in v1.1.2.
-
-**Parameters**
-
-<Parameter name="name" type="str" description="Name for the new Dict." />
-<Parameter name="allow_existing" type="bool" defaultValue="False" description="If True, do nothing when a Dict with this name already exists." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="Environment to create in; defaults to the active environment." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use; defaults to `Client.from_env()` when omitted." />
-
-**Usage**
-
-```python notest
-modal.Dict.objects.create("my-dict")
-```
-
-Dicts will be created in the active environment, or another one can be specified:
-
-```python notest
-modal.Dict.objects.create("my-dict", environment_name="dev")
-```
-
-By default, an error is raised if the Dict already exists; `allow_existing=True` makes that case a no-op:
-
-```python notest
-modal.Dict.objects.create("my-dict", allow_existing=True)
-```
-
-Note that this method does not return a local instance of the Dict. You can use
-`modal.Dict.from_name` to perform a lookup after creation.
-
-### objects.list
-
-```python
-list(self, *, max_objects=None, created_before=None, environment_name="",
-    client=None)
-```
-List named Dicts in the workspace environment as hydrated handles.
-
-Results are ordered newest to oldest. By default, all matching Dicts are returned.
-
-Added in v1.1.2.
-
-**Parameters**
-
-<Parameter name="max_objects" type="int | None" defaultValue="None" description="Maximum number of Dicts to return." />
-<Parameter name="created_before" type="datetime | str | None" defaultValue="None" description="Only include Dicts created before this time (datetime or ISO date string)." />
-<Parameter name="environment_name" type="str" defaultValue="&quot;&quot;" description="Environment to list from; defaults to the active environment." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use; defaults to `Client.from_env()` when omitted." />
-
-**Returns**
-
-Hydrated `Dict` objects for each named Dict in the listing.
-
-**Usage**
-
-```python
-dicts = modal.Dict.objects.list()
-print([d.name for d in dicts])
-```
-
-Dicts will be retrieved from the active environment, or another one can be specified:
-
-```python notest
-dev_dicts = modal.Dict.objects.list(environment_name="dev")
-```
-
-By default, all named Dicts are returned, newest to oldest. It's also possible to limit the
-number of results and to filter by creation date:
-
-```python
-dicts = modal.Dict.objects.list(max_objects=10, created_before="2025-01-01")
-```
-
-### objects.delete
-
-```python
-delete(self, name, *, allow_missing=False, environment_name=None, client=None)
-```
-Delete a named Dict entirely (not a single key).
-
-Deletion is irreversible and affects any Apps using this Dict.
-
-Added in v1.1.2.
-
-**Parameters**
-
-<Parameter name="name" type="str" description="Name of the Dict to delete." />
-<Parameter name="allow_missing" type="bool" defaultValue="False" description="If True, do nothing when the Dict does not exist." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="Environment to delete from; defaults to the active environment." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use; defaults to `Client.from_env()` when omitted." />
-
-**Usage**
-
-```python notest
-await modal.Dict.objects.delete("my-dict")
-```
-
-Dicts will be deleted from the active environment, or another one can be specified:
-
-```python notest
-await modal.Dict.objects.delete("my-dict", environment_name="dev")
-```
-
-## name
-
-```python
-name(self)
-```
-Name of the Dict object.
-
-**Usage**
-
-```python
-d = modal.Dict.from_name("my-dict")
-print(d.name)
-```
-
-## ephemeral
-
-```python
-ephemeral(cls, *, client=None, environment_name=None)
-```
-Create an anonymous Dict that exists for the duration of the context manager.
-
-**Parameters**
-
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use; defaults to `Client.from_env()` when omitted." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="Environment for the ephemeral Dict; defaults to the active environment." />
-
-**Usage**
-
-```python
-from modal import Dict
-
-with Dict.ephemeral() as d:
-    d["foo"] = "bar"
-```
-
-```python notest
-async with Dict.ephemeral() as d:
-    await d.put.aio("foo", "bar")
-```
-
-## from_name
-
-```python
-from_name(name, *, environment_name=None, create_if_missing=False, client=None)
-```
-Reference a named Dict, optionally creating it on the server first.
-
-Hydration is lazy: metadata is fetched from Modal the first time the handle is used.
-
-**Parameters**
-
-<Parameter name="name" type="str" description="Deployment name of the Dict." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="Environment to resolve the name in; defaults to the active environment." />
-<Parameter name="create_if_missing" type="bool" defaultValue="False" description="If True, create the Dict when it does not already exist." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use for loading; defaults to `Client.from_env()` when omitted." />
-
-**Returns**
-
-A `Dict` handle (possibly not yet hydrated).
-
-**Usage**
-
-```python
-d = modal.Dict.from_name("my-dict", create_if_missing=True)
-d[123] = 456
-```
-
-## from_id
-
-```python
-from_id(dict_id, client=None)
-```
-Construct a Dict from an id and look up the Dict metadata.
-
-This is a lazy method that defers hydrating the local
-object with metadata from Modal servers until the first
-time it is actually used.
-
-The ID of a Dict object can be accessed using `.object_id`.
-
-**Parameters**
-
-<Parameter name="dict_id" type="str" description="Dict object ID to attach to." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use for loading; defaults to `Client.from_env()` when omitted." />
-
-**Returns**
-
-A `Dict` handle (possibly not yet hydrated).
-
-**Usage**
-
-```python notest
-@app.function()
-def my_worker(dict_id: str):
-    d = modal.Dict.from_id(dict_id)
-    d["key"] = "Hello from remote function!"
-
-with modal.Dict.ephemeral() as d:
-    my_worker.remote(d.object_id)
-    print(d["key"])  # "Hello from remote function!"
-```
-
-## info
-
-```python
-info(self)
-```
-Return information about the Dict object.
-
-## clear
-
-```python
-clear(self)
-```
-Remove all items from the Dict.
-
-## get
-
-```python
-get(self, key, default=None)
-```
-Get the value associated with a key.
-
-Returns `default` if key does not exist.
-
-## contains
-
-```python
-contains(self, key)
-```
-Return if a key is present.
-
-## len
-
-```python
-len(self)
-```
-Return the length of the Dict.
-
-Note: This is an expensive operation and will return at most 100,000.
-
-## update
-
-```python
-update(self, other=None, **kwargs)
-```
-Update the Dict with additional items.
-
-## put
-
-```python
-put(self, key, value, *, skip_if_exists=False)
-```
-Add a specific key-value pair to the Dict.
-
-Returns True if the key-value pair was added and False if it wasn't because the key already existed and
-`skip_if_exists` was set.
-
-## pop
-
-```python
-pop(self, key, default=_NO_DEFAULT)
-```
-Remove a key from the Dict, returning the value if it exists.
-
-If key is not found, return default if provided, otherwise raise KeyError.
-
-## keys
-
-```python
-keys(self)
-```
-Return an iterator over the keys in this Dict.
-
-Note that (unlike with Python dicts) the return value is a simple iterator,
-and results are unordered.
-
-## values
-
-```python
-values(self)
-```
-Return an iterator over the values in this Dict.
-
-Note that (unlike with Python dicts) the return value is a simple iterator,
-and results are unordered.
-
-## items
-
-```python
-items(self)
-```
-Return an iterator over the (key, value) tuples in this Dict.
-
-Note that (unlike with Python dicts) the return value is a simple iterator,
-and results are unordered.

.agents/skills/modal/references/api/modal.Environment.md

@@ -1,166 +0,0 @@
-# modal.Environment
-
-
-```python
-class Environment(modal.object.Object)
-```
-
-
-## hydrate
-
-```python
-hydrate(self, client=None)
-```
-Synchronize the local object with its identity on the Modal server.
-
-It is rarely necessary to call this method explicitly, as most operations
-will lazily hydrate when needed. The main use case is when you need to
-access object metadata, such as its ID.
-
-*Added in v0.72.39*: This method replaces the deprecated `.resolve()` method.
-
-## name
-
-```python
-name(self)
-```
-
-
-## objects
-
-
-```python
-objects: EnvironmentManager
-```
-
-Namespace with methods for managing Environment objects.
-
-
-### objects.create
-
-```python
-create(self, name, *, restricted=False, client=None)
-```
-Create a new Environment.
-
-**Examples:**
-
-```python notest
-modal.Environment.objects.create("my-environment")
-```
-
-### objects.list
-
-```python
-list(self, *, client=None)
-```
-Return a list of hydrated Environment objects.
-
-**Examples:**
-
-```python notest
-environments = modal.Environment.objects.list()
-print([e.name for e in environments])
-```
-
-### objects.delete
-
-```python
-delete(self, name, *, client=None)
-```
-Delete a named Environment.
-
-Warning: This is irreversible and will transitively delete all objects in the Environment.
-
-**Examples:**
-
-```python notest
-modal.Environment.objects.delete("my-environment")
-```
-
-## members
-
-
-```python
-members: EnvironmentMembersManager
-```
-
-Namespace with methods for managing the membership of a restricted Environment.
-
-See https://modal.com/docs/guide/rbac for more information on restricted Environments.
-
-
-### members.list
-
-```python
-list(self)
-```
-Return the members of a restricted Environment with their roles.
-
-**Examples:**
-
-```python notest
-members = modal.Environment.from_name("my-restricted-env").members.list()
-print(members)
-# {
-#     "users": {"alice": "contributor", "bob": "viewer"},
-#     "service_users": {"alice-bot": "contributor"},
-# }
-```
-
-### members.update
-
-```python
-update(self, *, users=None, service_users=None)
-```
-Add or modify roles for members of a restricted Environment.
-
-Each user or service user will be added to the Environment if not currently a member;
-if already a member, the user or service user's role will be updated.
-
-**Examples:**
-
-```python notest
-env = modal.Environment.from_name("my-restricted-env")
-env.members.update(
-    users={"alice": "contributor", "bob": "viewer"},
-    service_users={"alice-bot": "contributor"},
-)
-```
-
-### members.remove
-
-```python
-remove(self, *, users=None, service_users=None)
-```
-Remove members from a restricted Environment.
-
-**Examples:**
-
-```python notest
-env = modal.Environment.from_name("my-restricted-env")
-env.members.remove(
-    users=["alice"],
-    service_users=["alice-bot"],
-)
-```
-
-## from_context
-
-```python
-from_context(*, client=None)
-```
-Look up an Environment object using the current context.
-
-This method returns the Environment that is defined by the local configuration
-(i.e., your active profile or the `MODAL_ENVIRONMENT` environment variable), or
-it fetches the default environment from the server when not defined locally.
-If called inside a Modal container, it will return the Environment that container
-is associated with.
-
-## from_name
-
-```python
-from_name(name, *, create_if_missing=False, client=None)
-```
-Look up an Environment object using its name.

.agents/skills/modal/references/api/modal.Error.md

@@ -1,22 +0,0 @@
-# modal.Error
-
-
-```python
-class Error(Exception)
-```
-
-Base class for all Modal errors. See [`modal.exception`](https://modal.com/docs/reference/modal.exception)
-for the specialized error classes.
-
-**Usage**
-
-```python notest
-import modal
-
-try:
-    ...
-except modal.Error:
-    # Catch any exception raised by Modal's systems.
-    print("Responding to error...")
-```
-

.agents/skills/modal/references/api/modal.FilePatternMatcher.md

@@ -1,69 +0,0 @@
-# modal.FilePatternMatcher
-
-
-```python
-class FilePatternMatcher(modal.file_pattern_matcher._AbstractPatternMatcher)
-```
-
-Allows matching file Path objects against a list of patterns.
-
-**Usage**
-
-```python
-from pathlib import Path
-from modal import FilePatternMatcher
-
-matcher = FilePatternMatcher("*.py")
-
-assert matcher(Path("foo.py"))
-
-# You can also negate the matcher.
-negated_matcher = ~matcher
-
-assert not negated_matcher(Path("foo.py"))
-```
-
-```python
-__init__(self, *pattern)
-```
-Initialize a new FilePatternMatcher instance.
-
-**Parameters**
-
-<Parameter name="*pattern" type="str" description="One or more pattern strings." />
-
-**Raises**
-
-- `ValueError`: If an illegal exclusion pattern is provided.
-
-## can_prune_directories
-
-```python
-can_prune_directories(self)
-```
-Returns True if this pattern matcher allows safe early directory pruning.
-
-Directory pruning is safe when matching directories can be skipped entirely
-without missing any files that should be included. This is for example not
-safe when we have inverted/negated ignore patterns (e.g. "!**/*.py").
-
-## from_file
-
-```python
-from_file(cls, file_path)
-```
-Initialize a new FilePatternMatcher instance from a file.
-
-The patterns in the file will be read lazily when the matcher is first used.
-
-**Parameters**
-
-<Parameter name="file_path" type="Path" description="The path to the file containing patterns." />
-
-**Usage**
-
-```python
-from modal import FilePatternMatcher
-
-matcher = FilePatternMatcher.from_file("/path/to/ignorefile")
-```

.agents/skills/modal/references/api/modal.Function.md

@@ -1,387 +0,0 @@
-# modal.Function
-
-
-```python
-class Function(typing.Generic, modal.object.Object)
-```
-
-Functions are the basic units of serverless execution on Modal.
-
-Generally, you will not construct a `Function` directly. Instead, use the
-`App.function()` decorator to register your Python functions with your App.
-
-
-## hydrate
-
-```python
-hydrate(self, client=None)
-```
-Synchronize the local object with its identity on the Modal server.
-
-It is rarely necessary to call this method explicitly, as most operations
-will lazily hydrate when needed. The main use case is when you need to
-access object metadata, such as its ID.
-
-*Added in v0.72.39*: This method replaces the deprecated `.resolve()` method.
-
-## update_autoscaler
-
-```python
-update_autoscaler(self, *, min_containers=None, max_containers=None,
-    buffer_containers=None, scaledown_window=None)
-```
-Override the current autoscaler behavior for this Function.
-
-Unspecified parameters will retain their current value, i.e. either the static value
-from the function decorator, or an override value from a previous call to this method.
-
-Subsequent deployments of the App containing this Function will reset the autoscaler back to
-its static configuration.
-
-**Parameters**
-
-<Parameter name="min_containers" type="int | None" defaultValue="None" description="Minimum number of containers to keep running, or `None` to leave unchanged." />
-<Parameter name="max_containers" type="int | None" defaultValue="None" description="Maximum concurrent containers, or `None` to leave unchanged." />
-<Parameter name="buffer_containers" type="int | None" defaultValue="None" description="Extra containers to keep warm beyond demand, or `None` to leave unchanged." />
-<Parameter name="scaledown_window" type="int | None" defaultValue="None" description="Seconds idle containers wait before scaling down, or `None` to leave unchanged." />
-
-**Usage**
-
-```python notest
-    f = modal.Function.from_name("my-app", "function")
-
-    # Always have at least 2 containers running, with an extra buffer when the Function is active
-    f.update_autoscaler(min_containers=2, buffer_containers=1)
-
-    # Limit this Function to avoid spinning up more than 5 containers
-    f.update_autoscaler(max_containers=5)
-
-    # Extend the scaledown window to increase the amount of time that idle containers stay alive
-    f.update_autoscaler(scaledown_window=300)
-```
-
-## from_name
-
-```python
-from_name(cls, app_name, name, *, version=None, environment_name=None,
-    client=None)
-```
-Reference a Function from a deployed App by its name.
-
-This is a lazy method that defers hydrating the local
-object with metadata from Modal servers until the first
-time it is actually used.
-
-**Parameters**
-
-<Parameter name="app_name" type="str" description="Name of the deployed App." />
-<Parameter name="name" type="str" description="Name of the Function within that App. For class methods, use `Cls.from_name` instead." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="Environment to look up the App in; defaults to the active environment." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use; defaults to `Client.from_env()` when omitted." />
-
-**Returns**
-
-A lazy `Function` handle.
-
-**Usage**
-
-```python
-f = modal.Function.from_name("other-app", "function")
-```
-
-The `version` parameter allows you to invoke a version-pinned function:
-
-```python
-f_v3 = modal.Function.from_name("other-app", "function", version=3)
-```
-
-## get_web_url
-
-```python
-get_web_url(self)
-```
-URL for addressing a Web Function via HTTP.
-
-**Returns**
-
-The HTTPS URL for the web endpoint, or `None` if this Function is not a web endpoint.
-
-## with_options
-
-```python
-with_options(self, *, cpu=None, memory=None, gpu=None, env=None, secrets=None,
-    volumes={}, retries=None, max_containers=None, buffer_containers=None,
-    scaledown_window=None, timeout=None, region=None, cloud=None)
-```
-Dynamically override the static Function configuration with invocation-specific values.
-
-This method returns a new Function instance with the dynamic configuration. Invocations of
-the new Function will run in a distinct container pool and autoscale independently from the
-base Function (and from other dynamic configurations).
-
-Note that options cannot be "unset" with this method (i.e., if a GPU is configured in the
-`@app.cls()` decorator, passing `gpu=None` here will not create a CPU-only instance).
-Additionally, container arguments like `volumes` and `secrets` will _replace_ the base
-configuration or any previous use of this method rather than extending it.
-
-**Usage:**
-
-You can use this method after looking up a deployed Function:
-
-```python notest
-fn = modal.Function.from_name("my_app", "fn").with_options(gpu="H100")
-fn.remote()  # will run on a H100 GPU
-```
-
-Or by referencing another Function defined in the same App:
-
-```python notest
-@app.function()
-def fn():
-    ...
-
-# From a local entrypoint or another Function
-fn.with_options(gpu="H100").remote()  # Uses an H100 GPU
-fn.remote()  # Uses the static configuration with no GPU
-```
-
-## with_concurrency
-
-```python
-with_concurrency(self, *, max_inputs, target_inputs=None)
-```
-Override the static Function configuration with invocation-specific input concurrency.
-
-Returns a new Function instance that is dynamically configured to behave like a Function using
-the `@modal.concurrent` decorator. This instance will autoscale independently from the base Function.
-
-## with_batching
-
-```python
-with_batching(self, *, max_batch_size, wait_ms)
-```
-Override the static Function configuration with invocation-specific dynamic batching.
-
-Returns a new Function instance that is dynamically configured to behave like a Function using
-the `@modal.batched` decorator. This instance will autoscale independently from the base Function.
-
-## remote
-
-```python
-remote(self, *args, **kwargs)
-```
-Calls the function remotely, executing it with the given arguments and returning the execution's result.
-
-**Parameters**
-
-<Parameter name="*args" type="P.args" description="Positional arguments forwarded to the deployed function." />
-<Parameter name="**kwargs" type="P.kwargs" description="Keyword arguments forwarded to the deployed function." />
-
-**Returns**
-
-The value returned by the remote function.
-
-## remote_gen
-
-```python
-remote_gen(self, *args, **kwargs)
-```
-Calls the generator remotely, executing it with the given arguments.
-
-**Parameters**
-
-<Parameter name="*args" type="" description="Positional arguments forwarded to the deployed generator function." />
-<Parameter name="**kwargs" type="" description="Keyword arguments forwarded to the deployed generator function." />
-
-**Returns**
-
-Values produced by the remote generator.
-
-## local
-
-```python
-local(self, *args, **kwargs)
-```
-Calls the function locally, executing it with the given arguments and returning the execution's result.
-
-The function will execute in the same environment as the caller, just like calling the underlying function
-directly in Python. In particular, only secrets available in the caller environment will be available
-through environment variables.
-
-**Parameters**
-
-<Parameter name="*args" type="P.args" description="Positional arguments passed to the underlying Python callable." />
-<Parameter name="**kwargs" type="P.kwargs" description="Keyword arguments passed to the underlying Python callable." />
-
-**Returns**
-
-The return value of the local call (or a coroutine for async functions).
-
-## spawn
-
-```python
-spawn(self, *args, **kwargs)
-```
-Calls the function with the given arguments, without waiting for the results.
-
-Conceptually similar to `multiprocessing.pool.apply_async`, or a Future/Promise in other contexts.
-
-**Parameters**
-
-<Parameter name="*args" type="P.args" description="Positional arguments forwarded to the remote function." />
-<Parameter name="**kwargs" type="P.kwargs" description="Keyword arguments forwarded to the remote function." />
-
-**Returns**
-
-A [`modal.FunctionCall`](https://modal.com/docs/reference/modal.FunctionCall) object
-that can later be polled or waited for using
-[`.get(timeout=...)`](https://modal.com/docs/reference/modal.FunctionCall#get).
-
-## get_raw_f
-
-```python
-get_raw_f(self)
-```
-Return the inner Python object wrapped by this Modal Function.
-
-**Returns**
-
-The original function object registered with Modal.
-
-## get_current_stats
-
-```python
-get_current_stats(self)
-```
-Return a `FunctionStats` object describing the current function's queue and runner counts.
-
-**Returns**
-
-Snapshot counts for backlog, runners, and running inputs.
-
-## map
-
-```python
-map(self, *input_iterators, kwargs={}, order_outputs=True,
-    return_exceptions=False, wrap_returned_exceptions=None)
-```
-Parallel map over a set of inputs.
-
-Pass one iterable per positional argument of the underlying function. Results are yielded as an
-iterable (sync) or async iterator (``map.aio``).
-
-If applied to an ``@app.function``, ``map()`` returns one result per input and output order matches
-input order by default. Set ``order_outputs=False`` to emit results in completion order.
-
-``return_exceptions`` can aggregate failures into the result stream instead of raising.
-
-**Parameters**
-
-<Parameter name="*input_iterators" type="typing.Iterable[Any]" description="One iterator per mapped positional parameter on the function." />
-<Parameter name="kwargs" type="" defaultValue="&#123;&#125;" description="Extra keyword arguments forwarded to every invocation." />
-<Parameter name="order_outputs" type="bool" defaultValue="True" description="If True, preserve input order in outputs; if False, use completion order." />
-<Parameter name="return_exceptions" type="bool" defaultValue="False" description="If True, failed inputs appear as exceptions in the result stream instead of raising." />
-<Parameter name="wrap_returned_exceptions" type="bool | None" defaultValue="None" description="Deprecated; no longer has any effect." />
-
-**Usage**
-
-```python
-@app.function()
-def my_func(a):
-    return a ** 2
-
-
-@app.local_entrypoint()
-def main():
-    assert list(my_func.map([1, 2, 3, 4])) == [1, 4, 9, 16]
-```
-
-```python
-@app.function()
-def my_func(a):
-    if a == 2:
-        raise Exception("ohno")
-    return a ** 2
-
-
-@app.local_entrypoint()
-def main():
-    print(list(my_func.map(range(3), return_exceptions=True)))
-```
-
-## starmap
-
-```python
-starmap(self, input_iterator, *, kwargs={}, order_outputs=True,
-    return_exceptions=False, wrap_returned_exceptions=None)
-```
-Like ``map``, but each input item is unpacked into multiple positional arguments.
-
-Every element of ``input_iterator`` should be a sequence (for example a tuple) with length equal to the
-arity of the function.
-
-**Parameters**
-
-<Parameter name="input_iterator" type="typing.Iterable[typing.Sequence[Any]]" description="Iterable of argument tuples to unpack into each call." />
-<Parameter name="kwargs" type="" defaultValue="&#123;&#125;" description="Extra keyword arguments forwarded to every invocation." />
-<Parameter name="order_outputs" type="bool" defaultValue="True" description="If True, preserve input order in outputs; if False, use completion order." />
-<Parameter name="return_exceptions" type="bool" defaultValue="False" description="If True, failed inputs appear as exceptions in the result stream instead of raising." />
-<Parameter name="wrap_returned_exceptions" type="bool | None" defaultValue="None" description="Deprecated; no longer has any effect." />
-
-**Usage**
-
-```python
-@app.function()
-def my_func(a, b):
-    return a + b
-
-
-@app.local_entrypoint()
-def main():
-    assert list(my_func.starmap([(1, 2), (3, 4)])) == [3, 7]
-```
-
-## for_each
-
-```python
-for_each(self, *input_iterators, kwargs={}, ignore_exceptions=False)
-```
-Execute the function for all inputs and wait for completion, discarding return values.
-
-Like ``.map()`` but you do not need to iterate the result to drive work—Modal processes every input.
-
-**Parameters**
-
-<Parameter name="*input_iterators" type="" description="One iterator per mapped positional parameter on the function." />
-<Parameter name="kwargs" type="" defaultValue="&#123;&#125;" description="Extra keyword arguments forwarded to every invocation." />
-<Parameter name="ignore_exceptions" type="bool" defaultValue="False" description="If True, failures are swallowed instead of propagating." />
-
-## spawn_map
-
-```python
-spawn_map(self, *input_iterators, kwargs={})
-```
-Spawn parallel execution over a set of inputs, exiting as soon as the inputs are created (without waiting
-for the map to complete).
-
-Takes one iterator argument per argument in the function being mapped over.
-
-Programmatic retrieval of results will be supported in a future update.
-
-**Parameters**
-
-<Parameter name="*input_iterators" type="" description="One iterator per mapped positional parameter on the function." />
-<Parameter name="kwargs" type="" defaultValue="&#123;&#125;" description="Extra keyword arguments forwarded to every invocation." />
-
-**Usage**
-
-```python
-@app.function()
-def my_func(a):
-    return a ** 2
-
-
-@app.local_entrypoint()
-def main():
-    my_func.spawn_map([1, 2, 3, 4])
-```

.agents/skills/modal/references/api/modal.FunctionCall.md

@@ -1,191 +0,0 @@
-# modal.FunctionCall
-
-
-```python
-class FunctionCall(typing.Generic, modal.object.Object)
-```
-
-A reference to an executed function call.
-
-Constructed using `.spawn(...)` on a Modal function with the same
-arguments that a function normally takes. Acts as a reference to
-an ongoing function call that can be passed around and used to
-poll or fetch function results at some later time.
-
-Conceptually similar to a Future/Promise/AsyncResult in other contexts and languages.
-
-
-## hydrate
-
-```python
-hydrate(self, client=None)
-```
-Synchronize the local object with its identity on the Modal server.
-
-It is rarely necessary to call this method explicitly, as most operations
-will lazily hydrate when needed. The main use case is when you need to
-access object metadata, such as its ID.
-
-*Added in v0.72.39*: This method replaces the deprecated `.resolve()` method.
-
-## num_inputs
-
-```python
-num_inputs(self)
-```
-Get the number of inputs in the function call.
-
-**Returns**
-
-How many inputs this function call includes (e.g. `1` for `.spawn()`, more for `.spawn_map()`).
-
-## get
-
-```python
-get(self, timeout=None, *, index=0)
-```
-Get the result of the index-th input of the function call.
-
-`.spawn()` calls have a single output, so only specifying `index=0` is valid.
-A non-zero index is useful when your function has multiple outputs, like via `.spawn_map()`.
-
-This function waits indefinitely by default. It takes an optional
-`timeout` argument that specifies the maximum number of seconds to wait,
-which can be set to `0` to poll for an output immediately.
-
-The returned coroutine is not cancellation-safe.
-
-**Parameters**
-
-<Parameter name="timeout" type="float | None" defaultValue="None" description="Maximum seconds to wait for a result, or `None` to wait indefinitely." />
-<Parameter name="index" type="int" defaultValue="0" description="Which input&#x27;s result to retrieve (typically `0` for `.spawn()`)." />
-
-**Returns**
-
-The deserialized return value from that input.
-
-## iter
-
-```python
-iter(self, *, start=0, end=None)
-```
-Iterate in-order over the results of the function call.
-
-Optionally, specify a range [start, end) to iterate over.
-
-If `end` is not provided, it will iterate over all results.
-
-**Parameters**
-
-<Parameter name="start" type="int" defaultValue="0" description="First input index to include (inclusive)." />
-<Parameter name="end" type="int | None" defaultValue="None" description="One past the last index to include, or `None` for all remaining inputs." />
-
-**Returns**
-
-Each result value in index order.
-
-**Usage**
-
-```python
-@app.function()
-def my_func(a):
-    return a ** 2
-
-
-@app.local_entrypoint()
-def main():
-    fc = my_func.spawn_map([1, 2, 3, 4])
-    assert list(fc.iter()) == [1, 4, 9, 16]
-    assert list(fc.iter(start=1, end=3)) == [4, 9]
-```
-
-## get_call_graph
-
-```python
-get_call_graph(self)
-```
-Returns a structure representing the call graph from a given root
-call ID, along with the status of execution for each node.
-
-See [`modal.call_graph`](https://modal.com/docs/reference/modal.call_graph) reference page
-for documentation on the structure of the returned `InputInfo` items.
-
-**Returns**
-
-A list of `InputInfo` nodes describing the call graph.
-
-## cancel
-
-```python
-cancel(self, terminate_containers=False)
-```
-Cancels the function call, which will stop its execution and mark its inputs as
-[`TERMINATED`](https://modal.com/docs/reference/modal.call_graph#modalcall_graphinputstatus).
-
-If `terminate_containers=True` - the containers running the cancelled inputs are all terminated
-causing any non-cancelled inputs on those containers to be rescheduled in new containers.
-
-**Parameters**
-
-<Parameter name="terminate_containers" type="bool" defaultValue="False" description="If True, forcibly terminate workers running cancelled inputs." />
-
-## from_id
-
-```python
-from_id(cls, function_call_id, client=None)
-```
-Instantiate a FunctionCall object from an existing ID.
-
-Note that it's only necessary to re-instantiate the `FunctionCall` with this method
-if you no longer have access to the original object returned from `Function.spawn`.
-
-**Parameters**
-
-<Parameter name="function_call_id" type="str" description="Object ID of an existing function call (e.g. from `FunctionCall.object_id`)." />
-<Parameter name="client" type="&quot;modal.client.Client | None&quot;" defaultValue="None" description="Modal client to use; defaults to `Client.from_env()` when omitted." />
-
-**Returns**
-
-A `FunctionCall` handle for the given ID.
-
-**Usage**
-
-```python notest
-# Spawn a FunctionCall and keep track of its object ID
-fc = my_func.spawn()
-fc_id = fc.object_id
-
-# Later, use the ID to re-instantiate the FunctionCall object
-fc = FunctionCall.from_id(fc_id)
-result = fc.get()
-```
-
-## gather
-
-```python
-gather(*function_calls)
-```
-Wait until all Modal FunctionCall objects have results before returning.
-
-Accepts a variable number of `FunctionCall` objects, as returned by `Function.spawn()`.
-
-Raises an exception from the first failing function call.
-
-*Added in v0.73.69*: This method replaces the deprecated `modal.functions.gather` function.
-
-**Parameters**
-
-<Parameter name="*function_calls" type="&quot;_FunctionCall[T]&quot;" description="`FunctionCall` instances to wait on (same order as the returned sequence)." />
-
-**Returns**
-
-Results in the same order as `function_calls` (like `asyncio.gather`).
-
-**Usage**
-
-```python notest
-fc1 = slow_func_1.spawn()
-fc2 = slow_func_2.spawn()
-
-result_1, result_2 = modal.FunctionCall.gather(fc1, fc2)
-```

.agents/skills/modal/references/api/modal.Image.md

@@ -1,1181 +0,0 @@
-# modal.Image
-
-
-```python
-class Image(modal.object.Object)
-```
-
-Base class for container images to run functions in.
-
-Do not construct this class directly; instead use one of its static factory methods,
-such as `modal.Image.debian_slim`, `modal.Image.from_registry`, or `modal.Image.micromamba`.
-
-
-## add_local_file
-
-```python
-add_local_file(self, local_path, remote_path, *, copy=False)
-```
-Adds a local file to the image at `remote_path` within the container.
-
-By default (`copy=False`), the files are added to containers on startup and are not built into the actual Image,
-which speeds up deployment.
-
-Set `copy=True` to copy the files into an Image layer at build time instead, similar to how
-[`COPY`](https://docs.docker.com/engine/reference/builder/#copy) works in a `Dockerfile`.
-
-copy=True can slow down iteration since it requires a rebuild of the Image and any subsequent
-build steps whenever the included files change, but it is required if you want to run additional
-build steps after this one.
-
-*Added in v0.66.40*: This method replaces the deprecated `modal.Image.copy_local_file` method.
-
-**Parameters**
-
-<Parameter name="local_path" type="str | Path" description="Path to the file on the local machine." />
-<Parameter name="remote_path" type="str" description="Absolute path inside the container where the file should appear." />
-<Parameter name="copy" type="bool" defaultValue="False" description="If True, bake the file into an image layer at build time; if False, mount at container startup." />
-
-**Returns**
-
-A new `Image` with the file layer or mount applied.
-
-## add_local_dir
-
-```python
-add_local_dir(self, local_path, remote_path, *, copy=False, ignore=[])
-```
-Adds a local directory's content to the image at `remote_path` within the container.
-
-By default (`copy=False`), the files are added to containers on startup and are not built into the actual Image,
-which speeds up deployment.
-
-Set `copy=True` to copy the files into an Image layer at build time instead, similar to how
-[`COPY`](https://docs.docker.com/engine/reference/builder/#copy) works in a `Dockerfile`.
-
-copy=True can slow down iteration since it requires a rebuild of the Image and any subsequent
-build steps whenever the included files change, but it is required if you want to run additional
-build steps after this one.
-
-*Added in v0.66.40*: This method replaces the deprecated `modal.Image.copy_local_dir` method.
-
-**Parameters**
-
-<Parameter name="local_path" type="str | Path" description="Path to the directory on the local machine." />
-<Parameter name="remote_path" type="str" description="Absolute path inside the container where the directory contents should appear." />
-<Parameter name="copy" type="bool" defaultValue="False" description="If True, bake the tree into an image layer at build time; if False, mount at container startup." />
-<Parameter name="ignore" type="Sequence[str] | Callable[[Path], bool]" defaultValue="[]" description="Predicate or pattern list for file exclusion (True means exclude). A sequence is converted to a dockerignore-style matcher." />
-
-**Returns**
-
-A new `Image` with the directory layer or mount applied.
-
-**Usage**
-
-```python
-from modal import FilePatternMatcher
-
-image = modal.Image.debian_slim().add_local_dir(
-    "~/assets",
-    remote_path="/assets",
-    ignore=["*.venv"],
-)
-
-image = modal.Image.debian_slim().add_local_dir(
-    "~/assets",
-    remote_path="/assets",
-    ignore=lambda p: p.is_relative_to(".venv"),
-)
-
-image = modal.Image.debian_slim().add_local_dir(
-    "~/assets",
-    remote_path="/assets",
-    ignore=FilePatternMatcher("**/*.txt"),
-)
-
-# When including files is simpler than excluding them, you can use the `~` operator to invert the matcher.
-image = modal.Image.debian_slim().add_local_dir(
-    "~/assets",
-    remote_path="/assets",
-    ignore=~FilePatternMatcher("**/*.py"),
-)
-
-# You can also read ignore patterns from a file.
-image = modal.Image.debian_slim().add_local_dir(
-    "~/assets",
-    remote_path="/assets",
-    ignore=FilePatternMatcher.from_file("/path/to/ignorefile"),
-)
-```
-
-## add_local_python_source
-
-```python
-add_local_python_source(self, *modules, copy=False, ignore=NON_PYTHON_FILES)
-```
-Adds locally available Python packages/modules to containers.
-
-Adds all files from the specified Python package or module to containers running the Image.
-
-Packages are added to the `/root` directory of containers, which is on the `PYTHONPATH`
-of any executed Modal Functions, enabling import of the module by that name.
-
-By default (`copy=False`), the files are added to containers on startup and are not built into the actual Image,
-which speeds up deployment.
-
-Set `copy=True` to copy the files into an Image layer at build time instead. This can slow down iteration since
-it requires a rebuild of the Image and any subsequent build steps whenever the included files change, but it is
-required if you want to run additional build steps after this one.
-
-**Note:** This excludes all dot-prefixed subdirectories or files and all `.pyc`/`__pycache__` files.
-To add full directories with finer control, use `.add_local_dir()` instead and specify `/root` as
-the destination directory.
-
-By default only includes `.py`-files in the source modules. Set the `ignore` argument to a list of patterns
-or a callable to override this behavior.
-
-*Added in v0.67.28*: This method replaces the deprecated `modal.Mount.from_local_python_packages` pattern.
-
-**Parameters**
-
-<Parameter name="*modules" type="str" description="Python package or module names to include from the local project." />
-<Parameter name="copy" type="bool" defaultValue="False" description="If True, bake sources into an image layer; if False, mount at container startup." />
-<Parameter name="ignore" type="Sequence[str] | Callable[[Path], bool]" defaultValue="NON_PYTHON_FILES" description="Patterns or callable controlling which files to exclude." />
-
-**Returns**
-
-A new `Image` with the Python source mount or layer applied.
-
-**Usage**
-
-```py
-# includes everything except data.json
-modal.Image.debian_slim().add_local_python_source("mymodule", ignore=["data.json"])
-
-# exclude large files
-modal.Image.debian_slim().add_local_python_source(
-    "mymodule",
-    ignore=lambda p: p.stat().st_size > 1e9
-)
-```
-
-## from_id
-
-```python
-from_id(cls, image_id, client=None)
-```
-Construct an Image from an id and look up the Image result.
-
-The ID of an Image object can be accessed using `.object_id`.
-
-**Parameters**
-
-<Parameter name="image_id" type="str" description="Image object ID to load." />
-<Parameter name="client" type="&quot;modal.client.Client | None&quot;" defaultValue="None" description="Optional Modal client; uses the default synchronizer client when omitted." />
-
-**Returns**
-
-A hydrated `Image` handle for the given ID.
-
-## build
-
-```python
-build(self, app)
-```
-Eagerly build an image.
-
-If your image was previously built, then this method will not rebuild your image
-and your cached image is returned.
-
-For defining Modal functions, images are built automatically when deploying or running an App.
-You do not need to build the image explicitly in that case.
-
-**Parameters**
-
-<Parameter name="app" type="modal.app._App" description="Initialized app used as the load context for the image build." />
-
-**Returns**
-
-This image after the build (and resolver load) completes.
-
-**Usage**
-
-```python
-image = modal.Image.debian_slim().uv_pip_install("scipy", "numpy")
-
-app = modal.App.lookup("build-image", create_if_missing=True)
-with modal.enable_output():  # To see logs in your local terminal
-    image.build(app)
-
-# Save the image id
-my_image_id = image.object_id
-
-# Reference the image with the id or uses it another context.
-built_image = modal.Image.from_id(my_image_id)
-```
-
-Alternatively, you can pre-build an image and use it in a sandbox:
-
-```python notest
-app = modal.App.lookup("sandbox-example", create_if_missing=True)
-
-with modal.enable_output():
-    image = modal.Image.debian_slim().uv_pip_install("scipy")
-    image.build(app)
-
-sb = modal.Sandbox.create("python", "-c", "import scipy; print(scipy)", app=app, image=image)
-print(sb.stdout.read())
-sb.terminate()
-```
-
-```python notest
-app = modal.App()
-image = modal.Image.debian_slim()
-
-# No need to explicitly build the image for defining a function.
-@app.function(image=image)
-def f():
-    ...
-```
-
-## pip_install
-
-```python
-pip_install(self, *packages, find_links=None, index_url=None,
-    extra_index_url=None, pre=False, extra_options="", force_build=False,
-    env=None, secrets=None, gpu=None)
-```
-Install a list of Python packages using pip.
-
-**Parameters**
-
-<Parameter name="*packages" type="str | list[str]" description="Python packages to install, e.g. ``numpy`` or ``matplotlib&gt;=3.5.0``." />
-<Parameter name="find_links" type="str | None" defaultValue="None" description="Passed as ``--find-links`` to pip." />
-<Parameter name="index_url" type="str | None" defaultValue="None" description="Passed as ``--index-url`` to pip." />
-<Parameter name="extra_index_url" type="str | None" defaultValue="None" description="Passed as ``--extra-index-url`` to pip." />
-<Parameter name="pre" type="bool" defaultValue="False" description="If True, allow pre-release versions (``--pre``)." />
-<Parameter name="extra_options" type="str" defaultValue="&quot;&quot;" description="Additional raw options for pip, e.g. ``--no-build-isolation``." />
-<Parameter name="force_build" type="bool" defaultValue="False" description="If True, skip cached image builds (similar to ``docker build --no-cache``)." />
-<Parameter name="env" type="dict[str, str | None] | None" defaultValue="None" description="Environment variables set in the build container." />
-<Parameter name="secrets" type="Collection[_Secret] | None" defaultValue="None" description="Secrets injected as environment variables during the build." />
-<Parameter name="gpu" type="str | None" defaultValue="None" description="GPU type to attach to the builder container." />
-
-**Returns**
-
-A new `Image` with the pip install layer applied.
-
-**Usage**
-
-Simple installation:
-
-```python
-image = modal.Image.debian_slim().pip_install("click", "httpx~=0.23.3")
-```
-
-More complex installation:
-
-```python
-image = (
-    modal.Image.from_registry(
-        "nvidia/cuda:12.2.0-devel-ubuntu22.04", add_python="3.11"
-    )
-    .pip_install(
-        "ninja",
-        "packaging",
-        "wheel",
-        "transformers==4.40.2",
-    )
-    .pip_install(
-        "flash-attn==2.5.8", extra_options="--no-build-isolation"
-    )
-)
-```
-
-## pip_install_private_repos
-
-```python
-pip_install_private_repos(self, *repositories, git_user, find_links=None,
-    index_url=None, extra_index_url=None, pre=False, extra_options="", gpu=None,
-    env=None, secrets=None, force_build=False)
-```
-Install a list of Python packages from private git repositories using pip.
-
-This method currently supports Github and Gitlab only.
-
-- **Github:** Provide a `modal.Secret` that contains a `GITHUB_TOKEN` key-value pair
-- **Gitlab:** Provide a `modal.Secret` that contains a `GITLAB_TOKEN` key-value pair
-
-These API tokens should have permissions to read the list of private repositories provided as arguments.
-
-We recommend using Github's ['fine-grained' access tokens](https://github.blog/2022-10-18-introducing-fine-grained-personal-access-tokens-for-github/).
-These tokens are repo-scoped, and avoid granting read permission across all of a user's private repos.
-
-**Parameters**
-
-<Parameter name="*repositories" type="str" description="Git URLs without scheme, e.g. ``github.com/org/repo@ref`` or with ``#subdirectory=``." />
-<Parameter name="git_user" type="str" description="Username embedded in HTTPS git URLs for authentication." />
-<Parameter name="find_links" type="str | None" defaultValue="None" description="Passed as ``--find-links`` to pip." />
-<Parameter name="index_url" type="str | None" defaultValue="None" description="Passed as ``--index-url`` to pip." />
-<Parameter name="extra_index_url" type="str | None" defaultValue="None" description="Passed as ``--extra-index-url`` to pip." />
-<Parameter name="pre" type="bool" defaultValue="False" description="If True, allow pre-release versions." />
-<Parameter name="extra_options" type="str" defaultValue="&quot;&quot;" description="Additional raw options for pip." />
-<Parameter name="gpu" type="str | None" defaultValue="None" description="GPU type to attach to the builder container." />
-<Parameter name="env" type="dict[str, str | None] | None" defaultValue="None" description="Environment variables set in the build container." />
-<Parameter name="secrets" type="Collection[_Secret] | None" defaultValue="None" description="Secrets that supply ``GITHUB_TOKEN`` / ``GITLAB_TOKEN`` as required." />
-<Parameter name="force_build" type="bool" defaultValue="False" description="If True, skip cached image builds." />
-
-**Returns**
-
-A new `Image` with private repositories installed.
-
-**Usage**
-
-```python
-image = (
-    modal.Image
-    .debian_slim()
-    .pip_install_private_repos(
-        "github.com/ecorp/private-one@1.0.0",
-        "github.com/ecorp/private-two@main"
-        "github.com/ecorp/private-three@d4776502"
-        # install from 'inner' directory on default branch.
-        "github.com/ecorp/private-four#subdirectory=inner",
-        git_user="erikbern",
-        secrets=[modal.Secret.from_name("github-read-private")],
-    )
-)
-```
-
-## pip_install_from_requirements
-
-```python
-pip_install_from_requirements(self, requirements_txt, find_links=None, *,
-    index_url=None, extra_index_url=None, pre=False, extra_options="",
-    force_build=False, env=None, secrets=None, gpu=None)
-```
-Install a list of Python packages from a local `requirements.txt` file.
-
-**Parameters**
-
-<Parameter name="requirements_txt" type="str" description="Path to a ``requirements.txt`` file on the local machine." />
-<Parameter name="find_links" type="str | None" defaultValue="None" description="Passed as ``--find-links`` to pip." />
-<Parameter name="index_url" type="str | None" defaultValue="None" description="Passed as ``--index-url`` to pip." />
-<Parameter name="extra_index_url" type="str | None" defaultValue="None" description="Passed as ``--extra-index-url`` to pip." />
-<Parameter name="pre" type="bool" defaultValue="False" description="If True, allow pre-release versions." />
-<Parameter name="extra_options" type="str" defaultValue="&quot;&quot;" description="Additional raw options for pip." />
-<Parameter name="force_build" type="bool" defaultValue="False" description="If True, skip cached image builds." />
-<Parameter name="env" type="dict[str, str | None] | None" defaultValue="None" description="Environment variables set in the build container." />
-<Parameter name="secrets" type="Collection[_Secret] | None" defaultValue="None" description="Secrets injected as environment variables during the build." />
-<Parameter name="gpu" type="str | None" defaultValue="None" description="GPU type to attach to the builder container." />
-
-**Returns**
-
-A new `Image` with requirements installed.
-
-## pip_install_from_pyproject
-
-```python
-pip_install_from_pyproject(self, pyproject_toml, optional_dependencies=[], *,
-    find_links=None, index_url=None, extra_index_url=None, pre=False,
-    extra_options="", force_build=False, env=None, secrets=None, gpu=None)
-```
-Install dependencies specified by a local `pyproject.toml` file.
-
-`optional_dependencies` is a list of the keys of the
-optional-dependencies section(s) of the `pyproject.toml` file
-(e.g. test, doc, experiment, etc). When provided,
-all of the packages in each listed section are installed as well.
-
-**Parameters**
-
-<Parameter name="pyproject_toml" type="str" description="Path to a ``pyproject.toml`` using PEP 621 ``[project.dependencies]``." />
-<Parameter name="optional_dependencies" type="list[str]" defaultValue="[]" description="Keys under ``[project.optional-dependencies]`` to install additionally." />
-<Parameter name="find_links" type="str | None" defaultValue="None" description="Passed as ``--find-links`` to pip." />
-<Parameter name="index_url" type="str | None" defaultValue="None" description="Passed as ``--index-url`` to pip." />
-<Parameter name="extra_index_url" type="str | None" defaultValue="None" description="Passed as ``--extra-index-url`` to pip." />
-<Parameter name="pre" type="bool" defaultValue="False" description="If True, allow pre-release versions." />
-<Parameter name="extra_options" type="str" defaultValue="&quot;&quot;" description="Additional raw options for pip." />
-<Parameter name="force_build" type="bool" defaultValue="False" description="If True, skip cached image builds." />
-<Parameter name="env" type="dict[str, str | None] | None" defaultValue="None" description="Environment variables set in the build container." />
-<Parameter name="secrets" type="Collection[_Secret] | None" defaultValue="None" description="Secrets injected as environment variables during the build." />
-<Parameter name="gpu" type="str | None" defaultValue="None" description="GPU type to attach to the builder container." />
-
-**Returns**
-
-A new `Image` with project dependencies installed.
-
-## uv_pip_install
-
-```python
-uv_pip_install(self, *packages, requirements=None, find_links=None,
-    index_url=None, extra_index_url=None, pre=False, extra_options="",
-    force_build=False, uv_version=None, env=None, secrets=None, gpu=None)
-```
-Install a list of Python packages using uv pip install.
-
-This method assumes that:
-- Python is on the ``$PATH`` and dependencies are installed with the first Python on the ``$PATH``.
-- The shell supports ``$()``-style substitution as used in the generated Dockerfile.
-- The ``command`` builtin is available on the ``$PATH``.
-
-Added in v1.1.0.
-
-**Parameters**
-
-<Parameter name="*packages" type="str | list[str]" description="Python packages to pass to ``uv pip install``." />
-<Parameter name="requirements" type="list[str] | None" defaultValue="None" description="Optional list of requirement file paths (passed as ``--requirements``)." />
-<Parameter name="find_links" type="str | None" defaultValue="None" description="Passed as ``--find-links`` to ``uv pip``." />
-<Parameter name="index_url" type="str | None" defaultValue="None" description="Passed as ``--index-url`` to ``uv pip``." />
-<Parameter name="extra_index_url" type="str | None" defaultValue="None" description="Passed as ``--extra-index-url`` to ``uv pip``." />
-<Parameter name="pre" type="bool" defaultValue="False" description="If True, allow pre-releases (``--prerelease allow``)." />
-<Parameter name="extra_options" type="str" defaultValue="&quot;&quot;" description="Additional raw options appended to the ``uv pip install`` invocation." />
-<Parameter name="force_build" type="bool" defaultValue="False" description="If True, skip cached image builds." />
-<Parameter name="uv_version" type="str | None" defaultValue="None" description="Pin the uv binary version copied from ``ghcr.io/astral-sh/uv``." />
-<Parameter name="env" type="dict[str, str | None] | None" defaultValue="None" description="Environment variables set in the build container." />
-<Parameter name="secrets" type="Collection[_Secret] | None" defaultValue="None" description="Secrets injected as environment variables during the build." />
-<Parameter name="gpu" type="str | None" defaultValue="None" description="GPU type to attach to the builder container." />
-
-**Returns**
-
-A new `Image` with packages installed via uv.
-
-**Usage**
-
-```python
-image = modal.Image.debian_slim().uv_pip_install("torch==2.7.1", "numpy")
-```
-
-## poetry_install_from_file
-
-```python
-poetry_install_from_file(self, poetry_pyproject_toml, poetry_lockfile=None, *,
-    ignore_lockfile=False, force_build=False, with_=[], without=[], only=[],
-    poetry_version="latest", old_installer=False, env=None, secrets=None,
-    gpu=None)
-```
-Install poetry *dependencies* specified by a local `pyproject.toml` file.
-
-If not provided as argument the path to the lockfile is inferred. However, the
-file has to exist, unless `ignore_lockfile` is set to `True`.
-
-Note that the root project of the poetry project is not installed, only the dependencies.
-For including local python source files see `add_local_python_source`
-
-Poetry will be installed to the Image (using pip) unless `poetry_version` is set to None.
-Note that the interpretation of `poetry_version="latest"` depends on the Modal Image Builder
-version, with versions 2024.10 and earlier limiting poetry to 1.x.
-
-**Parameters**
-
-<Parameter name="poetry_pyproject_toml" type="str" description="Path to a Poetry ``pyproject.toml`` file." />
-<Parameter name="poetry_lockfile" type="str | None" defaultValue="None" description="Path to ``poetry.lock``; if omitted, inferred next to the pyproject." />
-<Parameter name="ignore_lockfile" type="bool" defaultValue="False" description="If True, do not copy or use a lockfile even when present." />
-<Parameter name="force_build" type="bool" defaultValue="False" description="If True, skip cached image builds." />
-<Parameter name="with_" type="list[str]" defaultValue="[]" description="Optional dependency groups to include (``poetry install --with``)." />
-<Parameter name="without" type="list[str]" defaultValue="[]" description="Optional dependency groups to exclude (``poetry install --without``)." />
-<Parameter name="only" type="list[str]" defaultValue="[]" description="Only install dependency groups in this list (``poetry install --only``)." />
-<Parameter name="poetry_version" type="str | None" defaultValue="&quot;latest&quot;" description="Poetry version specifier to ``pip install``, or None to skip installing Poetry." />
-<Parameter name="old_installer" type="bool" defaultValue="False" description="If True, use Poetry&#x27;s legacy installer." />
-<Parameter name="env" type="dict[str, str | None] | None" defaultValue="None" description="Environment variables set in the build container." />
-<Parameter name="secrets" type="Collection[_Secret] | None" defaultValue="None" description="Secrets injected as environment variables during the build." />
-<Parameter name="gpu" type="str | None" defaultValue="None" description="GPU type to attach to the builder container." />
-
-**Returns**
-
-A new `Image` with Poetry dependencies installed.
-
-## uv_sync
-
-```python
-uv_sync(self, uv_project_dir="./", *, force_build=False, groups=None,
-    extras=None, frozen=True, extra_options="", uv_version=None, env=None,
-    secrets=None, gpu=None)
-```
-Creates a virtual environment with the dependencies in a uv managed project with `uv sync`.
-
-The `pyproject.toml` and `uv.lock` in `uv_project_dir` are automatically added to the build context. The
-`uv_project_dir` is relative to the current working directory of where `modal` is called.
-
-NOTE: This does *not* install the project itself into the environment (this is equivalent to the
-`--no-install-project` flag in the `uv sync` command) and you would be expected to add any local python source
-files using `Image.add_local_python_source` or similar methods after this call.
-
-This ensures that updates to your project code wouldn't require reinstalling third-party dependencies
-after every change.
-
-uv workspaces are currently not supported.
-
-Added in v1.1.0.
-
-**Parameters**
-
-<Parameter name="uv_project_dir" type="str" defaultValue="&quot;./&quot;" description="Path to the local uv project directory (contains ``pyproject.toml``)." />
-<Parameter name="force_build" type="bool" defaultValue="False" description="If True, skip cached image builds." />
-<Parameter name="groups" type="list[str] | None" defaultValue="None" description="Dependency groups passed as ``uv sync --group``." />
-<Parameter name="extras" type="list[str] | None" defaultValue="None" description="Optional extras passed as ``uv sync --extra``." />
-<Parameter name="frozen" type="bool" defaultValue="True" description="If True and a ``uv.lock`` exists, run ``uv sync --frozen`` so the lock is not updated at build time." />
-<Parameter name="extra_options" type="str" defaultValue="&quot;&quot;" description="Additional raw options appended to ``uv sync``." />
-<Parameter name="uv_version" type="str | None" defaultValue="None" description="Pin the uv binary version copied from ``ghcr.io/astral-sh/uv``." />
-<Parameter name="env" type="dict[str, str | None] | None" defaultValue="None" description="Environment variables set in the build container." />
-<Parameter name="secrets" type="Collection[_Secret] | None" defaultValue="None" description="Secrets injected as environment variables during the build." />
-<Parameter name="gpu" type="str | None" defaultValue="None" description="GPU type to attach to the builder container." />
-
-**Returns**
-
-A new `Image` with a uv-managed virtual environment.
-
-**Usage**
-
-```python
-image = modal.Image.debian_slim().uv_sync()
-```
-
-## dockerfile_commands
-
-```python
-dockerfile_commands(self, *dockerfile_commands, context_files={}, env=None,
-    secrets=None, gpu=None, context_dir=None, force_build=False,
-    ignore=AUTO_DOCKERIGNORE, build_args={})
-```
-Extend an image with arbitrary Dockerfile-like commands.
-
-**Parameters**
-
-<Parameter name="*dockerfile_commands" type="str | list[str]" description="Dockerfile lines to append after ``FROM base`` (strings or nested lists)." />
-<Parameter name="context_files" type="dict[str, str]" defaultValue="&#123;&#125;" description="Map of container paths to local files to include in the build context." />
-<Parameter name="env" type="dict[str, str | None] | None" defaultValue="None" description="Environment variables set in the build container." />
-<Parameter name="secrets" type="Collection[_Secret] | None" defaultValue="None" description="Secrets injected as environment variables during the build." />
-<Parameter name="gpu" type="str | None" defaultValue="None" description="GPU type to attach to the builder container." />
-<Parameter name="context_dir" type="Path | str | None" defaultValue="None" description="Root directory for resolving relative COPY paths in implicit context mounts." />
-<Parameter name="force_build" type="bool" defaultValue="False" description="If True, skip cached image builds." />
-<Parameter name="ignore" type="Sequence[str] | Callable[[Path], bool]" defaultValue="AUTO_DOCKERIGNORE" description="Ignore rules for the implicit context mount (defaults to auto ``.dockerignore`` behavior)." />
-<Parameter name="build_args" type="dict[str, str]" defaultValue="&#123;&#125;" description="Dockerfile ``ARG`` values forwarded to the build." />
-
-**Returns**
-
-A new `Image` with the Dockerfile fragment applied.
-
-**Usage**
-
-```python
-from modal import FilePatternMatcher
-
-# By default a .dockerignore file is used if present in the current working directory
-image = modal.Image.debian_slim().dockerfile_commands(
-    ["COPY data /data"],
-)
-
-image = modal.Image.debian_slim().dockerfile_commands(
-    ["COPY data /data"],
-    ignore=["*.venv"],
-)
-
-image = modal.Image.debian_slim().dockerfile_commands(
-    ["COPY data /data"],
-    ignore=lambda p: p.is_relative_to(".venv"),
-)
-
-image = modal.Image.debian_slim().dockerfile_commands(
-    ["COPY data /data"],
-    ignore=FilePatternMatcher("**/*.txt"),
-)
-
-# When including files is simpler than excluding them, you can use the `~` operator to invert the matcher.
-image = modal.Image.debian_slim().dockerfile_commands(
-    ["COPY data /data"],
-    ignore=~FilePatternMatcher("**/*.py"),
-)
-
-# You can also read ignore patterns from a file.
-image = modal.Image.debian_slim().dockerfile_commands(
-    ["COPY data /data"],
-    ignore=FilePatternMatcher.from_file("/path/to/dockerignore"),
-)
-```
-
-## entrypoint
-
-```python
-entrypoint(self, entrypoint_commands)
-```
-Set the ENTRYPOINT for the image.
-
-**Parameters**
-
-<Parameter name="entrypoint_commands" type="list[str]" description="argv tokens for the ``ENTRYPOINT`` JSON array form." />
-
-**Returns**
-
-A new `Image` with the entrypoint Dockerfile directive applied.
-
-## shell
-
-```python
-shell(self, shell_commands)
-```
-Overwrite default shell for the image.
-
-**Parameters**
-
-<Parameter name="shell_commands" type="list[str]" description="argv tokens for the ``SHELL`` JSON array form." />
-
-**Returns**
-
-A new `Image` with the shell Dockerfile directive applied.
-
-## run_commands
-
-```python
-run_commands(self, *commands, env=None, secrets=None, volumes=None, gpu=None,
-    force_build=False)
-```
-Extend an image with a list of shell commands to run.
-
-**Parameters**
-
-<Parameter name="*commands" type="str | list[str]" description="Shell commands to run as separate ``RUN`` lines (strings or nested lists)." />
-<Parameter name="env" type="dict[str, str | None] | None" defaultValue="None" description="Environment variables set in the build container." />
-<Parameter name="secrets" type="Collection[_Secret] | None" defaultValue="None" description="Secrets injected as environment variables during the build." />
-<Parameter name="volumes" type="dict[str | PurePosixPath, _Volume] | None" defaultValue="None" description="Modal volumes to attach during the build step." />
-<Parameter name="gpu" type="str | None" defaultValue="None" description="GPU type to attach to the builder container." />
-<Parameter name="force_build" type="bool" defaultValue="False" description="If True, skip cached image builds." />
-
-**Returns**
-
-A new `Image` with the commands executed as layers.
-
-## micromamba
-
-```python
-micromamba(python_version=None, force_build=False)
-```
-A Micromamba base image. Micromamba allows for fast building of small Conda-based containers.
-
-**Parameters**
-
-<Parameter name="python_version" type="str | None" defaultValue="None" description="Python series or full version to install in the base conda environment." />
-<Parameter name="force_build" type="bool" defaultValue="False" description="If True, skip cached image builds." />
-
-**Returns**
-
-A Micromamba-based `Image`.
-
-## micromamba_install
-
-```python
-micromamba_install(self, *packages, spec_file=None, channels=[],
-    force_build=False, env=None, secrets=None, gpu=None)
-```
-Install a list of additional packages using micromamba.
-
-**Parameters**
-
-<Parameter name="*packages" type="str | list[str]" description="Conda packages to install, e.g. ``numpy`` or version constraints." />
-<Parameter name="spec_file" type="str | None" defaultValue="None" description="Optional local path to a conda spec file to pass with ``-f``." />
-<Parameter name="channels" type="list[str]" defaultValue="[]" description="Conda channels to pass with repeated ``-c`` flags." />
-<Parameter name="force_build" type="bool" defaultValue="False" description="If True, skip cached image builds." />
-<Parameter name="env" type="dict[str, str | None] | None" defaultValue="None" description="Environment variables set in the build container." />
-<Parameter name="secrets" type="Collection[_Secret] | None" defaultValue="None" description="Secrets injected as environment variables during the build." />
-<Parameter name="gpu" type="str | None" defaultValue="None" description="GPU type to attach to the builder container." />
-
-**Returns**
-
-A new `Image` with micromamba packages installed.
-
-## from_registry
-
-```python
-from_registry(tag, secret=None, *, setup_dockerfile_commands=[],
-    force_build=False, add_python=None, **kwargs)
-```
-Build a Modal Image from a public or private image registry, such as Docker Hub.
-
-The image must be built for the `linux/amd64` platform.
-
-If your image does not come with Python installed, you can use the `add_python` parameter
-to specify a version of Python to add to the image. Otherwise, the image is expected to
-have Python on PATH as `python`, along with `pip`.
-
-You may also use `setup_dockerfile_commands` to run Dockerfile commands before the
-remaining commands run. This might be useful if you want a custom Python installation or to
-set a `SHELL`. Prefer `run_commands()` when possible though.
-
-To authenticate against a private registry with static credentials, you must set the `secret` parameter to
-a `modal.Secret` containing a username (`REGISTRY_USERNAME`) and
-an access token or password (`REGISTRY_PASSWORD`).
-
-To authenticate against private registries with credentials from a cloud provider,
-use `Image.from_gcp_artifact_registry()` or `Image.from_aws_ecr()`.
-
-**Parameters**
-
-<Parameter name="tag" type="str" description="Registry image reference (e.g. ``python:3.11-slim``)." />
-<Parameter name="secret" type="_Secret | None" defaultValue="None" description="Optional secret for static registry credentials." />
-<Parameter name="setup_dockerfile_commands" type="list[str]" defaultValue="[]" description="Extra Dockerfile lines run after ``FROM`` during base setup." />
-<Parameter name="force_build" type="bool" defaultValue="False" description="If True, skip cached image builds." />
-<Parameter name="add_python" type="str | None" defaultValue="None" description="Optional standalone Python series to inject when the base image lacks Python." />
-<Parameter name="**kwargs" type="" description="Additional arguments forwarded to the internal image constructor (e.g. registry config)." />
-
-**Returns**
-
-An `Image` based on the registry tag.
-
-**Usage**
-
-```python
-modal.Image.from_registry("python:3.11-slim-bookworm")
-modal.Image.from_registry("ubuntu:22.04", add_python="3.11")
-modal.Image.from_registry("nvcr.io/nvidia/pytorch:22.12-py3")
-```
-
-## from_gcp_artifact_registry
-
-```python
-from_gcp_artifact_registry(tag, secret=None, *, setup_dockerfile_commands=[],
-    force_build=False, add_python=None, **kwargs)
-```
-Build a Modal image from a private image in Google Cloud Platform (GCP) Artifact Registry.
-
-You will need to pass a `modal.Secret` containing [your GCP service account key data](https://cloud.google.com/iam/docs/keys-create-delete#creating)
-as `SERVICE_ACCOUNT_JSON`. This can be done from the [Secrets](https://modal.com/secrets) page.
-Your service account should be granted a specific role depending on the GCP registry used:
-
-- For Artifact Registry images (`pkg.dev` domains) use
-  the ["Artifact Registry Reader"](https://cloud.google.com/artifact-registry/docs/access-control#roles) role
-- For Container Registry images (`gcr.io` domains) use
-  the ["Storage Object Viewer"](https://cloud.google.com/artifact-registry/docs/transition/setup-gcr-repo) role
-
-**Note:** This method does not use `GOOGLE_APPLICATION_CREDENTIALS` as that
-variable accepts a path to a JSON file, not the actual JSON string.
-
-See `Image.from_registry()` for information about the other parameters.
-
-**Parameters**
-
-<Parameter name="tag" type="str" description="Full GCP Artifact Registry image reference." />
-<Parameter name="secret" type="_Secret | None" defaultValue="None" description="Secret containing ``SERVICE_ACCOUNT_JSON`` for registry authentication." />
-<Parameter name="setup_dockerfile_commands" type="list[str]" defaultValue="[]" description="Extra Dockerfile lines run after ``FROM`` during base setup." />
-<Parameter name="force_build" type="bool" defaultValue="False" description="If True, skip cached image builds." />
-<Parameter name="add_python" type="str | None" defaultValue="None" description="Optional standalone Python series to inject when the base image lacks Python." />
-<Parameter name="**kwargs" type="" description="Additional arguments forwarded to `from_registry`." />
-
-**Returns**
-
-An `Image` based on the private GCP artifact.
-
-**Usage**
-
-```python
-modal.Image.from_gcp_artifact_registry(
-    "us-east1-docker.pkg.dev/my-project-1234/my-repo/my-image:my-version",
-    secret=modal.Secret.from_name(
-        "my-gcp-secret",
-        required_keys=["SERVICE_ACCOUNT_JSON"],
-    ),
-    add_python="3.11",
-)
-```
-
-## from_aws_ecr
-
-```python
-from_aws_ecr(tag, secret=None, *, setup_dockerfile_commands=[],
-    force_build=False, add_python=None, **kwargs)
-```
-Build a Modal image from a private image in AWS Elastic Container Registry (ECR).
-
-You will need to pass a `modal.Secret` containing either IAM user credentials or OIDC
-configuration to access the target ECR registry.
-
-For IAM user authentication, set `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, and `AWS_REGION`.
-
-For OIDC authentication, set `AWS_ROLE_ARN` and `AWS_REGION`.
-
-IAM configuration details can be found in the AWS documentation for
-["Private repository policies"](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policies.html).
-
-For more details on using an AWS role to access ECR, see the [OIDC integration guide](https://modal.com/docs/guide/oidc-integration).
-
-See `Image.from_registry()` for information about the other parameters.
-
-**Parameters**
-
-<Parameter name="tag" type="str" description="Full ECR image URI." />
-<Parameter name="secret" type="_Secret | None" defaultValue="None" description="Secret with IAM or OIDC credentials for ECR." />
-<Parameter name="setup_dockerfile_commands" type="list[str]" defaultValue="[]" description="Extra Dockerfile lines run after ``FROM`` during base setup." />
-<Parameter name="force_build" type="bool" defaultValue="False" description="If True, skip cached image builds." />
-<Parameter name="add_python" type="str | None" defaultValue="None" description="Optional standalone Python series to inject when the base image lacks Python." />
-<Parameter name="**kwargs" type="" description="Additional arguments forwarded to `from_registry`." />
-
-**Returns**
-
-An `Image` based on the private ECR image.
-
-**Usage**
-
-```python
-modal.Image.from_aws_ecr(
-    "000000000000.dkr.ecr.us-east-1.amazonaws.com/my-private-registry:my-version",
-    secret=modal.Secret.from_name(
-        "aws",
-        required_keys=["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_REGION"],
-    ),
-    add_python="3.11",
-)
-```
-
-## from_dockerfile
-
-```python
-from_dockerfile(path, *, force_build=False, context_dir=None, env=None,
-    secrets=None, gpu=None, add_python=None, build_args={},
-    ignore=AUTO_DOCKERIGNORE)
-```
-Build a Modal image from a local Dockerfile.
-
-If your Dockerfile does not have Python installed, you can use the `add_python` parameter
-to specify a version of Python to add to the image.
-
-**Parameters**
-
-<Parameter name="path" type="str | Path" description="Path to the Dockerfile on the local machine." />
-<Parameter name="force_build" type="bool" defaultValue="False" description="If True, skip cached image builds." />
-<Parameter name="context_dir" type="Path | str | None" defaultValue="None" description="Build context directory for resolving relative COPY paths." />
-<Parameter name="env" type="dict[str, str | None] | None" defaultValue="None" description="Environment variables set in the build container." />
-<Parameter name="secrets" type="Collection[_Secret] | None" defaultValue="None" description="Secrets injected as environment variables during the build." />
-<Parameter name="gpu" type="str | None" defaultValue="None" description="GPU type to attach to the builder container." />
-<Parameter name="add_python" type="str | None" defaultValue="None" description="Standalone Python version to add when the Dockerfile does not install Python." />
-<Parameter name="build_args" type="dict[str, str]" defaultValue="&#123;&#125;" description="Dockerfile ``ARG`` values forwarded to the build." />
-<Parameter name="ignore" type="Sequence[str] | Callable[[Path], bool]" defaultValue="AUTO_DOCKERIGNORE" description="Ignore rules for the implicit context mount (defaults to auto ``.dockerignore`` behavior)." />
-
-**Returns**
-
-An `Image` built from the Dockerfile plus Modal runtime dependencies.
-
-**Usage**
-
-```python
-from modal import FilePatternMatcher
-
-# By default a .dockerignore file is used if present in the current working directory
-image = modal.Image.from_dockerfile(
-    "./Dockerfile",
-    add_python="3.12",
-)
-
-image = modal.Image.from_dockerfile(
-    "./Dockerfile",
-    add_python="3.12",
-    ignore=["*.venv"],
-)
-
-image = modal.Image.from_dockerfile(
-    "./Dockerfile",
-    add_python="3.12",
-    ignore=lambda p: p.is_relative_to(".venv"),
-)
-
-image = modal.Image.from_dockerfile(
-    "./Dockerfile",
-    add_python="3.12",
-    ignore=FilePatternMatcher("**/*.txt"),
-)
-
-# When including files is simpler than excluding them, you can use the `~` operator to invert the matcher.
-image = modal.Image.from_dockerfile(
-    "./Dockerfile",
-    add_python="3.12",
-    ignore=~FilePatternMatcher("**/*.py"),
-)
-
-# You can also read ignore patterns from a file.
-image = modal.Image.from_dockerfile(
-    "./Dockerfile",
-    add_python="3.12",
-    ignore=FilePatternMatcher.from_file("/path/to/dockerignore"),
-)
-```
-
-## from_scratch
-
-```python
-from_scratch(force_build=False)
-```
-Create an empty Image, equivalent to `FROM scratch` in Docker.
-
-The resulting Image has no operating system, shell, or package manager. It is
-primarily useful as a lightweight filesystem to mount into a Sandbox via
-`Sandbox.mount_image`.
-
-Note that since this Image doesn't contain Python or other standard OS utilities,
-higher-level Image build steps like `pip_install` cannot be chained onto it. It also
-cannot be used for `modal.Function` execution, which requires a Python interpreter.
-
-**Parameters**
-
-<Parameter name="force_build" type="bool" defaultValue="False" description="If True, skip cached image builds." />
-
-**Returns**
-
-An empty `Image` suitable for minimal filesystem mounts.
-
-**Usage**
-
-```python notest
-image = modal.Image.from_scratch().add_local_file(local_path, "/bin/my_binary", copy=True)
-```
-
-## debian_slim
-
-```python
-debian_slim(python_version=None, force_build=False)
-```
-Default image, based on the official `python` Docker images.
-
-**Parameters**
-
-<Parameter name="python_version" type="str | None" defaultValue="None" description="Python series or full version to use from the Debian slim images." />
-<Parameter name="force_build" type="bool" defaultValue="False" description="If True, skip cached image builds." />
-
-**Returns**
-
-The standard Debian slim Python `Image` used as Modal's default base.
-
-## apt_install
-
-```python
-apt_install(self, *packages, force_build=False, env=None, secrets=None,
-    gpu=None)
-```
-Install a list of Debian packages using `apt`.
-
-**Parameters**
-
-<Parameter name="*packages" type="str | list[str]" description="Apt package names to install, e.g. ``git`` or ``libpq-dev``." />
-<Parameter name="force_build" type="bool" defaultValue="False" description="If True, skip cached image builds." />
-<Parameter name="env" type="dict[str, str | None] | None" defaultValue="None" description="Environment variables set in the build container." />
-<Parameter name="secrets" type="Collection[_Secret] | None" defaultValue="None" description="Secrets injected as environment variables during the build." />
-<Parameter name="gpu" type="str | None" defaultValue="None" description="GPU type to attach to the builder container." />
-
-**Returns**
-
-A new `Image` with ``apt-get install`` layers applied.
-
-**Usage**
-
-```python
-image = modal.Image.debian_slim().apt_install("git")
-```
-
-## run_function
-
-```python
-run_function(self, raw_f, *, env=None, secrets=None, volumes={},
-    network_file_systems={}, gpu=None, cpu=None, memory=None, timeout=60 * 60,
-    cloud=None, region=None, force_build=False, args=(), kwargs={},
-    include_source=True)
-```
-Run user-defined function `raw_f` as an image build step.
-
-The function runs like an ordinary Modal Function, accepting a resource configuration and integrating
-with Modal features like Secrets and Volumes. Unlike ordinary Modal Functions, any changes to the
-filesystem state will be captured on container exit and saved as a new Image.
-
-Only the source code of `raw_f`, the contents of `**kwargs`, and any referenced *global* variables
-are used to determine whether the image has changed and needs to be rebuilt.
-If this function references other functions or variables, the image will not be rebuilt if you
-make changes to them. You can force a rebuild by changing the function's source code itself.
-
-**Parameters**
-
-<Parameter name="raw_f" type="Callable[..., Any]" description="Callable executed remotely during the image build." />
-<Parameter name="env" type="dict[str, str | None] | None" defaultValue="None" description="Environment variables set in the builder container." />
-<Parameter name="secrets" type="Collection[_Secret] | None" defaultValue="None" description="Secrets available to the builder function." />
-<Parameter name="volumes" type="dict[str | PurePosixPath, _Volume | _CloudBucketMount]" defaultValue="&#123;&#125;" description="Volume and bucket mounts attached for the build." />
-<Parameter name="network_file_systems" type="dict[str | PurePosixPath, _NetworkFileSystem]" defaultValue="&#123;&#125;" description="Network file systems attached for the build." />
-<Parameter name="gpu" type="str | list[str] | None" defaultValue="None" description="GPU type or list of types for the builder container." />
-<Parameter name="cpu" type="float | None" defaultValue="None" description="CPU cores to request (soft limit)." />
-<Parameter name="memory" type="int | None" defaultValue="None" description="Memory to request in MiB (soft limit)." />
-<Parameter name="timeout" type="int" defaultValue="60 * 60" description="Maximum build-step runtime in seconds." />
-<Parameter name="cloud" type="str | None" defaultValue="None" description="Cloud provider for the builder function." />
-<Parameter name="region" type="str | Sequence[str] | None" defaultValue="None" description="Region or regions for the builder function." />
-<Parameter name="force_build" type="bool" defaultValue="False" description="If True, skip cached image builds." />
-<Parameter name="args" type="Sequence[Any]" defaultValue="()" description="Positional arguments serialized to the builder function." />
-<Parameter name="kwargs" type="dict[str, Any]" defaultValue="&#123;&#125;" description="Keyword arguments serialized to the builder function." />
-<Parameter name="include_source" type="bool" defaultValue="True" description="Whether to include the function&#x27;s source in the builder image." />
-
-**Returns**
-
-A new `Image` capturing the filesystem after `raw_f` completes.
-
-**Usage**
-
-```python notest
-
-def my_build_function():
-    open("model.pt", "w").write("parameters!")
-
-image = (
-    modal.Image
-        .debian_slim()
-        .pip_install("torch")
-        .run_function(my_build_function, secrets=[...], volumes={...})
-)
-```
-
-## env
-
-```python
-env(self, vars)
-```
-Sets the environment variables in an Image.
-
-**Parameters**
-
-<Parameter name="vars" type="dict[str, str]" description="Map of environment variable names to string values." />
-
-**Returns**
-
-A new `Image` with ``ENV`` directives applied.
-
-**Usage**
-
-```python
-image = (
-    modal.Image.debian_slim()
-    .env({"HF_HUB_ENABLE_HF_TRANSFER": "1"})
-)
-```
-
-## workdir
-
-```python
-workdir(self, path)
-```
-Set the working directory for subsequent image build steps and function execution.
-
-**Parameters**
-
-<Parameter name="path" type="str | PurePosixPath" description="Working directory path inside the image." />
-
-**Returns**
-
-A new `Image` with ``WORKDIR`` applied.
-
-**Usage**
-
-```python
-image = (
-    modal.Image.debian_slim()
-    .run_commands("git clone https://xyz app")
-    .workdir("/app")
-    .run_commands("yarn install")
-)
-```
-
-## cmd
-
-```python
-cmd(self, cmd)
-```
-Set the default command (`CMD`) to run when a container is started.
-
-Used with `modal.Sandbox`. Has no effect on `modal.Function`.
-
-**Parameters**
-
-<Parameter name="cmd" type="list[str]" description="argv tokens for the default container command." />
-
-**Returns**
-
-A new `Image` with ``CMD`` applied.
-
-**Usage**
-
-```python
-image = (
-    modal.Image.debian_slim().cmd(["python", "app.py"])
-)
-```
-
-## pipe
-
-```python
-pipe(self, func, *args, **kwargs)
-```
-Apply a local function to expand the Image recipe.
-
-This method can be useful for defining reusable Image build
-recipes that compose well with the fluent Image builder interface.
-
-**Example**
-
-```python
-def workspace_setup(image: modal.Image, repo: str) -> modal.Image:
-    return image.run_commands(f"git clone {repo}").uv_pip_install(".")
-
-image = (
-    modal.Image.debian_slim()
-    .apt_install("git")
-    .pipe(workspace_setup, "https://github.com/example/repo.git")
-)
-```
-
-## imports
-
-```python
-imports(self)
-```
-Used to import packages in global scope that are only available when running remotely.
-
-By using this context manager you can avoid an `ImportError` due to not having certain
-packages installed locally.
-
-**Returns**
-
-Context manager that records import failures until the image is hydrated in the remote environment.
-
-**Usage**
-
-```python notest
-with image.imports():
-    import torch
-```
-
-## from_name
-
-```python
-from_name(name, *, environment_name=None, client=None)
-```
-Reference a named Image that was previously published with `.publish()`.
-
-Names can contain an optional `:tag` part - if no tag part is included `":latest"` is used,
-matching Docker conventions.
-
-```python notest
-image = modal.Image.from_name("my-image")     # references my-image:latest
-image_v1 = modal.Image.from_name("my-image:v1")
-
-@app.function(image=image)
-def run():
-    ...
-```
-
-## publish
-
-```python
-publish(self, name, *, environment_name=None, client=None)
-```
-Publish this image under the given name
-
-The Image must already be created (typically by calling `image.build()` or `sandbox.snapshot_filesystem()`).
-
-Image names can contain an explicit tag designation (using the `name:tag`). If no tag is included in the name,
-`":latest"` is used, matching Docker conventions. To publish multiple tags, call `.publish()` once per tag.
-
-```python notest
-image = modal.Image.debian_slim().pip_install("numpy")
-image.build(app)
-image.publish("my-image-with-numpy")     # my-image-with-numpy:latest
-image.publish("my-image-with-numpy:v1")
-```

.agents/skills/modal/references/api/modal.NetworkFileSystem.md

@@ -1,183 +0,0 @@
-# modal.NetworkFileSystem
-
-
-```python
-class NetworkFileSystem(modal.object.Object)
-```
-
-A shared, writable file system accessible by one or more Modal functions.
-
-By attaching this file system as a mount to one or more functions, they can
-share and persist data with each other.
-
-**Note: `NetworkFileSystem` has been deprecated and will be removed.**
-
-**Usage**
-
-```python
-import modal
-
-nfs = modal.NetworkFileSystem.from_name("my-nfs", create_if_missing=True)
-app = modal.App()
-
-@app.function(network_file_systems={"/root/foo": nfs})
-def f():
-    pass
-
-@app.function(network_file_systems={"/root/goo": nfs})
-def g():
-    pass
-```
-
-Also see the CLI methods for accessing network file systems:
-
-```
-modal nfs --help
-```
-
-A `NetworkFileSystem` can also be useful for some local scripting scenarios, e.g.:
-
-```python notest
-nfs = modal.NetworkFileSystem.from_name("my-network-file-system")
-for chunk in nfs.read_file("my_db_dump.csv"):
-    ...
-```
-
-
-## hydrate
-
-```python
-hydrate(self, client=None)
-```
-Synchronize the local object with its identity on the Modal server.
-
-It is rarely necessary to call this method explicitly, as most operations
-will lazily hydrate when needed. The main use case is when you need to
-access object metadata, such as its ID.
-
-*Added in v0.72.39*: This method replaces the deprecated `.resolve()` method.
-
-## from_name
-
-```python
-from_name(name, *, environment_name=None, create_if_missing=False, client=None)
-```
-Reference a NetworkFileSystem by name, optionally creating it on the server first.
-
-Hydration is lazy: metadata is fetched from Modal the first time the handle is used.
-
-**Parameters**
-
-<Parameter name="name" type="str" description="Deployment name of the network file system." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="Environment to resolve the name in; defaults to the active environment." />
-<Parameter name="create_if_missing" type="bool" defaultValue="False" description="If True, create the object when it does not already exist." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use for loading; defaults to `Client.from_env()` when omitted." />
-
-**Returns**
-
-A `NetworkFileSystem` handle (possibly not yet hydrated).
-
-**Usage**
-
-```python notest
-nfs = NetworkFileSystem.from_name("my-nfs", create_if_missing=True)
-
-@app.function(network_file_systems={"/data": nfs})
-def f():
-    pass
-```
-
-## ephemeral
-
-```python
-ephemeral(cls, client=None, environment_name=None)
-```
-Create an anonymous NetworkFileSystem that exists for the duration of the context manager.
-
-**Parameters**
-
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use; defaults to `Client.from_env()` when omitted." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="Environment for the ephemeral object; defaults to the active environment." />
-
-**Usage**
-
-```python
-with modal.NetworkFileSystem.ephemeral() as nfs:
-    assert nfs.listdir("/") == []
-```
-
-```python notest
-async with modal.NetworkFileSystem.ephemeral() as nfs:
-    assert await nfs.listdir("/") == []
-```
-
-## delete
-
-```python
-delete(name, client=None, environment_name=None)
-```
-
-
-## write_file
-
-```python
-write_file(self, remote_path, fp, progress_cb=None)
-```
-Write from a file object to a path on the network file system, atomically.
-
-Will create any needed parent directories automatically.
-
-If remote_path ends with `/` it's assumed to be a directory and the
-file will be uploaded with its current name to that directory.
-
-## read_file
-
-```python
-read_file(self, path)
-```
-Read a file from the network file system
-
-## iterdir
-
-```python
-iterdir(self, path)
-```
-Iterate over all files in a directory in the network file system.
-
-* Passing a directory path lists all files in the directory (names are relative to the directory)
-* Passing a file path returns a list containing only that file's listing description
-* Passing a glob path (including at least one * or ** sequence) returns all files matching
-that glob path (using absolute paths)
-
-## add_local_file
-
-```python
-add_local_file(self, local_path, remote_path=None, progress_cb=None)
-```
-
-
-## add_local_dir
-
-```python
-add_local_dir(self, local_path, remote_path=None, progress_cb=None)
-```
-
-
-## listdir
-
-```python
-listdir(self, path)
-```
-List all files in a directory in the network file system.
-
-* Passing a directory path lists all files in the directory (names are relative to the directory)
-* Passing a file path returns a list containing only that file's listing description
-* Passing a glob path (including at least one * or ** sequence) returns all files matching
-that glob path (using absolute paths)
-
-## remove_file
-
-```python
-remove_file(self, path, recursive=False)
-```
-Remove a file in a network file system.

.agents/skills/modal/references/api/modal.Period.md

@@ -1,40 +0,0 @@
-# modal.Period
-
-
-```python
-class Period(modal.schedule.Schedule)
-```
-
-Create a schedule that runs every given time interval.
-
-Only `seconds` can be a float. All other arguments are integers.
-
-Note that `days=1` will trigger the function the same time every day.
-This does not have the same behavior as `seconds=84000` since days have
-different lengths due to daylight savings and leap seconds. Similarly,
-using `months=1` will trigger the function on the same day each month.
-
-This behaves similar to the
-[dateutil](https://dateutil.readthedocs.io/en/latest/relativedelta.html)
-package.
-
-**Usage**
-
-```python
-import modal
-app = modal.App()
-
-@app.function(schedule=modal.Period(days=1))
-def f():
-    print("This function will run every day")
-
-modal.Period(hours=4)          # runs every 4 hours
-modal.Period(minutes=15)       # runs every 15 minutes
-modal.Period(seconds=math.pi)  # runs every 3.141592653589793 seconds
-```
-
-```python
-__init__(self, *, years=0, months=0, weeks=0, days=0, hours=0, minutes=0,
-    seconds=0)
-```
-

.agents/skills/modal/references/api/modal.Probe.md

@@ -1,47 +0,0 @@
-# modal.Probe
-
-
-```python
-class Probe(object)
-```
-
-Probe configuration for the Sandbox Readiness Probe.
-
-**Usage**
-
-```python notest
-# Wait until a file exists.
-readiness_probe = modal.Probe.with_exec(
-    "sh", "-c", "test -f /tmp/ready",
-)
-
-# Wait until a TCP port is accepting connections.
-readiness_probe = modal.Probe.with_tcp(8080)
-
-app = modal.App.lookup('sandbox-readiness-probe', create_if_missing=True)
-sandbox = modal.Sandbox.create(
-    "python3", "-m", "http.server", "8080",
-    readiness_probe=readiness_probe,
-    app=app,
-)
-sandbox.wait_until_ready()
-```
-
-```python
-__init__(self, tcp_port=None, exec_argv=None, interval_ms=100)
-```
-
-
-## with_tcp
-
-```python
-with_tcp(cls, port, *, interval_ms=100)
-```
-
-
-## with_exec
-
-```python
-with_exec(cls, *argv, interval_ms=100)
-```
-

.agents/skills/modal/references/api/modal.Proxy.md

@@ -1,45 +0,0 @@
-# modal.Proxy
-
-
-```python
-class Proxy(modal.object.Object)
-```
-
-Proxy objects give your Modal containers a static outbound IP address.
-
-This can be used for connecting to a remote address with network whitelist, for example
-a database. See [the guide](https://modal.com/docs/guide/proxy-ips) for more information.
-
-
-## hydrate
-
-```python
-hydrate(self, client=None)
-```
-Synchronize the local object with its identity on the Modal server.
-
-It is rarely necessary to call this method explicitly, as most operations
-will lazily hydrate when needed. The main use case is when you need to
-access object metadata, such as its ID.
-
-*Added in v0.72.39*: This method replaces the deprecated `.resolve()` method.
-
-## from_name
-
-```python
-from_name(name, *, environment_name=None, client=None)
-```
-Reference a Proxy by its name.
-
-In contrast to most other Modal objects, new Proxy objects must be
-provisioned via the Dashboard and cannot be created on the fly from code.
-
-**Parameters**
-
-<Parameter name="name" type="str" description="Name of the Proxy in the target environment." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="Environment to resolve the name in; defaults to the active environment." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use for loading; defaults to `Client.from_env()` when omitted." />
-
-**Returns**
-
-A lazy `Proxy` handle.

.agents/skills/modal/references/api/modal.Queue.md

@@ -1,464 +0,0 @@
-# modal.Queue
-
-
-```python
-class Queue(modal.object.Object)
-```
-
-Distributed, FIFO queue for data flow in Modal apps.
-
-The queue can contain any object serializable by `cloudpickle`, including Modal objects.
-
-By default, the `Queue` object acts as a single FIFO queue which supports puts and gets (blocking and non-blocking).
-
-**Usage**
-
-```python
-from modal import Queue
-
-# Create an ephemeral queue which is anonymous and garbage collected
-with Queue.ephemeral() as my_queue:
-    # Putting values
-    my_queue.put("some value")
-    my_queue.put(123)
-
-    # Getting values
-    assert my_queue.get() == "some value"
-    assert my_queue.get() == 123
-
-    # Using partitions
-    my_queue.put(0)
-    my_queue.put(1, partition="foo")
-    my_queue.put(2, partition="bar")
-
-    # Default and "foo" partition are ignored by the get operation.
-    assert my_queue.get(partition="bar") == 2
-
-    # Set custom 10s expiration time on "foo" partition.
-    my_queue.put(3, partition="foo", partition_ttl=10)
-
-    # Iterate through items in place (read immutably)
-    my_queue.put(1)
-    assert [v for v in my_queue.iterate()] == [0, 1]
-
-# You can also create persistent queues that can be used across apps
-queue = Queue.from_name("my-persisted-queue", create_if_missing=True)
-queue.put(42)
-assert queue.get() == 42
-```
-
-For more examples, see the [guide](https://modal.com/docs/guide/dicts-and-queues#modal-queues).
-
-**Queue partitions**
-
-Specifying partition keys gives access to other independent FIFO partitions within the same `Queue` object.
-Across any two partitions, puts and gets are completely independent.
-For example, a put in one partition does not affect a get in any other partition.
-
-When no partition key is specified (by default), puts and gets will operate on a default partition.
-This default partition is also isolated from all other partitions.
-Please see the Usage section below for an example using partitions.
-
-**Lifetime of a queue and its partitions**
-
-By default, each partition is cleared 24 hours after the last `put` operation.
-A lower TTL can be specified by the `partition_ttl` argument in the `put` or `put_many` methods.
-Each partition's expiry is handled independently.
-
-As such, `Queue`s are best used for communication between active functions and not relied on for persistent
-storage.
-
-On app completion or after stopping an app any associated `Queue` objects are cleaned up.
-All its partitions will be cleared.
-
-**Limits**
-
-A single `Queue` can contain up to 100,000 partitions, each with up to 5,000 items. Each item can be up to
-1 MiB.
-
-Partition keys must be non-empty and must not exceed 64 bytes.
-
-
-## hydrate
-
-```python
-hydrate(self, client=None)
-```
-Synchronize the local object with its identity on the Modal server.
-
-It is rarely necessary to call this method explicitly, as most operations
-will lazily hydrate when needed. The main use case is when you need to
-access object metadata, such as its ID.
-
-*Added in v0.72.39*: This method replaces the deprecated `.resolve()` method.
-
-## objects
-
-
-```python
-objects: QueueManager
-```
-
-Namespace with methods for managing named Queue objects.
-
-
-### objects.create
-
-```python
-create(self, name, *, allow_existing=False, environment_name=None, client=None)
-```
-Create a new named Queue in the workspace environment.
-
-This does not return a local handle; use `modal.Queue.from_name` to look up the Queue after creation.
-
-Added in v1.1.2.
-
-**Parameters**
-
-<Parameter name="name" type="str" description="Name for the new Queue." />
-<Parameter name="allow_existing" type="bool" defaultValue="False" description="If True, do nothing when a Queue with this name already exists." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="Environment to create in; defaults to the active environment." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use; defaults to `Client.from_env()` when omitted." />
-
-**Usage**
-
-```python notest
-modal.Queue.objects.create("my-queue")
-```
-
-Queues will be created in the active environment, or another one can be specified:
-
-```python notest
-modal.Queue.objects.create("my-queue", environment_name="dev")
-```
-
-By default, an error is raised if the Queue already exists; `allow_existing=True` makes that case a no-op:
-
-```python notest
-modal.Queue.objects.create("my-queue", allow_existing=True)
-```
-
-Note that this method does not return a local instance of the Queue. You can use
-`modal.Queue.from_name` to perform a lookup after creation.
-
-### objects.list
-
-```python
-list(self, *, max_objects=None, created_before=None, environment_name="",
-    client=None)
-```
-List named Queues in the workspace environment as hydrated handles.
-
-Results are ordered newest to oldest. By default, all matching Queues are returned.
-
-Added in v1.1.2.
-
-**Parameters**
-
-<Parameter name="max_objects" type="int | None" defaultValue="None" description="Maximum number of Queues to return." />
-<Parameter name="created_before" type="datetime | str | None" defaultValue="None" description="Only include Queues created before this time (datetime or ISO date string)." />
-<Parameter name="environment_name" type="str" defaultValue="&quot;&quot;" description="Environment to list from; defaults to the active environment." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use; defaults to `Client.from_env()` when omitted." />
-
-**Returns**
-
-Hydrated `Queue` objects for each named Queue in the listing.
-
-**Usage**
-
-```python
-queues = modal.Queue.objects.list()
-print([q.name for q in queues])
-```
-
-Queues will be retrieved from the active environment, or another one can be specified:
-
-```python notest
-dev_queues = modal.Queue.objects.list(environment_name="dev")
-```
-
-By default, all named Queues are returned, newest to oldest. It's also possible to limit the
-number of results and to filter by creation date:
-
-```python
-queues = modal.Queue.objects.list(max_objects=10, created_before="2025-01-01")
-```
-
-### objects.delete
-
-```python
-delete(self, name, *, allow_missing=False, environment_name=None, client=None)
-```
-Delete a named Queue entirely (not a single message or partition).
-
-Deletion is irreversible and affects any Apps using this Queue.
-
-Added in v1.1.2.
-
-**Parameters**
-
-<Parameter name="name" type="str" description="Name of the Queue to delete." />
-<Parameter name="allow_missing" type="bool" defaultValue="False" description="If True, do nothing when the Queue does not exist." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="Environment to delete from; defaults to the active environment." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use; defaults to `Client.from_env()` when omitted." />
-
-**Usage**
-
-```python notest
-await modal.Queue.objects.delete("my-queue")
-```
-
-Queues will be deleted from the active environment, or another one can be specified:
-
-```python notest
-await modal.Queue.objects.delete("my-queue", environment_name="dev")
-```
-
-## name
-
-```python
-name(self)
-```
-
-
-## validate_partition_key
-
-```python
-validate_partition_key(partition)
-```
-
-
-## ephemeral
-
-```python
-ephemeral(cls, client=None, environment_name=None)
-```
-Create an anonymous Queue that exists for the duration of the context manager.
-
-**Parameters**
-
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use; defaults to `Client.from_env()` when omitted." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="Environment for the ephemeral Queue; defaults to the active environment." />
-
-**Usage**
-
-```python
-from modal import Queue
-
-with Queue.ephemeral() as q:
-    q.put(123)
-```
-
-```python notest
-async with Queue.ephemeral() as q:
-    await q.put.aio(123)
-```
-
-## from_name
-
-```python
-from_name(name, *, environment_name=None, create_if_missing=False, client=None)
-```
-Reference a named Queue, optionally creating it on the server first.
-
-Hydration is lazy: metadata is fetched from Modal the first time the handle is used.
-
-**Parameters**
-
-<Parameter name="name" type="str" description="Deployment name of the Queue." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="Environment to resolve the name in; defaults to the active environment." />
-<Parameter name="create_if_missing" type="bool" defaultValue="False" description="If True, create the Queue when it does not already exist." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use for loading; defaults to `Client.from_env()` when omitted." />
-
-**Returns**
-
-A `Queue` handle (possibly not yet hydrated).
-
-**Usage**
-
-```python
-q = modal.Queue.from_name("my-queue", create_if_missing=True)
-q.put(123)
-```
-
-## from_id
-
-```python
-from_id(queue_id, client=None)
-```
-Construct a Queue from an id and look up the Queue metadata.
-
-This is a lazy method that defers hydrating the local
-object with metadata from Modal servers until the first
-time it is actually used.
-
-The ID of a Queue object can be accessed using `.object_id`.
-
-**Parameters**
-
-<Parameter name="queue_id" type="str" description="Queue object ID to attach to." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use for loading; defaults to `Client.from_env()` when omitted." />
-
-**Returns**
-
-A `Queue` handle (possibly not yet hydrated).
-
-**Usage**
-
-```python notest
-@app.function()
-def my_consumer(queue_id: str):
-    queue = modal.Queue.from_id(queue_id)
-    queue.put("Hello from remote function!")
-
-with modal.Queue.ephemeral() as q:
-    my_consumer.remote(q.object_id)
-    print(q.get())  # "Hello from remote function!"
-```
-
-## info
-
-```python
-info(self)
-```
-Return information about the Queue object.
-
-## clear
-
-```python
-clear(self, *, partition=None, all=False)
-```
-Clear the contents of a single partition or all partitions.
-
-Warning: this is a destructive operation and will irrevocably delete data.
-
-**Parameters**
-
-<Parameter name="partition" type="str | None" defaultValue="None" description="Partition to clear; omit with `all=True` to clear every partition." />
-<Parameter name="all" type="bool" defaultValue="False" description="If True, clear all partitions (`partition` must not be set)." />
-
-**Usage**
-
-```python
-q = modal.Queue.from_name("my-queue", create_if_missing=True)
-q.clear()
-```
-
-## get
-
-```python
-get(self, block=True, timeout=None, *, partition=None)
-```
-Remove and return the next object in the queue.
-
-If `block` is `True` (the default) and the queue is empty, `get` will wait indefinitely for
-an object, or until `timeout` if specified. Raises a native `queue.Empty` exception
-if the `timeout` is reached.
-
-If `block` is `False`, `get` returns `None` immediately if the queue is empty. The `timeout` is
-ignored in this case.
-
-**Parameters**
-
-<Parameter name="block" type="bool" defaultValue="True" description="If True, wait for an item; if False, return ``None`` immediately when empty." />
-<Parameter name="timeout" type="float | None" defaultValue="None" description="Seconds to wait when blocking; ignored when ``block`` is False." />
-<Parameter name="partition" type="str | None" defaultValue="None" description="FIFO partition to read from; uses the default partition when omitted." />
-
-## get_many
-
-```python
-get_many(self, n_values, block=True, timeout=None, *, partition=None)
-```
-Remove and return up to `n_values` objects from the queue.
-
-If there are fewer than `n_values` items in the queue, return all of them.
-
-If `block` is `True` (the default) and the queue is empty, `get_many` waits until at least one
-object is present, or until `timeout` if specified. Raises the stdlib's `queue.Empty` if the
-timeout is reached before any item arrives.
-
-If `block` is `False`, this returns an empty list immediately when the queue is empty. The `timeout`
-is ignored in that case.
-
-**Parameters**
-
-<Parameter name="n_values" type="int" description="Maximum number of items to remove and return." />
-<Parameter name="block" type="bool" defaultValue="True" description="If True, wait until at least one item is available (or until `timeout`); if False, return immediately when empty." />
-<Parameter name="timeout" type="float | None" defaultValue="None" description="Seconds to wait when blocking; ignored when ``block`` is False." />
-<Parameter name="partition" type="str | None" defaultValue="None" description="FIFO partition to read from; uses the default partition when omitted." />
-
-## put
-
-```python
-put(self, v, block=True, timeout=None, *, partition=None, partition_ttl=24 *
-    3600)
-```
-Add an object to the end of the queue.
-
-If `block` is `True` and the queue is full, this method will retry indefinitely or
-until `timeout` if specified. Raises the stdlib's `queue.Full` exception if the `timeout` is reached.
-If blocking it is not recommended to omit the `timeout`, as the operation could wait indefinitely.
-
-If `block` is `False`, this method raises `queue.Full` immediately if the queue is full. The `timeout` is
-ignored in this case.
-
-**Parameters**
-
-<Parameter name="v" type="Any" description="Value to enqueue (must be serializable)." />
-<Parameter name="block" type="bool" defaultValue="True" description="If True, wait for capacity; if False, fail immediately when full." />
-<Parameter name="timeout" type="float | None" defaultValue="None" description="Max seconds to wait when blocking." />
-<Parameter name="partition" type="str | None" defaultValue="None" description="FIFO partition to write to; uses the default partition when omitted." />
-<Parameter name="partition_ttl" type="int" defaultValue="24 * 3600" description="Seconds after the last activity before this partition may be cleared (default 24 hours)." />
-
-## put_many
-
-```python
-put_many(self, vs, block=True, timeout=None, *, partition=None, partition_ttl=24
-    * 3600)
-```
-Add several objects to the end of the queue.
-
-If `block` is `True` and the queue is full, this method will retry indefinitely or
-until `timeout` if specified. Raises the stdlib's `queue.Full` exception if the `timeout` is reached.
-If blocking it is not recommended to omit the `timeout`, as the operation could wait indefinitely.
-
-If `block` is `False`, this method raises `queue.Full` immediately if the queue is full. The `timeout` is
-ignored in this case.
-
-**Parameters**
-
-<Parameter name="vs" type="list[Any]" description="Values to enqueue (each must be serializable)." />
-<Parameter name="block" type="bool" defaultValue="True" description="If True, wait for capacity; if False, fail immediately when full." />
-<Parameter name="timeout" type="float | None" defaultValue="None" description="Max seconds to wait when blocking." />
-<Parameter name="partition" type="str | None" defaultValue="None" description="FIFO partition to write to; uses the default partition when omitted." />
-<Parameter name="partition_ttl" type="int" defaultValue="24 * 3600" description="Seconds after the last activity before this partition may be cleared (default 24 hours)." />
-
-## len
-
-```python
-len(self, *, partition=None, total=False)
-```
-Return the number of objects in the queue partition.
-
-**Parameters**
-
-<Parameter name="partition" type="str | None" defaultValue="None" description="Partition to measure; omit for the default partition." />
-<Parameter name="total" type="bool" defaultValue="False" description="If True, return the combined length of all partitions (do not pass `partition`)." />
-
-**Returns**
-
-Item count (capped by the server when very large).
-
-## iterate
-
-```python
-iterate(self, *, partition=None, item_poll_timeout=0.0)
-```
-Iterate through items in the queue without mutation.
-
-Specify `item_poll_timeout` to control how long the iterator should wait for the next time before giving up.
-
-**Parameters**
-
-<Parameter name="partition" type="str | None" defaultValue="None" description="Partition to scan; uses the default partition when omitted." />
-<Parameter name="item_poll_timeout" type="float" defaultValue="0.0" description="How long to wait for another item before stopping the iterator." />

.agents/skills/modal/references/api/modal.Retries.md

@@ -1,58 +0,0 @@
-# modal.Retries
-
-
-```python
-class Retries(object)
-```
-
-Adds a retry policy to a Modal function.
-
-**Usage**
-
-```python
-import modal
-app = modal.App()
-
-# Basic configuration.
-# This sets a policy of max 4 retries with 1-second delay between failures.
-@app.function(retries=4)
-def f():
-    pass
-
-
-# Fixed-interval retries with 3-second delay between failures.
-@app.function(
-    retries=modal.Retries(
-        max_retries=2,
-        backoff_coefficient=1.0,
-        initial_delay=3.0,
-    )
-)
-def g():
-    pass
-
-
-# Exponential backoff, with retry delay doubling after each failure.
-@app.function(
-    retries=modal.Retries(
-        max_retries=4,
-        backoff_coefficient=2.0,
-        initial_delay=1.0,
-    )
-)
-def h():
-    pass
-```
-
-```python
-__init__(self, *, max_retries, backoff_coefficient=2.0, initial_delay=1.0,
-    max_delay=60.0)
-```
-Construct a new retries policy, supporting exponential and fixed-interval delays via a backoff coefficient.
-
-**Parameters**
-
-<Parameter name="max_retries" type="int" description="Maximum number of retries after failures." />
-<Parameter name="backoff_coefficient" type="float" defaultValue="2.0" description="Multiplier applied to the delay after each attempt; ``1.0`` means fixed delay." />
-<Parameter name="initial_delay" type="float" defaultValue="1.0" description="Seconds before the first retry." />
-<Parameter name="max_delay" type="float" defaultValue="60.0" description="Upper cap on the delay between retries (seconds)." />

.agents/skills/modal/references/api/modal.Sandbox.md

@@ -1,950 +0,0 @@
-# modal.Sandbox
-
-
-```python
-class Sandbox(modal.object.Object)
-```
-
-A `Sandbox` object lets you interact with a running sandbox. This API is similar to Python's
-[asyncio.subprocess.Process](https://docs.python.org/3/library/asyncio-subprocess.html#asyncio.subprocess.Process).
-
-Refer to the [guide](https://modal.com/docs/guide/sandbox) on how to spawn and use sandboxes.
-
-
-## hydrate
-
-```python
-hydrate(self, client=None)
-```
-Synchronize the local object with its identity on the Modal server.
-
-It is rarely necessary to call this method explicitly, as most operations
-will lazily hydrate when needed. The main use case is when you need to
-access object metadata, such as its ID.
-
-*Added in v0.72.39*: This method replaces the deprecated `.resolve()` method.
-
-## create
-
-```python
-create(*args, app=None, name=None, tags=None, image=None, env=None,
-    secrets=None, network_file_systems={}, timeout=300, idle_timeout=None,
-    workdir=None, gpu=None, cloud=None, region=None, cpu=None, memory=None,
-    block_network=False, outbound_cidr_allowlist=None,
-    outbound_domain_allowlist=None, inbound_cidr_allowlist=None, volumes={},
-    pty=False, encrypted_ports=[], h2_ports=[], unencrypted_ports=[],
-    custom_domain=None, proxy=None, include_oidc_identity_token=False,
-    readiness_probe=None, verbose=False, experimental_options=None,
-    _experimental_enable_snapshot=False, client=None, environment_name=None,
-    pty_info=None, cidr_allowlist=None)
-```
-Create a new Sandbox to run untrusted, arbitrary code.
-
-The Sandbox's corresponding container will be created asynchronously.
-
-**Parameters**
-
-<Parameter name="*args" type="str" description="Set the CMD of the Sandbox, overriding any CMD of the container image." />
-<Parameter name="app" type="&quot;modal.app._App | None&quot;" defaultValue="None" description="Associate the sandbox with an app. Required unless creating from a container." />
-<Parameter name="name" type="str | None" defaultValue="None" description="Optionally give the sandbox a name. Unique within an app." />
-<Parameter name="tags" type="dict[str, str] | None" defaultValue="None" description="Tags to assign to the Sandbox." />
-<Parameter name="image" type="_Image | None" defaultValue="None" description="The image to run as the container for the sandbox." />
-<Parameter name="env" type="dict[str, str | None] | None" defaultValue="None" description="Environment variables to set in the Sandbox." />
-<Parameter name="secrets" type="Collection[_Secret] | None" defaultValue="None" description="Secrets to inject into the Sandbox as environment variables." />
-<Parameter name="network_file_systems" type="dict[str | os.PathLike, _NetworkFileSystem]" defaultValue="&#123;&#125;" description="Network file systems to mount into the sandbox." />
-<Parameter name="timeout" type="int" defaultValue="300" description="Maximum lifetime of the sandbox in seconds." />
-<Parameter name="idle_timeout" type="int | None" defaultValue="None" description="The amount of time in seconds that a sandbox can be idle before being terminated." />
-<Parameter name="workdir" type="str | None" defaultValue="None" description="Working directory of the sandbox." />
-<Parameter name="gpu" type="str | None" defaultValue="None" description="GPU reservation for the sandbox." />
-<Parameter name="cloud" type="str | None" defaultValue="None" description="Cloud provider for the sandbox." />
-<Parameter name="region" type="str | Sequence[str] | None" defaultValue="None" description="Region or regions to run the sandbox on." />
-<Parameter name="cpu" type="float | tuple[float, float] | None" defaultValue="None" description="Specify, in fractional CPU cores, how many CPU cores to request. Or, pass (request, limit) to additionally specify a hard limit in fractional CPU cores. CPU throttling will prevent a container from exceeding its specified limit." />
-<Parameter name="memory" type="int | tuple[int, int] | None" defaultValue="None" description="Specify, in MiB, a memory request which is the minimum memory required. Or, pass (request, limit) to additionally specify a hard limit in MiB." />
-<Parameter name="block_network" type="bool" defaultValue="False" description="Whether to block network access." />
-<Parameter name="outbound_cidr_allowlist" type="Sequence[str] | None" defaultValue="None" description="List of CIDRs the sandbox is allowed to access. If None, all CIDRs are allowed." />
-<Parameter name="outbound_domain_allowlist" type="Sequence[str] | None" defaultValue="None" description="List of domain names the sandbox is allowed to access. Supports wildcard prefixes (``*.``)." />
-<Parameter name="inbound_cidr_allowlist" type="Sequence[str] | None" defaultValue="None" description="List of CIDRs allowed to connect inbound to the sandbox (tunnels and connection tokens). If None, all CIDRs are allowed." />
-<Parameter name="volumes" type="dict[str | os.PathLike, _Volume | _CloudBucketMount]" defaultValue="&#123;&#125;" description="Mount points for Modal Volumes and CloudBucketMounts." />
-<Parameter name="pty" type="bool" defaultValue="False" description="Enable a PTY for the Sandbox entrypoint command. When enabled, all output (stdout and stderr from the process) is multiplexed into stdout, and the stderr stream is effectively empty." />
-<Parameter name="encrypted_ports" type="Sequence[int]" defaultValue="[]" description="List of ports to tunnel into the sandbox. Encrypted ports are tunneled with TLS." />
-<Parameter name="h2_ports" type="Sequence[int]" defaultValue="[]" description="List of encrypted ports to tunnel into the sandbox, using HTTP/2." />
-<Parameter name="unencrypted_ports" type="Sequence[int]" defaultValue="[]" description="List of ports to tunnel into the sandbox without encryption." />
-<Parameter name="custom_domain" type="str | None" defaultValue="None" description="Allow connections to the Sandbox via a subdomain of this parent rather than a default Modal domain." />
-<Parameter name="proxy" type="_Proxy | None" defaultValue="None" description="Reference to a Modal Proxy to use in front of this Sandbox." />
-<Parameter name="include_oidc_identity_token" type="bool" defaultValue="False" description="If True, the sandbox will receive a MODAL_IDENTITY_TOKEN env var for OIDC-based auth." />
-<Parameter name="readiness_probe" type="Probe | None" defaultValue="None" description="Probe used to determine when the sandbox has become ready." />
-<Parameter name="verbose" type="bool" defaultValue="False" description="Enable verbose logging for sandbox operations." />
-<Parameter name="experimental_options" type="dict[str, bool] | None" defaultValue="None" description="Experimental options to pass to the sandbox." />
-<Parameter name="_experimental_enable_snapshot" type="bool" defaultValue="False" description="Enable memory snapshots." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal Client to use for the sandbox." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="*DEPRECATED* Optionally override the default environment" />
-<Parameter name="pty_info" type="api_pb2.PTYInfo | None" defaultValue="None" description="*DEPRECATED* Use `pty` instead. `pty` will override `pty_info`." />
-<Parameter name="cidr_allowlist" type="Sequence[str] | None" defaultValue="None" description="*DEPRECATED* Use outbound_cidr_allowlist instead." />
-
-**Returns**
-
-A `Sandbox` object representing the created sandbox which can be used to interact with the sandbox.
-
-**Raises**
-
-- `AlreadyExistsError`: If a sandbox with the same name already exists.
-
-**Usage**
-
-```python
-app = modal.App.lookup('sandbox-hello-world', create_if_missing=True)
-sandbox = modal.Sandbox.create("echo", "hello world", app=app)
-print(sandbox.stdout.read())
-sandbox.wait()
-```
-
-## detach
-
-```python
-detach(self)
-```
-Disconnects your client from the sandbox and cleans up resources assoicated with the connection.
-
-Be sure to only call `detach` when you are done interacting with the sandbox. After calling `detach`,
-any operation using the Sandbox object is not guaranteed to work anymore. If you want to continue interacting
-with a running sandbox, use `Sandbox.from_id` to get a new Sandbox object.
-
-## from_name
-
-```python
-from_name(app_name, name, *, environment_name=None, client=None)
-```
-Get a running Sandbox by name from a deployed App.
-
-A Sandbox's name is the `name` argument passed to `Sandbox.create`.
-
-**Parameters**
-
-<Parameter name="app_name" type="str" description="Name of the deployed app to look up the sandbox under." />
-<Parameter name="name" type="str" description="Sandbox name to resolve." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="Optional environment name for the lookup; defaults to the configured environment." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use for the RPC; defaults to `Client.from_env()` when omitted." />
-
-**Returns**
-
-A `Sandbox` handle for the running sandbox.
-
-**Raises**
-
-- `NotFoundError`: If no running sandbox exists with the given name.
-
-## from_id
-
-```python
-from_id(sandbox_id, client=None)
-```
-Construct a Sandbox from an id and look up the Sandbox result.
-
-The ID of a Sandbox object can be accessed using `.object_id`.
-
-**Parameters**
-
-<Parameter name="sandbox_id" type="str" description="Sandbox object ID to attach to." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use for the lookup; defaults to the environment client when omitted." />
-
-**Returns**
-
-A `Sandbox` handle with any available result metadata populated from the server.
-
-## get_tags
-
-```python
-get_tags(self)
-```
-Fetches any tags (key-value pairs) currently attached to this Sandbox from the server.
-
-**Returns**
-
-Tags as a map from tag name to tag value.
-
-## set_tags
-
-```python
-set_tags(self, tags, *, client=None)
-```
-Set tags (key-value pairs) on the Sandbox. Tags can be used to filter results in `Sandbox.list`.
-
-**Parameters**
-
-<Parameter name="tags" type="dict[str, str]" description="Tag names and values to set on this sandbox." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Deprecated. Prefer setting the client when creating or re-attaching to the sandbox." />
-
-## snapshot_filesystem
-
-```python
-snapshot_filesystem(self, timeout=55, *, ttl=30 * 24 * 3600)
-```
-Snapshot the filesystem of the Sandbox.
-
-**Parameters**
-
-<Parameter name="timeout" type="int" defaultValue="55" description="Maximum time in seconds to wait for the snapshot operation. If the snapshot does not return within that window, the call is cancelled and `modal.exception.TimeoutError` is raised." />
-<Parameter name="ttl" type="int | None" defaultValue="30 * 24 * 3600" description="The resulting Image is retained for `ttl` seconds (default: 30 days). Pass `ttl=None` to retain the image indefinitely." />
-
-**Returns**
-
-An [`Image`](https://modal.com/docs/reference/modal.Image) object which can be used to spawn a new
-Sandbox with the same filesystem.
-
-## mount_image
-
-```python
-mount_image(self, path, image, *, _experimental_encryption_key=None)
-```
-Mount an Image at a specified path in a running Sandbox.
-
-`path` should be a directory that is **not** the root path (`/`). If the path doesn't exist
-it will be created. If it exists and contains data, the previous directory will be replaced
-by the mount.
-
-The `image` argument supports any Image that has an object ID, including:
-- Images built using `image.build()`
-- Images referenced by ID, e.g. `Image.from_id(...)`
-- Filesystem/directory snapshots, e.g. created by `.snapshot_directory()` or `.snapshot_filesystem()`
-- Empty images created with `Image.from_scratch()`
-
-**Parameters**
-
-<Parameter name="path" type="PurePosixPath | str" description="Absolute mount point directory inside the sandbox (not `/`)." />
-<Parameter name="image" type="_Image" description="Image to mount at `path` (must be built, referenced by ID, or snapshot-based as described above)." />
-
-**Usage**
-
-```py notest
-user_project_snapshot: Image = sandbox_session_1.snapshot_directory("/user_project")
-
-# You can later mount this snapshot to another Sandbox:
-sandbox_session_2 = modal.Sandbox.create(...)
-sandbox_session_2.mount_image("/user_project", user_project_snapshot)
-sandbox_session_2.filesystem.list_files("/user_project")
-```
-
-## unmount_image
-
-```python
-unmount_image(self, path)
-```
-Unmount a previously mounted Image from a running Sandbox.
-
-`path` must be the exact mount point that was passed to `.mount_image()`.
-After unmounting, the underlying Sandbox filesystem at that path becomes
-visible again.
-
-**Parameters**
-
-<Parameter name="path" type="PurePosixPath | str" description="Absolute mount point directory to unmount." />
-
-## snapshot_directory
-
-```python
-snapshot_directory(self, path, *, timeout=55, ttl=30 * 24 * 3600,
-    _experimental_encryption_key=None)
-```
-Snapshot a directory in a running Sandbox, creating a new Image with its content.
-
-`timeout` If the snapshot does not return within that window, the call is cancelled
-and `modal.exception.TimeoutError` is raised.
-
-`ttl` The resulting Image is retained for `ttl` seconds (default: 30 days)
-Pass `ttl=None` to retain the image indefinitely.
-
-**Parameters**
-
-<Parameter name="path" type="PurePosixPath | str" description="Absolute path of the directory inside the sandbox to snapshot." />
-
-**Returns**
-
-An `Image` containing the directory contents.
-
-**Usage**
-
-```py notest
-user_project_snapshot: Image = sandbox_session_1.snapshot_directory("/user_project")
-
-# You can later mount this snapshot to another Sandbox:
-sandbox_session_2 = modal.Sandbox.create(...)
-sandbox_session_2.mount_image("/user_project", user_project_snapshot)
-sandbox_session_2.filesystem.list_files("/user_project")
-```
-
-## wait
-
-```python
-wait(self, raise_on_termination=True)
-```
-Wait for the Sandbox to finish running.
-
-**Parameters**
-
-<Parameter name="raise_on_termination" type="bool" defaultValue="True" description="If True, raise when the sandbox is terminated externally." />
-
-## wait_until_ready
-
-```python
-wait_until_ready(self, *, timeout=300)
-```
-Wait for the Sandbox readiness probe to report that the Sandbox is ready.
-
-The Sandbox must be configured with a `readiness_probe` in order to use this method.
-
-**Parameters**
-
-<Parameter name="timeout" type="int" defaultValue="300" description="Maximum time in seconds to wait for readiness." />
-
-**Usage**
-
-```py notest
-app = modal.App.lookup('sandbox-wait-until-ready', create_if_missing=True)
-sandbox = modal.Sandbox.create(
-    "python3", "-m", "http.server", "8080",
-    readiness_probe=modal.Probe.with_tcp(8080),
-    app=app,
-)
-sandbox.wait_until_ready()
-```
-
-## tunnels
-
-```python
-tunnels(self, timeout=50)
-```
-Get Tunnel metadata for the sandbox.
-
-NOTE: Previous to client [v0.64.153](https://modal.com/docs/reference/changelog#064153-2024-09-30), this
-returned a list of `TunnelData` objects.
-
-**Parameters**
-
-<Parameter name="timeout" type="int" defaultValue="50" description="Maximum time in seconds to wait for tunnel metadata when not already cached." />
-
-**Returns**
-
-A dictionary mapping container port to `Tunnel` metadata.
-
-**Raises**
-
-- `SandboxTimeoutError`: If the tunnels are not available after the timeout.
-
-## create_connect_token
-
-```python
-create_connect_token(self, user_metadata=None)
-```
-Create a token for making HTTP connections to the Sandbox.
-
-Also accepts an optional user_metadata string or dict to associate with the token. This metadata
-will be added to the headers by the proxy when forwarding requests to the Sandbox.
-
-**Parameters**
-
-<Parameter name="user_metadata" type="str | dict[str, Any] | None" defaultValue="None" description="Optional JSON-serializable metadata or string stored with the connect token." />
-
-**Returns**
-
-URL and token credentials for connecting to the sandbox over HTTP.
-
-## reload_volumes
-
-```python
-reload_volumes(self)
-```
-Reload all Volumes mounted in the Sandbox.
-
-Added in v1.1.0.
-
-## terminate
-
-```python
-terminate(self, *, wait=False)
-```
-Terminate Sandbox execution.
-
-This is a no-op if the Sandbox has already finished running.
-
-**Parameters**
-
-<Parameter name="wait" type="bool" defaultValue="False" description="If True, block until termination completes and return the exit code." />
-
-**Returns**
-
-The sandbox exit code when `wait` is True; otherwise None.
-
-## poll
-
-```python
-poll(self)
-```
-Check if the Sandbox has finished running.
-
-**Returns**
-
-`None` if the Sandbox is still running, otherwise the exit code.
-
-## exec
-
-```python
-exec(self, *args, stdout=StreamType.PIPE, stderr=StreamType.PIPE, timeout=None,
-    workdir=None, env=None, secrets=None, text=True, bufsize=-1, pty=False,
-    _pty_info=None, pty_info=None)
-```
-Execute a command in the Sandbox and return a ContainerProcess handle.
-
-See the [`ContainerProcess`](https://modal.com/docs/reference/modal.container_process#modalcontainer_processcontainerprocess)
-docs for more information.
-
-**Parameters**
-
-<Parameter name="*args" type="str" description="Command and arguments to run inside the sandbox." />
-<Parameter name="stdout" type="StreamType" defaultValue="StreamType.PIPE" description="Where to connect the process stdout stream." />
-<Parameter name="stderr" type="StreamType" defaultValue="StreamType.PIPE" description="Where to connect the process stderr stream." />
-<Parameter name="timeout" type="int | None" defaultValue="None" description="Optional timeout in seconds for the exec session." />
-<Parameter name="workdir" type="str | None" defaultValue="None" description="Working directory for the command; must be absolute if set." />
-<Parameter name="env" type="dict[str, str | None] | None" defaultValue="None" description="Environment variables to set during command execution." />
-<Parameter name="secrets" type="Collection[_Secret] | None" defaultValue="None" description="Secrets to inject as environment variables during command execution." />
-<Parameter name="text" type="bool" defaultValue="True" description="If True, decode streams as text; if False, yield bytes." />
-<Parameter name="bufsize" type="Literal[-1, 1]" defaultValue="-1" description="Control line-buffered output. ``-1`` means unbuffered; ``1`` means line-buffered (only when ``text`` is True)." />
-<Parameter name="pty" type="bool" defaultValue="False" description="Enable a PTY for the command. When enabled, all output (stdout and stderr from the process) is multiplexed into stdout, and the stderr stream is effectively empty." />
-<Parameter name="_pty_info" type="api_pb2.PTYInfo | None" defaultValue="None" description="*DEPRECATED* Use `pty` instead. `pty` will override `_pty_info`." />
-<Parameter name="pty_info" type="api_pb2.PTYInfo | None" defaultValue="None" description="*DEPRECATED* Use `pty` instead. `pty` will override `pty_info`." />
-
-**Returns**
-
-A `ContainerProcess` handle for the running command (text or bytes depending on `text`).
-
-**Usage**
-
-```python fixture:sandbox
-process = sandbox.exec("bash", "-c", "for i in $(seq 1 3); do echo foo $i; sleep 0.1; done")
-for line in process.stdout:
-    print(line)
-```
-
-## filesystem
-
-
-```python
-filesystem: SandboxFilesystem
-```
-
-Namespace for Sandbox filesystem APIs.
-
-
-### filesystem.copy_from_local
-
-```python
-copy_from_local(self, local_path, remote_path)
-```
-Copy a local file into the Sandbox.
-
-`remote_path` must be an absolute path to a file in the Sandbox.
-Parent directories for `remote_path` are created if needed.
-The remote file is overwritten if it already exists.
-
-**Parameters**
-
-<Parameter name="local_path" type="str | os.PathLike" description="Path to the file on the local machine." />
-<Parameter name="remote_path" type="str" description="Absolute path to the file in the Sandbox." />
-
-**Raises**
-
-- `SandboxFilesystemNotADirectoryError`: A parent path component of ``remote_path`` is not a directory.
-- `SandboxFilesystemIsADirectoryError`: ``remote_path`` points to a directory.
-- `SandboxFilesystemPermissionError`: Write permission is denied in the Sandbox.
-- `SandboxFilesystemError`: The command fails for any other reason.
-- `FileNotFoundError`: ``local_path`` does not exist.
-- `IsADirectoryError`: ``local_path`` is a directory.
-- `PermissionError`: Reading ``local_path`` is not permitted.
-
-**Usage**
-
-```python fixture:sandbox fixture:tmpdir
-import tempfile
-from pathlib import Path
-
-local_path = Path(tempfile.mktemp())
-local_path.write_text("Hello, world!\n")
-sandbox.filesystem.copy_from_local(local_path, "/tmp/hello.txt")
-```
-
-### filesystem.copy_to_local
-
-```python
-copy_to_local(self, remote_path, local_path)
-```
-Copy a file from the Sandbox to a local path.
-
-`remote_path` must be an absolute path to a file in the Sandbox.
-Parent directories for `local_path` are created if needed.
-The local file is overwritten if it already exists.
-
-**Raises**
-
-- `SandboxFilesystemNotFoundError`: the remote path does not exist.
-- `SandboxFilesystemIsADirectoryError`: the remote path points to a directory.
-- `SandboxFilesystemPermissionError`: read permission is denied in the Sandbox.
-- `SandboxFilesystemError`: the command fails for any other reason.
-- `IsADirectoryError`: `local_path` points to a directory.
-- `NotADirectoryError`: a component of the `local_path` parent is not a directory.
-- `PermissionError`: writing `local_path` is not permitted.
-
-**Usage**
-
-```python fixture:sandbox fixture:tmpdir
-sandbox.filesystem.write_text("Hello, world!\n", "/tmp/hello.txt")
-sandbox.filesystem.copy_to_local("/tmp/hello.txt", "/tmp/local-hello.txt")
-```
-
-### filesystem.list_files
-
-```python
-list_files(self, remote_path)
-```
-List files and directories in a Sandbox directory.
-
-**Parameters**
-
-<Parameter name="remote_path" type="str" description="Absolute path to the directory in the Sandbox." />
-
-**Returns**
-
-A list of `FileInfo` objects describing each entry.
-
-**Raises**
-
-- `SandboxFilesystemNotFoundError`: The path does not exist.
-- `SandboxFilesystemNotADirectoryError`: The path is not a directory.
-- `SandboxFilesystemPermissionError`: Read permission is denied.
-- `SandboxFilesystemError`: The command fails for any other reason.
-
-**Usage**
-
-```python fixture:sandbox
-entries = sandbox.filesystem.list_files("/tmp")
-for entry in entries:
-    print(entry.name, entry.type, entry.size)
-```
-
-### filesystem.make_directory
-
-```python
-make_directory(self, remote_path, *, create_parents=True)
-```
-Create a new directory in the Sandbox.
-
-`remote_path` must be an absolute path in the Sandbox.
-
-When `create_parents` is `True` (the default), any missing parent directories are created and the call is
-idempotent (succeeds silently if the directory already exists). When `create_parents` is `False`, the
-immediate parent directory must already exist and the path must not already exist.
-
-**Parameters**
-
-<Parameter name="remote_path" type="str" description="Absolute path of the directory to create in the Sandbox." />
-<Parameter name="create_parents" type="bool" defaultValue="True" description="When ``True``, create missing parents and succeed if the directory already exists." />
-
-**Raises**
-
-- `SandboxFilesystemNotFoundError`: The parent directory does not exist and ``create_parents`` is false.
-- `SandboxFilesystemPathAlreadyExistsError`: The path already exists.
-- `SandboxFilesystemNotADirectoryError`: A path component is not a directory.
-- `SandboxFilesystemPermissionError`: Creation is not permitted.
-- `InvalidError`: The operation is not supported by the mount.
-- `SandboxFilesystemError`: The command fails for any other reason.
-
-**Usage**
-
-```python fixture:sandbox
-sandbox.filesystem.make_directory("/tmp/a/b/c")
-```
-
-### filesystem.read_bytes
-
-```python
-read_bytes(self, remote_path)
-```
-Read a file from the Sandbox and return its contents as bytes.
-
-`remote_path` must be an absolute path to a file in the Sandbox.
-
-**Parameters**
-
-<Parameter name="remote_path" type="str" description="Absolute path to the file in the Sandbox." />
-
-**Returns**
-
-Raw bytes read from the file.
-
-**Raises**
-
-- `SandboxFilesystemNotFoundError`: The path does not exist.
-- `SandboxFilesystemIsADirectoryError`: The path points to a directory.
-- `SandboxFilesystemPermissionError`: Read permission is denied.
-- `SandboxFilesystemError`: The command fails for any other reason.
-
-**Usage**
-
-```python fixture:sandbox
-sandbox.filesystem.write_bytes(b"Hello, world!\n", "/tmp/hello.bin")
-contents = sandbox.filesystem.read_bytes("/tmp/hello.bin")
-print(contents.decode("utf-8"))
-```
-
-### filesystem.read_text
-
-```python
-read_text(self, remote_path)
-```
-Read a file from the Sandbox and return its contents as a UTF-8 string.
-
-`remote_path` must be an absolute path to a file in the Sandbox.
-
-**Parameters**
-
-<Parameter name="remote_path" type="str" description="Absolute path to the file in the Sandbox." />
-
-**Returns**
-
-File contents decoded as UTF-8.
-
-**Raises**
-
-- `SandboxFilesystemNotFoundError`: The path does not exist.
-- `SandboxFilesystemIsADirectoryError`: The path points to a directory.
-- `SandboxFilesystemPermissionError`: Read permission is denied.
-- `SandboxFilesystemError`: The command fails for any other reason.
-
-**Usage**
-
-```python fixture:sandbox
-sandbox.filesystem.write_text("Hello, world!\n", "/tmp/hello.txt")
-contents = sandbox.filesystem.read_text("/tmp/hello.txt")
-print(contents)
-```
-
-### filesystem.remove
-
-```python
-remove(self, remote_path, *, recursive=False)
-```
-Remove a file or directory in the Sandbox.
-
-When `remote_path` is a directory and `recursive` is `False` (the
-default), removes it only if it is empty. When `recursive` is `True`,
-removes the directory and all its contents.
-
-Recursive directory removal is not supported on all mounts.
-In particular, `CloudBucketMount` does not support it. An
-`InvalidError` is raised in that case.
-
-**Parameters**
-
-<Parameter name="remote_path" type="str" description="Absolute path to the file in the Sandbox." />
-<Parameter name="recursive" type="bool" defaultValue="False" description="When ``True``, remove the directory and all its contents." />
-
-**Raises**
-
-- `SandboxFilesystemNotFoundError`: The remote path does not exist.
-- `SandboxFilesystemDirectoryNotEmptyError`: `recursive` is `False` and the directory is not empty.
-- `SandboxFilesystemPermissionError`: Read permission is denied in the Sandbox.
-- `InvalidError`: The operation is not supported by the mount.
-- `SandboxFilesystemError`: The command fails for any other reason.
-
-**Usage**
-
-To remove a file:
-
-```python fixture:sandbox
-sandbox.filesystem.write_bytes(b"Hello, world!\n", "/tmp/hello.bin")
-sandbox.filesystem.remove("/tmp/hello.bin")
-```
-
-To remove a directory and all its contents:
-
-```python fixture:sandbox
-sandbox.filesystem.make_directory("/tmp/mydir/subdir")
-sandbox.filesystem.remove("/tmp/mydir", recursive=True)
-```
-
-### filesystem.stat
-
-```python
-stat(self, remote_path)
-```
-Return metadata for a single file, directory, or symlink in the Sandbox.
-
-`remote_path` must be an absolute path in the Sandbox. If `remote_path` is a symlink, the returned
-`FileInfo` object describes the symlink, not the target it points to.
-
-**Raises**
-
-- `SandboxFilesystemNotFoundError`: the path does not exist.
-- `SandboxFilesystemNotADirectoryError`: a non-leaf component of the path is not a directory.
-- `SandboxFilesystemPermissionError`: a component of the path is not searchable.
-- `SandboxFilesystemError`: the command fails for any other reason.
-
-**Usage**
-
-```python fixture:sandbox
-sandbox.filesystem.write_text("Hello, world!\n", "/tmp/hello.txt")
-info = sandbox.filesystem.stat("/tmp/hello.txt")
-print(info.size, info.permissions, info.modified_time)
-```
-
-### filesystem.watch
-
-```python
-watch(self, remote_path, *, filter=None, recursive=False, timeout=None)
-```
-Watch a path in the Sandbox for filesystem changes.
-
-`remote_path` must be an absolute path in the Sandbox. If it points
-to a file, events for that file are reported. If it points to a
-directory, events for entries directly inside it are reported. Set
-`recursive=True` to also receive events for all nested subdirectories.
-If `remote_path` is a symlink, it is followed and events reference
-paths under the resolved target.
-
-Yields `FileWatchEvent` objects as changes occur, until either
-`timeout` seconds elapse, the iterator is closed, or the Sandbox
-is terminated.
-
-Optionally restrict the kinds of events emitted to those included
-in `filter`. The default filter `None` permits all event types.
-
-`timeout` is in seconds. `None` means watch indefinitely. When
-`timeout` elapses, the iterator stops without raising an exception.
-
-**Raises**
-
-- `SandboxFilesystemNotFoundError`: `remote_path` does not exist.
-- `SandboxFilesystemPermissionError`: watch access is denied.
-- `InvalidError`: the filesystem at `remote_path` does not support
-  watching.
-- `SandboxFilesystemError`: the command fails for any other reason.
-
-**Usage**
-
-```python notest
-for event in sandbox.filesystem.watch(
-    "/tmp/foo",
-    recursive=True,
-    filter=[FileWatchEventType.Create],
-    timeout=60,
-):
-    if any(p.endswith(".done") for p in event.paths):
-        break
-```
-
-### filesystem.write_bytes
-
-```python
-write_bytes(self, data, remote_path)
-```
-Write binary content to a file in the Sandbox.
-
-`remote_path` must be an absolute path to a file in the Sandbox.
-Parent directories for `remote_path` are created if needed.
-The remote file is overwritten if it already exists.
-
-**Parameters**
-
-<Parameter name="data" type="bytes | bytearray | memoryview" description="Bytes to write." />
-<Parameter name="remote_path" type="str" description="Absolute path to the file in the Sandbox." />
-
-**Raises**
-
-- `TypeError`: ``data`` is not bytes-like.
-- `SandboxFilesystemNotADirectoryError`: A parent path component is not a directory.
-- `SandboxFilesystemIsADirectoryError`: ``remote_path`` points to a directory.
-- `SandboxFilesystemPermissionError`: Write permission is denied.
-- `SandboxFilesystemError`: The command fails for any other reason.
-
-**Usage**
-
-```python fixture:sandbox
-sandbox.filesystem.write_bytes(b"Hello, world!\n", "/tmp/hello.bin")
-```
-
-### filesystem.write_text
-
-```python
-write_text(self, data, remote_path)
-```
-Write UTF-8 text to a file in the Sandbox.
-
-`remote_path` must be an absolute path to a file in the Sandbox.
-Parent directories for `remote_path` are created if needed.
-The remote file is overwritten if it already exists.
-
-**Parameters**
-
-<Parameter name="data" type="str" description="Text to write (encoded as UTF-8)." />
-<Parameter name="remote_path" type="str" description="Absolute path to the file in the Sandbox." />
-
-**Raises**
-
-- `TypeError`: ``data`` is not a string.
-- `SandboxFilesystemNotADirectoryError`: A parent path component is not a directory.
-- `SandboxFilesystemIsADirectoryError`: ``remote_path`` points to a directory.
-- `SandboxFilesystemPermissionError`: Write permission is denied.
-- `SandboxFilesystemError`: The command fails for any other reason.
-
-**Usage**
-
-```python fixture:sandbox
-sandbox.filesystem.write_text("Hello, world!\n", "/tmp/hello.txt")
-```
-
-## open
-
-```python
-open(self, path, mode="r")
-```
-[Alpha] Open a file in the Sandbox and return a FileIO handle.
-
-**Deprecated (2026-03-09):** Use the `Sandbox.filesystem` APIs instead for improved reliability.
-
-See the [`FileIO`](https://modal.com/docs/reference/modal.file_io#modalfile_iofileio) docs for more information.
-
-**Parameters**
-
-<Parameter name="path" type="str" description="Absolute path of the file inside the sandbox." />
-<Parameter name="mode" type="Union[_typeshed.OpenTextMode, _typeshed.OpenBinaryMode]" defaultValue="&quot;r&quot;" description="File open mode (text or binary), following built-in ``open`` conventions." />
-
-**Returns**
-
-A `FileIO` handle for reading or writing the remote file.
-
-**Usage**
-
-```python notest
-sb = modal.Sandbox.create(app=sb_app)
-f = sb.open("/test.txt", "w")
-f.write("hello")
-f.close()
-```
-
-## ls
-
-```python
-ls(self, path)
-```
-[Alpha] List the contents of a directory in the Sandbox.
-
-**Deprecated (2026-04-15):** Use `Sandbox.filesystem.list_files()` instead for improved reliability.
-
-**Parameters**
-
-<Parameter name="path" type="str" description="Absolute directory path inside the sandbox." />
-
-**Returns**
-
-Entry names in the directory as a list of strings.
-
-## mkdir
-
-```python
-mkdir(self, path, parents=False)
-```
-[Alpha] Create a new directory in the Sandbox.
-
-**Deprecated (2026-04-15):** Use `Sandbox.filesystem.make_directory()` instead for improved reliability.
-
-## rm
-
-```python
-rm(self, path, recursive=False)
-```
-[Alpha] Remove a file or directory in the Sandbox.
-
-**Deprecated (2026-04-15):** Use `Sandbox.filesystem.remove()` instead for improved reliability.
-
-## watch
-
-```python
-watch(self, path, filter=None, recursive=None, timeout=None)
-```
-[Alpha] Watch a file or directory in the Sandbox for changes.
-
-**Deprecated (2026-05-08):** Use `Sandbox.filesystem.watch()` instead for improved reliability.
-
-**Parameters**
-
-<Parameter name="path" type="str" description="Absolute path to watch." />
-<Parameter name="filter" type="builtins.list[FileWatchEventType] | None" defaultValue="None" description="Optional list of event types to include." />
-<Parameter name="recursive" type="bool | None" defaultValue="None" description="Whether to watch subdirectories; None uses server defaults." />
-<Parameter name="timeout" type="int | None" defaultValue="None" description="Optional timeout for the watch stream." />
-
-**Returns**
-
-An async iterator of `FileWatchEvent` values.
-
-## stdout
-
-```python
-stdout(self)
-```
-[`StreamReader`](https://modal.com/docs/reference/modal.io_streams#modalio_streamsstreamreader)
-for the sandbox's stdout stream.
-
-**Returns**
-
-Stream reader for sandbox stdout.
-
-## stderr
-
-```python
-stderr(self)
-```
-[`StreamReader`](https://modal.com/docs/reference/modal.io_streams#modalio_streamsstreamreader)
-for the Sandbox's stderr stream.
-
-**Returns**
-
-Stream reader for sandbox stderr.
-
-## stdin
-
-```python
-stdin(self)
-```
-[`StreamWriter`](https://modal.com/docs/reference/modal.io_streams#modalio_streamsstreamwriter)
-for the Sandbox's stdin stream.
-
-**Returns**
-
-Stream writer for sandbox stdin.
-
-## returncode
-
-```python
-returncode(self)
-```
-Return code of the Sandbox process if it has finished running, else `None`.
-
-**Returns**
-
-Exit code when the sandbox process has completed, otherwise None.
-
-## list
-
-```python
-list(*, app_id=None, tags=None, client=None)
-```
-List all Sandboxes for the current Environment or App ID (if specified). If tags are specified, only
-Sandboxes that have at least those tags are returned.
-
-**Parameters**
-
-<Parameter name="app_id" type="str | None" defaultValue="None" description="If set, restrict results to sandboxes under this app ID." />
-<Parameter name="tags" type="dict[str, str] | None" defaultValue="None" description="If set, only sandboxes containing at least these tags are returned." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use for listing; defaults to `Client.from_env()` when omitted." />
-
-**Returns**
-
-An async generator yielding `Sandbox` objects.

.agents/skills/modal/references/api/modal.SandboxSnapshot.md

@@ -1,42 +0,0 @@
-# modal.SandboxSnapshot
-
-
-```python
-class SandboxSnapshot(modal.object.Object)
-```
-
-> Sandbox memory snapshots are in **early preview**.
-
-A `SandboxSnapshot` object lets you interact with a stored Sandbox snapshot that was created by calling
-`._experimental_snapshot()` on a Sandbox instance. This includes both the filesystem and memory state of
-the original Sandbox at the time the snapshot was taken.
-
-
-## hydrate
-
-```python
-hydrate(self, client=None)
-```
-Synchronize the local object with its identity on the Modal server.
-
-It is rarely necessary to call this method explicitly, as most operations
-will lazily hydrate when needed. The main use case is when you need to
-access object metadata, such as its ID.
-
-*Added in v0.72.39*: This method replaces the deprecated `.resolve()` method.
-
-## from_id
-
-```python
-from_id(cls, sandbox_snapshot_id, client=None)
-```
-Construct a `SandboxSnapshot` for an existing snapshot ID.
-
-**Parameters**
-
-<Parameter name="sandbox_snapshot_id" type="str" description="Snapshot ID returned when the snapshot was created." />
-<Parameter name="client" type="&quot;modal.client.Client | None&quot;" defaultValue="None" description="Modal client to use; defaults to `Client.from_env()` when omitted." />
-
-**Returns**
-
-A `SandboxSnapshot` handle (hydration validates the ID when used).

.agents/skills/modal/references/api/modal.Secret.md

@@ -1,285 +0,0 @@
-# modal.Secret
-
-
-```python
-class Secret(modal.object.Object)
-```
-
-Secrets provide a dictionary of environment variables for images.
-
-Secrets are a secure way to add credentials and other sensitive information
-to the containers your functions run in. You can create and edit secrets on
-[the dashboard](https://modal.com/secrets), or programmatically from Python code.
-
-See [the secrets guide page](https://modal.com/docs/guide/secrets) for more information.
-
-
-## hydrate
-
-```python
-hydrate(self, client=None)
-```
-Synchronize the local object with its identity on the Modal server.
-
-It is rarely necessary to call this method explicitly, as most operations
-will lazily hydrate when needed. The main use case is when you need to
-access object metadata, such as its ID.
-
-*Added in v0.72.39*: This method replaces the deprecated `.resolve()` method.
-
-## objects
-
-
-```python
-objects: SecretManager
-```
-
-Namespace with methods for managing named Secret objects.
-
-
-### objects.create
-
-```python
-create(self, name, env_dict, *, allow_existing=False, environment_name=None,
-    client=None)
-```
-Create a new named Secret in the workspace environment.
-
-This does not return a local handle; use `modal.Secret.from_name` to look up the Secret after creation.
-
-Added in v1.1.2.
-
-**Parameters**
-
-<Parameter name="name" type="str" description="Name for the new Secret." />
-<Parameter name="env_dict" type="dict[str, str]" description="Environment variable keys and values stored in the Secret." />
-<Parameter name="allow_existing" type="bool" defaultValue="False" description="If True, do nothing when a Secret with this name already exists (existing values are kept)." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="Environment to create in; defaults to the active environment." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use; defaults to `Client.from_env()` when omitted." />
-
-**Usage**
-
-```python notest
-contents = {"MY_KEY": "my-value", "MY_OTHER_KEY": "my-other-value"}
-modal.Secret.objects.create("my-secret", contents)
-```
-
-Secrets will be created in the active environment, or another one can be specified:
-
-```python notest
-modal.Secret.objects.create("my-secret", contents, environment_name="dev")
-```
-
-By default, an error will be raised if the Secret already exists, but passing
-`allow_existing=True` will make the creation attempt a no-op in this case.
-If the `env_dict` data differs from the existing Secret, it will be ignored.
-
-```python notest
-modal.Secret.objects.create("my-secret", contents, allow_existing=True)
-```
-
-Note that this method does not return a local instance of the Secret. You can use
-`modal.Secret.from_name` to perform a lookup after creation.
-
-### objects.list
-
-```python
-list(self, *, max_objects=None, created_before=None, environment_name="",
-    client=None)
-```
-List named Secrets in the workspace environment as hydrated handles.
-
-Results are ordered newest to oldest. By default, all matching Secrets are returned.
-
-Added in v1.1.2.
-
-**Parameters**
-
-<Parameter name="max_objects" type="int | None" defaultValue="None" description="Maximum number of Secrets to return." />
-<Parameter name="created_before" type="datetime | str | None" defaultValue="None" description="Only include Secrets created before this time (datetime or ISO date string)." />
-<Parameter name="environment_name" type="str" defaultValue="&quot;&quot;" description="Environment to list from; defaults to the active environment." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use; defaults to `Client.from_env()` when omitted." />
-
-**Returns**
-
-Hydrated `Secret` objects for each named Secret in the listing.
-
-**Usage**
-
-```python
-secrets = modal.Secret.objects.list()
-print([s.name for s in secrets])
-```
-
-Secrets will be retrieved from the active environment, or another one can be specified:
-
-```python notest
-dev_secrets = modal.Secret.objects.list(environment_name="dev")
-```
-
-By default, all named Secrets are returned, newest to oldest. It's also possible to limit the
-number of results and to filter by creation date:
-
-```python
-secrets = modal.Secret.objects.list(max_objects=10, created_before="2025-01-01")
-```
-
-### objects.delete
-
-```python
-delete(self, name, *, allow_missing=False, environment_name=None, client=None)
-```
-Delete a named Secret entirely.
-
-Deletion is irreversible and affects any Apps using this Secret.
-
-Added in v1.1.2.
-
-**Parameters**
-
-<Parameter name="name" type="str" description="Name of the Secret to delete." />
-<Parameter name="allow_missing" type="bool" defaultValue="False" description="If True, do nothing when the Secret does not exist." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="Environment to delete from; defaults to the active environment." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use; defaults to `Client.from_env()` when omitted." />
-
-**Usage**
-
-```python notest
-await modal.Secret.objects.delete("my-secret")
-```
-
-Secrets will be deleted from the active environment, or another one can be specified:
-
-```python notest
-await modal.Secret.objects.delete("my-secret", environment_name="dev")
-```
-
-## name
-
-```python
-name(self)
-```
-
-
-## from_dict
-
-```python
-from_dict(env_dict={})
-```
-Create a Secret from a dictionary of environment variable names to string values.
-
-Values may be ``None``; those keys are omitted from the Secret.
-
-**Parameters**
-
-<Parameter name="env_dict" type="dict[str, str | None]" defaultValue="&#123;&#125;" description="Mapping of variable names to values (or ``None`` to skip a key)." />
-
-**Returns**
-
-A lazy `Secret` handle backed by the given key-value pairs.
-
-**Usage**
-
-```python
-@app.function(secrets=[modal.Secret.from_dict({"FOO": "bar"})])
-def run():
-    print(os.environ["FOO"])
-```
-
-## from_local_environ
-
-```python
-from_local_environ(env_keys)
-```
-Build a Secret from the current process environment (local runs only).
-
-In remote execution, returns an empty Secret.
-
-**Parameters**
-
-<Parameter name="env_keys" type="list[str]" description="Names of environment variables to copy into the Secret." />
-
-**Returns**
-
-A `Secret` containing the resolved variables (or empty when not local).
-
-## from_dotenv
-
-```python
-from_dotenv(path=None, *, filename=".env", client=None)
-```
-Load environment variables from a `.env` file into a Secret.
-
-With no `path`, searches from the current working directory (not the caller's file path).
-With `path` set, walks upward from that file or directory to find `filename`.
-
-**Parameters**
-
-<Parameter name="path" type="" defaultValue="None" description="File or directory to search from; omit to search from the process cwd." />
-<Parameter name="filename" type="" defaultValue="&quot;.env&quot;" description="Name of the env file to find (default ``.env``)." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client used when hydrating the Secret." />
-
-**Returns**
-
-A lazy `Secret` handle whose values are loaded from the resolved `.env` file.
-
-**Usage**
-
-```python
-@app.function(secrets=[modal.Secret.from_dotenv(__file__)])
-def run():
-    print(os.environ["USERNAME"])  # Assumes USERNAME is defined in your .env file
-```
-
-```python
-@app.function(secrets=[modal.Secret.from_dotenv(filename=".env-dev")])
-def run():
-    ...
-```
-
-## from_name
-
-```python
-from_name(name, *, environment_name=None, required_keys=[], client=None)
-```
-Reference a deployed Secret by name.
-
-Hydration is lazy until the Secret is used.
-
-**Parameters**
-
-<Parameter name="name" type="str" description="Deployment name of the Secret." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="Environment to resolve the name in; defaults to the active environment." />
-<Parameter name="required_keys" type="list[str]" defaultValue="[]" description="If non-empty, the server asserts these keys exist on the Secret." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use for loading; defaults to `Client.from_env()` when omitted." />
-
-**Returns**
-
-A `Secret` handle (possibly not yet hydrated).
-
-**Usage**
-
-```python
-secret = modal.Secret.from_name("my-secret")
-
-@app.function(secrets=[secret])
-def run():
-    ...
-```
-
-## info
-
-```python
-info(self)
-```
-Return information about the Secret object.
-
-## update
-
-```python
-update(self, env_dict)
-```
-Update this Secret, adding or overwriting key-value pairs.
-
-Like dict.update(), this merges `env_dict` into the existing Secret.
-Keys not mentioned in `env_dict` are left unchanged.

.agents/skills/modal/references/api/modal.Tunnel.md

@@ -1,36 +0,0 @@
-# modal.Tunnel
-
-
-```python
-class Tunnel(object)
-```
-
-A port forwarded from within a running Modal container. Created by `modal.forward()`.
-
-**Important:** This is an experimental API which may change in the future.
-
-```python
-__init__(self, host, port, unencrypted_host, unencrypted_port)
-```
-
-
-## url
-
-```python
-url(self)
-```
-Get the public HTTPS URL of the forwarded port.
-
-## tls_socket
-
-```python
-tls_socket(self)
-```
-Get the public TLS socket as a (host, port) tuple.
-
-## tcp_socket
-
-```python
-tcp_socket(self)
-```
-Get the public TCP socket as a (host, port) tuple.

.agents/skills/modal/references/api/modal.Volume.md

@@ -1,480 +0,0 @@
-# modal.Volume
-
-
-```python
-class Volume(modal.object.Object)
-```
-
-A writeable volume that can be used to share files between one or more Modal functions.
-
-The contents of a volume is exposed as a filesystem. You can use it to share data between different functions, or
-to persist durable state across several instances of the same function.
-
-Unlike a networked filesystem, you need to explicitly reload the volume to see changes made since it was mounted.
-Similarly, you need to explicitly commit any changes you make to the volume for the changes to become visible
-outside the current container.
-
-Concurrent modification is supported, but concurrent modifications of the same files should be avoided! Last write
-wins in case of concurrent modification of the same file - any data the last writer didn't have when committing
-changes will be lost!
-
-As a result, volumes are typically not a good fit for use cases where you need to make concurrent modifications to
-the same file (nor is distributed file locking supported).
-
-Volumes can only be reloaded if there are no open files for the volume - attempting to reload with open files
-will result in an error.
-
-**Usage**
-
-```python
-import modal
-
-app = modal.App()
-volume = modal.Volume.from_name("my-persisted-volume", create_if_missing=True)
-
-@app.function(volumes={"/root/foo": volume})
-def f():
-    with open("/root/foo/bar.txt", "w") as f:
-        f.write("hello")
-    volume.commit()  # Persist changes
-
-@app.function(volumes={"/root/foo": volume})
-def g():
-    volume.reload()  # Fetch latest changes
-    with open("/root/foo/bar.txt", "r") as f:
-        print(f.read())
-```
-
-
-## hydrate
-
-```python
-hydrate(self, client=None)
-```
-Synchronize the local object with its identity on the Modal server.
-
-It is rarely necessary to call this method explicitly, as most operations
-will lazily hydrate when needed. The main use case is when you need to
-access object metadata, such as its ID.
-
-*Added in v0.72.39*: This method replaces the deprecated `.resolve()` method.
-
-## objects
-
-
-```python
-objects: VolumeManager
-```
-
-Namespace with methods for managing named Volume objects.
-
-
-### objects.create
-
-```python
-create(self, name, *, version=None, allow_existing=False, environment_name=None,
-    client=None)
-```
-Create a new named Volume in the workspace environment.
-
-This does not return a local handle; use `modal.Volume.from_name` to look up the Volume after creation.
-
-Added in v1.1.2.
-
-**Parameters**
-
-<Parameter name="name" type="str" description="Name for the new Volume." />
-<Parameter name="version" type="int | None" defaultValue="None" description="Optional VolumeFS backend version (1 or 2); experimental." />
-<Parameter name="allow_existing" type="bool" defaultValue="False" description="If True, do nothing when a Volume with this name already exists." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="Environment to create in; defaults to the active environment." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use; defaults to `Client.from_env()` when omitted." />
-
-**Usage**
-
-```python notest
-modal.Volume.objects.create("my-volume")
-```
-
-Volumes will be created in the active environment, or another one can be specified:
-
-```python notest
-modal.Volume.objects.create("my-volume", environment_name="dev")
-```
-
-By default, an error is raised if the Volume already exists; `allow_existing=True` makes that case a no-op:
-
-```python notest
-modal.Volume.objects.create("my-volume", allow_existing=True)
-```
-
-Note that this method does not return a local instance of the Volume. You can use
-`modal.Volume.from_name` to perform a lookup after creation.
-
-### objects.list
-
-```python
-list(self, *, max_objects=None, created_before=None, environment_name="",
-    client=None)
-```
-List named Volumes in the workspace environment as hydrated handles.
-
-Results are ordered newest to oldest. By default, all matching Volumes are returned.
-
-Added in v1.1.2.
-
-**Parameters**
-
-<Parameter name="max_objects" type="int | None" defaultValue="None" description="Maximum number of Volumes to return." />
-<Parameter name="created_before" type="datetime | str | None" defaultValue="None" description="Only include Volumes created before this time (datetime or ISO date string)." />
-<Parameter name="environment_name" type="str" defaultValue="&quot;&quot;" description="Environment to list from; defaults to the active environment." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use; defaults to `Client.from_env()` when omitted." />
-
-**Returns**
-
-Hydrated `Volume` objects for each named Volume in the listing.
-
-**Usage**
-
-```python
-volumes = modal.Volume.objects.list()
-print([v.name for v in volumes])
-```
-
-Volumes will be retrieved from the active environment, or another one can be specified:
-
-```python notest
-dev_volumes = modal.Volume.objects.list(environment_name="dev")
-```
-
-By default, all named Volumes are returned, newest to oldest. It's also possible to limit the
-number of results and to filter by creation date:
-
-```python
-volumes = modal.Volume.objects.list(max_objects=10, created_before="2025-01-01")
-```
-
-### objects.delete
-
-```python
-delete(self, name, *, allow_missing=False, environment_name=None, client=None)
-```
-Delete a named Volume entirely (not individual files).
-
-Deletion is irreversible and affects any Apps using this Volume.
-
-Added in v1.1.2.
-
-**Parameters**
-
-<Parameter name="name" type="str" description="Name of the Volume to delete." />
-<Parameter name="allow_missing" type="bool" defaultValue="False" description="If True, do nothing when the Volume does not exist." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="Environment to delete from; defaults to the active environment." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use; defaults to `Client.from_env()` when omitted." />
-
-**Usage**
-
-```python notest
-await modal.Volume.objects.delete("my-volume")
-```
-
-Volumes will be deleted from the active environment, or another one can be specified:
-
-```python notest
-await modal.Volume.objects.delete("my-volume", environment_name="dev")
-```
-
-## name
-
-```python
-name(self)
-```
-
-
-## with_mount_options
-
-```python
-with_mount_options(self, *, read_only=None, sub_path=None)
-```
-Configure options used when mounting this Volume.
-
-Note that these options are not properties stored with the Volume itself - they can be individually configured
-for each Volume - container association.
-
-**Parameters**
-
-<Parameter name="read_only" type="bool | None" defaultValue="None" description="Set this to True to make the Volume read only from within containers." />
-<Parameter name="sub_path" type="str | PurePosixPath | None" defaultValue="None" description="Only mount this sub_path directory from the Volume. If the directory doesn&#x27;t exist in the Volume, it will be created when the container starts up." />
-
-**Returns**
-
-A `Volume` handle with the mount options applied.
-
-**Usage**
-
-To mount a volume in read-only mode:
-
-```python
-import modal
-
-volume = modal.Volume.from_name("my-volume")
-
-@app.function(volumes={"/mnt": volume.with_mount_options(read_only=True)})
-def f():
-    return os.mkdir("/mnt/foo")  # not possible!
-```
-
-To mount only part of a Volume using sub_path:
-
-```python
-import modal
-
-volume = modal.Volume.from_name("my-volume")
-
-@app.function(volumes={"/user_data": volume.with_mount_options(sub_path="/users/my_user")})
-def f():
-    return os.listdir("/user_data")  # lists data from /users/my_user
-```
-
-## from_name
-
-```python
-from_name(name, *, environment_name=None, create_if_missing=False, version=None,
-    client=None)
-```
-Reference a Volume by name, optionally creating it on the server first.
-
-Hydration is lazy: metadata is fetched from Modal the first time the handle is used.
-
-**Parameters**
-
-<Parameter name="name" type="str" description="Deployment name of the Volume." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="Environment to resolve the name in; defaults to the active environment." />
-<Parameter name="create_if_missing" type="bool" defaultValue="False" description="If True, create the Volume when it does not already exist." />
-<Parameter name="version" type="&quot;modal_proto.api_pb2.VolumeFsVersion.ValueType | None&quot;" defaultValue="None" description="Optional VolumeFS backend version; must match an existing Volume when set." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use for loading; defaults to `Client.from_env()` when omitted." />
-
-**Returns**
-
-A `Volume` handle (possibly not yet hydrated).
-
-**Usage**
-
-```python
-vol = modal.Volume.from_name("my-volume", create_if_missing=True)
-
-app = modal.App()
-
-@app.function(volumes={"/data": vol})
-def f():
-    pass
-```
-
-## from_id
-
-```python
-from_id(volume_id, client=None)
-```
-Construct a Volume from an id and look up the Volume metadata.
-
-This is a lazy method that defers hydrating the local
-object with metadata from Modal servers until the first
-time it is actually used.
-
-The ID of a Volume object can be accessed using `.object_id`.
-
-**Parameters**
-
-<Parameter name="volume_id" type="str" description="Volume object ID to attach to." />
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use for loading; defaults to `Client.from_env()` when omitted." />
-
-**Returns**
-
-A `Volume` handle (possibly not yet hydrated).
-
-**Usage**
-
-```python notest
-@app.function()
-def my_worker(volume_id: str):
-    vol = modal.Volume.from_id(volume_id)
-    for entry in vol.listdir("/"):
-        print(entry.path)
-
-with modal.Volume.ephemeral() as vol:
-    my_worker.remote(vol.object_id)
-```
-
-## ephemeral
-
-```python
-ephemeral(cls, client=None, environment_name=None, version=None)
-```
-Create an anonymous Volume that exists for the duration of the context manager.
-
-**Parameters**
-
-<Parameter name="client" type="_Client | None" defaultValue="None" description="Modal client to use; defaults to `Client.from_env()` when omitted." />
-<Parameter name="environment_name" type="str | None" defaultValue="None" description="Environment for the ephemeral Volume; defaults to the active environment." />
-<Parameter name="version" type="&quot;modal_proto.api_pb2.VolumeFsVersion.ValueType | None&quot;" defaultValue="None" description="Optional VolumeFS backend version for the ephemeral Volume." />
-
-**Usage**
-
-```python
-import modal
-
-with modal.Volume.ephemeral() as vol:
-    assert vol.listdir("/") == []
-```
-
-```python notest
-async with modal.Volume.ephemeral() as vol:
-    assert await vol.listdir("/") == []
-```
-
-## info
-
-```python
-info(self)
-```
-Return information about the Volume object.
-
-## commit
-
-```python
-commit(self)
-```
-Commit changes to a mounted volume.
-
-If successful, the changes made are now persisted in durable storage and available to other containers accessing
-the volume.
-
-## reload
-
-```python
-reload(self)
-```
-Make latest committed state of volume available in the running container.
-
-Any uncommitted changes to the volume, such as new or modified files, may implicitly be committed when
-reloading.
-
-Reloading will fail if there are open files for the volume.
-
-## iterdir
-
-```python
-iterdir(self, path, *, recursive=True)
-```
-Iterate over all files in a directory in the volume.
-
-Passing a directory path lists all files in the directory. For a file path, return only that
-file's description. If `recursive` is set to True, list all files and folders under the path
-recursively.
-
-## listdir
-
-```python
-listdir(self, path, *, recursive=False)
-```
-List all files under a path prefix in the modal.Volume.
-
-Passing a directory path lists all files in the directory. For a file path, return only that
-file's description. If `recursive` is set to True, list all files and folders under the path
-recursively.
-
-## read_file
-
-```python
-read_file(self, path)
-```
-Read a file from the modal.Volume.
-
-Note - this function is primarily intended to be used outside of a Modal App.
-For more information on downloading files from a Modal Volume, see
-[the guide](https://modal.com/docs/guide/volumes).
-
-**Parameters**
-
-<Parameter name="path" type="str" description="Path to the file inside the Volume." />
-
-**Usage**
-
-```python notest
-vol = modal.Volume.from_name("my-modal-volume")
-data = b""
-for chunk in vol.read_file("1mb.csv"):
-    data += chunk
-print(len(data))  # == 1024 * 1024
-```
-
-## remove_file
-
-```python
-remove_file(self, path, recursive=False)
-```
-Remove a file or directory from a volume.
-
-## copy_files
-
-```python
-copy_files(self, src_paths, dst_path, recursive=False)
-```
-Copy files within the volume from src_paths to dst_path.
-The semantics of the copy operation follow those of the UNIX cp command.
-
-The `src_paths` parameter is a list. If you want to copy a single file, you should pass a list with a
-single element.
-
-`src_paths` and `dst_path` should refer to the desired location *inside* the volume. You do not need to prepend
-the volume mount path.
-
-Note that if the volume is already mounted on the Modal function, you should use normal filesystem operations
-like `os.rename()` and then `commit()` the volume. The `copy_files()` method is useful when you don't have
-the volume mounted as a filesystem, e.g. when running a script on your local computer.
-
-**Parameters**
-
-<Parameter name="src_paths" type="Sequence[str]" description="Source paths inside the Volume (list of one or more paths)." />
-<Parameter name="dst_path" type="str" description="Destination path inside the Volume (file or directory, following ``cp`` semantics)." />
-<Parameter name="recursive" type="bool" defaultValue="False" description="Whether to copy directories recursively (V2 volumes only)." />
-
-**Usage**
-
-```python notest
-vol = modal.Volume.from_name("my-modal-volume")
-
-vol.copy_files(["bar/example.txt"], "bar2")
-vol.copy_files(["bar/example.txt"], "bar/example2.txt")
-```
-
-## batch_upload
-
-```python
-batch_upload(self, force=False)
-```
-Initiate a batched upload to a volume.
-
-To allow overwriting existing files, set `force` to `True` (you cannot overwrite existing directories with
-uploaded files regardless).
-
-**Parameters**
-
-<Parameter name="force" type="bool" defaultValue="False" description="If True, allow overwriting existing files with uploads (not directories)." />
-
-**Usage**
-
-```python notest
-vol = modal.Volume.from_name("my-modal-volume")
-
-with vol.batch_upload() as batch:
-    batch.put_file("local-path.txt", "/remote-path.txt")
-    batch.put_directory("/local/directory/", "/remote/directory")
-    batch.put_file(io.BytesIO(b"some data"), "/foobar")
-```
-
-## rename
-
-```python
-rename(old_name, new_name, *, client=None, environment_name=None)
-```
-

.agents/skills/modal/references/api/modal.Workspace.md

@@ -1,63 +0,0 @@
-# modal.Workspace
-
-
-```python
-class Workspace(modal.object.Object)
-```
-
-
-## hydrate
-
-```python
-hydrate(self, client=None)
-```
-Synchronize the local object with its identity on the Modal server.
-
-It is rarely necessary to call this method explicitly, as most operations
-will lazily hydrate when needed. The main use case is when you need to
-access object metadata, such as its ID.
-
-*Added in v0.72.39*: This method replaces the deprecated `.resolve()` method.
-
-## name
-
-```python
-name(self)
-```
-
-
-## members
-
-
-```python
-members: WorkspaceMembersManager
-```
-
-Namespace with methods for managing the membership of a Workspace.
-
-
-### members.list
-
-```python
-list(self)
-```
-Return the members of the Workspace.
-
-**Examples:**
-
-```python notest
-members = modal.Workspace.from_context().members.list()
-print([m.name for m in members])
-```
-
-## from_context
-
-```python
-from_context(*, client=None)
-```
-Look up the Workspace associated with the current context.
-
-This returns the Workspace that the active Modal credentials authenticate against
-(i.e., your active profile or the `MODAL_TOKEN_ID` / `MODAL_TOKEN_SECRET` environment
-variables). If called inside a Modal container, it returns the Workspace that the
-container is running in.

.agents/skills/modal/references/api/modal.asgi_app.md

@@ -1,23 +0,0 @@
-# modal.asgi_app
-
-```python
-asgi_app(*, label=None, custom_domains=None, requires_proxy_auth=False)
-```
-Decorator for registering an ASGI app as a Web Function.
-
-Asynchronous Server Gateway Interface (ASGI) is a standard for Python
-web apps, supported by all popular Python web libraries.
-
-To learn how to use Modal with popular web frameworks, see the
-[guide on Web Functions](https://modal.com/docs/guide/webhooks).
-
-**Usage**
-
-```python
-from typing import Callable
-
-@app.function()
-@modal.asgi_app()
-def create_asgi() -> Callable:
-    ...
-```

.agents/skills/modal/references/api/modal.batched.md

@@ -1,28 +0,0 @@
-# modal.batched
-
-```python
-batched(*, max_batch_size, wait_ms)
-```
-Decorator for functions or class methods that should be batched.
-
-See the [dynamic batching guide](https://modal.com/docs/guide/dynamic-batching) for more information.
-
-**Usage**
-
-```python
-# Stack the decorator under `@app.function()` to enable dynamic batching
-@app.function()
-@modal.batched(max_batch_size=4, wait_ms=1000)
-async def batched_multiply(xs: list[int], ys: list[int]) -> list[int]:
-    return [x * y for x, y in zip(xs, ys)]
-
-# call batched_multiply with individual inputs
-# batched_multiply.remote.aio(2, 100)
-
-# With `@app.cls()`, apply the decorator to a method (this may change in the future)
-@app.cls()
-class BatchedClass:
-    @modal.batched(max_batch_size=4, wait_ms=1000)
-    def batched_multiply(self, xs: list[int], ys: list[int]) -> list[int]:
-        return [x * y for x, y in zip(xs, ys)]
-```

.agents/skills/modal/references/api/modal.billing.md

@@ -1,46 +0,0 @@
-# modal.billing
-
-## modal.billing.WorkspaceBillingReportItem
-
-```python
-class WorkspaceBillingReportItem(TypedDict):
-    object_id: str
-    description: str
-    environment_name: str
-    interval_start: datetime.datetime
-    cost: decimal.Decimal
-    tags: dict[str, str]
-```
-
-## modal.billing.workspace_billing_report
-
-```python
-workspace_billing_report(*, start, end=None, resolution="d", tag_names=None,
-    client=None)
-```
-Generate a tabular report of workspace usage by object and time.
-
-The result will be a list of dictionaries for each interval (determined by `resolution`)
-between the `start` and `end` limits. The dictionary represents a single Modal object
-that billing can be attributed to (e.g., an App) along with metadata (including user-defined
-tags) for identifying that object.
-
-The `start` and `end` parameters are required to either have a UTC timezone or to be
-timezone-naive (which will be interpreted as UTC times). The timestamps in the result will
-be in UTC. Cost will be reported for full intervals, even if the provided `start` or `end`
-parameters are partial: `start` will be rounded to the beginning of its interval, while
-partial `end` intervals will be excluded.
-
-Additional user-provided metadata can be included in the report if the objects have tags
-and `tag_names` (i.e., keys) are specified in the request. Alternatively, pass `tag_names=["*"]`
-to include all tags in the report. Note that tags will be attributed to the entire interval even
-if they were added or removed at some point within it. If the tag name was not in use during an
-interval, it will be absent from the tags dictionary in that output row.
-
-In most cases, billing data will be available in the database that this API queries within
-minutes, although there may be collection delays. If completeness is important for your use
-case, we recommend leaving a buffer after the end of the query interval.
-
-It's also possible to generate reports using the
-[`modal billing report`](https://modal.com/docs/reference/cli/billing) CLI command. The CLI
-has a few convenience features for generating reports across relative time ranges.

.agents/skills/modal/references/api/modal.call_graph.md

@@ -1,33 +0,0 @@
-# modal.call_graph
-
-## modal.call_graph.InputInfo
-
-
-```python
-class InputInfo(object)
-```
-
-Simple data structure storing information about a function input.
-
-```python
-__init__(self, input_id, function_call_id, task_id, status, function_name,
-    module_name, children)
-```
-
-## modal.call_graph.InputStatus
-
-
-```python
-class InputStatus(enum.IntEnum)
-```
-
-Enum representing status of a function input.
-
-The possible values are:
-
-* `PENDING`
-* `SUCCESS`
-* `FAILURE`
-* `INIT_FAILURE`
-* `TERMINATED`
-* `TIMEOUT`

.agents/skills/modal/references/api/modal.concurrent.md

@@ -1,45 +0,0 @@
-# modal.concurrent
-
-```python
-concurrent(*, max_inputs=None, target_inputs=None)
-```
-Decorator that allows individual containers to handle multiple inputs concurrently.
-
-The concurrency mechanism depends on whether the function is async or not:
-- Async functions will run inputs on a single thread as asyncio tasks.
-- Synchronous functions will use multi-threading. The code must be thread-safe.
-
-Input concurrency will be most useful for workflows that are IO-bound
-(e.g., making network requests) or when running an inference server that supports
-dynamic batching.
-
-When `target_inputs` is set, Modal's autoscaler will try to provision resources
-such that each container is running that many inputs concurrently, rather than
-autoscaling based on `max_inputs`. Containers may burst up to up to `max_inputs`
-if resources are insufficient to remain at the target concurrency, e.g. when the
-arrival rate of inputs increases. This can trade-off a small increase in average
-latency to avoid larger tail latencies from input queuing.
-
-*Added in v0.73.148:* This decorator replaces the `allow_concurrent_inputs` parameter
-in `@app.function()` and `@app.cls()`.
-
-**Usage**
-
-```python
-# Stack the decorator under `@app.function()` to enable input concurrency
-@app.function()
-@modal.concurrent(max_inputs=100)
-async def f(data):
-    # Async function; will be scheduled as asyncio task
-    ...
-
-# With `@app.cls()`, apply the decorator at the class level, not on individual methods
-@app.cls()
-@modal.concurrent(max_inputs=100, target_inputs=80)
-class C:
-    @modal.method()
-    def f(self, data):
-        # Sync function; must be thread-safe
-        ...
-
-```

.agents/skills/modal/references/api/modal.config.md

@@ -1,163 +0,0 @@
-# modal.config
-
-Modal intentionally keeps configurability to a minimum.
-
-The main configuration options are the API tokens: the token id and the token secret.
-These can be configured in two ways:
-
-1. By running the `modal token set` command.
-   This writes the tokens to `.modal.toml` file in your home directory.
-2. By setting the environment variables `MODAL_TOKEN_ID` and `MODAL_TOKEN_SECRET`.
-   This takes precedence over the previous method.
-
-.modal.toml
----------------
-
-The `.modal.toml` file is generally stored in your home directory.
-It should look like this::
-
-```toml
-[default]
-token_id = "ak-12345..."
-token_secret = "as-12345..."
-```
-
-You can create this file manually, or you can run the `modal token set ...`
-command (see below).
-
-Setting tokens using the CLI
-----------------------------
-
-You can set a token by running the command::
-
-```
-modal token set \
-  --token-id <token id> \
-  --token-secret <token secret>
-```
-
-This will write the token id and secret to `.modal.toml`.
-
-If the token id or secret is provided as the string `-` (a single dash),
-then it will be read in a secret way from stdin instead.
-
-Other configuration options
----------------------------
-
-Other possible configuration options are:
-
-* `loglevel` (in the .toml file) / `MODAL_LOGLEVEL` (as an env var).
-  Defaults to `WARNING`. Set this to `DEBUG` to see internal messages.
-* `logs_timeout` (in the .toml file) / `MODAL_LOGS_TIMEOUT` (as an env var).
-  Defaults to 10.
-  Number of seconds to wait for logs to drain when closing the session,
-  before giving up.
-* `max_throttle_wait` (in the .toml file) / `MODAL_MAX_THROTTLE_WAIT` (as an env var).
-  Defaults to None (no limit).
-  Maximum number of seconds to wait when requests are being throttled (i.e., due
-  to rate limiting or other cases that can normally be resolved through backoff).
-* `force_build` (in the .toml file) / `MODAL_FORCE_BUILD` (as an env var).
-  Defaults to False.
-  When set, ignores the Image cache and builds all Image layers. Note that this
-  will break the cache for all images based on the rebuilt layers, so other images
-  may rebuild on subsequent runs / deploys even if the config is reverted.
-* `ignore_cache` (in the .toml file) / `MODAL_IGNORE_CACHE` (as an env var).
-  Defaults to False.
-  When set, ignores the Image cache and builds all Image layers. Unlike `force_build`,
-  this will not overwrite the cache for other images that have the same recipe.
-  Subsequent runs that do not use this option will pull the *previous* Image from
-  the cache, if one exists. It can be useful for testing an App's robustness to
-  Image rebuilds without clobbering Images used by other Apps.
-* `traceback` (in the .toml file) / `MODAL_TRACEBACK` (as an env var).
-  Defaults to False. Enables printing full tracebacks on unexpected CLI
-  errors, which can be useful for debugging client issues.
-* `log_pattern` (in the .toml file) / `MODAL_LOG_PATTERN` (as an env var).
-  Defaults to `"[modal-client] %(asctime)s %(message)s"`
-  The log formatting pattern that will be used by the modal client itself.
-  See https://docs.python.org/3/library/logging.html#logrecord-attributes for available
-  log attributes.
-* `dev_suffix` (in the .toml file) / `MODAL_DEV_SUFFIX` (as an env var).
-  Overrides the default `-dev` suffix added to URLs generated for Web Functions
-  when the App is ephemeral (i.e., created via `modal serve`). Must be a short
-  alphanumeric string.
-
-Meta-configuration
-------------------
-
-Some "meta-options" are set using environment variables only:
-
-* `MODAL_CONFIG_PATH` lets you override the location of the .toml file,
-  by default `~/.modal.toml`.
-* `MODAL_PROFILE` lets you use multiple sections in the .toml file
-  and switch between them. It defaults to "default".
-
-## modal.config.Config
-
-
-```python
-class Config(object)
-```
-
-Singleton that holds configuration used by Modal internally.
-
-```python
-__init__(self)
-```
-
-
-### get
-
-```python
-get(self, key, profile=None, use_env=True)
-```
-Look up a configuration value.
-
-Resolution order (highest priority first):
-
-1. Environment variable ``MODAL_<KEY>`` (underscore-separated, uppercased), when ``use_env`` is True.
-2. The named profile in ``.modal.toml``.
-3. The built-in default for that setting.
-
-**Parameters**
-
-<Parameter name="key" type="" description="Setting name (for example ``&quot;loglevel&quot;`` or ``&quot;server_url&quot;``); see the ``modal.config`` module docs." />
-<Parameter name="profile" type="" defaultValue="None" description="Profile section to read from the TOML file; defaults to the active profile." />
-<Parameter name="use_env" type="" defaultValue="True" description="When False, skip environment variables and read only from the file or defaults." />
-
-**Returns**
-
-The transformed configuration value (type depends on the setting).
-
-### override_locally
-
-```python
-override_locally(self, key, value)
-```
-
-
-### to_dict
-
-```python
-to_dict(self)
-```
-
-## modal.config.config_profiles
-
-```python
-config_profiles()
-```
-List the available Modal profiles in the ``.modal.toml`` file.
-
-**Returns**
-
-Profile section names present in the configuration file.
-## modal.config.config_set_active_profile
-
-```python
-config_set_active_profile(profile)
-```
-Set the user's active Modal profile by writing it to the ``.modal.toml`` file.
-
-**Parameters**
-
-<Parameter name="profile" type="str" description="Name of an existing profile section to mark as active." />

.agents/skills/modal/references/api/modal.container_process.md

@@ -1,64 +0,0 @@
-# modal.container_process
-
-## modal.container_process.ContainerProcess
-
-
-```python
-class ContainerProcess(typing.Generic)
-```
-
-Represents a running process in a container.
-
-Container processes communicate via direct communication with
-the Modal worker where the container is running.
-
-```python
-__init__(self, process_id, task_id, client, command_router_client,
-    stdout=StreamType.PIPE, stderr=StreamType.PIPE, exec_deadline=None,
-    text=True, by_line=False)
-```
-
-
-### stdout
-
-```python
-stdout(self)
-```
-StreamReader for the container process's stdout stream.
-
-### stderr
-
-```python
-stderr(self)
-```
-StreamReader for the container process's stderr stream.
-
-### stdin
-
-```python
-stdin(self)
-```
-StreamWriter for the container process's stdin stream.
-
-### returncode
-
-```python
-returncode(self)
-```
-
-
-### poll
-
-```python
-poll(self)
-```
-Check if the container process has finished running.
-
-Returns `None` if the process is still running, else returns the exit code.
-
-### wait
-
-```python
-wait(self)
-```
-Wait for the container process to finish running. Returns the exit code.

.agents/skills/modal/references/api/modal.current_function_call_id.md

@@ -1,16 +0,0 @@
-# modal.current_function_call_id
-
-```python
-current_function_call_id()
-```
-Returns the function call ID for the current input.
-
-Can only be called from Modal function (i.e. in a container context).
-
-```python
-from modal import current_function_call_id
-
-@app.function()
-def process_stuff():
-    print(f"Starting to process input from {current_function_call_id()}")
-```

.agents/skills/modal/references/api/modal.current_input_id.md

@@ -1,16 +0,0 @@
-# modal.current_input_id
-
-```python
-current_input_id()
-```
-Returns the input ID for the current input.
-
-Can only be called from Modal function (i.e. in a container context).
-
-```python
-from modal import current_input_id
-
-@app.function()
-def process_stuff():
-    print(f"Starting to process {current_input_id()}")
-```

.agents/skills/modal/references/api/modal.enable_output.md

@@ -1,20 +0,0 @@
-# modal.enable_output
-
-```python
-enable_output()
-```
-Context manager that enable output when using the Python SDK.
-
-This will print to stdout and stderr things such as
-1. Logs from running functions
-2. Status of creating objects
-3. Map progress
-
-**Usage**
-
-```python
-app = modal.App()
-with modal.enable_output():
-    with app.run():
-        ...
-```

.agents/skills/modal/references/api/modal.enter.md

@@ -1,8 +0,0 @@
-# modal.enter
-
-```python
-enter(*, snap=False)
-```
-Decorator for methods which should be executed when a new container is started.
-
-See the [lifeycle function guide](https://modal.com/docs/guide/lifecycle-functions#enter) for more information.

.agents/skills/modal/references/api/modal.exception.md

@@ -1,766 +0,0 @@
-# modal.exception
-
-Modal-specific exception types.
-
-## Notes on `grpclib.GRPCError` migration
-
-Historically, the Modal SDK could propagate `grpclib.GRPCError` exceptions out
-to user code.  As of v1.3, we are in the process of gracefully migrating to
-always raising a Modal exception type in these cases. To avoid breaking user
-code that relies on catching `grpclib.GRPCError`, a subset of Modal exception
-types temporarily inherit from `grpclib.GRPCError`.
-
-We encourage users to migrate any code that currently catches `grpclib.GRPCError`
-to instead catch the appropriate Modal exception type. The following mapping
-between GRPCError status codes and Modal exception types is currently in use:
-
-```
-CANCELLED -> ServiceError
-UNKNOWN -> ServiceError
-INVALID_ARGUMENT -> InvalidError
-DEADLINE_EXCEEDED -> ServiceError
-NOT_FOUND -> NotFoundError
-ALREADY_EXISTS -> AlreadyExistsError
-PERMISSION_DENIED -> PermissionDeniedError
-RESOURCE_EXHAUSTED -> ResourceExhaustedError
-FAILED_PRECONDITION -> ConflictError
-ABORTED -> ConflictError
-OUT_OF_RANGE -> InvalidError
-UNIMPLEMENTED -> UnimplementedError
-INTERNAL -> InternalError
-UNAVAILABLE -> ServiceError
-DATA_LOSS -> DataLossError
-UNAUTHENTICATED -> AuthError
-```
-
-## modal.exception.AlreadyExistsError
-
-
-```python
-class AlreadyExistsError(modal.exception.Error, modal.exception._GRPCErrorWrapper)
-```
-
-Raised when a resource creation conflicts with an existing resource.
-
-```python
-__init__(self, message=None)
-```
-
-
-### message
-
-```python
-message(self)
-```
-
-
-### status
-
-```python
-status(self)
-```
-
-
-### details
-
-```python
-details(self)
-```
-
-## modal.exception.AsyncUsageWarning
-
-
-```python
-class AsyncUsageWarning(UserWarning)
-```
-
-Warning emitted when a blocking Modal interface is used in an async context.
-
-## modal.exception.AuthError
-
-
-```python
-class AuthError(modal.exception.Error, modal.exception._GRPCErrorWrapper)
-```
-
-Raised when a client has missing or invalid authentication.
-
-```python
-__init__(self, message=None)
-```
-
-
-### message
-
-```python
-message(self)
-```
-
-
-### status
-
-```python
-status(self)
-```
-
-
-### details
-
-```python
-details(self)
-```
-
-## modal.exception.ClientClosed
-
-
-```python
-class ClientClosed(modal.exception.Error)
-```
-
-## modal.exception.ConflictError
-
-
-```python
-class ConflictError(modal.exception.InvalidError, modal.exception._GRPCErrorWrapper)
-```
-
-Raised when a resource conflict occurs between the request and current system state.
-
-```python
-__init__(self, message=None)
-```
-
-
-### message
-
-```python
-message(self)
-```
-
-
-### status
-
-```python
-status(self)
-```
-
-
-### details
-
-```python
-details(self)
-```
-
-## modal.exception.ConnectionError
-
-
-```python
-class ConnectionError(modal.exception.Error)
-```
-
-Raised when an issue occurs while connecting to the Modal servers.
-
-## modal.exception.DataLossError
-
-
-```python
-class DataLossError(modal.exception.Error, modal.exception._GRPCErrorWrapper)
-```
-
-Raised when data is lost or corrupted.
-
-```python
-__init__(self, message=None)
-```
-
-
-### message
-
-```python
-message(self)
-```
-
-
-### status
-
-```python
-status(self)
-```
-
-
-### details
-
-```python
-details(self)
-```
-
-## modal.exception.DeprecationError
-
-
-```python
-class DeprecationError(UserWarning)
-```
-
-UserWarning category emitted when a deprecated Modal feature or API is used.
-
-## modal.exception.DeserializationError
-
-
-```python
-class DeserializationError(modal.exception.Error)
-```
-
-Raised to provide more context when an error is encountered during deserialization.
-
-## modal.exception.Error
-
-
-```python
-class Error(Exception)
-```
-
-Base class for all Modal errors. See [`modal.exception`](https://modal.com/docs/reference/modal.exception)
-for the specialized error classes.
-
-**Usage**
-
-```python notest
-import modal
-
-try:
-    ...
-except modal.Error:
-    # Catch any exception raised by Modal's systems.
-    print("Responding to error...")
-```
-
-## modal.exception.ExecTimeoutError
-
-
-```python
-class ExecTimeoutError(modal.exception.TimeoutError)
-```
-
-Raised when a container process exceeds its execution duration limit and times out.
-
-## modal.exception.ExecutionError
-
-
-```python
-class ExecutionError(modal.exception.Error)
-```
-
-Raised when something unexpected happened during runtime.
-
-## modal.exception.FilesystemExecutionError
-
-
-```python
-class FilesystemExecutionError(modal.exception.Error)
-```
-
-Raised when an unknown error is thrown during a container filesystem operation.
-
-## modal.exception.FunctionTimeoutError
-
-
-```python
-class FunctionTimeoutError(modal.exception.TimeoutError)
-```
-
-Raised when a Function exceeds its execution duration limit and times out.
-
-## modal.exception.InputCancellation
-
-
-```python
-class InputCancellation(BaseException)
-```
-
-Raised when the current input is cancelled by the task
-
-Intentionally a BaseException instead of an Exception, so it won't get
-caught by unspecified user exception clauses that might be used for retries and
-other control flow.
-
-## modal.exception.InteractiveTimeoutError
-
-
-```python
-class InteractiveTimeoutError(modal.exception.TimeoutError)
-```
-
-Raised when interactive frontends time out while trying to connect to a container.
-
-## modal.exception.InternalError
-
-
-```python
-class InternalError(modal.exception.Error, modal.exception._GRPCErrorWrapper)
-```
-
-Raised when an internal error occurs in the Modal system.
-
-```python
-__init__(self, message=None)
-```
-
-
-### message
-
-```python
-message(self)
-```
-
-
-### status
-
-```python
-status(self)
-```
-
-
-### details
-
-```python
-details(self)
-```
-
-## modal.exception.InternalFailure
-
-
-```python
-class InternalFailure(modal.exception.Error)
-```
-
-Retriable internal error.
-
-## modal.exception.InvalidError
-
-
-```python
-class InvalidError(modal.exception.Error, modal.exception._GRPCErrorWrapper)
-```
-
-Raised when user does something invalid.
-
-```python
-__init__(self, message=None)
-```
-
-
-### message
-
-```python
-message(self)
-```
-
-
-### status
-
-```python
-status(self)
-```
-
-
-### details
-
-```python
-details(self)
-```
-
-## modal.exception.LogsFetchError
-
-
-```python
-class LogsFetchError(modal.exception.Error)
-```
-
-Raised when trying to fetch too many logs.
-
-## modal.exception.ModuleNotMountable
-
-
-```python
-class ModuleNotMountable(Exception)
-```
-
-## modal.exception.MountUploadTimeoutError
-
-
-```python
-class MountUploadTimeoutError(modal.exception.TimeoutError)
-```
-
-Raised when a Mount upload times out.
-
-## modal.exception.NotFoundError
-
-
-```python
-class NotFoundError(modal.exception.Error, modal.exception._GRPCErrorWrapper)
-```
-
-Raised when a requested resource was not found.
-
-```python
-__init__(self, message=None)
-```
-
-
-### message
-
-```python
-message(self)
-```
-
-
-### status
-
-```python
-status(self)
-```
-
-
-### details
-
-```python
-details(self)
-```
-
-## modal.exception.OutputExpiredError
-
-
-```python
-class OutputExpiredError(modal.exception.TimeoutError)
-```
-
-Raised when the Output exceeds expiration and times out.
-
-## modal.exception.PermissionDeniedError
-
-
-```python
-class PermissionDeniedError(modal.exception.Error, modal.exception._GRPCErrorWrapper)
-```
-
-Raised when a user does not have permission to perform the requested operation.
-
-```python
-__init__(self, message=None)
-```
-
-
-### message
-
-```python
-message(self)
-```
-
-
-### status
-
-```python
-status(self)
-```
-
-
-### details
-
-```python
-details(self)
-```
-
-## modal.exception.RemoteError
-
-
-```python
-class RemoteError(modal.exception.Error)
-```
-
-Raised when an error occurs on the Modal server.
-
-## modal.exception.RequestSizeError
-
-
-```python
-class RequestSizeError(modal.exception.Error)
-```
-
-Raised when an operation produces a gRPC request that is rejected by the server for being too large.
-
-## modal.exception.ResourceExhaustedError
-
-
-```python
-class ResourceExhaustedError(modal.exception.Error, modal.exception._GRPCErrorWrapper)
-```
-
-Raised when a server-side resource has been exhausted, e.g. a quota or rate limit.
-
-```python
-__init__(self, message=None)
-```
-
-
-### message
-
-```python
-message(self)
-```
-
-
-### status
-
-```python
-status(self)
-```
-
-
-### details
-
-```python
-details(self)
-```
-
-## modal.exception.SandboxFilesystemDirectoryNotEmptyError
-
-
-```python
-class SandboxFilesystemDirectoryNotEmptyError(modal.exception.SandboxFilesystemError)
-```
-
-Raised when a directory is not empty.
-
-## modal.exception.SandboxFilesystemError
-
-
-```python
-class SandboxFilesystemError(modal.exception.Error)
-```
-
-Base class for sandbox filesystem errors.
-
-## modal.exception.SandboxFilesystemFileTooLargeError
-
-
-```python
-class SandboxFilesystemFileTooLargeError(modal.exception.SandboxFilesystemError)
-```
-
-Raised when a file exceeds the maximum allowed size for a read operation in the sandbox.
-
-## modal.exception.SandboxFilesystemIsADirectoryError
-
-
-```python
-class SandboxFilesystemIsADirectoryError(modal.exception.SandboxFilesystemError)
-```
-
-Raised when a file operation in the sandbox targets a directory when it should target a non-directory file.
-
-## modal.exception.SandboxFilesystemNotADirectoryError
-
-
-```python
-class SandboxFilesystemNotADirectoryError(modal.exception.SandboxFilesystemError)
-```
-
-Raised when a path component in the sandbox is not a directory.
-
-## modal.exception.SandboxFilesystemNotFoundError
-
-
-```python
-class SandboxFilesystemNotFoundError(modal.exception.SandboxFilesystemError)
-```
-
-Raised when a file or directory is not found in the sandbox.
-
-## modal.exception.SandboxFilesystemPathAlreadyExistsError
-
-
-```python
-class SandboxFilesystemPathAlreadyExistsError(modal.exception.SandboxFilesystemError)
-```
-
-Raised when a path already exists and the operation requires it to be absent.
-
-## modal.exception.SandboxFilesystemPermissionError
-
-
-```python
-class SandboxFilesystemPermissionError(modal.exception.SandboxFilesystemError)
-```
-
-Raised when permission is denied for a file operation in the sandbox.
-
-## modal.exception.SandboxTerminatedError
-
-
-```python
-class SandboxTerminatedError(modal.exception.Error)
-```
-
-Raised when a Sandbox is terminated for an internal reason.
-
-## modal.exception.SandboxTimeoutError
-
-
-```python
-class SandboxTimeoutError(modal.exception.TimeoutError)
-```
-
-Raised when a Sandbox exceeds its execution duration limit and times out.
-
-## modal.exception.SerializationError
-
-
-```python
-class SerializationError(modal.exception.Error)
-```
-
-Raised to provide more context when an error is encountered during serialization.
-
-## modal.exception.ServerWarning
-
-
-```python
-class ServerWarning(UserWarning)
-```
-
-Warning originating from the Modal server and re-issued in client code.
-
-## modal.exception.ServiceError
-
-
-```python
-class ServiceError(modal.exception.Error, modal.exception._GRPCErrorWrapper)
-```
-
-Raised when an error occurs in basic client/server communication.
-
-```python
-__init__(self, message=None)
-```
-
-
-### message
-
-```python
-message(self)
-```
-
-
-### status
-
-```python
-status(self)
-```
-
-
-### details
-
-```python
-details(self)
-```
-
-## modal.exception.TimeoutError
-
-
-```python
-class TimeoutError(modal.exception.Error)
-```
-
-Base class for Modal timeouts.
-
-## modal.exception.UnimplementedError
-
-
-```python
-class UnimplementedError(modal.exception.Error, modal.exception._GRPCErrorWrapper)
-```
-
-Raised when a requested operation is not implemented or not supported.
-
-```python
-__init__(self, message=None)
-```
-
-
-### message
-
-```python
-message(self)
-```
-
-
-### status
-
-```python
-status(self)
-```
-
-
-### details
-
-```python
-details(self)
-```
-
-## modal.exception.VersionError
-
-
-```python
-class VersionError(modal.exception.Error)
-```
-
-Raised when the current client version of Modal is unsupported.
-
-## modal.exception.VolumeUploadTimeoutError
-
-
-```python
-class VolumeUploadTimeoutError(modal.exception.TimeoutError)
-```
-
-Raised when a Volume upload times out.
-
-## modal.exception.WorkspaceManagementError
-
-
-```python
-class WorkspaceManagementError(modal.exception.Error)
-```
-
-Raised when an error occurs while managing a workspace.
-
-## modal.exception.simulate_preemption
-
-```python
-simulate_preemption(wait_seconds, jitter_seconds=0)
-```
-Utility for simulating a preemption interrupt after `wait_seconds` seconds.
-The first interrupt is the SIGINT signal. After 30 seconds, a second
-interrupt will trigger.
-
-This second interrupt simulates SIGKILL, and should not be caught.
-Optionally add between zero and `jitter_seconds` seconds of additional waiting before first interrupt.
-
-**Usage**
-
-```python notest
-import time
-from modal.exception import simulate_preemption
-
-simulate_preemption(3)
-
-try:
-    time.sleep(4)
-except KeyboardInterrupt:
-    print("got preempted") # Handle interrupt
-    raise
-```
-
-See https://modal.com/docs/guide/preemption for more details on preemption
-handling.

.agents/skills/modal/references/api/modal.exit.md

@@ -1,8 +0,0 @@
-# modal.exit
-
-```python
-exit(_warn_parentheses_missing=None)
-```
-Decorator for methods which should be executed when a container is about to exit.
-
-See the [lifeycle function guide](https://modal.com/docs/guide/lifecycle-functions#exit) for more information.

.agents/skills/modal/references/api/modal.fastapi_endpoint.md

@@ -1,20 +0,0 @@
-# modal.fastapi_endpoint
-
-```python
-fastapi_endpoint(*, method="GET", label=None, custom_domains=None, docs=False,
-    requires_proxy_auth=False)
-```
-Create a Web Function that can be addressed via HTTP at a public URL.
-
-Modal will internally use [FastAPI](https://fastapi.tiangolo.com/) to expose a
-simple, single request handler. If you are defining your own `FastAPI` application
-(e.g. if you want to define multiple routes), use `@modal.asgi_app` instead.
-
-The Web Function created with this decorator will automatically have
-[CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) enabled
-and can leverage many of FastAPI's features.
-
-For more information on using Modal with popular web frameworks, see our
-[guide on Web Functions](https://modal.com/docs/guide/webhooks).
-
-*Added in v0.73.82*: This function replaces the deprecated `@web_endpoint` decorator.

.agents/skills/modal/references/api/modal.file_io.md

@@ -1,152 +0,0 @@
-# modal.file_io
-
-## modal.file_io.FileIO
-
-
-```python
-class FileIO(typing.Generic)
-```
-
-[Alpha] FileIO handle, used in the Sandbox filesystem API.
-
-Deprecated on 2026-03-09. Use the `Sandbox.filesystem` APIs instead.
-
-The API is designed to mimic Python's io.FileIO.
-
-Currently this API is in Alpha and is subject to change. File I/O operations
-may be limited in size to 100 MiB, and the throughput of requests is
-restricted in the current implementation. For our recommendations on large file transfers
-see the Sandbox [filesystem access guide](https://modal.com/docs/guide/sandbox-files).
-
-**Usage**
-
-```python notest
-import modal
-
-app = modal.App.lookup("my-app", create_if_missing=True)
-
-sb = modal.Sandbox.create(app=app)
-f = sb.open("/tmp/foo.txt", "w")
-f.write("hello")
-f.close()
-```
-
-```python
-__init__(self, client, task_id)
-```
-
-
-### create
-
-```python
-create(cls, path, mode, client, task_id)
-```
-Create a new FileIO handle.
-
-### read
-
-```python
-read(self, n=None)
-```
-Read n bytes from the current position, or the entire remaining file if n is None.
-
-### readline
-
-```python
-readline(self)
-```
-Read a single line from the current position.
-
-### readlines
-
-```python
-readlines(self)
-```
-Read all lines from the current position.
-
-### write
-
-```python
-write(self, data)
-```
-Write data to the current position.
-
-Writes may not appear until the entire buffer is flushed, which
-can be done manually with `flush()` or automatically when the file is
-closed.
-
-### flush
-
-```python
-flush(self)
-```
-Flush the buffer to disk.
-
-### seek
-
-```python
-seek(self, offset, whence=0)
-```
-Move to a new position in the file.
-
-`whence` defaults to 0 (absolute file positioning); other values are 1
-(relative to the current position) and 2 (relative to the file's end).
-
-### ls
-
-```python
-ls(cls, path, client, task_id)
-```
-List the contents of the provided directory.
-
-### mkdir
-
-```python
-mkdir(cls, path, client, task_id, parents=False)
-```
-Create a new directory.
-
-### rm
-
-```python
-rm(cls, path, client, task_id, recursive=False)
-```
-Remove a file or directory in the Sandbox.
-
-### watch
-
-```python
-watch(cls, path, client, task_id, filter=None, recursive=False, timeout=None)
-```
-
-
-### close
-
-```python
-close(self)
-```
-Flush the buffer and close the file.
-## modal.file_io.ls
-
-```python
-ls(path, client, task_id)
-```
-List the contents of the provided directory.
-## modal.file_io.mkdir
-
-```python
-mkdir(path, client, task_id, parents=False)
-```
-Create a new directory.
-## modal.file_io.rm
-
-```python
-rm(path, client, task_id, recursive=False)
-```
-Remove a file or directory in the Sandbox.
-## modal.file_io.watch
-
-```python
-watch(path, client, task_id, filter=None, recursive=False, timeout=None)
-```
-Watch a file or directory for changes.

.agents/skills/modal/references/api/modal.forward.md

@@ -1,117 +0,0 @@
-# modal.forward
-
-```python
-forward(port, *, unencrypted=False, h2_enabled=False, client=None)
-```
-Expose a port publicly from inside a running Modal container, with TLS.
-
-If `unencrypted` is set, this also exposes the TCP socket without encryption on a random port
-number. This can be used to SSH into a container (see example below). Note that it is on the public Internet, so
-make sure you are using a secure protocol over TCP.
-
-If `h2_enabled` is set, the TLS server will advertise support for HTTP/2.
-
-**Important:** This is an experimental API which may change in the future.
-
-**Usage**
-
-```python notest
-import modal
-from flask import Flask
-
-app = modal.App(image=modal.Image.debian_slim().pip_install("Flask"))
-flask_app = Flask(__name__)
-
-
-@flask_app.route("/")
-def hello_world():
-    return "Hello, World!"
-
-
-@app.function()
-def run_app():
-    # Start a web server inside the container at port 8000. `modal.forward(8000)` lets us
-    # expose that port to the world at a random HTTPS URL.
-    with modal.forward(8000) as tunnel:
-        print("Server listening at", tunnel.url)
-        flask_app.run("0.0.0.0", 8000)
-
-    # When the context manager exits, the port is no longer exposed.
-```
-
-**Raw TCP usage:**
-
-```python
-import socket
-import threading
-
-import modal
-
-
-def run_echo_server(port: int):
-    """Run a TCP echo server listening on the given port."""
-    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    sock.bind(("0.0.0.0", port))
-    sock.listen(1)
-
-    while True:
-        conn, addr = sock.accept()
-        print("Connection from:", addr)
-
-        # Start a new thread to handle the connection
-        def handle(conn):
-            with conn:
-                while True:
-                    data = conn.recv(1024)
-                    if not data:
-                        break
-                    conn.sendall(data)
-
-        threading.Thread(target=handle, args=(conn,)).start()
-
-
-app = modal.App()
-
-
-@app.function()
-def tcp_tunnel():
-    # This exposes port 8000 to public Internet traffic over TCP.
-    with modal.forward(8000, unencrypted=True) as tunnel:
-        # You can connect to this TCP socket from outside the container, for example, using `nc`:
-        #  nc <HOST> <PORT>
-        print("TCP tunnel listening at:", tunnel.tcp_socket)
-        run_echo_server(8000)
-```
-
-**SSH example:**
-This assumes you have a rsa keypair in `~/.ssh/id_rsa{.pub}`, this is a bare-bones example
-letting you SSH into a Modal container.
-
-```python
-import subprocess
-import time
-
-import modal
-
-app = modal.App()
-image = (
-    modal.Image.debian_slim()
-    .apt_install("openssh-server")
-    .run_commands("mkdir /run/sshd")
-    .add_local_file("~/.ssh/id_rsa.pub", "/root/.ssh/authorized_keys", copy=True)
-)
-
-
-@app.function(image=image, timeout=3600)
-def some_function():
-    subprocess.Popen(["/usr/sbin/sshd", "-D", "-e"])
-    with modal.forward(port=22, unencrypted=True) as tunnel:
-        hostname, port = tunnel.tcp_socket
-        connection_cmd = f'ssh -p {port} root@{hostname}'
-        print(f"ssh into container using: {connection_cmd}")
-        time.sleep(3600)  # keep alive for 1 hour or until killed
-```
-
-If you intend to use this more generally, a suggestion is to put the subprocess and port
-forwarding code in an `@enter` lifecycle method of an @app.cls, to only make a single
-ssh server and port for each container (and not one for each input to the function).

.agents/skills/modal/references/api/modal.interact.md

@@ -1,9 +0,0 @@
-# modal.interact
-
-```python
-interact()
-```
-Enable interactivity with user input inside a Modal container.
-
-See the [interactivity guide](https://modal.com/docs/guide/developing-debugging#interactivity)
-for more information on how to use this function.

.agents/skills/modal/references/api/modal.io_streams.md

@@ -1,96 +0,0 @@
-# modal.io_streams
-
-## modal.io_streams.StreamReader
-
-
-```python
-class StreamReader(typing.Generic)
-```
-
-Retrieve logs from a stream (`stdout` or `stderr`).
-
-As an asynchronous iterable, the object supports the `for` and `async for`
-statements. Just loop over the object to read in chunks.
-
-
-### file_descriptor
-
-```python
-file_descriptor(self)
-```
-Possible values are `1` for stdout and `2` for stderr.
-
-### read
-
-```python
-read(self)
-```
-Fetch the entire contents of the stream until EOF.
-## modal.io_streams.StreamWriter
-
-
-```python
-class StreamWriter(object)
-```
-
-Provides an interface to buffer and write logs to a sandbox or container process stream (`stdin`).
-
-
-### write
-
-```python
-write(self, data)
-```
-Write data to the stream but does not send it immediately.
-
-This is non-blocking and queues the data to an internal buffer. Must be
-used along with the `drain()` method, which flushes the buffer.
-
-**Usage**
-
-```python fixture:sandbox
-proc = sandbox.exec(
-    "bash",
-    "-c",
-    "while read line; do echo $line; done",
-)
-proc.stdin.write(b"foo\n")
-proc.stdin.write(b"bar\n")
-proc.stdin.write_eof()
-proc.stdin.drain()
-```
-
-### write_eof
-
-```python
-write_eof(self)
-```
-Close the write end of the stream after the buffered data is drained.
-
-If the process was blocked on input, it will become unblocked after
-`write_eof()`. This method needs to be used along with the `drain()`
-method, which flushes the EOF to the process.
-
-### drain
-
-```python
-drain(self)
-```
-Flush the write buffer and send data to the running process.
-
-This is a flow control method that blocks until data is sent. It returns
-when it is appropriate to continue writing data to the stream.
-
-**Usage**
-
-```python notest
-writer.write(data)
-writer.drain()
-```
-
-Async usage:
-
-```python notest
-writer.write(data)  # not a blocking operation
-await writer.drain.aio()
-```

.agents/skills/modal/references/api/modal.is_local.md

@@ -1,11 +0,0 @@
-# modal.is_local
-
-```python
-is_local()
-```
-Indicate the execution context of the current process.
-
-Note: this function specifically returns False when the current process is
-running a Modal Function and True in all other cases. It will return True
-when called from a child process of a Function or inside a Modal Sandbox,
-even though those processes are running on Modal hardware.

.agents/skills/modal/references/api/modal.method.md

@@ -1,17 +0,0 @@
-# modal.method
-
-```python
-method(*, is_generator=None)
-```
-Decorator for methods that should be transformed into a Modal Function registered against this class's App.
-
-**Usage**
-
-```python
-@app.cls(cpu=8)
-class MyCls:
-
-    @modal.method()
-    def f(self):
-        ...
-```

.agents/skills/modal/references/api/modal.parameter.md

@@ -1,17 +0,0 @@
-# modal.parameter
-
-```python
-parameter(*, default=_no_default, init=True)
-```
-Used to specify options for modal.cls parameters, similar to dataclass.field for dataclasses
-```
-class A:
-    a: str = modal.parameter()
-
-```
-
-If `init=False` is specified, the field is not considered a parameter for the
-Modal class and not used in the synthesized constructor. This can be used to
-optionally annotate the type of a field that's used internally, for example values
-being set by @enter lifecycle methods, without breaking type checkers, but it has
-no runtime effect on the class.

.agents/skills/modal/references/api/modal.web_server.md

@@ -1,31 +0,0 @@
-# modal.web_server
-
-```python
-web_server(port, *, startup_timeout=5.0, label=None, custom_domains=None,
-    requires_proxy_auth=False)
-```
-Decorator that registers an HTTP web server inside the container.
-
-This is similar to `@modal.asgi_app` and `@modal.wsgi_app`, but it allows you to expose a full
-HTTP server listening on a container port. This is useful for servers written in other languages
-like Rust, as well as integrating with non-ASGI frameworks like aiohttp and Tornado.
-
-The above example starts a simple file server, displaying the contents of the root directory.
-Here, requests to the URL will go to external port 8000 on the container. The
-`http.server` module is included with Python, but you could run anything here.
-
-Internally, the web server is transparently converted into a Web Function by Modal, so it has
-the same serverless autoscaling behavior as other Web Functions.
-
-For more info, see the [guide on Web Functions](https://modal.com/docs/guide/webhooks).
-
-**Usage**
-
-```python
-import subprocess
-
-@app.function()
-@modal.web_server(8000)
-def my_file_server():
-    subprocess.Popen("python -m http.server -d / 8000", shell=True)
-```

.agents/skills/modal/references/api/modal.wsgi_app.md

@@ -1,25 +0,0 @@
-# modal.wsgi_app
-
-```python
-wsgi_app(*, label=None, custom_domains=None, requires_proxy_auth=False)
-```
-Decorator for registering a WSGI app with a Modal function.
-
-Web Server Gateway Interface (WSGI) is a standard for synchronous Python web apps.
-It has been [succeeded by the ASGI interface](https://asgi.readthedocs.io/en/latest/introduction.html#wsgi-compatibility)
-which is compatible with ASGI and supports additional functionality such as web sockets.
-Modal supports ASGI via [`asgi_app`](https://modal.com/docs/reference/modal.asgi_app).
-
-To learn how to use this decorator with popular web frameworks, see the
-[guide on Web Functions](https://modal.com/docs/guide/webhooks).
-
-**Usage**
-
-```python
-from typing import Callable
-
-@app.function()
-@modal.wsgi_app()
-def create_wsgi() -> Callable:
-    ...
-```