Remove serverless worker from the SDK (BREAKING)

WaveSpeed no longer offers serverless as an external product. Shipping a
serverless worker implementation in the public Python SDK advertised a
capability customers cannot actually buy, which is misleading — so the
implementation is removed rather than left in place to rot.

Removed:
- src/wavespeed/serverless/ — the whole package: serverless.start(), the
  job scaler, handler-type dispatch, worker HTTP layer, FastAPI local dev
  server, local test mode, job/worker state, heartbeat, progress reporting,
  the boto3 S3 helpers, and utils.validate.
- tests/test_serverless/ — its test suite.
- images/ — the test_worker Docker image and build/push scripts, which
  existed solely to build and exercise the worker.
- wavespeed.config.serverless plus the import-time environment detection.
  RUNPOD_* and WAVERLESS_* variables are no longer read by this package.
- .dockerignore, which only ever scoped the worker image build.

The API client is deliberately untouched: run, run_no_throw, get_result,
upload, Client, wavespeed.config.api, and the channel-attribution headers
all behave exactly as they did in 1.0.x. config.py kept its `api` class and
the install_config_module() call, so wavespeed.config.patch() still works;
only the serverless namespace and its loaders were excised.

Dependencies drop to what the client actually uses: aiohttp,
aiohttp[speedups], aiohttp-retry and boto3 were serverless-only and are
gone. typing_extensions is now declared explicitly — _config_module has
always imported it, it was just never listed.

This removes public API, so the next release is 2.0.0. Worker users should
pin wavespeed<2 and plan to migrate.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LJJXU9zyoDSBjApcUpteDt

Author: chengzeyi

.dockerignore

@@ -0,0 +1,43 @@
+# Changelog
+
+All notable changes to this project are documented here.
+
+Versions are derived from Git tags via `setuptools_scm` — see [VERSIONING.md](VERSIONING.md).
+
+## 2.0.0 — Unreleased
+
+### Removed — BREAKING
+
+**The serverless worker implementation has been removed from the SDK.**
+
+WaveSpeed no longer offers serverless as an external product, so shipping a serverless worker in
+the public SDK was misleading: it advertised a capability customers cannot buy. Everything below is
+gone as of 2.0.0 and will not be restored.
+
+- `wavespeed.serverless` — the entire package, including `serverless.start()`, the job scaler, the
+  handler-type dispatcher, the worker HTTP layer, the FastAPI local dev server, local test mode,
+  worker/job state tracking, heartbeat and progress reporting, the S3 (`boto3`) upload helpers, and
+  `wavespeed.serverless.utils.validate`.
+- `wavespeed.config.serverless` — the serverless config namespace and its import-time environment
+  auto-detection (`RUNPOD_*` and `WAVERLESS_*` variables are no longer read by this package).
+- `images/` — the `test_worker` Docker image and its build/push scripts, which existed only to
+  build and exercise the worker.
+
+Anyone building workers against this package should pin `wavespeed<2` and plan to migrate.
+
+### Changed
+
+- Dependencies trimmed to what the API client actually needs. `aiohttp`, `aiohttp[speedups]`,
+  `aiohttp-retry`, and `boto3` are no longer installed; `typing_extensions` is now declared
+  explicitly (it was already imported by `wavespeed._config_module`).
+- README and CLAUDE.md rewritten to describe an API-client-only SDK.
+
+### Unchanged
+
+The API client surface is untouched: `wavespeed.run`, `wavespeed.run_no_throw`,
+`wavespeed.get_result`, `wavespeed.upload`, `wavespeed.Client`, `wavespeed.config.api`, and the
+channel-attribution request headers all behave exactly as they did in 1.0.x.
+
+## 1.0.14 and earlier
+
+See the Git history and GitHub releases.

CHANGELOG.md

@@ -4,7 +4,11 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Project Overview
 
-WaveSpeed Python SDK - Official Python SDK for WaveSpeedAI inference platform. Provides a serverless worker implementation compatible with RunPod infrastructure.
+WaveSpeed Python SDK - Official Python SDK for the WaveSpeedAI inference platform. It is an API
+client only: it submits jobs to the hosted WaveSpeed API, polls for results, and uploads files.
+
+> As of v2.0.0 the SDK no longer ships a serverless worker implementation. WaveSpeed does not offer
+> serverless as an external product, so that code was removed rather than left in the public SDK.
 
 ## Commands
 
@@ -14,73 +18,40 @@ WaveSpeed Python SDK - Official Python SDK for WaveSpeedAI inference platform. P
 python -m pytest
 
 # Run a single test file
-python -m pytest tests/test_serverless/test_modules/test_job.py
+python -m pytest tests/test_api.py
 
 # Run a specific test
-python -m pytest tests/test_serverless/test_modules/test_job.py::TestRunJob::test_sync_handler_success -v
+python -m pytest tests/test_api.py::TestClient::test_run_success -v
 ```
 
-### Local Development
+### Linting
 ```bash
-# Install in editable mode
-pip install -e .
-
-# Run handler locally with test input
-python handler.py --test_input '{"input": {"message": "hello"}}'
-
-# Run FastAPI development server
-python handler.py --waverless_serve_api --waverless_api_port 8000
+pre-commit run --all-files
 ```
 
-### Docker (test_worker image)
+### Local Development
 ```bash
-# Build and test
-./images/test_worker/build_and_test.sh
+# Install in editable mode
+pip install -e .
 ```
 
 ## Architecture
 
-### Serverless Worker (`src/wavespeed/serverless/`)
-
-Entry point: `serverless.start({"handler": handler})` in `__init__.py`
-
-Three execution modes:
-1. **Local test mode** - `--test_input` flag or `test_input.json` file
-2. **API server mode** - `--waverless_serve_api` for FastAPI dev server
-3. **Worker mode** - Production mode polling for jobs
-
-Key modules in `modules/`:
-- `job.py` - Job execution (`run_job`, `run_job_generator`, `handle_job`)
-- `scaler.py` - Concurrent job fetching and processing (`JobScaler`)
-- `handler.py` - Handler type detection (sync/async/generator)
-- `http.py` - HTTP communication (`fetch_jobs`, `send_result`, `stream_result`)
-- `fastapi.py` - Local development API server (`WorkerAPI`)
-- `local.py` - Local test execution
-- `state.py` - Job and worker state management
-- `validator.py` - Input validation (RunPod-compatible)
-
-### Handler Types
-
-Handlers can be sync/async functions or generators:
-```python
-def sync_handler(job): return {"output": result}
-async def async_handler(job): return {"output": result}
-def generator_handler(job): yield partial_result
-async def async_gen_handler(job): yield partial_result
-```
+### API client (`src/wavespeed/api/`)
 
-### Validation (RunPod-compatible)
+- `client.py` - `Client`, the only transport. Synchronous, built on `requests`. Handles job
+  submission, result polling, terminal-status handling, file upload, and the channel-attribution
+  headers (`X-Client-Name`, etc.).
+- `__init__.py` - module-level convenience wrappers over a lazily created default `Client`:
+  `run`, `run_no_throw`, `get_result`, `upload`.
 
-```python
-from wavespeed.serverless.utils import validate
+`run` raises on failure; `run_no_throw` returns `{"status", "outputs", "task_id", "error"}` instead,
+mirroring the JavaScript SDK. `get_result` recovers a task whose local wait timed out.
 
-schema = {
-    "prompt": {"type": str, "required": True},
-    "temperature": {"type": float, "required": False, "default": 0.7, "constraints": lambda x: 0 <= x <= 2},
-}
-result = validate(job_input, schema)  # Returns {"validated_input": ...} or {"errors": [...]}
-```
+### Configuration (`src/wavespeed/config.py`)
 
-### Environment Detection
+A single `api` config class, installed as a config module by `_config_module.py` (the PyTorch-style
+`install_config_module` shim). This gives `wavespeed.config.patch(...)` as a context manager /
+decorator for tests. `Client` reads its defaults from `wavespeed.config.api`.
 
-Auto-detects RunPod (`RUNPOD_*` env vars) or native Waverless (`WAVERLESS_*` env vars) environments.
+`WAVESPEED_API_KEY` seeds `config.api.api_key` at import time.

CLAUDE.md

@@ -113,106 +113,8 @@ url = wavespeed.upload("/path/to/image.png")
 print(url)
 ```
 
-## Serverless Worker
-
-Build serverless workers for the WaveSpeed platform.
-
-### Basic Handler
-
-```python
-import wavespeed.serverless as serverless
-
-def handler(job):
-    job_input = job["input"]
-    result = job_input.get("prompt", "").upper()
-    return {"output": result}
-
-serverless.start({"handler": handler})
-```
-
-### Async Handler
-
-```python
-import wavespeed.serverless as serverless
-
-async def handler(job):
-    job_input = job["input"]
-    result = await process_async(job_input)
-    return {"output": result}
-
-serverless.start({"handler": handler})
-```
-
-### Generator Handler (Streaming)
-
-```python
-import wavespeed.serverless as serverless
-
-def handler(job):
-    for i in range(10):
-        yield {"progress": i, "partial": f"chunk-{i}"}
-
-serverless.start({"handler": handler})
-```
-
-### Input Validation
-
-```python
-from wavespeed.serverless.utils import validate
-
-INPUT_SCHEMA = {
-    "prompt": {"type": str, "required": True},
-    "max_tokens": {"type": int, "required": False, "default": 100},
-    "temperature": {
-        "type": float,
-        "required": False,
-        "default": 0.7,
-        "constraints": lambda x: 0 <= x <= 2,
-    },
-}
-
-def handler(job):
-    result = validate(job["input"], INPUT_SCHEMA)
-    if "errors" in result:
-        return {"error": result["errors"]}
-
-    validated = result["validated_input"]
-    # process with validated input...
-    return {"output": "done"}
-```
-
-### Concurrent Execution
-
-Enable concurrent job processing with `concurrency_modifier`:
-
-```python
-import wavespeed.serverless as serverless
-
-def handler(job):
-    return {"output": job["input"]["data"]}
-
-def concurrency_modifier(current_concurrency):
-    return 2  # Process 2 jobs concurrently
-
-serverless.start({
-    "handler": handler,
-    "concurrency_modifier": concurrency_modifier
-})
-```
-
 ## Local Development
 
-### Test with JSON Input
-
-```bash
-# Using CLI argument
-python handler.py --test_input '{"input": {"prompt": "hello"}}'
-
-# Using test_input.json file (auto-detected)
-echo '{"input": {"prompt": "hello"}}' > test_input.json
-python handler.py
-```
-
 ### Running Tests
 
 ```bash
@@ -226,54 +128,13 @@ python -m pytest tests/test_api.py
 python -m pytest tests/test_api.py::TestClient::test_run_success -v
 ```
 
-### FastAPI Development Server
-
-```bash
-python handler.py --waverless_serve_api --waverless_api_port 8000
-```
-
-Then use the interactive Swagger UI at `http://localhost:8000/` or make requests:
-
-```bash
-# Synchronous execution
-curl -X POST http://localhost:8000/runsync \
-  -H "Content-Type: application/json" \
-  -d '{"input": {"prompt": "hello"}}'
-
-# Async execution
-curl -X POST http://localhost:8000/run \
-  -H "Content-Type: application/json" \
-  -d '{"input": {"prompt": "hello"}}'
-```
-
-## CLI Options
-
-| Option | Description |
-|--------|-------------|
-| `--test_input JSON` | Run locally with JSON test input |
-| `--waverless_serve_api` | Start FastAPI development server |
-| `--waverless_api_host HOST` | API server host (default: localhost) |
-| `--waverless_api_port PORT` | API server port (default: 8000) |
-| `--waverless_log_level LEVEL` | Log level (DEBUG, INFO, WARN, ERROR) |
-
 ## Environment Variables
 
-### API Client
-
 | Variable | Description |
 |----------|-------------|
 | `WAVESPEED_API_KEY` | WaveSpeed API key |
 | `WAVESPEED_CLIENT_NAME` | Channel-attribution name sent as the `X-Client-Name` header (overrides the `client_name` parameter; defaults to `wavespeed-python`) |
 
-### Serverless Worker
-
-| Variable | Description |
-|----------|-------------|
-| `WAVERLESS_POD_ID` | Worker/pod identifier |
-| `WAVERLESS_API_KEY` | API authentication key |
-| `WAVERLESS_WEBHOOK_GET_JOB` | Job fetch endpoint |
-| `WAVERLESS_WEBHOOK_POST_OUTPUT` | Result submission endpoint |
-
 ## License
 
 MIT