clean

.mlx_typings/mlx_lm/generate.pyi

@@ -254,14 +254,7 @@ class BatchResponse:
 
     texts: List[str]
     stats: BatchStats
-    caches: Optional[List[List[Any]]]
 
-def _left_pad_prompts(prompts: Any, max_length: Optional[int] = ...) -> mx.array: ...
-def _right_pad_prompts(prompts: Any, max_length: Optional[int] = ...) -> mx.array: ...
-def _make_cache(
-    model: Any, left_padding: Any, max_kv_size: Optional[int]
-) -> List[Any]: ...
-def _merge_caches(caches: Any) -> List[Any]: ...
 @dataclass
 class Batch:
     uids: List[int]
@@ -270,71 +263,39 @@ class Batch:
     max_tokens: List[int]
     num_tokens: List[int]
     cache: List[Any]
-    samplers: List[Any]
-    logits_processors: List[Any]
-    tokens: List[mx.array]
-    def __len__(self) -> int: ...
-    def filter(self, keep_idx: List[int]) -> None: ...
-    def extend(self, other: "Batch") -> None: ...
-    def extract_cache(self, idx: int) -> List[Any]: ...
+    def __len__(self):  # -> int:
+        ...
+    def filter(self, keep_idx: List[int]):  # -> None:
+        ...
+    def extend(self, other):  # -> None:
+        ...
 
 class BatchGenerator:
-    model: Any
-    max_kv_size: Optional[int]
-    prefill_step_size: int
-    unprocessed_prompts: List[Any]
-    active_batch: Optional[Batch]
-    prompt_progress_callback: Callable[[List[Tuple[int, int, int]]], None]
-    _stats: BatchStats
-
     @dataclass
     class Response:
         uid: int
         token: int
         logprobs: mx.array
         finish_reason: Optional[str]
-        prompt_cache: Any
 
     def __init__(
         self,
-        model: Any,
+        model,
         max_tokens: int = ...,
-        stop_tokens: Optional[set[int]] = ...,
+        stop_tokens: Optional[set] = ...,
         sampler: Optional[Callable[[mx.array], mx.array]] = ...,
-        logits_processors: Optional[
-            List[Callable[[mx.array, mx.array], mx.array]]
-        ] = ...,
         completion_batch_size: int = ...,
         prefill_batch_size: int = ...,
         prefill_step_size: int = ...,
-        prompt_progress_callback: Optional[
-            Callable[[List[Tuple[int, int, int]]], None]
-        ] = ...,
-        max_kv_size: Optional[int] = ...,
     ) -> None: ...
-    def close(self) -> None: ...
     def insert(
-        self,
-        prompts: Any,
-        max_tokens: Union[List[int], int, None] = ...,
-        caches: Any = ...,
-        samplers: Optional[List[Any]] = ...,
-        logits_processors: Optional[List[Any]] = ...,
-    ) -> List[int]: ...
-    def remove(
-        self, uids: List[int], return_prompt_caches: bool = ...
-    ) -> Optional[dict[int, List[Any]]]: ...
-    def stats(self) -> BatchStats: ...
-    def next(self) -> List[Response]: ...
-    def _process_prompts(self, prompts: List[Any]) -> Batch: ...
-    def _step(
-        self,
-        input_tokens: mx.array,
-        prompt_cache: List[Any],
-        samplers: Optional[List[Any]],
-        logits_processors: Optional[List[Any]],
-        tokens: List[mx.array],
-    ) -> Tuple[mx.array, List[mx.array]]: ...
+        self, prompts, max_tokens: Union[List[int], int, None] = ...
+    ):  # -> list[Any]:
+        ...
+    def stats(self):  # -> BatchStats:
+        ...
+    def next(self):  # -> list[Any]:
+        ...
 
 def batch_generate(
     model,

.mlx_typings/mlx_lm/models/cache.pyi

@@ -170,15 +170,7 @@ class KVCache(_BaseCache):
 
 class RotatingKVCache(_BaseCache):
     step = ...
-    keys: mx.array | None
-    values: mx.array | None
-    keep: int
-    max_size: int
-    _idx: int
     def __init__(self, max_size, keep=...) -> None: ...
-    def _trim(
-        self, trim_size: int, v: mx.array, append: mx.array | None = ...
-    ) -> mx.array: ...
     def update_and_fetch(
         self, keys, values
     ):  # -> tuple[array | Any, array | Any] | tuple[array | Any, array | Any | None]:

.mlx_typings/mlx_lm/sample_utils.pyi

@@ -48,7 +48,7 @@ def make_logits_processors(
     logit_bias: Optional[Dict[int, float]] = ...,
     repetition_penalty: Optional[float] = ...,
     repetition_context_size: Optional[int] = ...,
-) -> list[Callable[[mx.array, mx.array], mx.array]]:
+):  # -> list[Any]:
     """
     Make logits processors for use with ``generate_step``.
 

CONTRIBUTING.md

@@ -39,119 +39,6 @@ Write pure functions where possible. When adding new code, prefer Rust unless th
 
 Run `nix fmt` to auto-format your code before submitting.
 
-## Model Cards
-
-EXO uses TOML-based model cards to define model metadata and capabilities. Model cards are stored in:
-- `resources/inference_model_cards/` for text generation models
-- `resources/image_model_cards/` for image generation models
-- `~/.exo/custom_model_cards/` for user-added custom models
-
-### Adding a Model Card
-
-To add a new model, create a TOML file with the following structure:
-
-```toml
-model_id = "mlx-community/Llama-3.2-1B-Instruct-4bit"
-n_layers = 16
-hidden_size = 2048
-supports_tensor = true
-tasks = ["TextGeneration"]
-family = "llama"
-quantization = "4bit"
-base_model = "Llama 3.2 1B"
-capabilities = ["text"]
-
-[storage_size]
-in_bytes = 729808896
-```
-
-### Required Fields
-
-- `model_id`: Hugging Face model identifier
-- `n_layers`: Number of transformer layers
-- `hidden_size`: Hidden dimension size
-- `supports_tensor`: Whether the model supports tensor parallelism
-- `tasks`: List of supported tasks (`TextGeneration`, `TextToImage`, `ImageToImage`)
-- `family`: Model family (e.g., "llama", "deepseek", "qwen")
-- `quantization`: Quantization level (e.g., "4bit", "8bit", "bf16")
-- `base_model`: Human-readable base model name
-- `capabilities`: List of capabilities (e.g., `["text"]`, `["text", "thinking"]`)
-
-### Optional Fields
-
-- `components`: For multi-component models (like image models with separate text encoders and transformers)
-- `uses_cfg`: Whether the model uses classifier-free guidance (for image models)
-- `trust_remote_code`: Whether to allow remote code execution (defaults to `false` for security)
-
-### Capabilities
-
-The `capabilities` field defines what the model can do:
-- `text`: Standard text generation
-- `thinking`: Model supports chain-of-thought reasoning
-- `thinking_toggle`: Thinking can be enabled/disabled via `enable_thinking` parameter
-- `image_edit`: Model supports image-to-image editing (FLUX.1-Kontext)
-
-### Security Note
-
-By default, `trust_remote_code` is set to `false` for security. Only enable it if the model explicitly requires remote code execution from the Hugging Face hub.
-
-## API Adapters
-
-EXO supports multiple API formats through an adapter pattern. Adapters convert API-specific request formats to the internal `TextGenerationTaskParams` format and convert internal token chunks back to API-specific responses.
-
-### Adapter Architecture
-
-All adapters live in `src/exo/master/adapters/` and follow the same pattern:
-
-1. Convert API-specific requests to `TextGenerationTaskParams`
-2. Handle both streaming and non-streaming response generation
-3. Convert internal `TokenChunk` objects to API-specific formats
-4. Manage error handling and edge cases
-
-### Existing Adapters
-
-- `chat_completions.py`: OpenAI Chat Completions API
-- `claude.py`: Anthropic Claude Messages API
-- `responses.py`: OpenAI Responses API
-- `ollama.py`: Ollama API (for OpenWebUI compatibility)
-
-### Adding a New API Adapter
-
-To add support for a new API format:
-
-1. Create a new adapter file in `src/exo/master/adapters/`
-2. Implement a request conversion function:
-   ```python
-   def your_api_request_to_text_generation(
-       request: YourAPIRequest,
-   ) -> TextGenerationTaskParams:
-       # Convert API request to internal format
-       pass
-   ```
-3. Implement streaming response generation:
-   ```python
-   async def generate_your_api_stream(
-       command_id: CommandId,
-       chunk_stream: AsyncGenerator[TokenChunk | ErrorChunk | ToolCallChunk, None],
-   ) -> AsyncGenerator[str, None]:
-       # Convert internal chunks to API-specific streaming format
-       pass
-   ```
-4. Implement non-streaming response collection:
-   ```python
-   async def collect_your_api_response(
-       command_id: CommandId,
-       chunk_stream: AsyncGenerator[TokenChunk | ErrorChunk | ToolCallChunk, None],
-   ) -> AsyncGenerator[str]:
-       # Collect all chunks and return single response
-       pass
-   ```
-5. Register the adapter endpoints in `src/exo/master/api.py`
-
-The adapter pattern keeps API-specific logic isolated from core inference systems. Internal systems (worker, runner, event sourcing) only see `TextGenerationTaskParams` and `TokenChunk` objects - no API-specific types cross the adapter boundary.
-
-For detailed API documentation, see [docs/api.md](docs/api.md).
-
 ## Testing
 
 EXO relies heavily on manual testing at this point in the project, but this is evolving. Before submitting a change, test both before and after to demonstrate how your change improves behavior. Do the best you can with the hardware you have available - if you need help testing, ask and we'll do our best to assist. Add automated tests where possible - we're actively working to substantially improve our automated testing story.

Cargo.toml

@@ -1,6 +1,9 @@
 [workspace]
 resolver = "3"
-members = ["rust/networking", "rust/exo_pyo3_bindings", "rust/util"]
+members = [
+    "rust/networking",
+    "rust/exo_pyo3_bindings",
+]
 
 [workspace.package]
 version = "0.0.1"
@@ -20,7 +23,6 @@ opt-level = 3
 [workspace.dependencies]
 ## Crate members as common dependencies
 networking = { path = "rust/networking" }
-util = { path = "rust/util" }
 
 # Macro dependecies
 extend = "1.2"

README.md

@@ -26,8 +26,6 @@ exo connects all your devices into an AI cluster. Not only does exo enable runni
 - **Topology-Aware Auto Parallel**: exo figures out the best way to split your model across all available devices based on a realtime view of your device topology. It takes into account device resources and network latency/bandwidth between each link.
 - **Tensor Parallelism**: exo supports sharding models, for up to 1.8x speedup on 2 devices and 3.2x speedup on 4 devices.
 - **MLX Support**: exo uses [MLX](https://github.com/ml-explore/mlx) as an inference backend and [MLX distributed](https://ml-explore.github.io/mlx/build/html/usage/distributed.html) for distributed communication.
-- **Multiple API Compatibility**: Compatible with OpenAI Chat Completions API, Claude Messages API, OpenAI Responses API, and Ollama API - use your existing tools and clients.
-- **Custom Model Support**: Load custom models from HuggingFace hub to expand the range of available models.
 
 ## Dashboard
 
@@ -198,8 +196,6 @@ exo follows the [XDG Base Directory Specification](https://specifications.freede
 - **Configuration files**: `~/.config/exo/` (or `$XDG_CONFIG_HOME/exo/`)
 - **Data files**: `~/.local/share/exo/` (or `$XDG_DATA_HOME/exo/`)
 - **Cache files**: `~/.cache/exo/` (or `$XDG_CACHE_HOME/exo/`)
-- **Log files**: `~/.cache/exo/exo_log/` (with automatic log rotation)
-- **Custom model cards**: `~/.local/share/exo/custom_model_cards/`
 
 You can override these locations by setting the corresponding XDG environment variables.
 
@@ -279,47 +275,8 @@ After that, RDMA will be enabled in macOS and exo will take care of the rest.
 
 ---
 
-## Environment Variables
-
-exo supports several environment variables for configuration:
-
-| Variable | Description | Default |
-|----------|-------------|---------|
-| `EXO_MODELS_PATH` | Colon-separated paths to search for pre-downloaded models (e.g., on NFS mounts or shared storage) | None |
-| `EXO_MODELS_DIR` | Directory where exo downloads and stores models | `~/.local/share/exo/models` (Linux) or `~/.exo/models` (macOS) |
-| `EXO_OFFLINE` | Run without internet connection (uses only local models) | `false` |
-| `EXO_ENABLE_IMAGE_MODELS` | Enable image model support | `false` |
-| `EXO_LIBP2P_NAMESPACE` | Custom namespace for cluster isolation | None |
-| `EXO_FAST_SYNCH` | Control MLX_METAL_FAST_SYNCH behavior (for JACCL backend) | Auto |
-| `EXO_TRACING_ENABLED` | Enable distributed tracing for performance analysis | `false` |
-
-**Example usage:**
-
-```bash
-# Use pre-downloaded models from NFS mount
-EXO_MODELS_PATH=/mnt/nfs/models:/opt/ai-models uv run exo
-
-# Run in offline mode
-EXO_OFFLINE=true uv run exo
-
-# Enable image models
-EXO_ENABLE_IMAGE_MODELS=true uv run exo
-
-# Use custom namespace for cluster isolation
-EXO_LIBP2P_NAMESPACE=my-dev-cluster uv run exo
-```
-
----
-
 ### Using the API
 
-exo provides multiple API-compatible interfaces for maximum compatibility with existing tools:
-
-- **OpenAI Chat Completions API** - Compatible with OpenAI clients
-- **Claude Messages API** - Compatible with Anthropic's Claude format
-- **OpenAI Responses API** - Compatible with OpenAI's Responses format
-- **Ollama API** - Compatible with Ollama and tools like OpenWebUI
-
 If you prefer to interact with exo via the API, here is an example creating an instance of a small model (`mlx-community/Llama-3.2-1B-Instruct-4bit`), sending a chat completions request and deleting the instance.
 
 ---
@@ -409,85 +366,14 @@ When you're done, delete the instance by its ID (find it via `/state` or `/insta
 curl -X DELETE http://localhost:52415/instance/YOUR_INSTANCE_ID
 ```
 
-### Claude Messages API Compatibility
-
-Use the Claude Messages API format with the `/v1/messages` endpoint:
-
-```bash
-curl -N -X POST http://localhost:52415/v1/messages \
-  -H 'Content-Type: application/json' \
-  -d '{
-    "model": "mlx-community/Llama-3.2-1B-Instruct-4bit",
-    "messages": [
-      {"role": "user", "content": "Hello"}
-    ],
-    "max_tokens": 1024,
-    "stream": true
-  }'
-```
-
-### OpenAI Responses API Compatibility
-
-Use the OpenAI Responses API format with the `/v1/responses` endpoint:
-
-```bash
-curl -N -X POST http://localhost:52415/v1/responses \
-  -H 'Content-Type: application/json' \
-  -d '{
-    "model": "mlx-community/Llama-3.2-1B-Instruct-4bit",
-    "messages": [
-      {"role": "user", "content": "Hello"}
-    ],
-    "stream": true
-  }'
-```
-
-### Ollama API Compatibility
-
-exo supports Ollama API endpoints for compatibility with tools like OpenWebUI:
-
-```bash
-# Ollama chat
-curl -X POST http://localhost:52415/ollama/api/chat \
-  -H 'Content-Type: application/json' \
-  -d '{
-    "model": "mlx-community/Llama-3.2-1B-Instruct-4bit",
-    "messages": [
-      {"role": "user", "content": "Hello"}
-    ],
-    "stream": false
-  }'
-
-# List models (Ollama format)
-curl http://localhost:52415/ollama/api/tags
-```
-
-### Custom Model Loading from HuggingFace
-
-You can add custom models from the HuggingFace hub:
-
-```bash
-curl -X POST http://localhost:52415/models/add \
-  -H 'Content-Type: application/json' \
-  -d '{
-    "model_id": "mlx-community/my-custom-model"
-  }'
-```
-
-**Security Note:**
-
-Custom models requiring `trust_remote_code` in their configuration must be explicitly enabled (default is false) for security. Only enable this if you trust the model's remote code execution. Models are fetched from HuggingFace and stored locally as custom model cards.
-
 **Other useful API endpoints*:**
 
 - List all models: `curl http://localhost:52415/models`
-- List downloaded models only: `curl http://localhost:52415/models?status=downloaded`
-- Search HuggingFace: `curl "http://localhost:52415/models/search?query=llama&limit=10"`
 - Inspect instance IDs and deployment state: `curl http://localhost:52415/state`
 
 For further details, see:
 
-- API documentation in [docs/api.md](docs/api.md).
+- API basic documentation in [docs/api.md](docs/api.md).
 - API types and endpoints in [src/exo/master/api.py](src/exo/master/api.py).
 
 ---
@@ -546,4 +432,4 @@ On macOS, exo uses the GPU. On Linux, exo currently runs on CPU. We are working
 
 ## Contributing
 
-See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines on how to contribute to exo.
+See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines on how to contribute to exo.

bench/eval_configs/models.toml

@@ -1,292 +0,0 @@
-# Model evaluation configurations for exo_eval.
-#
-# Each [[model]] entry uses `patterns` — a list of substrings matched
-# against the model_id. First matching entry wins.
-#
-# Required fields:
-#   name, patterns, reasoning
-#
-# Optional per-model overrides (CLI flags take priority over these):
-#   temperature, top_p, max_tokens, reasoning_effort
-#
-# Fallback defaults (when no per-model config):
-#   reasoning:     temperature=1.0, max_tokens=131072, reasoning_effort="high"
-#   non-reasoning: temperature=0.0, max_tokens=16384
-#
-# All per-model values below are sourced from official model cards,
-# generation_config.json files, and vendor documentation.
-
-# ─── Qwen3.5 (Feb 2026) ─────────────────────────────────────────────
-# Source: HuggingFace model cards (Qwen/Qwen3.5-*)
-# 35B-A3B thinking general: temp=1.0, top_p=0.95, top_k=20
-# 397B thinking: temp=0.6, top_p=0.95, top_k=20
-# Non-thinking: temp=0.7, top_p=0.8, top_k=20
-# max_tokens: 32768 general, 81920 for complex math/code
-
-[[model]]
-name = "Qwen3.5 2B"
-patterns = ["Qwen3.5-2B"]
-reasoning = true
-temperature = 0.6
-top_p = 0.95
-max_tokens = 81920
-
-[[model]]
-name = "Qwen3.5 9B"
-patterns = ["Qwen3.5-9B"]
-reasoning = true
-temperature = 0.6
-top_p = 0.95
-max_tokens = 81920
-
-[[model]]
-name = "Qwen3.5 27B"
-patterns = ["Qwen3.5-27B"]
-reasoning = true
-temperature = 0.6
-top_p = 0.95
-max_tokens = 81920
-
-[[model]]
-name = "Qwen3.5 35B A3B"
-patterns = ["Qwen3.5-35B-A3B"]
-reasoning = true
-temperature = 1.0
-top_p = 0.95
-max_tokens = 81920
-
-[[model]]
-name = "Qwen3.5 122B A10B"
-patterns = ["Qwen3.5-122B-A10B"]
-reasoning = true
-temperature = 0.6
-top_p = 0.95
-max_tokens = 81920
-
-[[model]]
-name = "Qwen3.5 397B A17B"
-patterns = ["Qwen3.5-397B-A17B"]
-reasoning = true
-temperature = 0.6
-top_p = 0.95
-max_tokens = 81920
-
-# ─── Qwen3 (Apr 2025) ───────────────────────────────────────────────
-# Source: HuggingFace model cards (Qwen/Qwen3-*)
-# Thinking: temp=0.6, top_p=0.95, top_k=20
-# Non-thinking: temp=0.7, top_p=0.8, top_k=20
-# max_tokens: 32768 general, 38912 for complex math/code
-
-[[model]]
-name = "Qwen3 0.6B"
-patterns = ["Qwen3-0.6B"]
-reasoning = true
-temperature = 0.6
-top_p = 0.95
-max_tokens = 38912
-
-[[model]]
-name = "Qwen3 30B A3B"
-patterns = ["Qwen3-30B-A3B"]
-reasoning = true
-temperature = 0.6
-top_p = 0.95
-max_tokens = 38912
-
-[[model]]
-name = "Qwen3 235B A22B"
-patterns = ["Qwen3-235B-A22B"]
-reasoning = true
-temperature = 0.6
-top_p = 0.95
-max_tokens = 38912
-
-[[model]]
-name = "Qwen3 Next 80B Thinking"
-patterns = ["Qwen3-Next-80B-A3B-Thinking"]
-reasoning = true
-temperature = 0.6
-top_p = 0.95
-max_tokens = 38912
-
-[[model]]
-name = "Qwen3 Next 80B Instruct"
-patterns = ["Qwen3-Next-80B-A3B-Instruct"]
-reasoning = false
-temperature = 0.7
-top_p = 0.8
-max_tokens = 16384
-
-[[model]]
-name = "Qwen3 Coder 480B"
-patterns = ["Qwen3-Coder-480B"]
-reasoning = false
-temperature = 0.7
-top_p = 0.8
-max_tokens = 16384
-
-[[model]]
-name = "Qwen3 Coder Next"
-patterns = ["Qwen3-Coder-Next"]
-reasoning = false
-temperature = 0.7
-top_p = 0.8
-max_tokens = 16384
-
-# ─── GPT-OSS (OpenAI) ───────────────────────────────────────────────
-# Source: OpenAI GitHub README + HuggingFace discussion #21
-# temp=1.0, top_p=1.0, NO top_k, NO repetition_penalty
-# reasoning_effort supported: low/medium/high
-
-[[model]]
-name = "GPT-OSS 20B"
-patterns = ["gpt-oss-20b"]
-reasoning = true
-temperature = 1.0
-top_p = 1.0
-
-[[model]]
-name = "GPT-OSS 120B"
-patterns = ["gpt-oss-120b"]
-reasoning = true
-temperature = 1.0
-top_p = 1.0
-
-# ─── DeepSeek ────────────────────────────────────────────────────────
-# Source: https://api-docs.deepseek.com/quick_start/parameter_settings
-# Coding/Math: temp=0.0, General: temp=1.3, Creative: temp=1.5
-# NOTE: DeepSeek API applies nonlinear temp mapping. These are API values.
-# When running model directly: API temp 1.0 = model temp 0.3
-# We use temp=0.0 for eval (coding/math focus).
-
-[[model]]
-name = "DeepSeek V3.1"
-patterns = ["DeepSeek-V3.1"]
-reasoning = true
-temperature = 0.0
-
-# ─── GLM (ZhipuAI / THUDM) ──────────────────────────────────────────
-# Source: HuggingFace model cards + generation_config.json + docs.z.ai
-# GLM 4.5+: temp=1.0, top_p=0.95
-# Reasoning tasks: 131072 max_tokens; coding/SWE tasks: temp=0.7
-
-[[model]]
-name = "GLM-5"
-patterns = ["GLM-5"]
-reasoning = true
-temperature = 1.0
-top_p = 0.95
-max_tokens = 131072
-
-[[model]]
-name = "GLM 4.5 Air"
-patterns = ["GLM-4.5-Air"]
-reasoning = true
-temperature = 1.0
-top_p = 0.95
-
-[[model]]
-name = "GLM 4.7"
-patterns = ["GLM-4.7-"]
-reasoning = true
-temperature = 1.0
-top_p = 0.95
-max_tokens = 131072
-# Note: matches both GLM-4.7 and GLM-4.7-Flash
-
-# ─── Kimi (Moonshot AI) ─────────────────────────────────────────────
-# Source: HuggingFace model cards (moonshotai/Kimi-K2-*)
-# K2-Instruct: temp=0.6
-# K2-Thinking: temp=1.0, max_length=262144
-# K2.5: thinking temp=1.0, top_p=0.95; instant temp=0.6, top_p=0.95
-
-[[model]]
-name = "Kimi K2 Thinking"
-patterns = ["Kimi-K2-Thinking"]
-reasoning = true
-temperature = 1.0
-max_tokens = 131072
-
-[[model]]
-name = "Kimi K2.5"
-patterns = ["Kimi-K2.5"]
-reasoning = true
-temperature = 1.0
-top_p = 0.95
-max_tokens = 131072
-
-[[model]]
-name = "Kimi K2 Instruct"
-patterns = ["Kimi-K2-Instruct"]
-reasoning = false
-temperature = 0.6
-
-# ─── MiniMax ─────────────────────────────────────────────────────────
-# Source: HuggingFace model cards + generation_config.json
-# All models: temp=1.0, top_p=0.95, top_k=40
-
-[[model]]
-name = "MiniMax M2.5"
-patterns = ["MiniMax-M2.5"]
-reasoning = true
-temperature = 1.0
-top_p = 0.95
-
-[[model]]
-name = "MiniMax M2.1"
-patterns = ["MiniMax-M2.1"]
-reasoning = true
-temperature = 1.0
-top_p = 0.95
-
-# ─── Step (StepFun) ─────────────────────────────────────────────────
-# Source: HuggingFace model card (stepfun-ai/Step-3.5-Flash)
-# Reasoning: temp=1.0, top_p=0.95
-# General chat: temp=0.6, top_p=0.95
-# We use reasoning settings for eval.
-
-[[model]]
-name = "Step 3.5 Flash"
-patterns = ["Step-3.5-Flash"]
-reasoning = true
-temperature = 1.0
-top_p = 0.95
-
-# ─── Llama (Meta) ───────────────────────────────────────────────────
-# Source: generation_config.json + meta-llama/llama-models generation.py
-# All variants: temp=0.6, top_p=0.9
-
-[[model]]
-name = "Llama 3.2 1B"
-patterns = ["Llama-3.2-1B"]
-reasoning = false
-temperature = 0.6
-top_p = 0.9
-
-[[model]]
-name = "Llama 3.2 3B"
-patterns = ["Llama-3.2-3B"]
-reasoning = false
-temperature = 0.6
-top_p = 0.9
-
-[[model]]
-name = "Llama 3.1 8B"
-patterns = ["Llama-3.1-8B", "Meta-Llama-3.1-8B"]
-reasoning = false
-temperature = 0.6
-top_p = 0.9
-
-[[model]]
-name = "Llama 3.1 70B"
-patterns = ["Llama-3.1-70B", "Meta-Llama-3.1-70B"]
-reasoning = false
-temperature = 0.6
-top_p = 0.9
-
-[[model]]
-name = "Llama 3.3 70B"
-patterns = ["Llama-3.3-70B", "llama-3.3-70b"]
-reasoning = false
-temperature = 0.6
-top_p = 0.9

bench/exo_bench.py

@@ -24,7 +24,6 @@ import json
 import sys
 import time
 from collections.abc import Callable
-from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 from statistics import mean
 from typing import Any
@@ -253,12 +252,6 @@ def main() -> int:
     ap.add_argument(
         "--repeat", type=int, default=1, help="Repetitions per (pp,tg) pair."
     )
-    ap.add_argument(
-        "--concurrency",
-        nargs="+",
-        default=["1"],
-        help="Concurrency levels (ints). Accepts commas. E.g. --concurrency 1,2,4,8. Default 1.",
-    )
     ap.add_argument(
         "--warmup",
         type=int,
@@ -289,10 +282,6 @@ def main() -> int:
     if args.repeat <= 0:
         logger.error("--repeat must be >= 1")
         return 2
-    concurrency_list = parse_int_list(args.concurrency)
-    if not concurrency_list or any(c <= 0 for c in concurrency_list):
-        logger.error("--concurrency values must be >= 1")
-        return 2
 
     # Log pairing mode
     use_combinations = args.all_combinations or len(pp_list) != len(tg_list)
@@ -304,9 +293,7 @@ def main() -> int:
         logger.info(f"pp/tg mode: tandem (zip) - {len(pp_list)} pairs")
 
     client = ExoClient(args.host, args.port, timeout_s=args.timeout)
-    short_id, full_model_id = resolve_model_short_id(
-        client, args.model, force_download=args.force_download
-    )
+    short_id, full_model_id = resolve_model_short_id(client, args.model)
 
     tokenizer = load_tokenizer_for_bench(full_model_id)
     if tokenizer is None:
@@ -405,123 +392,52 @@ def main() -> int:
                 pp_tg_pairs = list(zip(pp_list, tg_list, strict=True))
 
             for pp, tg in pp_tg_pairs:
-                for concurrency in concurrency_list:
-                    logger.info(f"--- pp={pp} tg={tg} concurrency={concurrency} ---")
-                    runs: list[dict[str, Any]] = []
-                    for r in range(args.repeat):
-                        time.sleep(3)
-
-                        if concurrency <= 1:
-                            # Sequential: single request
-                            try:
-                                row, actual_pp_tokens = run_one_completion(
-                                    client, full_model_id, pp, tg, prompt_sizer
-                                )
-                            except Exception as e:
-                                logger.error(e)
-                                continue
-                            row.update(
-                                {
-                                    "model_short_id": short_id,
-                                    "model_id": full_model_id,
-                                    "placement_sharding": sharding,
-                                    "placement_instance_meta": instance_meta,
-                                    "placement_nodes": n_nodes,
-                                    "instance_id": instance_id,
-                                    "pp_tokens": actual_pp_tokens,
-                                    "tg": tg,
-                                    "repeat_index": r,
-                                    "concurrency": 1,
-                                    **(
-                                        {"download_duration_s": download_duration_s}
-                                        if download_duration_s is not None
-                                        else {}
-                                    ),
-                                }
-                            )
-                            runs.append(row)
-                            all_rows.append(row)
-                        else:
-                            # Concurrent: fire N requests in parallel
-                            # Each thread gets its own ExoClient (separate HTTP connection)
-                            batch_results: list[tuple[dict[str, Any], int]] = []
-                            batch_errors = 0
-
-                            def _run_concurrent(
-                                idx: int, *, _pp: int = pp, _tg: int = tg
-                            ) -> tuple[dict[str, Any], int]:
-                                c = ExoClient(
-                                    args.host, args.port, timeout_s=args.timeout
-                                )
-                                return run_one_completion(
-                                    c, full_model_id, _pp, _tg, prompt_sizer
-                                )
-
-                            with ThreadPoolExecutor(max_workers=concurrency) as pool:
-                                futures = {
-                                    pool.submit(_run_concurrent, i): i
-                                    for i in range(concurrency)
-                                }
-                                for fut in as_completed(futures):
-                                    try:
-                                        batch_results.append(fut.result())
-                                    except Exception as e:
-                                        logger.error(f"Concurrent request failed: {e}")
-                                        batch_errors += 1
-
-                            for idx, (row, actual_pp_tokens) in enumerate(
-                                batch_results
-                            ):
-                                row.update(
-                                    {
-                                        "model_short_id": short_id,
-                                        "model_id": full_model_id,
-                                        "placement_sharding": sharding,
-                                        "placement_instance_meta": instance_meta,
-                                        "placement_nodes": n_nodes,
-                                        "instance_id": instance_id,
-                                        "pp_tokens": actual_pp_tokens,
-                                        "tg": tg,
-                                        "repeat_index": r,
-                                        "concurrency": concurrency,
-                                        "concurrent_index": idx,
-                                        **(
-                                            {"download_duration_s": download_duration_s}
-                                            if download_duration_s is not None
-                                            else {}
-                                        ),
-                                    }
-                                )
-                                runs.append(row)
-                                all_rows.append(row)
-
-                            if batch_results:
-                                agg_gen_tps = sum(
-                                    x["stats"]["generation_tps"]
-                                    for x, _ in batch_results
-                                    if x["stats"]["generation_tps"] > 0
-                                )
-                                logger.info(
-                                    f"[concurrent {concurrency}x]  "
-                                    f"agg_gen_tps={agg_gen_tps:.2f}  "
-                                    f"errors={batch_errors}"
-                                )
-
-                    if runs:
-                        prompt_tps = mean(x["stats"]["prompt_tps"] for x in runs)
-                        gen_tps = mean(x["stats"]["generation_tps"] for x in runs)
-                        ptok = mean(x["stats"]["prompt_tokens"] for x in runs)
-                        gtok = mean(x["stats"]["generation_tokens"] for x in runs)
-                        peak = mean(
-                            x["stats"]["peak_memory_usage"]["inBytes"] for x in runs
+                runs: list[dict[str, Any]] = []
+                for r in range(args.repeat):
+                    time.sleep(3)
+                    try:
+                        row, actual_pp_tokens = run_one_completion(
+                            client, full_model_id, pp, tg, prompt_sizer
                         )
+                    except Exception as e:
+                        logger.error(e)
+                        continue
+                    row.update(
+                        {
+                            "model_short_id": short_id,
+                            "model_id": full_model_id,
+                            "placement_sharding": sharding,
+                            "placement_instance_meta": instance_meta,
+                            "placement_nodes": n_nodes,
+                            "instance_id": instance_id,
+                            "pp_tokens": actual_pp_tokens,
+                            "tg": tg,
+                            "repeat_index": r,
+                            **(
+                                {"download_duration_s": download_duration_s}
+                                if download_duration_s is not None
+                                else {}
+                            ),
+                        }
+                    )
+                    runs.append(row)
+                    all_rows.append(row)
 
-                        logger.info(
-                            f"prompt_tps={prompt_tps:.2f} gen_tps={gen_tps:.2f}    "
-                            f"prompt_tokens={ptok} gen_tokens={gtok}    "
-                            f"peak_memory={format_peak_memory(peak)}\n"
-                        )
-                    time.sleep(2)
+                if runs:
+                    prompt_tps = mean(x["stats"]["prompt_tps"] for x in runs)
+                    gen_tps = mean(x["stats"]["generation_tps"] for x in runs)
+                    ptok = mean(x["stats"]["prompt_tokens"] for x in runs)
+                    gtok = mean(x["stats"]["generation_tokens"] for x in runs)
+                    peak = mean(
+                        x["stats"]["peak_memory_usage"]["inBytes"] for x in runs
+                    )
+
+                    logger.info(
+                        f"prompt_tps={prompt_tps:.2f} gen_tps={gen_tps:.2f}    "
+                        f"prompt_tokens={ptok} gen_tokens={gtok}    "
+                        f"peak_memory={format_peak_memory(peak)}\n"
+                    )
+                time.sleep(2)
         finally:
             try:
                 client.request_json("DELETE", f"/instance/{instance_id}")

bench/harness.py

@@ -165,9 +165,7 @@ def wait_for_instance_gone(
     raise TimeoutError(f"Instance {instance_id} did not get deleted within {timeout=}")
 
 
-def resolve_model_short_id(
-    client: ExoClient, model_arg: str, *, force_download: bool = False
-) -> tuple[str, str]:
+def resolve_model_short_id(client: ExoClient, model_arg: str) -> tuple[str, str]:
     models = client.request_json("GET", "/models") or {}
     data = models.get("data") or []
 
@@ -183,16 +181,6 @@ def resolve_model_short_id(
             full_id = str(m["hugging_face_id"])
             return short_id, full_id
 
-    if force_download and "/" in model_arg:
-        logger.info(f"Model not in /models, adding from HuggingFace: {model_arg}")
-        result = client.request_json(
-            "POST", "/models/add", body={"model_id": model_arg}
-        )
-        if result:
-            short_id = str(result.get("name") or model_arg.rsplit("/", 1)[-1])
-            full_id = str(result.get("hugging_face_id") or model_arg)
-            return short_id, full_id
-
     raise ValueError(f"Model not found in /models: {model_arg}")
 
 
@@ -457,11 +445,6 @@ def add_common_instance_args(ap: argparse.ArgumentParser) -> None:
         "--port", type=int, default=int(os.environ.get("EXO_PORT", "52415"))
     )
     ap.add_argument("--model", required=True, help="Model short id or huggingface id")
-    ap.add_argument(
-        "--force-download",
-        action="store_true",
-        help="If model not in /models, add it from HuggingFace via exo and download.",
-    )
     ap.add_argument(
         "--max-nodes",
         type=int,

bench/parallel_requests.py

@@ -1,255 +0,0 @@
-# type: ignore
-import argparse
-import asyncio
-import sys
-import termios
-import time
-import tty
-
-import aiohttp
-
-NUM_REQUESTS = 10
-BASE_URL = ""
-
-QUESTIONS = [
-    "What is the capital of Australia?",
-    "How many bones are in the human body?",
-    "What year did World War II end?",
-    "What is the speed of light in meters per second?",
-    "Who wrote Romeo and Juliet?",
-    "What is the chemical formula for water?",
-    "How many planets are in our solar system?",
-    "What is the largest ocean on Earth?",
-    "Who painted the Mona Lisa?",
-    "What is the boiling point of water in Celsius?",
-]
-
-
-def write(s: str) -> None:
-    sys.stdout.write(s)
-
-
-# ---------------------------------------------------------------------------
-# Model picker (same style as exo_eval)
-# ---------------------------------------------------------------------------
-
-
-def fetch_models() -> list[str]:
-    import json
-    import urllib.request
-
-    with urllib.request.urlopen(f"{BASE_URL}/state") as resp:
-        data = json.loads(resp.read())
-    model_ids: set[str] = set()
-    for instance in data.get("instances", {}).values():
-        for variant in instance.values():
-            sa = variant.get("shardAssignments", {})
-            model_id = sa.get("modelId")
-            if model_id:
-                model_ids.add(model_id)
-    return sorted(model_ids)
-
-
-def pick_model() -> str | None:
-    models = fetch_models()
-    if not models:
-        print("No models found.")
-        return None
-
-    cursor = 0
-    total_lines = len(models) + 4
-
-    def render(first: bool = False) -> None:
-        if not first:
-            write(f"\033[{total_lines}A")
-        write("\033[J")
-        write("\033[1mSelect model\033[0m (up/down, enter confirm, q quit)\r\n\r\n")
-        for i, model in enumerate(models):
-            line = f"  {'>' if i == cursor else ' '} {model}"
-            write(f"\033[7m{line}\033[0m\r\n" if i == cursor else f"{line}\r\n")
-        write("\r\n")
-        sys.stdout.flush()
-
-    fd = sys.stdin.fileno()
-    old = termios.tcgetattr(fd)
-    try:
-        tty.setraw(fd)
-        write("\033[?25l")
-        render(first=True)
-        while True:
-            ch = sys.stdin.read(1)
-            if ch in ("q", "\x03"):
-                write("\033[?25h\033[0m\r\n")
-                return None
-            elif ch in ("\r", "\n"):
-                break
-            elif ch == "\x1b":
-                seq = sys.stdin.read(2)
-                if seq == "[A":
-                    cursor = (cursor - 1) % len(models)
-                elif seq == "[B":
-                    cursor = (cursor + 1) % len(models)
-            render()
-    finally:
-        termios.tcsetattr(fd, termios.TCSADRAIN, old)
-        write(f"\033[{total_lines}A\033[J")  # clear picker UI
-        write("\033[?25h\033[0m")
-        sys.stdout.flush()
-
-    return models[cursor]
-
-
-# ---------------------------------------------------------------------------
-# Parallel requests
-# ---------------------------------------------------------------------------
-
-statuses: list[str] = []
-times: list[str] = []
-previews: list[str] = []
-tokens: list[str] = []
-full_responses: list[dict | None] = []
-total_lines = 0
-start_time: float = 0
-selected_model: str = ""
-
-
-def render_progress(first: bool = False) -> None:
-    if not first:
-        write(f"\033[{total_lines}A")
-    write("\033[J")
-    elapsed = time.monotonic() - start_time if start_time else 0
-    done = sum(1 for s in statuses if s == "done")
-    write(
-        f"\033[1m{selected_model}\033[0m  [{done}/{NUM_REQUESTS}]  {elapsed:.1f}s\r\n\r\n"
-    )
-
-    for i in range(NUM_REQUESTS):
-        q = QUESTIONS[i % len(QUESTIONS)]
-        status = statuses[i]
-        if status == "pending":
-            color = "\033[33m"  # yellow
-        elif status == "running":
-            color = "\033[36m"  # cyan
-        elif status == "done":
-            color = "\033[32m"  # green
-        else:
-            color = "\033[31m"  # red
-        write(
-            f"  {i:>2}  {color}{status:<8}\033[0m  {times[i]:>6}  {tokens[i]:>5}tok  {q[:40]:<40}  {previews[i][:50]}\r\n"
-        )
-
-    write("\r\n")
-    sys.stdout.flush()
-
-
-async def send_request(
-    session: aiohttp.ClientSession, i: int, lock: asyncio.Lock
-) -> None:
-    payload = {
-        "model": selected_model,
-        "messages": [{"role": "user", "content": QUESTIONS[i % len(QUESTIONS)]}],
-        "max_tokens": 1024,
-    }
-    statuses[i] = "running"
-    async with lock:
-        render_progress()
-    t0 = time.monotonic()
-    try:
-        async with session.post(
-            f"{BASE_URL}/v1/chat/completions", json=payload
-        ) as resp:
-            data = await resp.json()
-            elapsed = time.monotonic() - t0
-            full_responses[i] = data
-            times[i] = f"{elapsed:.1f}s"
-            if resp.status == 200:
-                choice = data["choices"][0]
-                msg = choice["message"]
-                content = msg.get("content", "")
-                previews[i] = content[:50].replace("\n", " ") or "(empty)"
-                if "usage" in data:
-                    tokens[i] = str(data["usage"].get("total_tokens", ""))
-                statuses[i] = "done"
-            else:
-                statuses[i] = f"err:{resp.status}"
-                previews[i] = str(data.get("error", {}).get("message", ""))[:50]
-    except Exception as e:
-        elapsed = time.monotonic() - t0
-        times[i] = f"{elapsed:.1f}s"
-        statuses[i] = "error"
-        previews[i] = str(e)[:50]
-    async with lock:
-        render_progress()
-
-
-async def run_requests(print_stdout: bool = False) -> None:
-    global start_time, total_lines, statuses, times, previews, tokens, full_responses
-
-    statuses = ["pending"] * NUM_REQUESTS
-    times = ["-"] * NUM_REQUESTS
-    previews = ["-"] * NUM_REQUESTS
-    tokens = ["-"] * NUM_REQUESTS
-    full_responses = [None] * NUM_REQUESTS
-    total_lines = NUM_REQUESTS + 4
-
-    write("\033[?25l")  # hide cursor
-    start_time = time.monotonic()
-    render_progress(first=True)
-    lock = asyncio.Lock()
-    try:
-        async with aiohttp.ClientSession() as session:
-            tasks = [send_request(session, i, lock) for i in range(NUM_REQUESTS)]
-            await asyncio.gather(*tasks)
-        total = time.monotonic() - start_time
-        write(
-            f"\033[1m=== All {NUM_REQUESTS} requests done in {total:.1f}s ===\033[0m\r\n\r\n"
-        )
-
-        if print_stdout:
-            for i in range(NUM_REQUESTS):
-                data = full_responses[i]
-                if not data or "choices" not in data:
-                    continue
-                choice = data["choices"][0]
-                msg = choice["message"]
-                q = QUESTIONS[i % len(QUESTIONS)]
-                write(f"\033[1m--- #{i}: {q} ---\033[0m\r\n")
-                if msg.get("reasoning_content"):
-                    write(f"\033[2m[Thinking]: {msg['reasoning_content']}\033[0m\r\n")
-                write(f"{msg.get('content', '')}\r\n")
-                if "usage" in data:
-                    u = data["usage"]
-                    write(
-                        f"\033[2m[Usage: prompt={u.get('prompt_tokens')}, "
-                        f"completion={u.get('completion_tokens')}, "
-                        f"total={u.get('total_tokens')}]\033[0m\r\n"
-                    )
-                write("\r\n")
-    finally:
-        write("\033[?25h")  # show cursor
-        sys.stdout.flush()
-
-
-def main() -> None:
-    global selected_model, BASE_URL
-    parser = argparse.ArgumentParser(
-        description="Send parallel requests to an exo cluster"
-    )
-    parser.add_argument(
-        "--host", required=True, help="Hostname of the exo node (e.g. s1)"
-    )
-    parser.add_argument("--port", type=int, default=52415, help="Port (default: 52415)")
-    parser.add_argument(
-        "--stdout", action="store_true", help="Print full responses after completion"
-    )
-    args = parser.parse_args()
-    BASE_URL = f"http://{args.host}:{args.port}"
-    model = pick_model()
-    if not model:
-        return
-    selected_model = model
-    asyncio.run(run_requests(print_stdout=args.stdout))
-
-
-if __name__ == "__main__":
-    main()

bench/pyproject.toml

@@ -11,11 +11,6 @@ dependencies = [
   "tiktoken>=0.12.0",
   "jinja2>=3.1.0",
   "protobuf>=5.29.0",
-  "datasets>=2.0.0",
-  "math-verify>=0.7.0",
-  "lm-eval[api,math]>=0.4.0",
-  "human-eval>=1.0.3",
-  "numpy>=1.24.0",
 ]
 
 [build-system]

bench/vendor/lcb_testing_util.py

@@ -1,593 +0,0 @@
-# type: ignore
-# Vendored from LiveCodeBench (https://github.com/LiveCodeBench/LiveCodeBench)
-# File: lcb_runner/evaluation/testing_util.py
-# License: MIT
-# Vendored 2026-03-07 — do not modify without updating from upstream.
-
-import ast
-import faulthandler
-import json
-import platform
-
-# to run the solution files we're using a timing based approach
-import signal
-import sys
-import time
-
-# used for debugging to time steps
-from datetime import datetime
-from decimal import Decimal
-from enum import Enum
-from io import StringIO
-
-# from pyext import RuntimeModule
-from types import ModuleType
-
-# used for testing the code that reads from input
-from unittest.mock import mock_open, patch
-
-import_string = "from string import *\nfrom re import *\nfrom datetime import *\nfrom collections import *\nfrom heapq import *\nfrom bisect import *\nfrom copy import *\nfrom math import *\nfrom random import *\nfrom statistics import *\nfrom itertools import *\nfrom functools import *\nfrom operator import *\nfrom io import *\nfrom sys import *\nfrom json import *\nfrom builtins import *\nfrom typing import *\nimport string\nimport re\nimport datetime\nimport collections\nimport heapq\nimport bisect\nimport copy\nimport math\nimport random\nimport statistics\nimport itertools\nimport functools\nimport operator\nimport io\nimport sys\nimport json\nsys.setrecursionlimit(50000)\n"
-
-
-def truncatefn(s, length=300):
-    if isinstance(s, str):
-        pass
-    else:
-        s = str(s)
-    if len(s) <= length:
-        return s
-
-    return s[: length // 2] + "...(truncated) ..." + s[-length // 2 :]
-
-
-class CODE_TYPE(Enum):
-    call_based = 0
-    standard_input = 1
-
-
-# stuff for setting up signal timer
-class TimeoutException(Exception):
-    pass
-
-
-def timeout_handler(signum, frame):
-    print("timeout occured: alarm went off")
-    raise TimeoutException
-
-
-# used to capture stdout as a list
-# from https://stackoverflow.com/a/16571630/6416660
-# alternative use redirect_stdout() from contextlib
-class Capturing(list):
-    def __enter__(self):
-        self._stdout = sys.stdout
-        sys.stdout = self._stringio = StringIO()
-        # Make closing the StringIO a no-op
-        self._stringio.close = lambda x: 1
-        return self
-
-    def __exit__(self, *args):
-        self.append(self._stringio.getvalue())
-        del self._stringio  # free up some memory
-        sys.stdout = self._stdout
-
-
-# Custom mock for sys.stdin that supports buffer attribute
-class MockStdinWithBuffer:
-    def __init__(self, inputs: str):
-        self.inputs = inputs
-        self._stringio = StringIO(inputs)
-        self.buffer = MockBuffer(inputs)
-
-    def read(self, *args):
-        return self.inputs
-
-    def readline(self, *args):
-        return self._stringio.readline(*args)
-
-    def readlines(self, *args):
-        return self.inputs.split("\n")
-
-    def __getattr__(self, name):
-        # Delegate other attributes to StringIO
-        return getattr(self._stringio, name)
-
-
-class MockBuffer:
-    def __init__(self, inputs: str):
-        self.inputs = inputs.encode("utf-8")  # Convert to bytes
-
-    def read(self, *args):
-        # Return as byte strings that can be split
-        return self.inputs
-
-    def readline(self, *args):
-        return self.inputs.split(b"\n")[0] + b"\n"
-
-
-def clean_if_name(code: str) -> str:
-    try:
-        astree = ast.parse(code)
-        last_block = astree.body[-1]
-        if isinstance(last_block, ast.If):
-            condition = last_block.test
-            if ast.unparse(condition).strip() == "__name__ == '__main__'":
-                code = (
-                    ast.unparse(astree.body[:-1]) + "\n" + ast.unparse(last_block.body)  # type: ignore
-                )
-    except:
-        pass
-
-    return code
-
-
-def make_function(code: str) -> str:
-    try:
-        import_stmts = []
-        all_other_stmts = []
-        astree = ast.parse(code)
-        for stmt in astree.body:
-            if isinstance(stmt, (ast.Import, ast.ImportFrom)):
-                import_stmts.append(stmt)
-            else:
-                all_other_stmts.append(stmt)
-
-        function_ast = ast.FunctionDef(
-            name="wrapped_function",
-            args=ast.arguments(
-                posonlyargs=[], args=[], kwonlyargs=[], kw_defaults=[], defaults=[]
-            ),
-            body=all_other_stmts,
-            decorator_list=[],
-            lineno=-1,
-        )
-        main_code = (
-            import_string
-            + "\n"
-            + ast.unparse(import_stmts)
-            + "\n"
-            + ast.unparse(function_ast)
-        )
-        return main_code
-    except Exception:
-        return code
-
-
-def call_method(method, inputs):
-    if isinstance(inputs, list):
-        inputs = "\n".join(inputs)
-
-    inputs_line_iterator = iter(inputs.split("\n"))
-
-    # Create custom stdin mock with buffer support
-    mock_stdin = MockStdinWithBuffer(inputs)
-
-    # sys.setrecursionlimit(10000)
-
-    # @patch('builtins.input', side_effect=inputs.split("\n"))
-    @patch("builtins.open", mock_open(read_data=inputs))
-    @patch("sys.stdin", mock_stdin)  # Use our custom mock instead of StringIO
-    @patch("sys.stdin.readline", lambda *args: next(inputs_line_iterator))
-    @patch("sys.stdin.readlines", lambda *args: inputs.split("\n"))
-    @patch("sys.stdin.read", lambda *args: inputs)
-    # @patch('sys.stdout.write', print)
-    def _inner_call_method(_method):
-        try:
-            return _method()
-        except SystemExit:
-            pass
-        finally:
-            pass
-
-    return _inner_call_method(method)
-
-
-def get_function(compiled_sol, fn_name: str):  # type: ignore
-    try:
-        assert hasattr(compiled_sol, fn_name)
-        return getattr(compiled_sol, fn_name)
-    except Exception:
-        return
-
-
-def compile_code(code: str, timeout: int):
-    signal.alarm(timeout)
-    try:
-        tmp_sol = ModuleType("tmp_sol", "")
-        exec(code, tmp_sol.__dict__)
-        if "class Solution" in code:
-            # leetcode wraps solutions in `Solution`
-            # this is a hack to check if it is leetcode solution or not
-            # currently livecodebench only supports LeetCode but
-            # else condition allows future extensibility to other platforms
-            compiled_sol = tmp_sol.Solution()
-        else:
-            # do nothing in the other case since function is accesible
-            compiled_sol = tmp_sol
-
-        assert compiled_sol is not None
-    finally:
-        signal.alarm(0)
-
-    return compiled_sol
-
-
-def convert_line_to_decimals(line: str) -> tuple[bool, list[Decimal]]:
-    try:
-        decimal_line = [Decimal(elem) for elem in line.split()]
-    except:
-        return False, []
-    return True, decimal_line
-
-
-def get_stripped_lines(val: str):
-    ## you don't want empty lines to add empty list after splitlines!
-    val = val.strip()
-
-    return [val_line.strip() for val_line in val.split("\n")]
-
-
-def grade_call_based(
-    code: str, all_inputs: list, all_outputs: list, fn_name: str, timeout: int
-):
-    # call-based clean up logic
-    # need to wrap in try-catch logic after to catch the correct errors, but for now this is fine.
-    code = import_string + "\n\n" + code
-    compiled_sol = compile_code(code, timeout)
-
-    if compiled_sol is None:
-        return
-
-    method = get_function(compiled_sol, fn_name)
-
-    if method is None:
-        return
-
-    all_inputs = [
-        [json.loads(line) for line in inputs.split("\n")] for inputs in all_inputs
-    ]
-
-    all_outputs = [json.loads(output) for output in all_outputs]
-
-    total_execution = 0
-    all_results = []
-    for idx, (gt_inp, gt_out) in enumerate(zip(all_inputs, all_outputs)):
-        signal.alarm(timeout)
-        faulthandler.enable()
-        try:
-            # can lock here so time is useful
-            start = time.time()
-            prediction = method(*gt_inp)
-            total_execution += time.time() - start
-            signal.alarm(0)
-
-            # don't penalize model if it produces tuples instead of lists
-            # ground truth sequences are not tuples
-            if isinstance(prediction, tuple):
-                prediction = list(prediction)
-
-            tmp_result = prediction == gt_out
-
-            # handle floating point comparisons
-
-            all_results.append(tmp_result)
-
-            if not tmp_result:
-                return all_results, {
-                    "output": truncatefn(prediction),
-                    "inputs": truncatefn(gt_inp),
-                    "expected": truncatefn(gt_out),
-                    "error_code": -2,
-                    "error_message": "Wrong Answer",
-                }
-        except Exception as e:
-            signal.alarm(0)
-            if "timeoutexception" in repr(e).lower():
-                all_results.append(-3)
-                return all_results, {
-                    "error": repr(e),
-                    "error_code": -3,
-                    "error_message": "Time Limit Exceeded",
-                    "inputs": truncatefn(gt_inp),
-                    "expected": truncatefn(gt_out),
-                }
-            else:
-                all_results.append(-4)
-                return all_results, {
-                    "error": repr(e),
-                    "error_code": -4,
-                    "error_message": "Runtime Error",
-                    "inputs": truncatefn(gt_inp),
-                    "expected": truncatefn(gt_out),
-                }
-
-        finally:
-            signal.alarm(0)
-            faulthandler.disable()
-
-    return all_results, {"execution time": total_execution}
-
-
-def grade_stdio(
-    code: str,
-    all_inputs: list,
-    all_outputs: list,
-    timeout: int,
-):
-    ## runtime doesn't interact well with __name__ == '__main__'
-    code = clean_if_name(code)
-
-    ## we wrap the given code inside another function
-    code = make_function(code)
-
-    compiled_sol = compile_code(code, timeout)
-    if compiled_sol is None:
-        return
-
-    method = get_function(compiled_sol, "wrapped_function")
-
-    if method is None:
-        return
-
-    all_results = []
-    total_execution_time = 0
-    for idx, (gt_inp, gt_out) in enumerate(zip(all_inputs, all_outputs)):
-        signal.alarm(timeout)
-        faulthandler.enable()
-
-        signal.alarm(timeout)
-        with Capturing() as captured_output:
-            try:
-                start = time.time()
-                call_method(method, gt_inp)
-                total_execution_time += time.time() - start
-                # reset the alarm
-                signal.alarm(0)
-            except Exception as e:
-                signal.alarm(0)
-                if "timeoutexception" in repr(e).lower():
-                    all_results.append(-3)
-                    return all_results, {
-                        "error": repr(e),
-                        "error_code": -3,
-                        "error_message": "Time Limit Exceeded",
-                        "inputs": truncatefn(gt_inp),
-                        "expected": truncatefn(gt_out),
-                    }
-                else:
-                    all_results.append(-4)
-                    return all_results, {
-                        "error": repr(e),
-                        "error_code": -4,
-                        "error_message": "Runtime Error",
-                        "inputs": truncatefn(gt_inp),
-                        "expected": truncatefn(gt_out),
-                    }
-
-            finally:
-                signal.alarm(0)
-                faulthandler.disable()
-
-        prediction = captured_output[0]
-
-        stripped_prediction_lines = get_stripped_lines(prediction)
-        stripped_gt_out_lines = get_stripped_lines(gt_out)
-
-        ## WA happens in multiple circumstances
-        ## so cache the return to make it clean!
-        WA_send_args = {
-            "output": truncatefn(prediction),
-            "inputs": truncatefn(gt_inp),
-            "expected": truncatefn(gt_out),
-            "error_code": -2,
-        }
-
-        if len(stripped_prediction_lines) != len(stripped_gt_out_lines):
-            all_results.append(-2)
-            WA_send_args["error_message"] = "Wrong answer: mismatched output length"
-            return all_results, WA_send_args
-
-        for output_line_idx, (
-            stripped_prediction_line,
-            stripped_gt_out_line,
-        ) in enumerate(zip(stripped_prediction_lines, stripped_gt_out_lines)):
-            WA_send_args["error_message"] = (
-                f"Wrong answer at {output_line_idx=}: {truncatefn(stripped_prediction_line)} != {truncatefn(stripped_gt_out_line)}"
-            )
-
-            ## CASE 1: exact match
-            if stripped_prediction_line == stripped_gt_out_line:
-                continue
-
-            ## CASE 2: element-wise comparision
-            ## if there are floating elements
-            ## use `decimal` library for good floating point comparision
-            ## otherwise gotcha: np.isclose(50000000000000000, 50000000000000001) = True
-            ## note that we should always be able to convert to decimals
-
-            success, decimal_prediction_line = convert_line_to_decimals(
-                stripped_prediction_line
-            )
-            if not success:
-                all_results.append(-2)
-                return all_results, WA_send_args
-            success, decimal_gtout_line = convert_line_to_decimals(stripped_gt_out_line)
-            if not success:
-                all_results.append(-2)
-                return all_results, WA_send_args
-
-            if decimal_prediction_line == decimal_gtout_line:
-                continue
-
-            all_results.append(-2)
-            return all_results, WA_send_args
-        all_results.append(True)
-
-    return all_results, {"execution time": total_execution_time}
-
-
-def run_test(sample, test=None, debug=False, timeout=6):
-    """
-    if test(generated_code) is not None it'll try to run the code.
-    otherwise it'll just return an input and output pair.
-    """
-    signal.signal(signal.SIGALRM, timeout_handler)
-
-    # Disable functionalities that can make destructive changes to the test.
-    # max memory is set to 4GB
-    reliability_guard()
-
-    if debug:
-        print(f"start = {datetime.now().time()}")
-
-    try:
-        in_outs = json.loads(sample["input_output"])
-    except ValueError as e:
-        raise e
-        in_outs = None
-
-    if in_outs:
-        if in_outs.get("fn_name") is None:
-            which_type = CODE_TYPE.standard_input  # Standard input
-            method_name = None
-
-        else:
-            which_type = CODE_TYPE.call_based  # Call-based
-            method_name = in_outs["fn_name"]
-
-    if debug:
-        print(f"loaded input_output = {datetime.now().time()}")
-
-    if test is None:
-        assert False, "should not happen: test code is none"
-        return in_outs, {"error": "no test code provided"}
-    elif test is not None:
-        results = []
-        sol = import_string
-        if debug:
-            print(f"loading test code = {datetime.now().time()}")
-
-        if which_type == CODE_TYPE.call_based:
-            signal.alarm(timeout)
-            try:
-                results, metadata = grade_call_based(
-                    code=test,
-                    all_inputs=in_outs["inputs"],
-                    all_outputs=in_outs["outputs"],
-                    fn_name=method_name,
-                    timeout=timeout,
-                )
-                return results, metadata
-            except Exception as e:
-                return [-4], {
-                    "error_code": -4,
-                    "error_message": f"Error during testing: {e}",
-                }
-            finally:
-                signal.alarm(0)
-        elif which_type == CODE_TYPE.standard_input:
-            # sol
-            # if code has if __name__ == "__main__": then remove it
-
-            signal.alarm(timeout)
-            try:
-                results, metadata = grade_stdio(
-                    code=test,
-                    all_inputs=in_outs["inputs"],
-                    all_outputs=in_outs["outputs"],
-                    timeout=timeout,
-                )
-                return results, metadata
-            except Exception as e:
-                return [-4], {
-                    "error_code": -4,
-                    "error_message": f"Error during testing: {e}",
-                }
-            finally:
-                signal.alarm(0)
-
-
-def reliability_guard(maximum_memory_bytes=None):
-    """
-    This disables various destructive functions and prevents the generated code
-    from interfering with the test (e.g. fork bomb, killing other processes,
-    removing filesystem files, etc.)
-    WARNING
-    This function is NOT a security sandbox. Untrusted code, including, model-
-    generated code, should not be blindly executed outside of one. See the
-    Codex paper for more information about OpenAI's code sandbox, and proceed
-    with caution.
-    """
-
-    if maximum_memory_bytes is not None:
-        import resource
-
-        resource.setrlimit(
-            resource.RLIMIT_AS, (maximum_memory_bytes, maximum_memory_bytes)
-        )
-        resource.setrlimit(
-            resource.RLIMIT_DATA, (maximum_memory_bytes, maximum_memory_bytes)
-        )
-        if not platform.uname().system == "Darwin":
-            resource.setrlimit(
-                resource.RLIMIT_STACK, (maximum_memory_bytes, maximum_memory_bytes)
-            )
-
-    faulthandler.disable()
-
-    import builtins
-
-    # builtins.exit = None
-    builtins.quit = None
-
-    import os
-
-    os.environ["OMP_NUM_THREADS"] = "1"
-
-    os.kill = None
-    os.system = None
-    os.putenv = None
-    os.remove = None
-    os.removedirs = None
-    os.rmdir = None
-    os.fchdir = None
-    os.setuid = None
-    os.fork = None
-    os.forkpty = None
-    os.killpg = None
-    os.rename = None
-    os.renames = None
-    os.truncate = None
-    os.replace = None
-    os.unlink = None
-    os.fchmod = None
-    os.fchown = None
-    os.chmod = None
-    os.chown = None
-    os.chroot = None
-    os.fchdir = None
-    os.lchflags = None
-    os.lchmod = None
-    os.lchown = None
-    os.getcwd = None
-    os.chdir = None
-
-    import shutil
-
-    shutil.rmtree = None
-    shutil.move = None
-    shutil.chown = None
-
-    import subprocess
-
-    subprocess.Popen = None
-
-    __builtins__["help"] = None
-
-    import sys
-
-    sys.modules["ipdb"] = None
-    sys.modules["joblib"] = None
-    sys.modules["resource"] = None
-    sys.modules["psutil"] = None
-    sys.modules["tkinter"] = None

dashboard/src/lib/components/ChatSidebar.svelte

@@ -18,18 +18,12 @@
     class?: string;
     onNewChat?: () => void;
     onSelectConversation?: () => void;
-    isMobileDrawer?: boolean;
-    isOpen?: boolean;
-    onClose?: () => void;
   }
 
   let {
     class: className = "",
     onNewChat,
     onSelectConversation,
-    isMobileDrawer = false,
-    isOpen = false,
-    onClose,
   }: Props = $props();
 
   const conversationList = $derived(conversations());
@@ -59,10 +53,6 @@
   function handleSelectConversation(id: string) {
     onSelectConversation?.();
     loadConversation(id);
-    // Close mobile drawer when selecting a conversation
-    if (isMobileDrawer && isOpen) {
-      onClose?.();
-    }
   }
 
   function handleStartEdit(id: string, name: string, event: MouseEvent) {
@@ -262,7 +252,9 @@
   }
 </script>
 
-{#snippet sidebarContent()}
+<aside
+  class="flex flex-col h-full bg-exo-dark-gray border-r border-exo-yellow/10 {className}"
+>
   <!-- Header -->
   <div class="p-4">
     <button
@@ -599,30 +591,4 @@
       </button>
     </div>
   </div>
-{/snippet}
-
-{#if isMobileDrawer}
-  <!-- Mobile drawer with overlay -->
-  {#if isOpen}
-    <!-- Overlay backdrop -->
-    <button
-      type="button"
-      class="fixed inset-0 bg-black/60 backdrop-blur-sm z-40 md:hidden"
-      onclick={() => onClose?.()}
-      aria-label="Close sidebar"
-    ></button>
-    <!-- Drawer panel -->
-    <aside
-      class="fixed left-0 top-0 bottom-0 w-72 bg-exo-dark-gray border-r border-exo-yellow/10 z-50 flex flex-col md:hidden"
-    >
-      {@render sidebarContent()}
-    </aside>
-  {/if}
-{:else}
-  <!-- Desktop sidebar -->
-  <aside
-    class="flex flex-col h-full bg-exo-dark-gray border-r border-exo-yellow/10 {className}"
-  >
-    {@render sidebarContent()}
-  </aside>
-{/if}
+</aside>

dashboard/src/lib/components/FamilySidebar.svelte

@@ -41,13 +41,13 @@
 </script>
 
 <div
-  class="flex flex-col gap-1 py-2 px-1 border-r border-exo-yellow/10 bg-exo-medium-gray/30 min-w-[72px] sm:min-w-[64px] overflow-y-auto scrollbar-hide"
+  class="flex flex-col gap-1 py-2 px-1 border-r border-exo-yellow/10 bg-exo-medium-gray/30 min-w-[64px] overflow-y-auto scrollbar-hide"
 >
   <!-- All models (no filter) -->
   <button
     type="button"
     onclick={() => onSelect(null)}
-    class="group flex flex-col items-center justify-center p-2 sm:p-2 rounded transition-all duration-200 cursor-pointer min-h-[44px] sm:min-h-0 {selectedFamily ===
+    class="group flex flex-col items-center justify-center p-2 rounded transition-all duration-200 cursor-pointer {selectedFamily ===
     null
       ? 'bg-exo-yellow/20 border-l-2 border-exo-yellow'
       : 'hover:bg-white/5 border-l-2 border-transparent'}"

dashboard/src/lib/components/HeaderNav.svelte

@@ -6,12 +6,6 @@
   export let showSidebarToggle = false;
   export let sidebarVisible = true;
   export let onToggleSidebar: (() => void) | null = null;
-  export let showMobileMenuToggle = false;
-  export let mobileMenuOpen = false;
-  export let onToggleMobileMenu: (() => void) | null = null;
-  export let showMobileRightToggle = false;
-  export let mobileRightOpen = false;
-  export let onToggleMobileRight: (() => void) | null = null;
   export let downloadProgress: {
     count: number;
     percentage: number;
@@ -33,96 +27,49 @@
       onToggleSidebar();
     }
   }
-
-  function handleToggleMobileMenu(): void {
-    if (onToggleMobileMenu) {
-      onToggleMobileMenu();
-    }
-  }
-
-  function handleToggleMobileRight(): void {
-    if (onToggleMobileRight) {
-      onToggleMobileRight();
-    }
-  }
 </script>
 
 <header
-  class="relative z-20 flex items-center justify-center px-4 md:px-6 pt-4 md:pt-8 pb-3 md:pb-4 bg-exo-dark-gray"
+  class="relative z-20 flex items-center justify-center px-6 pt-8 pb-4 bg-exo-dark-gray"
 >
-  <!-- Left: Sidebar Toggle (desktop) or Mobile Sidebar Toggle (mobile) -->
-  <div
-    class="absolute left-4 md:left-6 top-1/2 -translate-y-1/2 flex items-center gap-2"
-  >
-    <!-- Mobile sidebar toggle -->
-    <button
-      onclick={handleToggleMobileMenu}
-      class="p-2 rounded border border-exo-light-gray/30 hover:border-exo-yellow/50 hover:bg-exo-medium-gray/30 transition-colors cursor-pointer md:hidden"
-      title={mobileMenuOpen ? "Hide sidebar" : "Show sidebar"}
-      aria-label={mobileMenuOpen
-        ? "Hide conversation sidebar"
-        : "Show conversation sidebar"}
-      aria-pressed={mobileMenuOpen}
-    >
-      <svg
-        fill="none"
-        viewBox="0 0 24 24"
-        stroke="currentColor"
-        stroke-width="2"
-        class="w-5 h-5 {mobileMenuOpen
-          ? 'text-exo-yellow'
-          : 'text-exo-light-gray'}"
+  <!-- Left: Sidebar Toggle -->
+  {#if showSidebarToggle}
+    <div class="absolute left-6 top-1/2 -translate-y-1/2">
+      <button
+        onclick={handleToggleSidebar}
+        class="p-2 rounded border border-exo-light-gray/30 hover:border-exo-yellow/50 hover:bg-exo-medium-gray/30 transition-colors cursor-pointer"
+        title={sidebarVisible ? "Hide sidebar" : "Show sidebar"}
+        aria-label={sidebarVisible
+          ? "Hide conversation sidebar"
+          : "Show conversation sidebar"}
+        aria-pressed={sidebarVisible}
       >
-        {#if mobileMenuOpen}
-          <path
-            stroke-linecap="round"
-            stroke-linejoin="round"
-            d="M11 19l-7-7 7-7m8 14l-7-7 7-7"
-          ></path>
-        {:else}
-          <path
-            stroke-linecap="round"
-            stroke-linejoin="round"
-            d="M13 5l7 7-7 7M5 5l7 7-7 7"
-          ></path>
-        {/if}
-      </svg>
-    </button>
-    <!-- Desktop sidebar toggle -->
-    <button
-      onclick={handleToggleSidebar}
-      class="p-2 rounded border border-exo-light-gray/30 hover:border-exo-yellow/50 hover:bg-exo-medium-gray/30 transition-colors cursor-pointer hidden md:block"
-      title={sidebarVisible ? "Hide sidebar" : "Show sidebar"}
-      aria-label={sidebarVisible
-        ? "Hide conversation sidebar"
-        : "Show conversation sidebar"}
-      aria-pressed={sidebarVisible}
-    >
-      <svg
-        fill="none"
-        viewBox="0 0 24 24"
-        stroke="currentColor"
-        stroke-width="2"
-        class="w-5 h-5 {sidebarVisible
-          ? 'text-exo-yellow'
-          : 'text-exo-light-gray'}"
-      >
-        {#if sidebarVisible}
-          <path
-            stroke-linecap="round"
-            stroke-linejoin="round"
-            d="M11 19l-7-7 7-7m8 14l-7-7 7-7"
-          ></path>
-        {:else}
-          <path
-            stroke-linecap="round"
-            stroke-linejoin="round"
-            d="M13 5l7 7-7 7M5 5l7 7-7 7"
-          ></path>
-        {/if}
-      </svg>
-    </button>
-  </div>
+        <svg
+          class="w-5 h-5 {sidebarVisible
+            ? 'text-exo-yellow'
+            : 'text-exo-light-gray'}"
+          fill="none"
+          viewBox="0 0 24 24"
+          stroke="currentColor"
+          stroke-width="2"
+        >
+          {#if sidebarVisible}
+            <path
+              stroke-linecap="round"
+              stroke-linejoin="round"
+              d="M11 19l-7-7 7-7m8 14l-7-7 7-7"
+            />
+          {:else}
+            <path
+              stroke-linecap="round"
+              stroke-linejoin="round"
+              d="M13 5l7 7-7 7M5 5l7 7-7 7"
+            />
+          {/if}
+        </svg>
+      </button>
+    </div>
+  {/if}
 
   <!-- Center: Logo (clickable to go home) -->
   <button
@@ -136,55 +83,19 @@
     <img
       src="/exo-logo.png"
       alt="EXO"
-      class="h-12 md:h-18 drop-shadow-[0_0_4px_rgba(255,215,0,0.3)]"
+      class="h-18 drop-shadow-[0_0_4px_rgba(255,215,0,0.3)]"
     />
   </button>
 
-  <!-- Right: Home + Downloads + Mobile Right Toggle -->
+  <!-- Right: Home + Downloads -->
   <nav
-    class="absolute right-4 md:right-6 top-1/2 -translate-y-1/2 flex items-center gap-2 md:gap-4"
+    class="absolute right-6 top-1/2 -translate-y-1/2 flex items-center gap-4"
     aria-label="Main navigation"
   >
-    <!-- Mobile right sidebar toggle (instances/models) - only show when not in chat mode -->
-    {#if showMobileRightToggle}
-      <button
-        onclick={handleToggleMobileRight}
-        class="p-2 rounded border border-exo-light-gray/30 hover:border-exo-yellow/50 hover:bg-exo-medium-gray/30 transition-colors cursor-pointer md:hidden"
-        title={mobileRightOpen ? "Hide instances" : "Show instances"}
-        aria-label={mobileRightOpen
-          ? "Hide instances panel"
-          : "Show instances panel"}
-        aria-pressed={mobileRightOpen}
-      >
-        <svg
-          fill="none"
-          viewBox="0 0 24 24"
-          stroke="currentColor"
-          stroke-width="2"
-          class="w-5 h-5 {mobileRightOpen
-            ? 'text-exo-yellow'
-            : 'text-exo-light-gray'}"
-        >
-          {#if mobileRightOpen}
-            <path
-              stroke-linecap="round"
-              stroke-linejoin="round"
-              d="M13 5l7 7-7 7M5 5l7 7-7 7"
-            ></path>
-          {:else}
-            <path
-              stroke-linecap="round"
-              stroke-linejoin="round"
-              d="M11 19l-7-7 7-7m8 14l-7-7 7-7"
-            ></path>
-          {/if}
-        </svg>
-      </button>
-    {/if}
     {#if showHome}
       <button
         onclick={handleHome}
-        class="flex text-sm text-white/70 hover:text-exo-yellow transition-colors tracking-wider uppercase items-center gap-2 cursor-pointer"
+        class="text-sm text-white/70 hover:text-exo-yellow transition-colors tracking-wider uppercase flex items-center gap-2 cursor-pointer"
         title="Back to topology view"
       >
         <svg
@@ -200,12 +111,12 @@
             d="M3 12l2-2m0 0l7-7 7 7M5 10v10a1 1 0 001 1h3m10-11l2 2m-2-2v10a1 1 0 01-1 1h-3m-6 0a1 1 0 001-1v-4a1 1 0 011-1h2a1 1 0 011 1v4a1 1 0 001 1m-6 0h6"
           />
         </svg>
-        <span class="hidden sm:inline">Home</span>
+        Home
       </button>
     {/if}
     <a
       href="/#/downloads"
-      class="text-xs md:text-sm text-white/70 hover:text-exo-yellow transition-colors tracking-wider uppercase flex items-center gap-1.5 md:gap-2 cursor-pointer"
+      class="text-sm text-white/70 hover:text-exo-yellow transition-colors tracking-wider uppercase flex items-center gap-2 cursor-pointer"
       title="View downloads overview"
     >
       {#if downloadProgress}
@@ -257,7 +168,7 @@
           <path d="M5 21h14" />
         </svg>
       {/if}
-      <span class="hidden sm:inline">Downloads</span>
+      Downloads
     </a>
   </nav>
 </header>

dashboard/src/lib/components/HuggingFaceResultItem.svelte

@@ -36,12 +36,8 @@
     return num.toString();
   }
 
-  // Show short name for mlx-community models, full ID for everything else
-  const modelName = $derived(
-    model.author === "mlx-community"
-      ? model.id.split("/").pop() || model.id
-      : model.id,
-  );
+  // Extract model name from full ID (e.g., "mlx-community/Llama-3.2-1B" -> "Llama-3.2-1B")
+  const modelName = $derived(model.id.split("/").pop() || model.id);
 </script>
 
 <div

dashboard/src/lib/components/MarkdownContent.svelte

@@ -507,29 +507,9 @@
   });
 
   $effect(() => {
-    if (!containerRef || !browser) return;
-
-    function handleDelegatedClick(event: MouseEvent) {
-      const codeBtn = (event.target as HTMLElement).closest(
-        ".copy-code-btn",
-      ) as HTMLButtonElement | null;
-      if (codeBtn) {
-        handleCopyClick({ currentTarget: codeBtn } as unknown as Event);
-        return;
-      }
-      const mathBtn = (event.target as HTMLElement).closest(
-        ".copy-math-btn",
-      ) as HTMLButtonElement | null;
-      if (mathBtn) {
-        handleMathCopyClick({ currentTarget: mathBtn } as unknown as Event);
-        return;
-      }
+    if (containerRef && processedHtml) {
+      setupCopyButtons();
     }
-
-    containerRef.addEventListener("click", handleDelegatedClick);
-    return () => {
-      containerRef?.removeEventListener("click", handleDelegatedClick);
-    };
   });
 </script>
 

dashboard/src/lib/components/ModelPickerGroup.svelte

@@ -32,7 +32,6 @@
     group: ModelGroup;
     isExpanded: boolean;
     isFavorite: boolean;
-    isHighlighted?: boolean;
     selectedModelId: string | null;
     canModelFit: (id: string) => boolean;
     getModelFitStatus: (id: string) => ModelFitStatus;
@@ -49,7 +48,6 @@
     group,
     isExpanded,
     isFavorite,
-    isHighlighted = false,
     selectedModelId,
     canModelFit,
     getModelFitStatus,
@@ -152,11 +150,10 @@
 </script>
 
 <div
-  data-model-ids={group.variants.map((v) => v.id).join(" ")}
   class="border-b border-white/5 last:border-b-0 {!anyVariantFits &&
   !anyVariantHasInstance
     ? 'opacity-50'
-    : ''} {isHighlighted ? 'model-just-added' : ''}"
+    : ''}"
 >
   <!-- Main row -->
   <div
@@ -647,21 +644,3 @@
     </div>
   {/if}
 </div>
-
-<style>
-  .model-just-added {
-    animation: highlightFade 4s ease-out forwards;
-  }
-
-  @keyframes highlightFade {
-    0%,
-    40% {
-      background-color: rgba(20, 83, 45, 0.25);
-      box-shadow: inset 0 0 0 1px rgba(74, 222, 128, 0.4);
-    }
-    100% {
-      background-color: transparent;
-      box-shadow: none;
-    }
-  }
-</style>

dashboard/src/lib/components/ModelPickerModal.svelte

@@ -1,5 +1,4 @@
 <script lang="ts">
-  import { tick } from "svelte";
   import { fade, fly } from "svelte/transition";
   import { cubicOut } from "svelte/easing";
   import FamilySidebar from "./FamilySidebar.svelte";
@@ -8,7 +7,6 @@
   import HuggingFaceResultItem from "./HuggingFaceResultItem.svelte";
   import { getNodesWithModelDownloaded } from "$lib/utils/downloads";
   import { getRecentEntries } from "$lib/stores/recents.svelte";
-  import { addToast } from "$lib/stores/toast.svelte";
 
   interface ModelInfo {
     id: string;
@@ -193,13 +191,6 @@
   let hfSearchDebounceTimer: ReturnType<typeof setTimeout> | null = null;
   let manualModelId = $state("");
   let addModelError = $state<string | null>(null);
-  let justAddedModelId = $state<string | null>(null);
-  let justAddedTimer: ReturnType<typeof setTimeout> | null = null;
-
-  // Inline HuggingFace search in main search bar
-  let mainSearchHfResults = $state<HuggingFaceModel[]>([]);
-  let mainSearchHfLoading = $state(false);
-  let mainSearchDebounceTimer: ReturnType<typeof setTimeout> | null = null;
 
   // Reset transient state when modal opens, but preserve tab selection
   $effect(() => {
@@ -209,11 +200,6 @@
       showFilters = false;
       manualModelId = "";
       addModelError = null;
-      justAddedModelId = null;
-      if (justAddedTimer) {
-        clearTimeout(justAddedTimer);
-        justAddedTimer = null;
-      }
     }
   });
 
@@ -228,50 +214,6 @@
     }
   });
 
-  // Inline HuggingFace search when local search returns no results
-  $effect(() => {
-    const query = searchQuery.trim();
-    const noLocalResults = filteredGroups.length === 0;
-
-    if (mainSearchDebounceTimer) {
-      clearTimeout(mainSearchDebounceTimer);
-      mainSearchDebounceTimer = null;
-    }
-
-    if (
-      selectedFamily === "huggingface" ||
-      selectedFamily === "recents" ||
-      selectedFamily === "favorites" ||
-      query.length < 2 ||
-      !noLocalResults
-    ) {
-      mainSearchHfResults = [];
-      mainSearchHfLoading = false;
-      return;
-    }
-
-    mainSearchHfLoading = true;
-    mainSearchDebounceTimer = setTimeout(async () => {
-      try {
-        const response = await fetch(
-          `/models/search?query=${encodeURIComponent(query)}&limit=10`,
-        );
-        if (response.ok) {
-          const results: HuggingFaceModel[] = await response.json();
-          mainSearchHfResults = results.filter(
-            (r) => !existingModelIds.has(r.id),
-          );
-        } else {
-          mainSearchHfResults = [];
-        }
-      } catch {
-        mainSearchHfResults = [];
-      } finally {
-        mainSearchHfLoading = false;
-      }
-    }, 500);
-  });
-
   async function fetchTrendingModels() {
     hfIsLoadingTrending = true;
     try {
@@ -332,24 +274,6 @@
     addModelError = null;
     try {
       await onAddModel(modelId);
-      // Success: show toast, switch to All Models, highlight the model
-      const shortName = modelId.split("/").pop() || modelId;
-      addToast({ type: "success", message: `Added ${shortName}` });
-      justAddedModelId = modelId;
-      selectedFamily = null;
-      searchQuery = "";
-      // Scroll to the newly added model after DOM update
-      await tick();
-      const el = document.querySelector(
-        `[data-model-ids~="${CSS.escape(modelId)}"]`,
-      );
-      el?.scrollIntoView({ behavior: "smooth", block: "center" });
-      // Clear highlight after 4 seconds
-      if (justAddedTimer) clearTimeout(justAddedTimer);
-      justAddedTimer = setTimeout(() => {
-        justAddedModelId = null;
-        justAddedTimer = null;
-      }, 4000);
     } catch (error) {
       addModelError =
         error instanceof Error ? error.message : "Failed to add model";
@@ -917,8 +841,6 @@
                 {group}
                 isExpanded={expandedGroups.has(group.id)}
                 isFavorite={favorites.has(group.id)}
-                isHighlighted={justAddedModelId !== null &&
-                  group.variants.some((v) => v.id === justAddedModelId)}
                 {selectedModelId}
                 {canModelFit}
                 {getModelFitStatus}
@@ -988,8 +910,6 @@
               {group}
               isExpanded={expandedGroups.has(group.id)}
               isFavorite={favorites.has(group.id)}
-              isHighlighted={justAddedModelId !== null &&
-                group.variants.some((v) => v.id === justAddedModelId)}
               {selectedModelId}
               {canModelFit}
               {getModelFitStatus}
@@ -1017,8 +937,6 @@
               {group}
               isExpanded={expandedGroups.has(group.id)}
               isFavorite={favorites.has(group.id)}
-              isHighlighted={justAddedModelId !== null &&
-                group.variants.some((v) => v.id === justAddedModelId)}
               {selectedModelId}
               {canModelFit}
               {getModelFitStatus}
@@ -1030,55 +948,6 @@
               {instanceStatuses}
             />
           {/each}
-          <!-- Inline HuggingFace search results (shown when no local results match) -->
-          {#if filteredGroups.length === 0 && searchQuery.trim().length >= 2 && selectedFamily !== "huggingface" && selectedFamily !== "recents" && selectedFamily !== "favorites"}
-            {#if mainSearchHfLoading}
-              <div
-                class="flex items-center gap-2 px-3 py-2 border-t border-orange-400/20 bg-orange-950/20"
-              >
-                <span
-                  class="w-4 h-4 border-2 border-orange-400 border-t-transparent rounded-full animate-spin"
-                ></span>
-                <span class="text-xs font-mono text-orange-400/60"
-                  >Searching HuggingFace...</span
-                >
-              </div>
-            {:else if mainSearchHfResults.length > 0}
-              <div
-                class="sticky top-0 z-10 flex items-center gap-2 px-3 py-2 bg-orange-950/30 border-y border-orange-400/20 backdrop-blur-sm"
-              >
-                <span
-                  class="text-xs font-mono text-orange-400 tracking-wider uppercase"
-                  >From HuggingFace</span
-                >
-              </div>
-              {#each mainSearchHfResults as model}
-                <HuggingFaceResultItem
-                  {model}
-                  isAdded={existingModelIds.has(model.id)}
-                  isAdding={addingModelId === model.id}
-                  onAdd={() => handleAddModel(model.id)}
-                  onSelect={() => handleSelectHfModel(model.id)}
-                  downloadedOnNodes={downloadsData
-                    ? getNodesWithModelDownloaded(downloadsData, model.id).map(
-                        getNodeName,
-                      )
-                    : []}
-                />
-              {/each}
-              <button
-                type="button"
-                class="w-full px-3 py-2 text-xs font-mono text-orange-400/60 hover:text-orange-400 hover:bg-orange-500/10 transition-colors text-center"
-                onclick={() => {
-                  hfSearchQuery = searchQuery;
-                  searchHuggingFace(searchQuery);
-                  selectedFamily = "huggingface";
-                }}
-              >
-                See all results on Hub
-              </button>
-            {/if}
-          {/if}
         {/if}
       </div>
     </div>

dashboard/src/lib/stores/app.svelte.ts

@@ -580,8 +580,6 @@ class AppStore {
   debugMode = $state(false);
   topologyOnlyMode = $state(false);
   chatSidebarVisible = $state(true); // Shown by default
-  mobileChatSidebarOpen = $state(false); // Mobile drawer state
-  mobileRightSidebarOpen = $state(false); // Mobile right drawer state
 
   // Image generation params
   imageGenerationParams = $state<ImageGenerationParams>({
@@ -1247,30 +1245,6 @@ class AppStore {
     this.saveChatSidebarVisibleToStorage();
   }
 
-  getMobileChatSidebarOpen(): boolean {
-    return this.mobileChatSidebarOpen;
-  }
-
-  setMobileChatSidebarOpen(open: boolean) {
-    this.mobileChatSidebarOpen = open;
-  }
-
-  toggleMobileChatSidebar() {
-    this.mobileChatSidebarOpen = !this.mobileChatSidebarOpen;
-  }
-
-  getMobileRightSidebarOpen(): boolean {
-    return this.mobileRightSidebarOpen;
-  }
-
-  setMobileRightSidebarOpen(open: boolean) {
-    this.mobileRightSidebarOpen = open;
-  }
-
-  toggleMobileRightSidebar() {
-    this.mobileRightSidebarOpen = !this.mobileRightSidebarOpen;
-  }
-
   startPolling() {
     this.fetchState();
     this.fetchInterval = setInterval(() => this.fetchState(), 1000);
@@ -3308,18 +3282,6 @@ export const toggleChatSidebarVisible = () =>
   appStore.toggleChatSidebarVisible();
 export const setChatSidebarVisible = (visible: boolean) =>
   appStore.setChatSidebarVisible(visible);
-
-// Mobile sidebar state
-export const mobileChatSidebarOpen = () => appStore.mobileChatSidebarOpen;
-export const toggleMobileChatSidebar = () => appStore.toggleMobileChatSidebar();
-export const setMobileChatSidebarOpen = (open: boolean) =>
-  appStore.setMobileChatSidebarOpen(open);
-export const mobileRightSidebarOpen = () => appStore.mobileRightSidebarOpen;
-export const toggleMobileRightSidebar = () =>
-  appStore.toggleMobileRightSidebar();
-export const setMobileRightSidebarOpen = (open: boolean) =>
-  appStore.setMobileRightSidebarOpen(open);
-
 export const refreshState = () => appStore.fetchState();
 
 // Connection status

dashboard/src/routes/+page.svelte

@@ -49,12 +49,6 @@
     toggleTopologyOnlyMode,
     chatSidebarVisible,
     toggleChatSidebarVisible,
-    mobileChatSidebarOpen,
-    toggleMobileChatSidebar,
-    setMobileChatSidebarOpen,
-    mobileRightSidebarOpen,
-    toggleMobileRightSidebar,
-    setMobileRightSidebarOpen,
     nodeThunderbolt,
     nodeRdmaCtl,
     thunderboltBridgeCycles,
@@ -85,8 +79,6 @@
   const debugEnabled = $derived(debugMode());
   const topologyOnlyEnabled = $derived(topologyOnlyMode());
   const sidebarVisible = $derived(chatSidebarVisible());
-  const mobileChatOpen = $derived(mobileChatSidebarOpen());
-  const mobileRightOpen = $derived(mobileRightSidebarOpen());
   const tbBridgeCycles = $derived(thunderboltBridgeCycles());
   const tbBridgeData = $derived(nodeThunderboltBridge());
   const identitiesData = $derived(nodeIdentities());
@@ -4612,35 +4604,16 @@
       showSidebarToggle={true}
       {sidebarVisible}
       onToggleSidebar={toggleChatSidebarVisible}
-      showMobileMenuToggle={true}
-      mobileMenuOpen={mobileChatOpen}
-      onToggleMobileMenu={toggleMobileChatSidebar}
-      showMobileRightToggle={!chatStarted && !topologyOnlyEnabled}
-      {mobileRightOpen}
-      onToggleMobileRight={toggleMobileRightSidebar}
       downloadProgress={activeDownloadSummary}
     />
   {/if}
 
-  <!-- Mobile Chat Sidebar Drawer -->
-  {#if !topologyOnlyEnabled}
-    <ChatSidebar
-      isMobileDrawer={true}
-      isOpen={mobileChatOpen}
-      onClose={() => setMobileChatSidebarOpen(false)}
-      onNewChat={handleNewChat}
-      onSelectConversation={() => {
-        userForcedIdle = false;
-      }}
-    />
-  {/if}
-
   <!-- Main Content -->
   <main class="flex-1 flex overflow-hidden relative">
-    <!-- Left: Conversation History Sidebar (hidden in topology-only mode, welcome state, or when toggled off) - Desktop only -->
+    <!-- Left: Conversation History Sidebar (hidden in topology-only mode, welcome state, or when toggled off) -->
     {#if !topologyOnlyEnabled && sidebarVisible}
       <div
-        class="hidden md:block w-80 flex-shrink-0 border-r border-exo-yellow/10"
+        class="w-80 flex-shrink-0 border-r border-exo-yellow/10"
         role="complementary"
         aria-label="Conversation history"
       >
@@ -4950,33 +4923,11 @@
           </div>
         </div>
 
-        <!-- Mobile Right Sidebar Drawer (Instances) -->
-        {#if mobileRightOpen}
-          <!-- Overlay backdrop -->
-          <button
-            type="button"
-            class="fixed inset-0 bg-black/60 backdrop-blur-sm z-40 md:hidden"
-            onclick={() => setMobileRightSidebarOpen(false)}
-            aria-label="Close instances panel"
-          ></button>
-          <!-- Drawer panel -->
-          <aside
-            class="fixed right-0 top-0 bottom-0 w-80 bg-exo-dark-gray border-l border-exo-yellow/10 z-50 flex flex-col md:hidden overflow-y-auto"
-            aria-label="Instance controls mobile"
-          >
-            {@render rightSidebarContent()}
-          </aside>
-        {/if}
-
-        <!-- Right Sidebar: Instance Controls (wider on welcome page for better visibility) - Desktop only -->
+        <!-- Right Sidebar: Instance Controls (wider on welcome page for better visibility) -->
         <aside
-          class="hidden md:flex w-80 border-l border-exo-yellow/10 bg-exo-dark-gray flex-col flex-shrink-0"
+          class="w-80 border-l border-exo-yellow/10 bg-exo-dark-gray flex flex-col flex-shrink-0"
           aria-label="Instance controls"
         >
-          {@render rightSidebarContent()}
-        </aside>
-
-        {#snippet rightSidebarContent()}
           <!-- Running Instances Panel (only shown when instances exist) - Scrollable -->
           {#if instanceCount > 0}
             <div class="p-4 flex-shrink-0">
@@ -5858,7 +5809,7 @@
               {/if}
             </div>
           </div>
-        {/snippet}
+        </aside>
       </div>
     {:else}
       <!-- CHAT STATE: Chat + Mini-Map -->
@@ -6071,10 +6022,10 @@
           {/if}
         </div>
 
-        <!-- Right: Mini-Map Sidebar - Desktop only -->
+        <!-- Right: Mini-Map Sidebar -->
         {#if minimized}
           <aside
-            class="hidden md:flex w-80 border-l border-exo-yellow/20 bg-exo-dark-gray flex-col flex-shrink-0 overflow-y-auto"
+            class="w-80 border-l border-exo-yellow/20 bg-exo-dark-gray flex flex-col flex-shrink-0 overflow-y-auto"
             in:fly={{ x: 100, duration: 400, easing: cubicInOut }}
             aria-label="Cluster topology"
           >

docs/api.md

@@ -4,7 +4,7 @@ This document describes the REST API exposed by the **EXO** service, as implemen
 
 `src/exo/master/api.py`
 
-The API is used to manage model instances in the cluster, inspect cluster state, and perform inference using multiple API-compatible interfaces.
+The API is used to manage model instances in the cluster, inspect cluster state, and perform inference using an OpenAI-compatible interface.
 
 Base URL example:
 
@@ -144,59 +144,8 @@ Placement result.
 
 Returns the list of available models and their metadata.
 
-**Query parameters:**
-
-* `status`: string (optional) - Filter by `downloaded` to show only downloaded models
-
 **Response:**
-Array of model descriptors including `is_custom` field for custom HuggingFace models.
-
-### Add Custom Model
-
-**POST** `/models/add`
-
-Add a custom model from HuggingFace hub.
-
-**Request body (example):**
-
-```json
-{
-  "model_id": "mlx-community/my-custom-model"
-}
-```
-
-**Response:**
-Model descriptor for the added model.
-
-**Security note:**
-Models with `trust_remote_code` enabled in their configuration require explicit opt-in (default is false) for security.
-
-### Delete Custom Model
-
-**DELETE** `/models/custom/{model_id}`
-
-Delete a user-added custom model card.
-
-**Path parameters:**
-
-* `model_id`: string, ID of the custom model to delete
-
-**Response:**
-Confirmation JSON with deleted model ID.
-
-### Search Models
-
-**GET** `/models/search`
-
-Search HuggingFace Hub for mlx-community models.
-
-**Query parameters:**
-
-* `query`: string (optional) - Search query
-* `limit`: integer (default: 20) - Maximum number of results
-
-**Response:**
-Array of HuggingFace model search results.
+Array of model descriptors.
 
 ## 4. Inference / Chat Completions
 
@@ -219,123 +168,9 @@ Executes a chat completion request using an OpenAI-compatible schema. Supports s
 }
 ```
 
-**Request parameters:**
-
-* `model`: string, required - Model ID to use
-* `messages`: array, required - Conversation messages
-* `stream`: boolean (default: false) - Enable streaming responses
-* `max_tokens`: integer (optional) - Maximum tokens to generate
-* `temperature`: float (optional) - Sampling temperature
-* `top_p`: float (optional) - Nucleus sampling parameter
-* `top_k`: integer (optional) - Top-k sampling parameter
-* `stop`: string or array (optional) - Stop sequences
-* `seed`: integer (optional) - Random seed for reproducibility
-* `enable_thinking`: boolean (optional) - Enable thinking mode for capable models (DeepSeek V3.1, Qwen3, GLM-4.7)
-* `tools`: array (optional) - Tool definitions for function calling
-* `logprobs`: boolean (optional) - Return log probabilities
-* `top_logprobs`: integer (optional) - Number of top log probabilities to return
-
 **Response:**
 OpenAI-compatible chat completion response.
 
-**Streaming response format:**
-When `stream=true`, returns Server-Sent Events (SSE) with format:
-
-```
-data: {"id":"...","object":"chat.completion","created":...,"model":"...","choices":[...]}
-
-data: [DONE]
-```
-
-**Non-streaming response includes usage statistics:**
-
-```json
-{
-  "id": "...",
-  "object": "chat.completion",
-  "created": 1234567890,
-  "model": "llama-3.2-1b",
-  "choices": [{
-    "index": 0,
-    "message": {
-      "role": "assistant",
-      "content": "Hello! How can I help you?"
-    },
-    "finish_reason": "stop"
-  }],
-  "usage": {
-    "prompt_tokens": 15,
-    "completion_tokens": 8,
-    "total_tokens": 23
-  }
-}
-```
-
-**Cancellation:**
-You can cancel an active generation by closing the HTTP connection. The server detects the disconnection and stops processing.
-
-### Claude Messages API
-
-**POST** `/v1/messages`
-
-Executes a chat completion request using the Claude Messages API format. Supports streaming and non-streaming modes.
-
-**Request body (example):**
-
-```json
-{
-  "model": "llama-3.2-1b",
-  "messages": [
-    { "role": "user", "content": "Hello" }
-  ],
-  "max_tokens": 1024,
-  "stream": false
-}
-```
-
-**Streaming response format:**
-When `stream=true`, returns Server-Sent Events with Claude-specific event types:
-
-* `message_start` - Message generation started
-* `content_block_start` - Content block started
-* `content_block_delta` - Incremental content chunk
-* `content_block_stop` - Content block completed
-* `message_delta` - Message metadata updates
-* `message_stop` - Message generation completed
-
-**Response:**
-Claude-compatible messages response.
-
-### OpenAI Responses API
-
-**POST** `/v1/responses`
-
-Executes a chat completion request using the OpenAI Responses API format. Supports streaming and non-streaming modes.
-
-**Request body (example):**
-
-```json
-{
-  "model": "llama-3.2-1b",
-  "messages": [
-    { "role": "user", "content": "Hello" }
-  ],
-  "stream": false
-}
-```
-
-**Streaming response format:**
-When `stream=true`, returns Server-Sent Events with response-specific event types:
-
-* `response.created` - Response generation started
-* `response.in_progress` - Response is being generated
-* `response.output_item.added` - New output item added
-* `response.output_item.done` - Output item completed
-* `response.done` - Response generation completed
-
-**Response:**
-OpenAI Responses API-compatible response.
-
 ### Benchmarked Chat Completions
 
 **POST** `/bench/chat/completions`
@@ -346,13 +181,7 @@ Same as `/v1/chat/completions`, but also returns performance and generation stat
 Same schema as `/v1/chat/completions`.
 
 **Response:**
-Chat completion plus benchmarking metrics including:
-
-* `prompt_tps` - Tokens per second during prompt processing
-* `generation_tps` - Tokens per second during generation
-* `prompt_tokens` - Number of prompt tokens
-* `generation_tokens` - Number of generated tokens
-* `peak_memory_usage` - Peak memory used during generation
+Chat completion plus benchmarking metrics.
 
 ### Cancel Command
 
@@ -375,148 +204,24 @@ Cancels an active generation command (text or image). Notifies workers and close
 
 Returns 404 if the command is not found or already completed.
 
-## 5. Ollama API Compatibility
-
-EXO provides Ollama API compatibility for tools like OpenWebUI.
-
-### Ollama Chat
-
-**POST** `/ollama/api/chat`
-**POST** `/ollama/api/api/chat` (alias)
-**POST** `/ollama/api/v1/chat` (alias)
-
-Execute a chat request using Ollama API format.
-
-**Request body (example):**
-
-```json
-{
-  "model": "llama-3.2-1b",
-  "messages": [
-    { "role": "user", "content": "Hello" }
-  ],
-  "stream": false
-}
-```
-
-**Response:**
-Ollama-compatible chat response.
-
-### Ollama Generate
-
-**POST** `/ollama/api/generate`
-
-Execute a text generation request using Ollama API format.
-
-**Request body (example):**
-
-```json
-{
-  "model": "llama-3.2-1b",
-  "prompt": "Hello",
-  "stream": false
-}
-```
-
-**Response:**
-Ollama-compatible generation response.
-
-### Ollama Tags
-
-**GET** `/ollama/api/tags`
-**GET** `/ollama/api/api/tags` (alias)
-**GET** `/ollama/api/v1/tags` (alias)
-
-Returns list of downloaded models in Ollama tags format.
-
-**Response:**
-Array of model tags with metadata.
-
-### Ollama Show
-
-**POST** `/ollama/api/show`
-
-Returns model information in Ollama show format.
-
-**Request body:**
-
-```json
-{
-  "name": "llama-3.2-1b"
-}
-```
-
-**Response:**
-Model details including modelfile and family.
-
-### Ollama PS
-
-**GET** `/ollama/api/ps`
-
-Returns list of running models (active instances).
-
-**Response:**
-Array of active model instances.
-
-### Ollama Version
-
-**GET** `/ollama/api/version`
-**HEAD** `/ollama/` (alias)
-**HEAD** `/ollama/api/version` (alias)
-
-Returns version information for Ollama API compatibility.
-
-**Response:**
-
-```json
-{
-  "version": "exo v1.0"
-}
-```
-
-## 6. Image Generation & Editing
+## 5. Image Generation & Editing
 
 ### Image Generation
 
 **POST** `/v1/images/generations`
 
-Executes an image generation request using an OpenAI-compatible schema with additional advanced_params. Supports both streaming and non-streaming modes.
+Executes an image generation request using an OpenAI-compatible schema with additional advanced_params.
 
 **Request body (example):**
 
 ```json
 {
   "prompt": "a robot playing chess",
-  "model": "exolabs/FLUX.1-dev",
-  "n": 1,
-  "size": "1024x1024",
+  "model": "flux-dev",
   "stream": false,
-  "response_format": "b64_json"
 }
 ```
 
-**Request parameters:**
-
-* `prompt`: string, required - Text description of the image
-* `model`: string, required - Image model ID
-* `n`: integer (default: 1) - Number of images to generate
-* `size`: string (default: "auto") - Image dimensions. Supported sizes:
-  - `512x512`
-  - `768x768`
-  - `1024x768`
-  - `768x1024`
-  - `1024x1024`
-  - `1024x1536`
-  - `1536x1024`
-  - `1024x1365`
-  - `1365x1024`
-* `stream`: boolean (default: false) - Enable streaming for partial images
-* `partial_images`: integer (default: 0) - Number of partial images to stream during generation
-* `response_format`: string (default: "b64_json") - Either `url` or `b64_json`
-* `quality`: string (default: "medium") - Either `high`, `medium`, or `low`
-* `output_format`: string (default: "png") - Either `png`, `jpeg`, or `webp`
-* `advanced_params`: object (optional) - Advanced generation parameters
-
 **Advanced Parameters (`advanced_params`):**
 
 | Parameter | Type | Constraints | Description |
@@ -526,54 +231,8 @@ Executes an image generation request using an OpenAI-compatible schema with addi
 | `guidance` | float | 1.0-20.0 | Classifier-free guidance scale |
 | `negative_prompt` | string | - | Text describing what to avoid in the image |
 
-**Non-streaming response:**
-
-```json
-{
-  "created": 1234567890,
-  "data": [
-    {
-      "b64_json": "iVBORw0KGgoAAAANSUhEUgAA...",
-      "url": null
-    }
-  ]
-}
-```
-
-**Streaming response format:**
-When `stream=true` and `partial_images > 0`, returns Server-Sent Events:
-
-```
-data: {"type":"partial","image_index":0,"partial_index":1,"total_partials":5,"format":"png","data":{"b64_json":"..."}}
-
-data: {"type":"final","image_index":0,"format":"png","data":{"b64_json":"..."}}
-
-data: [DONE]
-```
-
-### Image Editing
-
-**POST** `/v1/images/edits`
-
-Executes an image editing request (img2img) using FLUX.1-Kontext-dev or similar models.
-
-**Request (multipart/form-data):**
-
-* `image`: file, required - Input image to edit
-* `prompt`: string, required - Text description of desired changes
-* `model`: string, required - Image editing model ID (e.g., `exolabs/FLUX.1-Kontext-dev`)
-* `n`: integer (default: 1) - Number of edited images to generate
-* `size`: string (optional) - Output image dimensions
-* `response_format`: string (default: "b64_json") - Either `url` or `b64_json`
-* `input_fidelity`: string (default: "low") - Either `low` or `high` - Controls how closely the output follows the input image
-* `stream`: string (default: "false") - Enable streaming
-* `partial_images`: string (default: "0") - Number of partial images to stream
-* `quality`: string (default: "medium") - Either `high`, `medium`, or `low`
-* `output_format`: string (default: "png") - Either `png`, `jpeg`, or `webp`
-* `advanced_params`: string (optional) - JSON-encoded advanced parameters
-
 **Response:**
-Same format as `/v1/images/generations`.
+OpenAI-compatible image generation response.
 
 ### Benchmarked Image Generation
 
@@ -585,15 +244,16 @@ Same as `/v1/images/generations`, but also returns generation statistics.
 Same schema as `/v1/images/generations`.
 
 **Response:**
-Image generation plus benchmarking metrics including:
+Image generation plus benchmarking metrics.
 
-* `seconds_per_step` - Average time per denoising step
-* `total_generation_time` - Total generation time
-* `num_inference_steps` - Number of inference steps used
-* `num_images` - Number of images generated
-* `image_width` - Output image width
-* `image_height` - Output image height
-* `peak_memory_usage` - Peak memory used during generation
+### Image Editing
+
+**POST** `/v1/images/edits`
+
+Executes an image editing request using an OpenAI-compatible schema with additional advanced_params (same as `/v1/images/generations`).
+
+**Response:**
+Same format as `/v1/images/generations`.
 
 ### Benchmarked Image Editing
 
@@ -607,127 +267,37 @@ Same schema as `/v1/images/edits`.
 **Response:**
 Same format as `/bench/images/generations`, including `generation_stats`.
 
-### List Images
-
-**GET** `/images`
-
-List all stored images.
-
-**Response:**
-Array of image metadata including URLs and expiration times.
-
-### Get Image
-
-**GET** `/images/{image_id}`
-
-Retrieve a stored image by ID.
-
-**Path parameters:**
-
-* `image_id`: string, ID of the image
-
-**Response:**
-Image file with appropriate content type.
-
-## 7. Complete Endpoint Summary
+## 6. Complete Endpoint Summary
 
 ```
-# General
 GET     /node_id
 GET     /state
 GET     /events
 
-# Instance Management
 POST    /instance
 GET     /instance/{instance_id}
 DELETE  /instance/{instance_id}
+
 GET     /instance/previews
 GET     /instance/placement
 POST    /place_instance
 
-# Models
 GET     /models
 GET     /v1/models
-POST    /models/add
-DELETE  /models/custom/{model_id}
-GET     /models/search
 
-# Text Generation (OpenAI Chat Completions)
 POST    /v1/chat/completions
 POST    /bench/chat/completions
-
-# Text Generation (Claude Messages API)
-POST    /v1/messages
-
-# Text Generation (OpenAI Responses API)
-POST    /v1/responses
-
-# Text Generation (Ollama API)
-POST    /ollama/api/chat
-POST    /ollama/api/api/chat
-POST    /ollama/api/v1/chat
-POST    /ollama/api/generate
-GET     /ollama/api/tags
-GET     /ollama/api/api/tags
-GET     /ollama/api/v1/tags
-POST    /ollama/api/show
-GET     /ollama/api/ps
-GET     /ollama/api/version
-HEAD    /ollama/
-HEAD    /ollama/api/version
-
-# Command Control
 POST    /v1/cancel/{command_id}
 
-# Image Generation
 POST    /v1/images/generations
 POST    /bench/images/generations
 POST    /v1/images/edits
 POST    /bench/images/edits
-GET     /images
-GET     /images/{image_id}
 ```
 
-## 8. Notes
+## 7. Notes
 
-### API Compatibility
-
-EXO provides multiple API-compatible interfaces:
-
-* **OpenAI Chat Completions API** - Compatible with OpenAI clients and tools
-* **Claude Messages API** - Compatible with Anthropic's Claude API format
-* **OpenAI Responses API** - Compatible with OpenAI's Responses API format
-* **Ollama API** - Compatible with Ollama and tools like OpenWebUI
-
-Existing OpenAI, Claude, or Ollama clients can be pointed to EXO by changing the base URL.
-
-### Custom Models
-
-You can add custom models from HuggingFace using the `/models/add` endpoint. Custom models are identified by the `is_custom` field in model list responses.
-
-**Security:** Models requiring `trust_remote_code` must be explicitly enabled (default is false) for security. Only enable this if you trust the model's remote code.
-
-### Usage Statistics
-
-Chat completion responses include usage statistics with:
-
-* `prompt_tokens` - Number of tokens in the prompt
-* `completion_tokens` - Number of tokens generated
-* `total_tokens` - Sum of prompt and completion tokens
-
-### Request Cancellation
-
-You can cancel active requests by:
-
-1. Closing the HTTP connection (for streaming requests)
-2. Calling `/v1/cancel/{command_id}` (for any request)
-
-The server detects cancellation and stops processing immediately.
-
-### Instance Placement
-
-The instance placement endpoints allow you to plan and preview cluster allocations before creating instances. This helps optimize resource usage across nodes.
-
-### Observability
-
-The `/events` and `/state` endpoints are primarily intended for operational visibility and debugging.
+* The `/v1/chat/completions` endpoint is compatible with the OpenAI Chat API format, so existing OpenAI clients can be pointed to EXO by changing the base URL.
+* The `/v1/images/generations` and `/v1/images/edits` endpoints are compatible with the OpenAI Images API format.
+* The instance placement endpoints allow you to plan and preview cluster allocations before actually creating instances.
+* The `/events` and `/state` endpoints are primarily intended for operational visibility and debugging.

docs/architecture.md

@@ -28,26 +28,6 @@ There are currently 5 major systems:
     
     Implements a distributed algorithm for master election in unstable networking conditions
 
-## API Layer
-
-The API system uses multiple adapters to support multiple API formats, converting them to a single request / response type.
-
-### Adapter Pattern
-
-Adapters convert between external API formats and EXO's internal types:
-
-```
-Chat Completions → [adapter] → TextGenerationTaskParams → Application
-Claude Messages  → [adapter] → TextGenerationTaskParams → Application
-Responses API    → [adapter] → TextGenerationTaskParams → Application
-Ollama API       → [adapter] → TextGenerationTaskParams → Application
-```
-
-Each adapter implements two key functions:
-1. **Request conversion**: Converts API-specific requests to `TextGenerationTaskParams`
-2. **Response generation**: Converts internal `TokenChunk` streams back to API-specific formats (streaming and non-streaming)
-
-
 ## Topics
 
 There are currently 5 topics:

pyproject.toml

@@ -62,7 +62,7 @@ members = ["rust/exo_pyo3_bindings", "bench"]
 [tool.uv.sources]
 exo_pyo3_bindings = { workspace = true }
 mlx = { git = "https://github.com/rltakashige/mlx-jaccl-fix-small-recv.git", branch = "address-rdma-gpu-locks", marker = "sys_platform == 'darwin'" }
-mlx-lm = { git = "https://github.com/rltakashige/mlx-lm", branch = "fix/float32-logprobs" }
+mlx-lm = { git = "https://github.com/ml-explore/mlx-lm", rev = "834fac934c4e04de9b3d723e2b9287a2c60cfd4a" }
 # Uncomment to use local mlx/mlx-lm development versions:
 # mlx = { path = "/Users/Shared/mlx", editable=true }
 # mlx-lm = { path = "/Users/Shared/mlx-lm", editable=true }
@@ -125,7 +125,6 @@ extend-exclude = [
   "shared/protobufs/**",
   "*mlx_typings/**",
   "rust/exo_pyo3_bindings/**",
-  "bench/vendor/**",
 ]
 
 [tool.ruff.lint]

python/parts.nix

@@ -43,27 +43,6 @@
             final.setuptools
           ];
         });
-        # rouge-score and sacrebleu don't declare setuptools as a build dependency
-        rouge-score = prev.rouge-score.overrideAttrs (old: {
-          nativeBuildInputs = (old.nativeBuildInputs or [ ]) ++ [
-            final.setuptools
-          ];
-        });
-        sacrebleu = prev.sacrebleu.overrideAttrs (old: {
-          nativeBuildInputs = (old.nativeBuildInputs or [ ]) ++ [
-            final.setuptools
-          ];
-        });
-        sqlitedict = prev.sqlitedict.overrideAttrs (old: {
-          nativeBuildInputs = (old.nativeBuildInputs or [ ]) ++ [
-            final.setuptools
-          ];
-        });
-        word2number = prev.word2number.overrideAttrs (old: {
-          nativeBuildInputs = (old.nativeBuildInputs or [ ]) ++ [
-            final.setuptools
-          ];
-        });
       } // lib.optionalAttrs pkgs.stdenv.hostPlatform.isDarwin {
         # Use our pure Nix-built MLX with Metal support (macOS only)
         mlx = self'.packages.mlx;
@@ -117,16 +96,13 @@
         "lib/python3.13/site-packages/nvidia*"
       ];
 
-      # Exclude bench deps from main env (bench has its own benchVenv)
-      exoDeps = removeAttrs workspace.deps.default [ "exo-bench" ];
-
-      exoVenv = (pythonSet.mkVirtualEnv "exo-env" exoDeps).overrideAttrs {
+      exoVenv = (pythonSet.mkVirtualEnv "exo-env" workspace.deps.default).overrideAttrs {
         venvIgnoreCollisions = venvCollisionPaths;
       };
 
       # Virtual environment with dev dependencies for testing
       testVenv = (pythonSet.mkVirtualEnv "exo-test-env" (
-        exoDeps // {
+        workspace.deps.default // {
           exo = [ "dev" ]; # Include pytest, pytest-asyncio, pytest-env
         }
       )).overrideAttrs {
@@ -182,7 +158,6 @@
           exo-test-env = testVenv;
         } // {
         exo-bench = mkBenchScript "exo-bench" (inputs.self + /bench/exo_bench.py);
-        exo-eval = mkBenchScript "exo-eval" (inputs.self + /bench/exo_eval.py);
         exo-eval-tool-calls = mkBenchScript "exo-eval-tool-calls" (inputs.self + /bench/eval_tool_calls.py);
         exo-get-all-models-on-cluster = mkSimplePythonScript "exo-get-all-models-on-cluster" (inputs.self + /tests/get_all_models_on_cluster.py);
       };

rust/exo_pyo3_bindings/Cargo.toml

@@ -5,7 +5,6 @@ edition = { workspace = true }
 publish = false
 
 [lib]
-doctest = false
 path = "src/lib.rs"
 name = "exo_pyo3_bindings"
 
@@ -48,19 +47,11 @@ pyo3-log = "0.13.2"
 
 # macro dependencies
 extend = { workspace = true }
-delegate = { workspace = true }
 
 # async runtime
 tokio = { workspace = true, features = ["full", "tracing"] }
 futures-lite = { workspace = true }
 
-# utility dependencies
-util = { workspace = true }
-
 # Tracing
 log = { workspace = true }
 env_logger = "0.11"
-
-# Networking
-libp2p = { workspace = true, features = ["full"] }
-pin-project = "1.1.10"

rust/exo_pyo3_bindings/README.md

@@ -1 +0,0 @@
-TODO: do something here....

rust/exo_pyo3_bindings/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "exo_pyo3_bindings"
-version = "0.2.1"
+version = "0.2.0"
 description = "Add your description here"
 readme = "README.md"
 authors = [

rust/exo_pyo3_bindings/src/allow_threading.rs

@@ -1,37 +1,22 @@
-//! SEE: https://pyo3.rs/v0.26.0/async-await.html#detaching-from-the-interpreter-across-await
-//!
-
-use pin_project::pin_project;
+//! See: <https://pyo3.rs/v0.27.2/async-await.html#detaching-from-the-interpreter-across-await>
 use pyo3::prelude::*;
 use std::{
     future::Future,
-    pin::Pin,
+    pin::{Pin, pin},
     task::{Context, Poll},
 };
 
-/// SEE: https://pyo3.rs/v0.26.0/async-await.html#detaching-from-the-interpreter-across-await
-#[pin_project]
-#[repr(transparent)]
-pub(crate) struct AllowThreads<F>(#[pin] F);
-
-impl<F> AllowThreads<F>
-where
-    Self: Future,
-{
-    pub fn new(f: F) -> Self {
-        Self(f)
-    }
-}
+pub struct AllowThreads<F>(pub(crate) F);
 
 impl<F> Future for AllowThreads<F>
 where
-    F: Future + Send,
+    F: Future + Unpin + Send,
     F::Output: Send,
 {
     type Output = F::Output;
 
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let waker = cx.waker();
-        Python::attach(|py| py.detach(|| self.project().0.poll(&mut Context::from_waker(waker))))
+        Python::attach(|py| py.detach(|| pin!(&mut self.0).poll(&mut Context::from_waker(waker))))
     }
 }

rust/exo_pyo3_bindings/src/lib.rs

@@ -1,174 +1,5 @@
-//! TODO: crate documentation
-//!
-//! this is here as a placeholder documentation
-//!
-//!
-
-mod allow_threading;
-mod ident;
-mod networking;
-
-use crate::ident::PyKeypair;
-use crate::networking::networking_submodule;
-use pyo3::prelude::PyModule;
-use pyo3::types::PyModuleMethods;
-use pyo3::{Bound, PyResult, pyclass, pymodule};
 use pyo3_stub_gen::define_stub_info_gatherer;
 
-/// Namespace for all the constants used by this crate.
-pub(crate) mod r#const {
-    pub const MPSC_CHANNEL_SIZE: usize = 1024;
-}
-
-/// Namespace for crate-wide extension traits/methods
-pub(crate) mod ext {
-    use crate::allow_threading::AllowThreads;
-    use extend::ext;
-    use pyo3::exceptions::{PyConnectionError, PyRuntimeError};
-    use pyo3::types::PyBytes;
-    use pyo3::{Py, PyErr, PyResult, Python};
-    use tokio::runtime::Runtime;
-    use tokio::sync::mpsc;
-    use tokio::sync::mpsc::error::TryRecvError;
-    use tokio::task::JoinHandle;
-
-    #[ext(pub, name = ByteArrayExt)]
-    impl [u8] {
-        fn pybytes(&self) -> Py<PyBytes> {
-            Python::attach(|py| PyBytes::new(py, self).unbind())
-        }
-    }
-
-    #[ext(pub, name = ResultExt)]
-    impl<T, E> Result<T, E>
-    where
-        E: ToString,
-    {
-        fn pyerr(self) -> PyResult<T> {
-            self.map_err(|e| PyRuntimeError::new_err(e.to_string()))
-        }
-    }
-
-    pub trait FutureExt: Future + Sized {
-        /// SEE: https://pyo3.rs/v0.26.0/async-await.html#detaching-from-the-interpreter-across-await
-        fn allow_threads_py(self) -> AllowThreads<Self>
-        where
-            AllowThreads<Self>: Future,
-        {
-            AllowThreads::new(self)
-        }
-    }
-
-    impl<T: Future> FutureExt for T {}
-
-    #[ext(pub, name = PyErrExt)]
-    impl PyErr {
-        fn receiver_channel_closed() -> Self {
-            PyConnectionError::new_err("Receiver channel closed unexpectedly")
-        }
-    }
-
-    #[ext(pub, name = PyResultExt)]
-    impl<T> PyResult<T> {
-        fn write_unraisable(self) -> Option<T> {
-            Python::attach(|py| self.write_unraisable_with(py))
-        }
-
-        fn write_unraisable_with(self, py: Python<'_>) -> Option<T> {
-            match self {
-                Ok(v) => Some(v),
-                Err(e) => {
-                    // write error back to python
-                    e.write_unraisable(py, None);
-                    None
-                }
-            }
-        }
-    }
-
-    #[ext(pub, name = TokioRuntimeExt)]
-    impl Runtime {
-        fn spawn_with_scope<F>(&self, py: Python<'_>, future: F) -> PyResult<JoinHandle<F::Output>>
-        where
-            F: Future + Send + 'static,
-            F::Output: Send + 'static,
-        {
-            let locals = pyo3_async_runtimes::tokio::get_current_locals(py)?;
-            Ok(self.spawn(pyo3_async_runtimes::tokio::scope(locals, future)))
-        }
-    }
-
-    #[ext(pub, name = TokioMpscSenderExt)]
-    impl<T> mpsc::Sender<T> {
-        /// Sends a value, waiting until there is capacity.
-        ///
-        /// A successful send occurs when it is determined that the other end of the
-        /// channel has not hung up already. An unsuccessful send would be one where
-        /// the corresponding receiver has already been closed.
-        async fn send_py(&self, value: T) -> PyResult<()> {
-            self.send(value)
-                .await
-                .map_err(|_| PyErr::receiver_channel_closed())
-        }
-    }
-
-    #[ext(pub, name = TokioMpscReceiverExt)]
-    impl<T> mpsc::Receiver<T> {
-        /// Receives the next value for this receiver.
-        async fn recv_py(&mut self) -> PyResult<T> {
-            self.recv().await.ok_or_else(PyErr::receiver_channel_closed)
-        }
-
-        /// Receives at most `limit` values for this receiver and returns them.
-        ///
-        /// For `limit = 0`, an empty collection of messages will be returned immediately.
-        /// For `limit > 0`, if there are no messages in the channel's queue this method
-        /// will sleep until a message is sent.
-        async fn recv_many_py(&mut self, limit: usize) -> PyResult<Vec<T>> {
-            // get updates from receiver channel
-            let mut updates = Vec::with_capacity(limit);
-            let received = self.recv_many(&mut updates, limit).await;
-
-            // if we received zero items, then the channel was unexpectedly closed
-            if limit != 0 && received == 0 {
-                return Err(PyErr::receiver_channel_closed());
-            }
-
-            Ok(updates)
-        }
-
-        /// Tries to receive the next value for this receiver.
-        fn try_recv_py(&mut self) -> PyResult<Option<T>> {
-            match self.try_recv() {
-                Ok(v) => Ok(Some(v)),
-                Err(TryRecvError::Empty) => Ok(None),
-                Err(TryRecvError::Disconnected) => Err(PyErr::receiver_channel_closed()),
-            }
-        }
-    }
-}
-
-/// A Python module implemented in Rust. The name of this function must match
-/// the `lib.name` setting in the `Cargo.toml`, else Python will not be able to
-/// import the module.
-#[pymodule(name = "exo_pyo3_bindings")]
-fn main_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
-    // install logger
-    pyo3_log::init();
-    let mut builder = tokio::runtime::Builder::new_multi_thread();
-    builder.enable_all();
-    pyo3_async_runtimes::tokio::init(builder);
-
-    // TODO: for now this is all NOT a submodule, but figure out how to make the submodule system
-    //       work with maturin, where the types generate correctly, in the right folder, without
-    //       too many importing issues...
-    m.add_class::<PyKeypair>()?;
-    networking_submodule(m)?;
-
-    // top-level constructs
-    // TODO: ...
-
-    Ok(())
-}
+mod allow_threading;
 
 define_stub_info_gatherer!(stub_info);

rust/exo_pyo3_bindings/src/networking.rs

@@ -1,311 +0,0 @@
-use std::pin::Pin;
-use std::sync::Arc;
-
-use crate::r#const::MPSC_CHANNEL_SIZE;
-use crate::ext::{ByteArrayExt as _, FutureExt, PyErrExt as _};
-use crate::ext::{ResultExt as _, TokioMpscSenderExt as _};
-use crate::ident::PyKeypair;
-use crate::networking::exception::{
-    PyAllQueuesFullError, PyMessageTooLargeError, PyNoPeersSubscribedToTopicError,
-};
-use crate::pyclass;
-use futures_lite::{Stream, StreamExt as _};
-use libp2p::gossipsub::PublishError;
-use networking::swarm::{FromSwarm, ToSwarm, create_swarm};
-use pyo3::exceptions::PyRuntimeError;
-use pyo3::prelude::{PyModule, PyModuleMethods as _};
-use pyo3::types::PyBytes;
-use pyo3::{Bound, Py, PyAny, PyErr, PyResult, Python, pymethods};
-use pyo3_stub_gen::derive::{
-    gen_methods_from_python, gen_stub_pyclass, gen_stub_pyclass_complex_enum, gen_stub_pymethods,
-};
-use tokio::sync::{Mutex, mpsc, oneshot};
-
-mod exception {
-    use pyo3::types::PyTuple;
-    use pyo3::{exceptions::PyException, prelude::*};
-    use pyo3_stub_gen::derive::*;
-
-    #[gen_stub_pyclass]
-    #[pyclass(frozen, extends=PyException, name="NoPeersSubscribedToTopicError")]
-    pub struct PyNoPeersSubscribedToTopicError {}
-
-    impl PyNoPeersSubscribedToTopicError {
-        const MSG: &'static str = "\
-        No peers are currently subscribed to receive messages on this topic. \
-        Wait for peers to subscribe or check your network connectivity.";
-
-        ///   Creates a new  [ `PyErr` ]  of this type.
-        ///
-        ///   [`PyErr`] :  https://docs.rs/pyo3/latest/pyo3/struct.PyErr.html   "PyErr in pyo3"
-        pub(crate) fn new_err() -> PyErr {
-            PyErr::new::<Self, _>(()) // TODO: check if this needs to be replaced???
-        }
-    }
-
-    #[gen_stub_pymethods]
-    #[pymethods]
-    impl PyNoPeersSubscribedToTopicError {
-        #[new]
-        #[pyo3(signature = (*args))]
-        #[allow(unused_variables)]
-        pub(crate) fn new(args: &Bound<'_, PyTuple>) -> Self {
-            Self {}
-        }
-
-        fn __repr__(&self) -> String {
-            format!("PeerId(\"{}\")", Self::MSG)
-        }
-
-        fn __str__(&self) -> String {
-            Self::MSG.to_string()
-        }
-    }
-
-    #[gen_stub_pyclass]
-    #[pyclass(frozen, extends=PyException, name="AllQueuesFullError")]
-    pub struct PyAllQueuesFullError {}
-
-    impl PyAllQueuesFullError {
-        const MSG: &'static str =
-            "All libp2p peers are unresponsive, resend the message or reconnect.";
-
-        ///   Creates a new  [ `PyErr` ]  of this type.
-        ///
-        ///   [`PyErr`] :  https://docs.rs/pyo3/latest/pyo3/struct.PyErr.html   "PyErr in pyo3"
-        pub(crate) fn new_err() -> PyErr {
-            PyErr::new::<Self, _>(()) // TODO: check if this needs to be replaced???
-        }
-    }
-
-    #[gen_stub_pymethods]
-    #[pymethods]
-    impl PyAllQueuesFullError {
-        #[new]
-        #[pyo3(signature = (*args))]
-        #[allow(unused_variables)]
-        pub(crate) fn new(args: &Bound<'_, PyTuple>) -> Self {
-            Self {}
-        }
-
-        fn __repr__(&self) -> String {
-            format!("PeerId(\"{}\")", Self::MSG)
-        }
-
-        fn __str__(&self) -> String {
-            Self::MSG.to_string()
-        }
-    }
-
-    #[gen_stub_pyclass]
-    #[pyclass(frozen, extends=PyException, name="MessageTooLargeError")]
-    pub struct PyMessageTooLargeError {}
-
-    impl PyMessageTooLargeError {
-        const MSG: &'static str = "Gossipsub message exceeds max_transmit_size. Reduce prompt length or increase the limit.";
-
-        pub(crate) fn new_err() -> PyErr {
-            PyErr::new::<Self, _>(())
-        }
-    }
-
-    #[gen_stub_pymethods]
-    #[pymethods]
-    impl PyMessageTooLargeError {
-        #[new]
-        #[pyo3(signature = (*args))]
-        #[allow(unused_variables)]
-        pub(crate) fn new(args: &Bound<'_, PyTuple>) -> Self {
-            Self {}
-        }
-
-        fn __repr__(&self) -> String {
-            format!("MessageTooLargeError(\"{}\")", Self::MSG)
-        }
-
-        fn __str__(&self) -> String {
-            Self::MSG.to_string()
-        }
-    }
-}
-
-#[gen_stub_pyclass]
-#[pyclass(name = "NetworkingHandle")]
-struct PyNetworkingHandle {
-    // channels
-    pub to_swarm: mpsc::Sender<ToSwarm>,
-    pub swarm: Arc<Mutex<Pin<Box<dyn Stream<Item = FromSwarm> + Send>>>>,
-}
-
-#[gen_stub_pyclass_complex_enum]
-#[pyclass]
-enum PyFromSwarm {
-    Connection {
-        peer_id: String,
-        connected: bool,
-    },
-    Message {
-        origin: String,
-        topic: String,
-        data: Py<PyBytes>,
-    },
-}
-impl From<FromSwarm> for PyFromSwarm {
-    fn from(value: FromSwarm) -> Self {
-        match value {
-            FromSwarm::Discovered { peer_id } => Self::Connection {
-                peer_id: peer_id.to_base58(),
-                connected: true,
-            },
-            FromSwarm::Expired { peer_id } => Self::Connection {
-                peer_id: peer_id.to_base58(),
-                connected: false,
-            },
-            FromSwarm::Message { from, topic, data } => Self::Message {
-                origin: from.to_base58(),
-                topic: topic,
-                data: data.pybytes(),
-            },
-        }
-    }
-}
-
-#[gen_stub_pymethods]
-#[pymethods]
-impl PyNetworkingHandle {
-    // NOTE: `async fn`s here that use `.await` will wrap the future in `.allow_threads_py()`
-    //       immediately beforehand to release the interpreter.
-    //       SEE: https://pyo3.rs/v0.26.0/async-await.html#detaching-from-the-interpreter-across-await
-
-    // ---- Lifecycle management methods ----
-
-    #[new]
-    fn py_new(identity: Bound<'_, PyKeypair>) -> PyResult<Self> {
-        // create communication channels
-        let (to_swarm, from_client) = mpsc::channel(MPSC_CHANNEL_SIZE);
-
-        // get identity
-        let identity = identity.borrow().0.clone();
-
-        // create networking swarm (within tokio context!! or it crashes)
-        let _guard = pyo3_async_runtimes::tokio::get_runtime().enter();
-        let swarm = create_swarm(identity, from_client).pyerr()?.into_stream();
-
-        Ok(Self {
-            swarm: Arc::new(Mutex::new(swarm)),
-            to_swarm,
-        })
-    }
-
-    #[gen_stub(skip)]
-    fn recv<'py>(&'py self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
-        let swarm = Arc::clone(&self.swarm);
-        pyo3_async_runtimes::tokio::future_into_py(py, async move {
-            swarm
-                .try_lock()
-                .map_err(|_| PyRuntimeError::new_err("called recv twice concurrently"))?
-                .next()
-                .await
-                .ok_or(PyErr::receiver_channel_closed())
-                .map(PyFromSwarm::from)
-        })
-    }
-
-    // ---- Gossipsub management methods ----
-
-    /// Subscribe to a `GossipSub` topic.
-    ///
-    /// Returns `True` if the subscription worked. Returns `False` if we were already subscribed.
-    async fn gossipsub_subscribe(&self, topic: String) -> PyResult<bool> {
-        let (tx, rx) = oneshot::channel();
-
-        // send off request to subscribe
-        self.to_swarm
-            .send_py(ToSwarm::Subscribe {
-                topic,
-                result_sender: tx,
-            })
-            .allow_threads_py() // allow-threads-aware async call
-            .await?;
-
-        // wait for response & return any errors
-        rx.allow_threads_py() // allow-threads-aware async call
-            .await
-            .map_err(|_| PyErr::receiver_channel_closed())?
-            .pyerr()
-    }
-
-    /// Unsubscribes from a `GossipSub` topic.
-    ///
-    /// Returns `True` if we were subscribed to this topic. Returns `False` if we were not subscribed.
-    async fn gossipsub_unsubscribe(&self, topic: String) -> PyResult<bool> {
-        let (tx, rx) = oneshot::channel();
-
-        // send off request to unsubscribe
-        self.to_swarm
-            .send_py(ToSwarm::Unsubscribe {
-                topic,
-                result_sender: tx,
-            })
-            .allow_threads_py() // allow-threads-aware async call
-            .await?;
-
-        // wait for response & convert any errors
-        rx.allow_threads_py() // allow-threads-aware async call
-            .await
-            .map_err(|_| PyErr::receiver_channel_closed())
-    }
-
-    /// Publishes a message with multiple topics to the `GossipSub` network.
-    ///
-    /// If no peers are found that subscribe to this topic, throws `NoPeersSubscribedToTopicError` exception.
-    async fn gossipsub_publish(&self, topic: String, data: Py<PyBytes>) -> PyResult<()> {
-        let (tx, rx) = oneshot::channel();
-
-        // send off request to subscribe
-        let data = Python::attach(|py| Vec::from(data.as_bytes(py)));
-        self.to_swarm
-            .send_py(ToSwarm::Publish {
-                topic,
-                data,
-                result_sender: tx,
-            })
-            .allow_threads_py() // allow-threads-aware async call
-            .await?;
-
-        // wait for response & return any errors => ignore messageID for now!!!
-        let _ = rx
-            .allow_threads_py() // allow-threads-aware async call
-            .await
-            .map_err(|_| PyErr::receiver_channel_closed())?
-            .map_err(|e| match e {
-                PublishError::AllQueuesFull(_) => PyAllQueuesFullError::new_err(),
-                PublishError::MessageTooLarge => PyMessageTooLargeError::new_err(),
-                PublishError::NoPeersSubscribedToTopic => {
-                    PyNoPeersSubscribedToTopicError::new_err()
-                }
-                e => PyRuntimeError::new_err(e.to_string()),
-            })?;
-        Ok(())
-    }
-}
-
-pyo3_stub_gen::inventory::submit! {
-    gen_methods_from_python! {
-        r#"
-            class PyNetworkingHandle:
-                async def recv() -> PyFromSwarm: ...
-        "#
-    }
-}
-
-pub fn networking_submodule(m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add_class::<exception::PyNoPeersSubscribedToTopicError>()?;
-    m.add_class::<exception::PyAllQueuesFullError>()?;
-    m.add_class::<exception::PyMessageTooLargeError>()?;
-
-    m.add_class::<PyNetworkingHandle>()?;
-    m.add_class::<PyFromSwarm>()?;
-
-    Ok(())
-}

rust/exo_pyo3_bindings/tests/dummy.rs

@@ -1,54 +0,0 @@
-#[cfg(test)]
-mod tests {
-    use core::mem::drop;
-    use core::option::Option::Some;
-    use core::time::Duration;
-    use tokio;
-    use tokio::sync::mpsc;
-
-    #[tokio::test]
-    async fn test_drop_channel() {
-        struct Ping;
-
-        let (tx, mut rx) = mpsc::channel::<Ping>(10);
-
-        let _ = tokio::spawn(async move {
-            println!("TASK: entered");
-
-            loop {
-                tokio::select! {
-                    result = rx.recv() => {
-                        match result {
-                            Some(_) => {
-                                println!("TASK: pinged");
-                            }
-                            None => {
-                                println!("TASK: closing channel");
-                                break;
-                            }
-                        }
-                    }
-                    _ = tokio::time::sleep(Duration::from_secs_f32(0.1)) => {
-                        println!("TASK: heartbeat");
-                    }
-                }
-            }
-
-            println!("TASK: exited");
-        });
-
-        let tx2 = tx.clone();
-
-        tokio::time::sleep(Duration::from_secs_f32(0.11)).await;
-
-        tx.send(Ping).await.expect("Should not fail");
-        drop(tx);
-
-        tokio::time::sleep(Duration::from_secs_f32(0.11)).await;
-
-        tx2.send(Ping).await.expect("Should not fail");
-        drop(tx2);
-
-        tokio::time::sleep(Duration::from_secs_f32(0.11)).await;
-    }
-}

rust/networking/Cargo.toml

@@ -5,7 +5,6 @@ edition = { workspace = true }
 publish = false
 
 [lib]
-doctest = false
 name = "networking"
 path = "src/lib.rs"
 
@@ -13,30 +12,22 @@ path = "src/lib.rs"
 workspace = true
 
 [dependencies]
-# datastructures
-either = { workspace = true }
-
 # macro dependencies
 extend = { workspace = true }
-delegate = { workspace = true }
 
 # async
-async-stream = { workspace = true }
-futures-lite = { workspace = true }
-futures-timer = { workspace = true }
 tokio = { workspace = true, features = ["full"] }
+futures-lite = { workspace = true }
 
 # utility dependencies
-util = { workspace = true }
-tracing-subscriber = { version = "0.3.19", features = [
-  "default",
-  "env-filter",
-] }
-keccak-const = { workspace = true }
+tracing-subscriber = { version = "0.3.19", features = ["default", "env-filter"] }
+pin-project = "1.1.10"
 
 # tracing/logging
 log = { workspace = true }
+iroh = "0.96.1"
+iroh-gossip = "0.96.0"
+iroh-blobs = "0.98.0"
+iroh-docs = "0.96.0"
 
 # networking
-libp2p = { workspace = true, features = ["full"] }
-pin-project = "1.1.10"

rust/networking/examples/chatroom.rs

@@ -1,9 +1,3 @@
-use futures_lite::StreamExt;
-use libp2p::identity;
-use networking::swarm;
-use networking::swarm::{FromSwarm, ToSwarm};
-use tokio::sync::{mpsc, oneshot};
-use tokio::{io, io::AsyncBufReadExt as _};
 use tracing_subscriber::EnvFilter;
 use tracing_subscriber::filter::LevelFilter;
 
@@ -12,70 +6,4 @@ async fn main() {
     let _ = tracing_subscriber::fmt()
         .with_env_filter(EnvFilter::from_default_env().add_directive(LevelFilter::INFO.into()))
         .try_init();
-
-    let (to_swarm, from_client) = mpsc::channel(20);
-
-    // Configure swarm
-    let mut swarm = swarm::create_swarm(identity::Keypair::generate_ed25519(), from_client)
-        .expect("Swarm creation failed")
-        .into_stream();
-
-    // Create a Gossipsub topic & subscribe
-    let (tx, rx) = oneshot::channel();
-    _ = to_swarm
-        .send(ToSwarm::Subscribe {
-            topic: "test-net".to_string(),
-            result_sender: tx,
-        })
-        .await
-        .expect("should send");
-
-    // Read full lines from stdin
-    let mut stdin = io::BufReader::new(io::stdin()).lines();
-    println!("Enter messages via STDIN and they will be sent to connected peers using Gossipsub");
-
-    tokio::task::spawn(async move {
-        rx.await
-            .expect("tx not dropped")
-            .expect("subscribe shouldn't fail");
-        loop {
-            if let Ok(Some(line)) = stdin.next_line().await {
-                let (tx, rx) = oneshot::channel();
-                if let Err(e) = to_swarm
-                    .send(swarm::ToSwarm::Publish {
-                        topic: "test-net".to_string(),
-                        data: line.as_bytes().to_vec(),
-                        result_sender: tx,
-                    })
-                    .await
-                {
-                    println!("Send error: {e:?}");
-                    return;
-                };
-                match rx.await {
-                    Ok(Err(e)) => println!("Publish error: {e:?}"),
-                    Err(e) => println!("Publish error: {e:?}"),
-                    Ok(_) => {}
-                }
-            }
-        }
-    });
-
-    // Kick it off
-    loop {
-        // on gossipsub outgoing
-        match swarm.next().await {
-            // on gossipsub incoming
-            Some(FromSwarm::Discovered { peer_id }) => {
-                println!("\n\nconnected to {peer_id}\n\n")
-            }
-            Some(FromSwarm::Expired { peer_id }) => {
-                println!("\n\ndisconnected from {peer_id}\n\n")
-            }
-            Some(FromSwarm::Message { from, topic, data }) => {
-                println!("{topic}/{from}:\n{}", String::from_utf8_lossy(&data))
-            }
-            None => {}
-        }
-    }
 }

rust/networking/src/RESEARCH_NOTES.txt

@@ -1,44 +0,0 @@
-https://github.com/ml-explore/mlx/commit/3fe98bacc7640d857acf3539f1d21b47a32e5609
-^raw sockets distributed -> `<net/ndrv.h>` -> https://newosxbook.com/code/xnu-3247.1.106/bsd/net/ndrv.h.auto.html
---> header file for a networking component found in the macOS kernel (XNU) that defines structures for network device driver registration, specifically the ndrv_demux_desc and ndrv_protocol_desc structures used for demultiplexing protocol data at the network interface level. It specifies how to describe protocol data, such as an Ethernet type or a SNAP header, and how to associate these descriptions with a specific protocol family to receive matching packets.
---> Used to bind an NDRV socket so that packets that match given protocol demux descriptions can be received.
---> An NDRV socket is a special kind of socket in the Darwin/macOS operating system's XNU kernel, used for low-level network packet manipulation and binding to specific protocols for packet processing. It allows user-space applications or drivers to directly write Layer 2 (L2) network packets or interact with the network stack at a lower level, often by binding to protocol descriptors like the ndrv_protocol_desc. This type of socket is used for functions such as capturing and injecting packets, especially in network infrastructure software like routers or for kernel-level network monitoring and security tools.
---> also called PF_NDRV sockets --> https://newosxbook.com/bonus/vol1ch16.html
-----> they are conceptually similar to https://scapy.disruptivelabs.in/networking/socket-interface PF_RAW or PF_PACKET
-
-https://stackoverflow.com/questions/17169298/af-packet-on-osx
-^AF_PACKET duplicates the packets as soon as it receives them from the physical layer (for incoming packets) or just before sending them out to the physical layer (for outgoing packets). -> this is on Linux only
-^it doesn't exist on OS X so you can use /dev/bpfX (Berkeley Packet Filter) for sniffing
-
-https://www.unix.com/man_page/mojave/4/ip/
-^OS X manpages for IP
-
-https://developer.apple.com/documentation/kernel/implementing_drivers_system_extensions_and_kexts
-^driver kit, system extensions & kexts for macOS
-
-----
-
-To set up a Linux system to use a Thunderbolt connection as a network device, connect the two computers with a Thunderbolt cable, load the thunderbolt-net kernel module (usually automatic but modprobe is an option for manual loading), and then the operating system will create virtual Ethernet interfaces (e.g., thunderbolt0) for networking. You can then use standard tools like ifconfig or your desktop environment's network manager to configure these new interfaces for a link-local network.
---> https://gist.github.com/geosp/80fbd39e617b7d1d9421683df4ea224a
-----> here is a guide on how to set up thunderbolt-ethernet on linux
-----> I may be able to steal the thunderbolt-net code ideas to implement a kernel module for MacOS
-
-https://chatgpt.com/s/t_68af8e41a8548191993281a014f846a7
-^GPT discussion about making socket interface
-
-https://chatgpt.com/s/t_68afb798a85c8191973c02a0fa7a48a3 --> link-local address,,??
-https://chatgpt.com/s/t_68afb02987e08191b2b0044d3667ece2
-^GPT discussion about accessing TB on MacOS low level interactions
-
---------------------------------
-
-https://www.intel.com/content/www/us/en/support/articles/000098893/software.html
-^Thunderbolt Share & Thunderbolt Networking Mode => intel's equivalent of thunderbolt bridge
-
-
----------------------------------
-
-https://www.zerotier.com/blog/how-zerotier-eliminated-kernel-extensions-on-macos/
--->fake ethernet devices on MacOS -> omg??? we can detect thunderbolt bridge, then bind to it, then re-expose it as fake ethernet??
--->ps: https://chatgpt.com/s/t_68afb2b25fb881919526763fb5d7359c, AF/PF_NDRV are one and the same!!!
--->https://github.com/zerotier/ZeroTierOne/blob/dev/osdep/MacEthernetTapAgent.c

rust/networking/src/discovery.rs

@@ -1,382 +0,0 @@
-use crate::ext::MultiaddrExt;
-use delegate::delegate;
-use either::Either;
-use futures_lite::FutureExt;
-use futures_timer::Delay;
-use libp2p::core::transport::PortUse;
-use libp2p::core::{ConnectedPoint, Endpoint};
-use libp2p::swarm::behaviour::ConnectionEstablished;
-use libp2p::swarm::dial_opts::DialOpts;
-use libp2p::swarm::{
-    CloseConnection, ConnectionClosed, ConnectionDenied, ConnectionHandler,
-    ConnectionHandlerSelect, ConnectionId, FromSwarm, NetworkBehaviour, THandler, THandlerInEvent,
-    THandlerOutEvent, ToSwarm, dummy,
-};
-use libp2p::{Multiaddr, PeerId, identity, mdns};
-use std::collections::{BTreeSet, HashMap};
-use std::convert::Infallible;
-use std::io;
-use std::net::IpAddr;
-use std::task::{Context, Poll};
-use std::time::Duration;
-use util::wakerdeque::WakerDeque;
-
-const RETRY_CONNECT_INTERVAL: Duration = Duration::from_secs(5);
-
-mod managed {
-    use libp2p::swarm::NetworkBehaviour;
-    use libp2p::{identity, mdns, ping};
-    use std::io;
-    use std::time::Duration;
-
-    const MDNS_RECORD_TTL: Duration = Duration::from_secs(2_500);
-    const MDNS_QUERY_INTERVAL: Duration = Duration::from_secs(1_500);
-    const PING_TIMEOUT: Duration = Duration::from_millis(2_500);
-    const PING_INTERVAL: Duration = Duration::from_millis(2_500);
-
-    #[derive(NetworkBehaviour)]
-    pub struct Behaviour {
-        mdns: mdns::tokio::Behaviour,
-        ping: ping::Behaviour,
-    }
-
-    impl Behaviour {
-        pub fn new(keypair: &identity::Keypair) -> io::Result<Self> {
-            Ok(Self {
-                mdns: mdns_behaviour(keypair)?,
-                ping: ping_behaviour(),
-            })
-        }
-    }
-
-    fn mdns_behaviour(keypair: &identity::Keypair) -> io::Result<mdns::tokio::Behaviour> {
-        use mdns::{Config, tokio};
-
-        // mDNS config => enable IPv6
-        let mdns_config = Config {
-            ttl: MDNS_RECORD_TTL,
-            query_interval: MDNS_QUERY_INTERVAL,
-
-            // enable_ipv6: true, // TODO: for some reason, TCP+mDNS don't work well with ipv6?? figure out how to make work
-            ..Default::default()
-        };
-
-        let mdns_behaviour = tokio::Behaviour::new(mdns_config, keypair.public().to_peer_id());
-        Ok(mdns_behaviour?)
-    }
-
-    fn ping_behaviour() -> ping::Behaviour {
-        ping::Behaviour::new(
-            ping::Config::new()
-                .with_timeout(PING_TIMEOUT)
-                .with_interval(PING_INTERVAL),
-        )
-    }
-}
-
-/// Events for when a listening connection is truly established and truly closed.
-#[derive(Debug, Clone)]
-pub enum Event {
-    ConnectionEstablished {
-        peer_id: PeerId,
-        connection_id: ConnectionId,
-        remote_ip: IpAddr,
-        remote_tcp_port: u16,
-    },
-    ConnectionClosed {
-        peer_id: PeerId,
-        connection_id: ConnectionId,
-        remote_ip: IpAddr,
-        remote_tcp_port: u16,
-    },
-}
-
-/// Discovery behavior that wraps mDNS to produce truly discovered durable peer-connections.
-///
-/// The behaviour operates as such:
-///  1) All true (listening) connections/disconnections are tracked, emitting corresponding events
-///     to the swarm.
-///  1) mDNS discovered/expired peers are tracked; discovered but not connected peers are dialed
-///     immediately, and expired but connected peers are disconnected from immediately.
-///  2) Every fixed interval: discovered but not connected peers are dialed, and expired but
-///     connected peers are disconnected from.
-pub struct Behaviour {
-    // state-tracking for managed behaviors & mDNS-discovered peers
-    managed: managed::Behaviour,
-    mdns_discovered: HashMap<PeerId, BTreeSet<Multiaddr>>,
-
-    retry_delay: Delay, // retry interval
-
-    // pending events to emmit => waker-backed Deque to control polling
-    pending_events: WakerDeque<ToSwarm<Event, Infallible>>,
-}
-
-impl Behaviour {
-    pub fn new(keypair: &identity::Keypair) -> io::Result<Self> {
-        Ok(Self {
-            managed: managed::Behaviour::new(keypair)?,
-            mdns_discovered: HashMap::new(),
-            retry_delay: Delay::new(RETRY_CONNECT_INTERVAL),
-            pending_events: WakerDeque::new(),
-        })
-    }
-
-    fn dial(&mut self, peer_id: PeerId, addr: Multiaddr) {
-        self.pending_events.push_back(ToSwarm::Dial {
-            opts: DialOpts::peer_id(peer_id).addresses(vec![addr]).build(),
-        })
-    }
-
-    fn close_connection(&mut self, peer_id: PeerId, connection: ConnectionId) {
-        // push front to make this IMMEDIATE
-        self.pending_events.push_front(ToSwarm::CloseConnection {
-            peer_id,
-            connection: CloseConnection::One(connection),
-        })
-    }
-
-    fn handle_mdns_discovered(&mut self, peers: Vec<(PeerId, Multiaddr)>) {
-        for (p, ma) in peers {
-            self.dial(p, ma.clone()); // always connect
-
-            // get peer's multi-addresses or insert if missing
-            let Some(mas) = self.mdns_discovered.get_mut(&p) else {
-                self.mdns_discovered.insert(p, BTreeSet::from([ma]));
-                continue;
-            };
-
-            // multiaddress should never already be present - else something has gone wrong
-            let is_new_addr = mas.insert(ma);
-            assert!(is_new_addr, "cannot discover a discovered peer");
-        }
-    }
-
-    fn handle_mdns_expired(&mut self, peers: Vec<(PeerId, Multiaddr)>) {
-        for (p, ma) in peers {
-            // at this point, we *must* have the peer
-            let mas = self
-                .mdns_discovered
-                .get_mut(&p)
-                .expect("nonexistent peer cannot expire");
-
-            // at this point, we *must* have the multiaddress
-            let was_present = mas.remove(&ma);
-            assert!(was_present, "nonexistent multiaddress cannot expire");
-
-            // if empty, remove the peer-id entirely
-            if mas.is_empty() {
-                self.mdns_discovered.remove(&p);
-            }
-        }
-    }
-
-    fn on_connection_established(
-        &mut self,
-        peer_id: PeerId,
-        connection_id: ConnectionId,
-        remote_ip: IpAddr,
-        remote_tcp_port: u16,
-    ) {
-        // send out connected event
-        self.pending_events
-            .push_back(ToSwarm::GenerateEvent(Event::ConnectionEstablished {
-                peer_id,
-                connection_id,
-                remote_ip,
-                remote_tcp_port,
-            }));
-    }
-
-    fn on_connection_closed(
-        &mut self,
-        peer_id: PeerId,
-        connection_id: ConnectionId,
-        remote_ip: IpAddr,
-        remote_tcp_port: u16,
-    ) {
-        // send out disconnected event
-        self.pending_events
-            .push_back(ToSwarm::GenerateEvent(Event::ConnectionClosed {
-                peer_id,
-                connection_id,
-                remote_ip,
-                remote_tcp_port,
-            }));
-    }
-}
-
-impl NetworkBehaviour for Behaviour {
-    type ConnectionHandler =
-        ConnectionHandlerSelect<dummy::ConnectionHandler, THandler<managed::Behaviour>>;
-    type ToSwarm = Event;
-
-    // simply delegate to underlying mDNS behaviour
-
-    delegate! {
-        to self.managed {
-            fn handle_pending_inbound_connection(&mut self, connection_id: ConnectionId, local_addr: &Multiaddr, remote_addr: &Multiaddr) -> Result<(), ConnectionDenied>;
-            fn handle_pending_outbound_connection(&mut self, connection_id: ConnectionId, maybe_peer: Option<PeerId>, addresses: &[Multiaddr], effective_role: Endpoint) -> Result<Vec<Multiaddr>, ConnectionDenied>;
-        }
-    }
-
-    fn handle_established_inbound_connection(
-        &mut self,
-        connection_id: ConnectionId,
-        peer: PeerId,
-        local_addr: &Multiaddr,
-        remote_addr: &Multiaddr,
-    ) -> Result<THandler<Self>, ConnectionDenied> {
-        Ok(ConnectionHandler::select(
-            dummy::ConnectionHandler,
-            self.managed.handle_established_inbound_connection(
-                connection_id,
-                peer,
-                local_addr,
-                remote_addr,
-            )?,
-        ))
-    }
-
-    #[allow(clippy::needless_question_mark)]
-    fn handle_established_outbound_connection(
-        &mut self,
-        connection_id: ConnectionId,
-        peer: PeerId,
-        addr: &Multiaddr,
-        role_override: Endpoint,
-        port_use: PortUse,
-    ) -> Result<THandler<Self>, ConnectionDenied> {
-        Ok(ConnectionHandler::select(
-            dummy::ConnectionHandler,
-            self.managed.handle_established_outbound_connection(
-                connection_id,
-                peer,
-                addr,
-                role_override,
-                port_use,
-            )?,
-        ))
-    }
-
-    fn on_connection_handler_event(
-        &mut self,
-        peer_id: PeerId,
-        connection_id: ConnectionId,
-        event: THandlerOutEvent<Self>,
-    ) {
-        match event {
-            Either::Left(ev) => libp2p::core::util::unreachable(ev),
-            Either::Right(ev) => {
-                self.managed
-                    .on_connection_handler_event(peer_id, connection_id, ev)
-            }
-        }
-    }
-
-    // hook into these methods to drive behavior
-
-    fn on_swarm_event(&mut self, event: FromSwarm) {
-        self.managed.on_swarm_event(event); // let mDNS handle swarm events
-
-        // handle swarm events to update internal state:
-        match event {
-            FromSwarm::ConnectionEstablished(ConnectionEstablished {
-                peer_id,
-                connection_id,
-                endpoint,
-                ..
-            }) => {
-                let remote_address = match endpoint {
-                    ConnectedPoint::Dialer { address, .. } => address,
-                    ConnectedPoint::Listener { send_back_addr, .. } => send_back_addr,
-                };
-
-                if let Some((ip, port)) = remote_address.try_to_tcp_addr() {
-                    // handle connection established event which is filtered correctly
-                    self.on_connection_established(peer_id, connection_id, ip, port)
-                }
-            }
-            FromSwarm::ConnectionClosed(ConnectionClosed {
-                peer_id,
-                connection_id,
-                endpoint,
-                ..
-            }) => {
-                let remote_address = match endpoint {
-                    ConnectedPoint::Dialer { address, .. } => address,
-                    ConnectedPoint::Listener { send_back_addr, .. } => send_back_addr,
-                };
-
-                if let Some((ip, port)) = remote_address.try_to_tcp_addr() {
-                    // handle connection closed event which is filtered correctly
-                    self.on_connection_closed(peer_id, connection_id, ip, port)
-                }
-            }
-
-            // since we are running TCP/IP transport layer, we are assuming that
-            // no address changes can occur, hence encountering one is a fatal error
-            FromSwarm::AddressChange(a) => {
-                unreachable!("unhandlable: address change encountered: {:?}", a)
-            }
-            _ => {}
-        }
-    }
-
-    fn poll(&mut self, cx: &mut Context) -> Poll<ToSwarm<Self::ToSwarm, THandlerInEvent<Self>>> {
-        // delegate to managed behaviors for any behaviors they need to perform
-        match self.managed.poll(cx) {
-            Poll::Ready(ToSwarm::GenerateEvent(e)) => {
-                match e {
-                    // handle discovered and expired events from mDNS
-                    managed::BehaviourEvent::Mdns(e) => match e.clone() {
-                        mdns::Event::Discovered(peers) => {
-                            self.handle_mdns_discovered(peers);
-                        }
-                        mdns::Event::Expired(peers) => {
-                            self.handle_mdns_expired(peers);
-                        }
-                    },
-
-                    // handle ping events => if error then disconnect
-                    managed::BehaviourEvent::Ping(e) => {
-                        if let Err(_) = e.result {
-                            self.close_connection(e.peer, e.connection.clone())
-                        }
-                    }
-                }
-
-                // since we just consumed an event, we should immediately wake just in case
-                // there are more events to come where that came from
-                cx.waker().wake_by_ref();
-            }
-
-            // forward any other mDNS event to the swarm or its connection handler(s)
-            Poll::Ready(e) => {
-                return Poll::Ready(
-                    e.map_out(|_| unreachable!("events returning to swarm already handled"))
-                        .map_in(Either::Right),
-                );
-            }
-
-            Poll::Pending => {}
-        }
-
-        // retry connecting to all mDNS peers periodically (fails safely if already connected)
-        if self.retry_delay.poll(cx).is_ready() {
-            for (p, mas) in self.mdns_discovered.clone() {
-                for ma in mas {
-                    self.dial(p, ma)
-                }
-            }
-            self.retry_delay.reset(RETRY_CONNECT_INTERVAL) // reset timeout
-        }
-
-        // send out any pending events from our own service
-        if let Some(e) = self.pending_events.pop_front(cx) {
-            return Poll::Ready(e.map_in(Either::Left));
-        }
-
-        // wait for pending events
-        Poll::Pending
-    }
-}

rust/networking/src/lib.rs

@@ -1,44 +0,0 @@
-//! TODO: crate documentation
-//!
-//! this is here as a placeholder documentation
-//!
-//!
-pub mod discovery;
-pub mod swarm;
-
-/// Namespace for all the type/trait aliases used by this crate.
-pub(crate) mod alias {
-    use std::error::Error;
-
-    pub type AnyError = Box<dyn Error + Send + Sync + 'static>;
-    pub type AnyResult<T> = Result<T, AnyError>;
-}
-
-/// Namespace for crate-wide extension traits/methods
-pub(crate) mod ext {
-    use extend::ext;
-    use libp2p::Multiaddr;
-    use libp2p::multiaddr::Protocol;
-    use std::net::IpAddr;
-
-    #[ext(pub, name = MultiaddrExt)]
-    impl Multiaddr {
-        /// If the multiaddress corresponds to a TCP address, extracts it
-        fn try_to_tcp_addr(&self) -> Option<(IpAddr, u16)> {
-            let mut ps = self.into_iter();
-            let ip = if let Some(p) = ps.next() {
-                match p {
-                    Protocol::Ip4(ip) => IpAddr::V4(ip),
-                    Protocol::Ip6(ip) => IpAddr::V6(ip),
-                    _ => return None,
-                }
-            } else {
-                return None;
-            };
-            let Some(Protocol::Tcp(port)) = ps.next() else {
-                return None;
-            };
-            Some((ip, port))
-        }
-    }
-}

rust/networking/src/swarm.rs

@@ -1,273 +0,0 @@
-use std::pin::Pin;
-
-use crate::swarm::transport::tcp_transport;
-use crate::{alias, discovery};
-pub use behaviour::{Behaviour, BehaviourEvent};
-use futures_lite::{Stream, StreamExt};
-use libp2p::{PeerId, SwarmBuilder, gossipsub, identity, swarm::SwarmEvent};
-use tokio::sync::{mpsc, oneshot};
-
-/// The current version of the network: this prevents devices running different versions of the
-/// software from interacting with each other.
-///
-/// TODO: right now this is a hardcoded constant; figure out what the versioning semantics should
-///       even be, and how to inject the right version into this config/initialization. E.g. should
-///       this be passed in as a parameter? What about rapidly changing versions in debug builds?
-///       this is all VERY very hard to figure out and needs to be mulled over as a team.
-pub const NETWORK_VERSION: &[u8] = b"v0.0.1";
-pub const OVERRIDE_VERSION_ENV_VAR: &str = "EXO_LIBP2P_NAMESPACE";
-
-// Uses oneshot senders to emulate function calling apis while avoiding requiring unique ownership
-// of the Swarm.
-pub enum ToSwarm {
-    Unsubscribe {
-        topic: String,
-        result_sender: oneshot::Sender<bool>,
-    },
-    Subscribe {
-        topic: String,
-        result_sender: oneshot::Sender<Result<bool, gossipsub::SubscriptionError>>,
-    },
-    Publish {
-        topic: String,
-        data: Vec<u8>,
-        result_sender: oneshot::Sender<Result<gossipsub::MessageId, gossipsub::PublishError>>,
-    },
-}
-pub enum FromSwarm {
-    Message {
-        from: PeerId,
-        topic: String,
-        data: Vec<u8>,
-    },
-    Discovered {
-        peer_id: PeerId,
-    },
-    Expired {
-        peer_id: PeerId,
-    },
-}
-
-pub struct Swarm {
-    swarm: libp2p::Swarm<Behaviour>,
-    from_client: mpsc::Receiver<ToSwarm>,
-}
-
-impl Swarm {
-    pub fn into_stream(self) -> Pin<Box<dyn Stream<Item = FromSwarm> + Send>> {
-        let Swarm {
-            mut swarm,
-            mut from_client,
-        } = self;
-        let stream = async_stream::stream! {
-            loop {
-                tokio::select! {
-                    msg = from_client.recv() => {
-                        let Some(msg) = msg else { break };
-                        on_message(&mut swarm, msg);
-                    }
-                    event = swarm.next() => {
-                        let Some(event) = event else { break };
-                        if let Some(item) = filter_swarm_event(event) {
-                            yield item;
-                        }
-                    }
-                }
-            }
-        };
-        Box::pin(stream)
-    }
-}
-
-fn on_message(swarm: &mut libp2p::Swarm<Behaviour>, message: ToSwarm) {
-    match message {
-        ToSwarm::Subscribe {
-            topic,
-            result_sender,
-        } => {
-            let result = swarm
-                .behaviour_mut()
-                .gossipsub
-                .subscribe(&gossipsub::IdentTopic::new(topic));
-            _ = result_sender.send(result);
-        }
-        ToSwarm::Unsubscribe {
-            topic,
-            result_sender,
-        } => {
-            let result = swarm
-                .behaviour_mut()
-                .gossipsub
-                .unsubscribe(&gossipsub::IdentTopic::new(topic));
-            _ = result_sender.send(result);
-        }
-        ToSwarm::Publish {
-            topic,
-            data,
-            result_sender,
-        } => {
-            let result = swarm
-                .behaviour_mut()
-                .gossipsub
-                .publish(gossipsub::IdentTopic::new(topic), data);
-            _ = result_sender.send(result);
-        }
-    }
-}
-
-fn filter_swarm_event(event: SwarmEvent<BehaviourEvent>) -> Option<FromSwarm> {
-    match event {
-        SwarmEvent::Behaviour(BehaviourEvent::Gossipsub(gossipsub::Event::Message {
-            message:
-                gossipsub::Message {
-                    source: Some(peer_id),
-                    topic,
-                    data,
-                    ..
-                },
-            ..
-        })) => Some(FromSwarm::Message {
-            from: peer_id,
-            topic: topic.into_string(),
-            data,
-        }),
-        SwarmEvent::Behaviour(BehaviourEvent::Discovery(
-            discovery::Event::ConnectionEstablished { peer_id, .. },
-        )) => Some(FromSwarm::Discovered { peer_id }),
-        SwarmEvent::Behaviour(BehaviourEvent::Discovery(discovery::Event::ConnectionClosed {
-            peer_id,
-            ..
-        })) => Some(FromSwarm::Expired { peer_id }),
-        _ => None,
-    }
-}
-
-/// Create and configure a swarm which listens to all ports on OS
-pub fn create_swarm(
-    keypair: identity::Keypair,
-    from_client: mpsc::Receiver<ToSwarm>,
-) -> alias::AnyResult<Swarm> {
-    let mut swarm = SwarmBuilder::with_existing_identity(keypair)
-        .with_tokio()
-        .with_other_transport(tcp_transport)?
-        .with_behaviour(Behaviour::new)?
-        .build();
-
-    // Listen on all interfaces and whatever port the OS assigns
-    swarm.listen_on("/ip4/0.0.0.0/tcp/0".parse()?)?;
-    Ok(Swarm { swarm, from_client })
-}
-
-mod transport {
-    use crate::alias;
-    use crate::swarm::{NETWORK_VERSION, OVERRIDE_VERSION_ENV_VAR};
-    use futures_lite::{AsyncRead, AsyncWrite};
-    use keccak_const::Sha3_256;
-    use libp2p::core::muxing;
-    use libp2p::core::transport::Boxed;
-    use libp2p::pnet::{PnetError, PnetOutput};
-    use libp2p::{PeerId, Transport, identity, noise, pnet, yamux};
-    use std::{env, sync::LazyLock};
-
-    /// Key used for networking's private network; parametrized on the [`NETWORK_VERSION`].
-    /// See [`pnet_upgrade`] for more.
-    static PNET_PRESHARED_KEY: LazyLock<[u8; 32]> = LazyLock::new(|| {
-        let builder = Sha3_256::new().update(b"exo_discovery_network");
-
-        if let Ok(var) = env::var(OVERRIDE_VERSION_ENV_VAR) {
-            let bytes = var.into_bytes();
-            builder.update(&bytes)
-        } else {
-            builder.update(NETWORK_VERSION)
-        }
-        .finalize()
-    });
-
-    /// Make the Swarm run on a private network, as to not clash with public libp2p nodes and
-    /// also different-versioned instances of this same network.
-    /// This is implemented as an additional "upgrade" ontop of existing [`libp2p::Transport`] layers.
-    async fn pnet_upgrade<TSocket>(
-        socket: TSocket,
-        _: impl Sized,
-    ) -> Result<PnetOutput<TSocket>, PnetError>
-    where
-        TSocket: AsyncRead + AsyncWrite + Send + Unpin + 'static,
-    {
-        use pnet::{PnetConfig, PreSharedKey};
-        PnetConfig::new(PreSharedKey::new(*PNET_PRESHARED_KEY))
-            .handshake(socket)
-            .await
-    }
-
-    /// TCP/IP transport layer configuration.
-    pub fn tcp_transport(
-        keypair: &identity::Keypair,
-    ) -> alias::AnyResult<Boxed<(PeerId, muxing::StreamMuxerBox)>> {
-        use libp2p::{
-            core::upgrade::Version,
-            tcp::{Config, tokio},
-        };
-
-        // `TCP_NODELAY` enabled => avoid latency
-        let tcp_config = Config::default().nodelay(true);
-
-        // V1 + lazy flushing => 0-RTT negotiation
-        let upgrade_version = Version::V1Lazy;
-
-        // Noise is faster than TLS + we don't care much for security
-        let noise_config = noise::Config::new(keypair)?;
-
-        // Use default Yamux config for multiplexing
-        let yamux_config = yamux::Config::default();
-
-        // Create new Tokio-driven TCP/IP transport layer
-        let base_transport = tokio::Transport::new(tcp_config)
-            .and_then(pnet_upgrade)
-            .upgrade(upgrade_version)
-            .authenticate(noise_config)
-            .multiplex(yamux_config);
-
-        // Return boxed transport (to flatten complex type)
-        Ok(base_transport.boxed())
-    }
-}
-
-mod behaviour {
-    use crate::{alias, discovery};
-    use libp2p::swarm::NetworkBehaviour;
-    use libp2p::{gossipsub, identity};
-
-    /// Behavior of the Swarm which composes all desired behaviors:
-    /// Right now its just [`discovery::Behaviour`] and [`gossipsub::Behaviour`].
-    #[derive(NetworkBehaviour)]
-    pub struct Behaviour {
-        pub discovery: discovery::Behaviour,
-        pub gossipsub: gossipsub::Behaviour,
-    }
-
-    impl Behaviour {
-        pub fn new(keypair: &identity::Keypair) -> alias::AnyResult<Self> {
-            Ok(Self {
-                discovery: discovery::Behaviour::new(keypair)?,
-                gossipsub: gossipsub_behaviour(keypair),
-            })
-        }
-    }
-
-    fn gossipsub_behaviour(keypair: &identity::Keypair) -> gossipsub::Behaviour {
-        use gossipsub::{ConfigBuilder, MessageAuthenticity, ValidationMode};
-
-        // build a gossipsub network behaviour
-        //  => signed message authenticity + strict validation mode means the message-ID is
-        //     automatically provided by gossipsub w/out needing to provide custom message-ID function
-        gossipsub::Behaviour::new(
-            MessageAuthenticity::Signed(keypair.clone()),
-            ConfigBuilder::default()
-                .max_transmit_size(8 * 1024 * 1024)
-                .validation_mode(ValidationMode::Strict)
-                .build()
-                .expect("the configuration should always be valid"),
-        )
-        .expect("creating gossipsub behavior should always work")
-    }
-}

rust/networking/tests/dummy.rs

@@ -1,7 +0,0 @@
-// maybe this will hold test in the future...??
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn does_nothing() {}
-}

rust/util/Cargo.toml

@@ -1,15 +0,0 @@
-[package]
-name = "util"
-version = { workspace = true }
-edition = { workspace = true }
-publish = false
-
-[lib]
-doctest = false
-name = "util"
-path = "src/lib.rs"
-
-[lints]
-workspace = true
-
-[dependencies]

rust/util/src/lib.rs

@@ -1 +0,0 @@
-pub mod wakerdeque;

rust/util/src/wakerdeque.rs

@@ -1,55 +0,0 @@
-use std::collections::VecDeque;
-use std::fmt::{Debug, Formatter};
-use std::task::{Context, Waker};
-
-/// A wrapper around [`VecDeque`] which wakes (if it can) on any `push_*` methods,
-/// and updates the internally stored waker by consuming [`Context`] on any `pop_*` methods.
-pub struct WakerDeque<T> {
-    waker: Option<Waker>,
-    deque: VecDeque<T>,
-}
-
-impl<T: Debug> Debug for WakerDeque<T> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        self.deque.fmt(f)
-    }
-}
-
-impl<T> WakerDeque<T> {
-    pub fn new() -> Self {
-        Self {
-            waker: None,
-            deque: VecDeque::new(),
-        }
-    }
-
-    fn update(&mut self, cx: &mut Context<'_>) {
-        self.waker = Some(cx.waker().clone());
-    }
-
-    fn wake(&mut self) {
-        let Some(ref mut w) = self.waker else { return };
-        w.wake_by_ref();
-        self.waker = None;
-    }
-
-    pub fn pop_front(&mut self, cx: &mut Context<'_>) -> Option<T> {
-        self.update(cx);
-        self.deque.pop_front()
-    }
-
-    pub fn pop_back(&mut self, cx: &mut Context<'_>) -> Option<T> {
-        self.update(cx);
-        self.deque.pop_back()
-    }
-
-    pub fn push_front(&mut self, value: T) {
-        self.wake();
-        self.deque.push_front(value);
-    }
-
-    pub fn push_back(&mut self, value: T) {
-        self.wake();
-        self.deque.push_back(value);
-    }
-}

src/exo/download/coordinator.py

@@ -133,16 +133,6 @@ class DownloadCoordinator:
         if model_id in self.active_downloads and model_id in self.download_status:
             logger.info(f"Cancelling download for {model_id}")
             self.active_downloads.pop(model_id).cancel()
-            current_status = self.download_status[model_id]
-            pending = DownloadPending(
-                shard_metadata=current_status.shard_metadata,
-                node_id=self.node_id,
-                model_directory=self._model_dir(model_id),
-            )
-            self.download_status[model_id] = pending
-            await self.event_sender.send(
-                NodeDownloadProgress(download_progress=pending)
-            )
 
     async def _start_download(self, shard: ShardMetadata) -> None:
         model_id = shard.model_card.model_id
@@ -297,8 +287,8 @@ class DownloadCoordinator:
             del self.download_status[model_id]
 
     async def _emit_existing_download_progress(self) -> None:
-        while True:
-            try:
+        try:
+            while True:
                 logger.debug(
                     "DownloadCoordinator: Fetching and emitting existing download progress..."
                 )
@@ -386,8 +376,8 @@ class DownloadCoordinator:
                 logger.debug(
                     "DownloadCoordinator: Done emitting existing download progress."
                 )
-            except Exception as e:
-                logger.error(
-                    f"DownloadCoordinator: Error emitting existing download progress: {e}"
-                )
-            await anyio.sleep(60)
+                await anyio.sleep(60)
+        except Exception as e:
+            logger.error(
+                f"DownloadCoordinator: Error emitting existing download progress: {e}"
+            )

src/exo/download/impl_shard_downloader.py

@@ -19,7 +19,9 @@ def exo_shard_downloader(
     max_parallel_downloads: int = 8, offline: bool = False
 ) -> ShardDownloader:
     return SingletonShardDownloader(
-        ResumableShardDownloader(max_parallel_downloads, offline=offline)
+        CachedShardDownloader(
+            ResumableShardDownloader(max_parallel_downloads, offline=offline)
+        )
     )
 
 
@@ -83,6 +85,39 @@ class SingletonShardDownloader(ShardDownloader):
         return await self.shard_downloader.get_shard_download_status_for_shard(shard)
 
 
+class CachedShardDownloader(ShardDownloader):
+    def __init__(self, shard_downloader: ShardDownloader):
+        self.shard_downloader = shard_downloader
+        self.cache: dict[tuple[str, ShardMetadata], Path] = {}
+
+    def on_progress(
+        self,
+        callback: Callable[[ShardMetadata, RepoDownloadProgress], Awaitable[None]],
+    ) -> None:
+        self.shard_downloader.on_progress(callback)
+
+    async def ensure_shard(
+        self, shard: ShardMetadata, config_only: bool = False
+    ) -> Path:
+        if (shard.model_card.model_id, shard) in self.cache:
+            return self.cache[(shard.model_card.model_id, shard)]
+
+        target_dir = await self.shard_downloader.ensure_shard(shard, config_only)
+        self.cache[(shard.model_card.model_id, shard)] = target_dir
+        return target_dir
+
+    async def get_shard_download_status(
+        self,
+    ) -> AsyncIterator[tuple[Path, RepoDownloadProgress]]:
+        async for path, status in self.shard_downloader.get_shard_download_status():
+            yield path, status
+
+    async def get_shard_download_status_for_shard(
+        self, shard: ShardMetadata
+    ) -> RepoDownloadProgress:
+        return await self.shard_downloader.get_shard_download_status_for_shard(shard)
+
+
 class ResumableShardDownloader(ShardDownloader):
     def __init__(self, max_parallel_downloads: int = 8, offline: bool = False):
         self.max_parallel_downloads = max_parallel_downloads

src/exo/download/tests/test_re_download.py

@@ -1,211 +0,0 @@
-"""Tests that re-downloading a previously deleted model completes successfully."""
-
-import asyncio
-import contextlib
-from collections.abc import AsyncIterator, Awaitable
-from datetime import timedelta
-from pathlib import Path
-from typing import Callable
-from unittest.mock import AsyncMock, patch
-
-from exo.download.coordinator import DownloadCoordinator
-from exo.download.download_utils import RepoDownloadProgress
-from exo.download.impl_shard_downloader import SingletonShardDownloader
-from exo.download.shard_downloader import ShardDownloader
-from exo.shared.models.model_cards import ModelCard, ModelId, ModelTask
-from exo.shared.types.commands import (
-    DeleteDownload,
-    ForwarderDownloadCommand,
-    StartDownload,
-)
-from exo.shared.types.common import NodeId, SystemId
-from exo.shared.types.events import Event, NodeDownloadProgress
-from exo.shared.types.memory import Memory
-from exo.shared.types.worker.downloads import DownloadCompleted
-from exo.shared.types.worker.shards import PipelineShardMetadata, ShardMetadata
-from exo.utils.channels import Receiver, Sender, channel
-
-NODE_ID = NodeId("aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa")
-MODEL_ID = ModelId("test-org/test-model")
-
-
-def _make_shard(model_id: ModelId = MODEL_ID) -> ShardMetadata:
-    return PipelineShardMetadata(
-        model_card=ModelCard(
-            model_id=model_id,
-            storage_size=Memory.from_mb(100),
-            n_layers=28,
-            hidden_size=1024,
-            supports_tensor=False,
-            tasks=[ModelTask.TextGeneration],
-        ),
-        device_rank=0,
-        world_size=1,
-        start_layer=0,
-        end_layer=28,
-        n_layers=28,
-    )
-
-
-class FakeShardDownloader(ShardDownloader):
-    """Fake downloader that simulates a successful download by firing the
-    progress callback with status='complete' when ensure_shard is called."""
-
-    def __init__(self) -> None:
-        self._progress_callbacks: list[
-            Callable[[ShardMetadata, RepoDownloadProgress], Awaitable[None]]
-        ] = []
-
-    def on_progress(
-        self,
-        callback: Callable[[ShardMetadata, RepoDownloadProgress], Awaitable[None]],
-    ) -> None:
-        self._progress_callbacks.append(callback)
-
-    async def ensure_shard(
-        self,
-        shard: ShardMetadata,
-        config_only: bool = False,  # noqa: ARG002
-    ) -> Path:
-        # Simulate a completed download by firing the progress callback
-        progress = RepoDownloadProgress(
-            repo_id=str(shard.model_card.model_id),
-            repo_revision="main",
-            shard=shard,
-            completed_files=1,
-            total_files=1,
-            downloaded=Memory.from_mb(100),
-            downloaded_this_session=Memory.from_mb(100),
-            total=Memory.from_mb(100),
-            overall_speed=0,
-            overall_eta=timedelta(seconds=0),
-            status="complete",
-        )
-        for cb in self._progress_callbacks:
-            await cb(shard, progress)
-        return Path("/fake/models") / shard.model_card.model_id.normalize()
-
-    async def get_shard_download_status(
-        self,
-    ) -> AsyncIterator[tuple[Path, RepoDownloadProgress]]:
-        if False:  # noqa: SIM108  # empty async generator
-            yield (
-                Path(),
-                RepoDownloadProgress(  # pyright: ignore[reportUnreachable]
-                    repo_id="",
-                    repo_revision="",
-                    shard=_make_shard(),
-                    completed_files=0,
-                    total_files=0,
-                    downloaded=Memory.from_bytes(0),
-                    downloaded_this_session=Memory.from_bytes(0),
-                    total=Memory.from_bytes(0),
-                    overall_speed=0,
-                    overall_eta=timedelta(seconds=0),
-                    status="not_started",
-                ),
-            )
-
-    async def get_shard_download_status_for_shard(
-        self,
-        shard: ShardMetadata,
-    ) -> RepoDownloadProgress:
-        return RepoDownloadProgress(
-            repo_id=str(shard.model_card.model_id),
-            repo_revision="main",
-            shard=shard,
-            completed_files=0,
-            total_files=1,
-            downloaded=Memory.from_bytes(0),
-            downloaded_this_session=Memory.from_bytes(0),
-            total=Memory.from_mb(100),
-            overall_speed=0,
-            overall_eta=timedelta(seconds=0),
-            status="not_started",
-        )
-
-
-async def test_re_download_after_delete_completes() -> None:
-    """A model that was downloaded, deleted, and then re-downloaded should
-    reach DownloadCompleted status. This is an end-to-end test through
-    the DownloadCoordinator."""
-    cmd_send: Sender[ForwarderDownloadCommand]
-    cmd_send, cmd_recv = channel[ForwarderDownloadCommand]()
-    event_send, event_recv = channel[Event]()
-
-    fake_downloader = FakeShardDownloader()
-    wrapped_downloader = SingletonShardDownloader(fake_downloader)
-    coordinator = DownloadCoordinator(
-        node_id=NODE_ID,
-        shard_downloader=wrapped_downloader,
-        download_command_receiver=cmd_recv,
-        event_sender=event_send,
-    )
-
-    shard = _make_shard()
-    origin = SystemId("test")
-
-    with patch("exo.download.coordinator.delete_model", new_callable=AsyncMock):
-        # Run the coordinator in the background
-        coordinator_task = asyncio.create_task(coordinator.run())
-
-        try:
-            # 1. Start first download
-            await cmd_send.send(
-                ForwarderDownloadCommand(
-                    origin=origin,
-                    command=StartDownload(target_node_id=NODE_ID, shard_metadata=shard),
-                )
-            )
-
-            # Wait for DownloadCompleted
-            first_completed = await _wait_for_download_completed(event_recv, MODEL_ID)
-            assert first_completed is not None, "First download should complete"
-
-            # 2. Delete the model
-            await cmd_send.send(
-                ForwarderDownloadCommand(
-                    origin=origin,
-                    command=DeleteDownload(target_node_id=NODE_ID, model_id=MODEL_ID),
-                )
-            )
-            # Give the coordinator time to process the delete
-            await asyncio.sleep(0.05)
-
-            # 3. Re-download the same model
-            await cmd_send.send(
-                ForwarderDownloadCommand(
-                    origin=origin,
-                    command=StartDownload(target_node_id=NODE_ID, shard_metadata=shard),
-                )
-            )
-
-            # Wait for second DownloadCompleted — this is the bug: it never arrives
-            second_completed = await _wait_for_download_completed(event_recv, MODEL_ID)
-            assert second_completed is not None, (
-                "Re-download after deletion should complete"
-            )
-        finally:
-            coordinator.shutdown()
-            coordinator_task.cancel()
-            with contextlib.suppress(asyncio.CancelledError):
-                await coordinator_task
-
-
-async def _wait_for_download_completed(
-    event_recv: Receiver[Event], model_id: ModelId, timeout: float = 2.0
-) -> DownloadCompleted | None:
-    """Drain events until we see a DownloadCompleted for the given model, or timeout."""
-    try:
-        async with asyncio.timeout(timeout):
-            while True:
-                event = await event_recv.receive()
-                if (
-                    isinstance(event, NodeDownloadProgress)
-                    and isinstance(event.download_progress, DownloadCompleted)
-                    and event.download_progress.shard_metadata.model_card.model_id
-                    == model_id
-                ):
-                    return event.download_progress
-    except TimeoutError:
-        return None

src/exo/main.py

@@ -270,10 +270,6 @@ def main():
     if args.offline:
         logger.info("Running in OFFLINE mode — no internet checks, local models only")
 
-    if args.no_batch:
-        os.environ["EXO_NO_BATCH"] = "1"
-        logger.info("Continuous batching disabled (--no-batch)")
-
     # Set FAST_SYNCH override env var for runner subprocesses
     if args.fast_synch is True:
         os.environ["EXO_FAST_SYNCH"] = "on"
@@ -304,7 +300,6 @@ class Args(CamelCaseModel):
     no_worker: bool = False
     no_downloads: bool = False
     offline: bool = os.getenv("EXO_OFFLINE", "false").lower() == "true"
-    no_batch: bool = False
     fast_synch: bool | None = None  # None = auto, True = force on, False = force off
 
     @classmethod
@@ -358,11 +353,6 @@ class Args(CamelCaseModel):
             default=os.getenv("EXO_OFFLINE", "false").lower() == "true",
             help="Run in offline/air-gapped mode: skip internet checks, use only pre-staged local models",
         )
-        parser.add_argument(
-            "--no-batch",
-            action="store_true",
-            help="Disable continuous batching, use sequential generation",
-        )
         fast_synch_group = parser.add_mutually_exclusive_group()
         fast_synch_group.add_argument(
             "--fast-synch",

src/exo/master/adapters/chat_completions.py

@@ -104,9 +104,6 @@ def chat_request_to_text_generation(
         else None,
         logprobs=request.logprobs or False,
         top_logprobs=request.top_logprobs,
-        min_p=request.min_p,
-        repetition_penalty=request.repetition_penalty,
-        repetition_context_size=request.repetition_context_size,
     )
 
 

src/exo/master/api.py

@@ -3,7 +3,7 @@ import contextlib
 import json
 import random
 import time
-from collections.abc import AsyncGenerator, Awaitable, Callable, Iterable
+from collections.abc import AsyncGenerator, Awaitable, Callable, Iterator
 from datetime import datetime, timezone
 from http import HTTPStatus
 from pathlib import Path
@@ -775,7 +775,7 @@ class API:
         return resolved_model
 
     def stream_events(self) -> StreamingResponse:
-        def _generate_json_array(events: Iterable[Event]) -> Iterable[str]:
+        def _generate_json_array(events: Iterator[Event]) -> Iterator[str]:
             yield "["
             first = True
             for event in events:
@@ -1586,42 +1586,26 @@ class API:
     async def search_models(
         self, query: str = "", limit: int = 20
     ) -> list[HuggingFaceSearchResult]:
-        """Search HuggingFace Hub — tries mlx-community first, falls back to all of HuggingFace."""
-        from huggingface_hub import ModelInfo, list_models
+        """Search HuggingFace Hub for mlx-community models."""
+        from huggingface_hub import list_models
 
-        def _to_results(models: Iterable[ModelInfo]) -> list[HuggingFaceSearchResult]:
-            return [
-                HuggingFaceSearchResult(
-                    id=m.id,
-                    author=m.author or "",
-                    downloads=m.downloads or 0,
-                    likes=m.likes or 0,
-                    last_modified=str(m.last_modified or ""),
-                    tags=list(m.tags or []),
-                )
-                for m in models
-            ]
-
-        # Search mlx-community first
-        mlx_results = _to_results(
-            list_models(
-                search=query or None,
-                author="mlx-community",
-                sort="downloads",
-                limit=limit,
-            )
+        results = list_models(
+            search=query or None,
+            author="mlx-community",
+            sort="downloads",
+            limit=limit,
         )
-        if mlx_results:
-            return mlx_results
-
-        # Fall back to searching all of HuggingFace
-        return _to_results(
-            list_models(
-                search=query or None,
-                sort="downloads",
-                limit=limit,
+        return [
+            HuggingFaceSearchResult(
+                id=m.id,
+                author=m.author or "",
+                downloads=m.downloads or 0,
+                likes=m.likes or 0,
+                last_modified=str(m.last_modified or ""),
+                tags=list(m.tags or []),
             )
-        )
+            for m in results
+        ]
 
     async def run(self):
         shutdown_ev = anyio.Event()

src/exo/master/tests/test_placement.py

@@ -14,11 +14,7 @@ from exo.shared.models.model_cards import ModelCard, ModelId, ModelTask
 from exo.shared.topology import Topology
 from exo.shared.types.commands import PlaceInstance
 from exo.shared.types.common import CommandId, NodeId
-from exo.shared.types.events import (
-    InstanceCreated,
-    InstanceDeleted,
-    TaskStatusUpdated,
-)
+from exo.shared.types.events import InstanceCreated, InstanceDeleted, TaskStatusUpdated
 from exo.shared.types.memory import Memory
 from exo.shared.types.multiaddr import Multiaddr
 from exo.shared.types.profiling import NetworkInterfaceInfo, NodeNetworkInfo

src/exo/routing/router.py

@@ -219,10 +219,6 @@ class Router:
             async for topic, data in networked_items:
                 try:
                     logger.trace(f"Sending message on {topic} with payload {data}")
-                    if len(data) > 1024 * 1024:
-                        logger.warning(
-                            "Sending overlarge payload, network performance may be temporarily degraded"
-                        )
                     await self._net.gossipsub_publish(topic, data)
                 except NoPeersSubscribedToTopicError:
                     pass

src/exo/shared/apply.py

@@ -15,6 +15,7 @@ from exo.shared.types.events import (
     NodeDownloadProgress,
     NodeGatheredInfo,
     NodeTimedOut,
+    RunnerDeleted,
     RunnerStatusUpdated,
     TaskAcknowledged,
     TaskCreated,
@@ -39,7 +40,7 @@ from exo.shared.types.tasks import Task, TaskId, TaskStatus
 from exo.shared.types.topology import Connection, RDMAConnection
 from exo.shared.types.worker.downloads import DownloadProgress
 from exo.shared.types.worker.instances import Instance, InstanceId
-from exo.shared.types.worker.runners import RunnerId, RunnerShutdown, RunnerStatus
+from exo.shared.types.worker.runners import RunnerId, RunnerStatus
 from exo.utils.info_gatherer.info_gatherer import (
     MacmonMetrics,
     MacThunderboltConnections,
@@ -77,6 +78,8 @@ def event_apply(event: Event, state: State) -> State:
             return apply_node_download_progress(event, state)
         case NodeGatheredInfo():
             return apply_node_gathered_info(event, state)
+        case RunnerDeleted():
+            return apply_runner_deleted(event, state)
         case RunnerStatusUpdated():
             return apply_runner_status_updated(event, state)
         case TaskCreated():
@@ -188,18 +191,23 @@ def apply_instance_deleted(event: InstanceDeleted, state: State) -> State:
 
 
 def apply_runner_status_updated(event: RunnerStatusUpdated, state: State) -> State:
-    if isinstance(event.runner_status, RunnerShutdown):
-        new_runners: Mapping[RunnerId, RunnerStatus] = {
-            rid: rs for rid, rs in state.runners.items() if rid != event.runner_id
-        }
-        return state.model_copy(update={"runners": new_runners})
-    new_runners = {
+    new_runners: Mapping[RunnerId, RunnerStatus] = {
         **state.runners,
         event.runner_id: event.runner_status,
     }
     return state.model_copy(update={"runners": new_runners})
 
 
+def apply_runner_deleted(event: RunnerDeleted, state: State) -> State:
+    assert event.runner_id in state.runners, (
+        "RunnerDeleted before any RunnerStatusUpdated events"
+    )
+    new_runners: Mapping[RunnerId, RunnerStatus] = {
+        rid: rs for rid, rs in state.runners.items() if rid != event.runner_id
+    }
+    return state.model_copy(update={"runners": new_runners})
+
+
 def apply_node_timed_out(event: NodeTimedOut, state: State) -> State:
     topology = copy.deepcopy(state.topology)
     topology.remove_node(event.node_id)

src/exo/shared/constants.py

@@ -81,5 +81,3 @@ EXO_ENABLE_IMAGE_MODELS = (
 EXO_OFFLINE = os.getenv("EXO_OFFLINE", "false").lower() == "true"
 
 EXO_TRACING_ENABLED = os.getenv("EXO_TRACING_ENABLED", "false").lower() == "true"
-
-EXO_MAX_CONCURRENT_REQUESTS = int(os.getenv("EXO_MAX_CONCURRENT_REQUESTS", "8"))

src/exo/shared/tests/test_apply/test_apply_runner_deleted.py

@@ -1,26 +0,0 @@
-from exo.shared.apply import apply_runner_status_updated
-from exo.shared.types.events import RunnerStatusUpdated
-from exo.shared.types.state import State
-from exo.shared.types.worker.runners import RunnerId, RunnerIdle, RunnerShutdown
-
-
-def test_apply_runner_shutdown_removes_runner():
-    runner_id = RunnerId()
-    state = State(runners={runner_id: RunnerIdle()})
-
-    new_state = apply_runner_status_updated(
-        RunnerStatusUpdated(runner_id=runner_id, runner_status=RunnerShutdown()), state
-    )
-
-    assert runner_id not in new_state.runners
-
-
-def test_apply_runner_status_updated_adds_runner():
-    runner_id = RunnerId()
-    state = State()
-
-    new_state = apply_runner_status_updated(
-        RunnerStatusUpdated(runner_id=runner_id, runner_status=RunnerIdle()), state
-    )
-
-    assert runner_id in new_state.runners

src/exo/shared/types/api.py

@@ -201,9 +201,6 @@ class ChatCompletionRequest(BaseModel):
     tools: list[dict[str, Any]] | None = None
     reasoning_effort: ReasoningEffort | None = None
     enable_thinking: bool | None = None
-    min_p: float | None = None
-    repetition_penalty: float | None = None
-    repetition_context_size: int | None = None
     tool_choice: str | dict[str, Any] | None = None
     parallel_tool_calls: bool | None = None
     user: str | None = None

src/exo/shared/types/events.py

@@ -73,6 +73,10 @@ class RunnerStatusUpdated(BaseEvent):
     runner_status: RunnerStatus
 
 
+class RunnerDeleted(BaseEvent):
+    runner_id: RunnerId
+
+
 class NodeTimedOut(BaseEvent):
     node_id: NodeId
 
@@ -138,6 +142,7 @@ Event = (
     | InstanceCreated
     | InstanceDeleted
     | RunnerStatusUpdated
+    | RunnerDeleted
     | NodeTimedOut
     | NodeGatheredInfo
     | NodeDownloadProgress

src/exo/shared/types/tasks.py

@@ -18,9 +18,6 @@ class TaskId(Id):
     pass
 
 
-CANCEL_ALL_TASKS = TaskId("CANCEL_ALL_TASKS")
-
-
 class TaskStatus(str, Enum):
     Pending = "Pending"
     Running = "Running"

src/exo/shared/types/text_generation.py

@@ -67,6 +67,3 @@ class TextGenerationTaskParams(BaseModel, frozen=True):
     enable_thinking: bool | None = None
     logprobs: bool = False
     top_logprobs: int | None = None
-    min_p: float | None = None
-    repetition_penalty: float | None = None
-    repetition_context_size: int | None = None

src/exo/worker/engines/mlx/generator/batch_generate.py

@@ -1,383 +0,0 @@
-import time
-from dataclasses import dataclass, field
-from typing import Callable, cast
-
-import mlx.core as mx
-from mlx_lm.generate import (
-    BatchGenerator as MlxBatchGenerator,
-)
-from mlx_lm.models.cache import RotatingKVCache
-from mlx_lm.sample_utils import make_logits_processors, make_sampler
-from mlx_lm.tokenizer_utils import TokenizerWrapper
-
-from exo.shared.types.api import (
-    CompletionTokensDetails,
-    FinishReason,
-    GenerationStats,
-    PromptTokensDetails,
-    TopLogprobItem,
-    Usage,
-)
-from exo.shared.types.memory import Memory
-from exo.shared.types.mlx import KVCacheType, Model
-from exo.shared.types.text_generation import TextGenerationTaskParams
-from exo.shared.types.worker.runner_response import GenerationResponse
-from exo.worker.engines.mlx.cache import (
-    CacheSnapshot,
-    KVPrefixCache,
-    encode_prompt,
-    make_kv_cache,
-)
-from exo.worker.engines.mlx.constants import DEFAULT_TOP_LOGPROBS, MAX_TOKENS
-from exo.worker.engines.mlx.generator.generate import (
-    ban_token_ids,
-    eos_ids_from_tokenizer,
-    extract_top_logprobs,
-    prefill,
-)
-from exo.worker.engines.mlx.utils_mlx import fix_unmatched_think_end_tokens
-from exo.worker.runner.bootstrap import logger
-
-_MIN_PREFIX_HIT_RATIO_TO_UPDATE = 0.5
-
-
-def _stop_sequences(task_params: TextGenerationTaskParams) -> list[str]:
-    if task_params.stop is None:
-        return []
-    if isinstance(task_params.stop, str):
-        return [task_params.stop]
-    return task_params.stop
-
-
-@dataclass
-class _EngineTask:
-    uid: int
-    task_params: TextGenerationTaskParams
-    all_prompt_tokens: mx.array
-    prefix_hit_length: int
-    matched_index: int | None
-    cache_snapshots: list[CacheSnapshot] | None
-    on_generation_token: Callable[[], None] | None = None
-    generated_text_parts: list[str] = field(default_factory=list)
-    potential_stop_sequence_text: str = ""
-    completion_tokens: int = 0
-    generation_start_time: float = 0.0
-    in_thinking: bool = False
-    reasoning_tokens: int = 0
-
-
-@dataclass(eq=False)
-class ExoBatchGenerator:
-    model: Model
-    tokenizer: TokenizerWrapper
-    group: mx.distributed.Group | None
-    kv_prefix_cache: KVPrefixCache | None
-
-    _exo_gen: MlxBatchGenerator = field(init=False)
-    _active_tasks: dict[int, _EngineTask] = field(default_factory=dict, init=False)
-
-    def __post_init__(self) -> None:
-        self._exo_gen = MlxBatchGenerator(
-            model=self.model,
-            stop_tokens=set(eos_ids_from_tokenizer(self.tokenizer)),
-            prefill_step_size=4096,
-        )
-
-    @property
-    def has_work(self) -> bool:
-        return (
-            bool(self._active_tasks)
-            or bool(self._exo_gen.unprocessed_prompts)
-            or self._exo_gen.active_batch is not None
-        )
-
-    def submit(
-        self,
-        task_params: TextGenerationTaskParams,
-        prompt: str,
-        on_prefill_progress: Callable[[int, int], None] | None = None,
-        distributed_prompt_progress_callback: Callable[[], None] | None = None,
-        on_generation_token: Callable[[], None] | None = None,
-    ) -> int:
-        all_prompt_tokens = encode_prompt(self.tokenizer, prompt)
-        all_prompt_tokens = fix_unmatched_think_end_tokens(
-            all_prompt_tokens, self.tokenizer
-        )
-
-        is_bench = task_params.bench
-
-        prefix_hit_length = 0
-        matched_index: int | None = None
-        prompt_tokens = all_prompt_tokens
-
-        if self.kv_prefix_cache is not None and not is_bench:
-            cache, remaining_tokens, matched_index = self.kv_prefix_cache.get_kv_cache(
-                self.model, all_prompt_tokens
-            )
-            prefix_hit_length = len(all_prompt_tokens) - len(remaining_tokens)
-            if prefix_hit_length > 0:
-                logger.info(
-                    f"KV cache hit: {prefix_hit_length}/{len(all_prompt_tokens)} tokens "
-                    f"cached ({100 * prefix_hit_length / len(all_prompt_tokens):.1f}%)"
-                )
-                prompt_tokens = remaining_tokens
-            else:
-                cache = make_kv_cache(self.model)
-        else:
-            cache = make_kv_cache(self.model)
-
-        seed = task_params.seed if task_params.seed is not None else 42
-        mx.random.seed(seed)
-
-        sampler = make_sampler(
-            temp=task_params.temperature
-            if task_params.temperature is not None
-            else 0.7,
-            top_p=task_params.top_p if task_params.top_p is not None else 1.0,
-            min_p=task_params.min_p if task_params.min_p is not None else 0.05,
-            top_k=task_params.top_k if task_params.top_k is not None else 0,
-        )
-
-        _prefill_tps, _prefill_tokens, cache_snapshots = prefill(
-            self.model,
-            self.tokenizer,
-            sampler,
-            prompt_tokens[:-1],
-            cache,
-            self.group,
-            on_prefill_progress,
-            distributed_prompt_progress_callback,
-        )
-
-        # We need to clamp rotating kv caches to max size so that mlx lm's _merge_caches behaves
-        for c in cache:
-            if (
-                isinstance(c, RotatingKVCache)
-                and c.keys is not None
-                and c.values is not None
-                and c.keys.shape[2] > c.max_size
-            ):
-                trim_size = c.keys.shape[2] - c.max_size
-                c.keys = c._trim(trim_size, c.keys)
-                c.values = c._trim(trim_size, c.values)
-                c._idx = c.max_size
-
-        if not is_bench:
-            self._save_prefix_cache(
-                all_prompt_tokens,
-                list(cache),
-                cache_snapshots,
-                prefix_hit_length,
-                matched_index,
-            )
-
-        last_tokens = prompt_tokens[-2:]
-
-        logits_processors: list[Callable[[mx.array, mx.array], mx.array]] = (
-            make_logits_processors(
-                repetition_penalty=task_params.repetition_penalty,
-                repetition_context_size=task_params.repetition_context_size,
-            )
-        )
-        if is_bench:
-            # Only sample length eos tokens
-            eos_ids = eos_ids_from_tokenizer(self.tokenizer)
-            logits_processors = [ban_token_ids(eos_ids)] + logits_processors
-
-        max_tokens = task_params.max_output_tokens or MAX_TOKENS
-
-        uids = self._exo_gen.insert(
-            prompts=[last_tokens.tolist()],
-            max_tokens=[max_tokens],
-            caches=[list(cache)],
-            samplers=[sampler],
-            logits_processors=[logits_processors],
-        )
-
-        assert len(uids) == 1
-
-        uid = uids[0]
-
-        self._active_tasks[uid] = _EngineTask(
-            uid=uid,
-            task_params=task_params,
-            all_prompt_tokens=all_prompt_tokens,
-            prefix_hit_length=prefix_hit_length,
-            matched_index=matched_index,
-            cache_snapshots=cache_snapshots or None,
-            on_generation_token=on_generation_token,
-            generation_start_time=time.perf_counter(),
-        )
-
-        return uid
-
-    def step(self) -> list[tuple[int, GenerationResponse]]:
-        if not self.has_work:
-            return []
-
-        responses = self._exo_gen.next()
-
-        results: list[tuple[int, GenerationResponse]] = []
-
-        for response in responses:
-            if response.uid not in self._active_tasks:
-                logger.warning(
-                    f"response uid {response.uid} was not found - should be active"
-                )
-                continue
-
-            state = self._active_tasks[response.uid]
-            if state.on_generation_token is not None:
-                state.on_generation_token()
-            text = (
-                ""
-                if response.finish_reason == "stop"
-                else self.tokenizer.decode([response.token])
-            )
-            state.completion_tokens += 1
-            state.generated_text_parts.append(text)
-            state.potential_stop_sequence_text += text
-
-            think_start = self.tokenizer.think_start
-            think_end = self.tokenizer.think_end
-            if think_start is not None and text == think_start:
-                state.in_thinking = True
-            elif think_end is not None and text == think_end:
-                state.in_thinking = False
-            if state.in_thinking:
-                state.reasoning_tokens += 1
-
-            finish_reason: FinishReason | None = cast(
-                FinishReason | None, response.finish_reason
-            )
-            task_params = state.task_params
-            stop_sequences = _stop_sequences(task_params)
-            max_stop_len = max((len(s) for s in stop_sequences), default=0)
-
-            if stop_sequences:
-                for stop_seq in stop_sequences:
-                    if stop_seq in state.potential_stop_sequence_text:
-                        stop_index = state.potential_stop_sequence_text.find(stop_seq)
-                        text_before_stop = state.potential_stop_sequence_text[
-                            :stop_index
-                        ]
-                        chunk_start = len(state.potential_stop_sequence_text) - len(
-                            text
-                        )
-                        text = text_before_stop[chunk_start:]
-                        finish_reason = "stop"
-                        break
-
-            is_done = finish_reason is not None
-
-            logprob: float | None = None
-            top_logprobs: list[TopLogprobItem] | None = None
-            if task_params.logprobs:
-                logprob, top_logprobs = extract_top_logprobs(
-                    logprobs=response.logprobs,
-                    tokenizer=self.tokenizer,
-                    top_logprobs=task_params.top_logprobs or DEFAULT_TOP_LOGPROBS,
-                    selected_token=response.token,
-                )
-
-            stats: GenerationStats | None = None
-            usage: Usage | None = None
-            if is_done:
-                generation_elapsed = time.perf_counter() - state.generation_start_time
-                generation_tps = (
-                    state.completion_tokens / generation_elapsed
-                    if generation_elapsed > 0
-                    else 0.0
-                )
-                mlx_stats = self._exo_gen.stats()
-                stats = GenerationStats(
-                    prompt_tps=float(mlx_stats.prompt_tps)
-                    if mlx_stats.prompt_time > 0
-                    else 0.0,
-                    generation_tps=float(generation_tps),
-                    prompt_tokens=len(state.all_prompt_tokens),
-                    generation_tokens=state.completion_tokens,
-                    peak_memory_usage=Memory.from_gb(mx.get_peak_memory() / 1e9),
-                )
-                total_prompt_tokens = len(state.all_prompt_tokens)
-                usage = Usage(
-                    prompt_tokens=total_prompt_tokens,
-                    completion_tokens=state.completion_tokens,
-                    total_tokens=total_prompt_tokens + state.completion_tokens,
-                    prompt_tokens_details=PromptTokensDetails(
-                        cached_tokens=state.prefix_hit_length
-                    ),
-                    completion_tokens_details=CompletionTokensDetails(
-                        reasoning_tokens=state.reasoning_tokens
-                    ),
-                )
-
-            results.append(
-                (
-                    response.uid,
-                    GenerationResponse(
-                        text=text,
-                        token=response.token,
-                        logprob=logprob,
-                        top_logprobs=top_logprobs,
-                        finish_reason=finish_reason,
-                        stats=stats,
-                        usage=usage,
-                    ),
-                )
-            )
-
-            if is_done:
-                del self._active_tasks[response.uid]
-            elif (
-                max_stop_len > 0
-                and len(state.potential_stop_sequence_text) > max_stop_len
-            ):
-                state.potential_stop_sequence_text = state.potential_stop_sequence_text[
-                    -max_stop_len:
-                ]
-
-        return results
-
-    def cancel(self, uids: list[int]) -> None:
-        self._exo_gen.remove(uids)
-        for uid in uids:
-            self._active_tasks.pop(uid, None)
-
-    def close(self) -> None:
-        self._exo_gen.close()
-
-    def _save_prefix_cache(
-        self,
-        all_prompt_tokens: mx.array,
-        cache: KVCacheType,
-        cache_snapshots: list[CacheSnapshot] | None,
-        prefix_hit_length: int,
-        matched_index: int | None,
-    ) -> None:
-        if self.kv_prefix_cache is None:
-            return
-
-        try:
-            hit_ratio = (
-                prefix_hit_length / len(all_prompt_tokens)
-                if len(all_prompt_tokens) > 0
-                else 0.0
-            )
-            if (
-                matched_index is not None
-                and hit_ratio >= _MIN_PREFIX_HIT_RATIO_TO_UPDATE
-            ):
-                self.kv_prefix_cache.update_kv_cache(
-                    matched_index,
-                    all_prompt_tokens,
-                    cache,
-                    cache_snapshots,
-                    restore_pos=prefix_hit_length,
-                )
-            else:
-                self.kv_prefix_cache.add_kv_cache(
-                    all_prompt_tokens, cache, cache_snapshots
-                )
-        except Exception:
-            logger.warning("Failed to save prefix cache", exc_info=True)

src/exo/worker/engines/mlx/generator/generate.py

@@ -10,7 +10,7 @@ from mlx_lm.generate import (
     stream_generate,
 )
 from mlx_lm.models.cache import ArraysCache, RotatingKVCache
-from mlx_lm.sample_utils import make_logits_processors, make_sampler
+from mlx_lm.sample_utils import make_sampler
 from mlx_lm.tokenizer_utils import TokenizerWrapper
 
 from exo.shared.types.api import (
@@ -309,11 +309,7 @@ def warmup_inference(
     model: Model,
     tokenizer: TokenizerWrapper,
     group: mx.distributed.Group | None,
-    model_id: ModelId,
 ) -> int:
-    logger.info(f"warming up inference for instance: {model_id}")
-    t = time.monotonic()
-
     content = "Prompt to warm up the inference engine. Repeat this."
 
     warmup_prompt = apply_chat_template(
@@ -354,25 +350,7 @@ def warmup_inference(
 
     mx_barrier(group)
 
-    logger.info(f"warmed up by generating {tokens_generated} tokens")
-    check_for_cancel_every = min(
-        math.ceil(tokens_generated / min(time.monotonic() - t, 0.001)), 100
-    )
-    if group is not None:
-        check_for_cancel_every = int(
-            mx.max(
-                mx.distributed.all_gather(
-                    mx.array([check_for_cancel_every]),
-                    group=group,
-                )
-            ).item()
-        )
-
-    logger.info(
-        f"runner checking for cancellation every {check_for_cancel_every} tokens"
-    )
-
-    return check_for_cancel_every
+    return tokens_generated
 
 
 def ban_token_ids(token_ids: list[int]) -> Callable[[mx.array, mx.array], mx.array]:
@@ -492,21 +470,15 @@ def mlx_generate(
                 f"KV cache hit: {prefix_hit_length}/{len(all_prompt_tokens)} tokens cached ({100 * prefix_hit_length / len(all_prompt_tokens):.1f}%)"
             )
 
-    logits_processors: list[Callable[[mx.array, mx.array], mx.array]] = (
-        make_logits_processors(
-            repetition_penalty=task.repetition_penalty,
-            repetition_context_size=task.repetition_context_size,
-        )
-    )
+    logits_processors: list[Callable[[mx.array, mx.array], mx.array]] = []
     if is_bench:
         # Only sample length eos tokens
         eos_ids = eos_ids_from_tokenizer(tokenizer)
-        logits_processors = [ban_token_ids(eos_ids)] + logits_processors
+        logits_processors = [ban_token_ids(eos_ids)]
 
     sampler = make_sampler(
         temp=task.temperature if task.temperature is not None else 0.7,
         top_p=task.top_p if task.top_p is not None else 1.0,
-        min_p=task.min_p if task.min_p is not None else 0.05,
         top_k=task.top_k if task.top_k is not None else 0,
     )
 

src/exo/worker/engines/mlx/tests/test_batch_generate.py

@@ -1,268 +0,0 @@
-# pyright: reportAny=false, reportUnknownVariableType=false
-# pyright: reportUnknownMemberType=false, reportUnknownArgumentType=false
-# pyright: reportUnknownLambdaType=false, reportPrivateUsage=false
-# pyright: reportInvalidCast=false, reportArgumentType=false
-# pyright: reportUnusedImport=false
-"""Test B=1 vs B=2 equivalence for batch generation.
-
-Verifies that running two requests concurrently in a batch (B=2) produces
-identical token selections to running them sequentially (B=1).
-Uses random weights — no model download required.
-"""
-
-from pathlib import Path
-from typing import cast
-
-import mlx.core as mx
-import mlx.nn as nn
-import mlx.utils
-import pytest
-from mlx_lm.generate import _merge_caches
-from mlx_lm.sample_utils import make_sampler
-from mlx_lm.tokenizer_utils import TokenizerWrapper
-from transformers import AutoTokenizer
-
-# Import batch_generate to activate the right-padding BatchKVCache patch
-import exo.worker.engines.mlx.generator.batch_generate  # noqa: F401
-from exo.shared.types.mlx import Model
-from exo.worker.engines.mlx.cache import encode_prompt, make_kv_cache
-from exo.worker.engines.mlx.generator.generate import prefill
-
-NUM_STEPS = 20
-
-
-def _init_random(model: nn.Module) -> None:
-    """Initialize all model parameters with random values."""
-    params = model.parameters()
-    new_params = mlx.utils.tree_map(
-        lambda p: mx.random.normal(shape=p.shape, dtype=p.dtype)
-        if isinstance(p, mx.array)
-        else p,
-        params,
-    )
-    model.update(new_params)
-    mx.eval(model.parameters())
-
-
-def _run_b1_vs_b2(
-    model: Model,
-    tokenizer: TokenizerWrapper,
-    tokens_a: mx.array,
-    tokens_b: mx.array,
-) -> tuple[float, int]:
-    """Run B=1 sequential and B=2 batched, return (max_diff, mismatches)."""
-    sampler = make_sampler(temp=0.0)
-
-    # B=1 sequential
-    cache_a1 = make_kv_cache(model)
-    prefill(model, tokenizer, sampler, tokens_a[:-1], cache_a1, None, None, None)
-    merged_a1 = _merge_caches([[c for c in cache_a1]])
-    for c in merged_a1:
-        c.prepare(lengths=[1], right_padding=[0])
-    model(mx.array([[tokens_a[-2].item()]]), cache=merged_a1)
-    mx.eval([c.state for c in merged_a1])
-    for c in merged_a1:
-        c.finalize()
-
-    cache_b1 = make_kv_cache(model)
-    prefill(model, tokenizer, sampler, tokens_b[:-1], cache_b1, None, None, None)
-    merged_b1 = _merge_caches([[c for c in cache_b1]])
-    for c in merged_b1:
-        c.prepare(lengths=[1], right_padding=[0])
-    model(mx.array([[tokens_b[-2].item()]]), cache=merged_b1)
-    mx.eval([c.state for c in merged_b1])
-    for c in merged_b1:
-        c.finalize()
-
-    b1_logits_a: list[mx.array] = []
-    b1_logits_b: list[mx.array] = []
-    next_a, next_b = tokens_a[-1].item(), tokens_b[-1].item()
-    for _ in range(NUM_STEPS):
-        la = model(mx.array([[next_a]]), cache=merged_a1)
-        mx.eval(la)
-        b1_logits_a.append(la[0, -1])
-        next_a = int(mx.argmax(la[0, -1]).item())
-        lb = model(mx.array([[next_b]]), cache=merged_b1)
-        mx.eval(lb)
-        b1_logits_b.append(lb[0, -1])
-        next_b = int(mx.argmax(lb[0, -1]).item())
-
-    # B=2 batched
-    cache_a2 = make_kv_cache(model)
-    cache_b2 = make_kv_cache(model)
-    prefill(model, tokenizer, sampler, tokens_a[:-1], cache_a2, None, None, None)
-    prefill(model, tokenizer, sampler, tokens_b[:-1], cache_b2, None, None, None)
-    merged_b2 = _merge_caches([list(cache_a2), list(cache_b2)])
-    for c in merged_b2:
-        c.prepare(lengths=[1, 1], right_padding=[0, 0])
-    model(
-        mx.array([[tokens_a[-2].item()], [tokens_b[-2].item()]]),
-        cache=merged_b2,
-    )
-    mx.eval([c.state for c in merged_b2])
-    for c in merged_b2:
-        c.finalize()
-
-    b2_logits_a: list[mx.array] = []
-    b2_logits_b: list[mx.array] = []
-    next_a2, next_b2 = tokens_a[-1].item(), tokens_b[-1].item()
-    for _ in range(NUM_STEPS):
-        l2 = model(mx.array([[next_a2], [next_b2]]), cache=merged_b2)
-        mx.eval(l2)
-        b2_logits_a.append(l2[0, -1])
-        b2_logits_b.append(l2[1, -1])
-        next_a2 = int(mx.argmax(l2[0, -1]).item())
-        next_b2 = int(mx.argmax(l2[1, -1]).item())
-
-    # Compare
-    max_diff = 0.0
-    mismatches = 0
-    for step in range(NUM_STEPS):
-        diff_a = float(
-            mx.max(
-                mx.abs(
-                    b1_logits_a[step].astype(mx.float32)
-                    - b2_logits_a[step].astype(mx.float32)
-                )
-            ).item()
-        )
-        diff_b = float(
-            mx.max(
-                mx.abs(
-                    b1_logits_b[step].astype(mx.float32)
-                    - b2_logits_b[step].astype(mx.float32)
-                )
-            ).item()
-        )
-        max_diff = max(max_diff, diff_a, diff_b)
-        if int(mx.argmax(b1_logits_a[step]).item()) != int(
-            mx.argmax(b2_logits_a[step]).item()
-        ):
-            mismatches += 1
-        if int(mx.argmax(b1_logits_b[step]).item()) != int(
-            mx.argmax(b2_logits_b[step]).item()
-        ):
-            mismatches += 1
-
-    return max_diff, mismatches
-
-
-def _make_tokenizer() -> TokenizerWrapper:
-    """Load the Qwen tokenizer (tiny download, shared across Qwen models)."""
-    from huggingface_hub import snapshot_download
-
-    model_path = Path(
-        snapshot_download(
-            "mlx-community/Qwen3.5-35B-A3B-4bit",
-            allow_patterns=["tokenizer*", "*.jinja"],
-        )
-    )
-    hf_tokenizer = AutoTokenizer.from_pretrained(model_path)
-    return TokenizerWrapper(hf_tokenizer)
-
-
-@pytest.mark.slow
-def test_batch_b2_llama() -> None:
-    """Llama-style model (KVCache only) must produce bit-exact logits in B=2.
-
-    Right-padded BatchKVCache keeps data at position 0 for all sequences,
-    so flash attention sees identical data layout as B=1 → bit-exact output.
-    """
-    from mlx_lm.models.llama import Model as LlamaModel
-    from mlx_lm.models.llama import ModelArgs
-
-    mx.random.seed(42)
-    args = ModelArgs(
-        model_type="llama",
-        hidden_size=256,
-        num_hidden_layers=4,
-        intermediate_size=512,
-        num_attention_heads=4,
-        num_key_value_heads=2,
-        rms_norm_eps=1e-6,
-        vocab_size=248320,
-        rope_theta=10000.0,
-        tie_word_embeddings=True,
-    )
-    model = LlamaModel(args)
-    _init_random(model)
-
-    tokenizer = _make_tokenizer()
-    tokens_a = encode_prompt(tokenizer, "Write a short essay about AI.")
-    tokens_b = encode_prompt(tokenizer, "Explain evolution briefly.")
-
-    max_diff, mismatches = _run_b1_vs_b2(
-        cast(Model, model), tokenizer, tokens_a, tokens_b
-    )
-    assert mismatches == 0, f"Llama B=2 token mismatches: {mismatches}/{NUM_STEPS * 2}"
-    assert max_diff < 0.002, f"Llama B=2 max logit diff: {max_diff}"
-
-
-@pytest.mark.slow
-def test_batch_b2_qwen35_moe() -> None:
-    """Qwen3.5 MoE model (hybrid SSM+attention+MoE) must produce bit-exact logits in B=2.
-
-    Right-padded BatchKVCache keeps data at position 0 for all sequences,
-    so flash attention sees identical data layout as B=1 → bit-exact output.
-    """
-    from mlx_lm.models.qwen3_5_moe import Model as Qwen35MoeModel
-    from mlx_lm.models.qwen3_5_moe import ModelArgs
-
-    mx.random.seed(42)
-    config = {
-        "model_type": "qwen3_5_moe",
-        "text_config": {
-            "model_type": "qwen3_5_moe_text",
-            "hidden_size": 256,
-            "num_hidden_layers": 8,
-            "intermediate_size": 512,
-            "num_attention_heads": 4,
-            "num_key_value_heads": 2,
-            "rms_norm_eps": 1e-6,
-            "vocab_size": 248320,
-            "head_dim": 64,
-            "max_position_embeddings": 4096,
-            "full_attention_interval": 4,
-            "layer_types": [
-                "linear_attention",
-                "linear_attention",
-                "linear_attention",
-                "full_attention",
-                "linear_attention",
-                "linear_attention",
-                "linear_attention",
-                "full_attention",
-            ],
-            "linear_conv_kernel_dim": 4,
-            "linear_key_head_dim": 64,
-            "linear_num_key_heads": 4,
-            "linear_num_value_heads": 4,
-            "linear_value_head_dim": 64,
-            "mamba_ssm_dtype": "float32",
-            "num_experts": 8,
-            "num_experts_per_tok": 2,
-            "moe_intermediate_size": 256,
-            "shared_expert_intermediate_size": 256,
-            "rope_parameters": {
-                "rope_type": "default",
-                "rope_theta": 10000000,
-            },
-            "attention_bias": False,
-            "attn_output_gate": True,
-        },
-    }
-    args = ModelArgs.from_dict(config)
-    model = Qwen35MoeModel(args)
-    _init_random(model)
-
-    tokenizer = _make_tokenizer()
-    tokens_a = encode_prompt(tokenizer, "Write a short essay about AI.")
-    tokens_b = encode_prompt(tokenizer, "Explain evolution briefly.")
-
-    max_diff, mismatches = _run_b1_vs_b2(
-        cast(Model, model), tokenizer, tokens_a, tokens_b
-    )
-    assert mismatches == 0, (
-        f"Qwen3.5 MoE B=2 token mismatches: {mismatches}/{NUM_STEPS * 2}"
-    )
-    assert max_diff < 0.002, f"Qwen3.5 MoE B=2 max logit diff: {max_diff}"

src/exo/worker/engines/mlx/utils_mlx.py

@@ -41,7 +41,6 @@ from exo.download.download_utils import build_model_path
 from exo.shared.types.common import Host
 from exo.shared.types.memory import Memory
 from exo.shared.types.mlx import Model
-from exo.shared.types.tasks import TaskId, TextGeneration
 from exo.shared.types.text_generation import TextGenerationTaskParams
 from exo.shared.types.worker.instances import (
     BoundInstance,
@@ -751,56 +750,3 @@ def _parse_kimi_tool_calls(text: str):
         return [_parse_single_tool(match) for match in tool_matches]  # pyright: ignore[reportAny]
     else:
         return [_parse_single_tool(text)]
-
-
-def mx_all_gather_tasks(
-    tasks: list[TextGeneration],
-    group: mx.distributed.Group | None,
-) -> tuple[list[TextGeneration], list[TextGeneration]]:
-    def encode_task_id(task_id: TaskId) -> list[int]:
-        utf8_task_id = task_id.encode()
-        return [
-            int.from_bytes(utf8_task_id[i : i + 1]) for i in range(len(utf8_task_id))
-        ]
-
-    def decode_task_id(encoded_task_id: list[int]) -> TaskId:
-        return TaskId(
-            bytes.decode(b"".join((x).to_bytes(length=1) for x in encoded_task_id))
-        )
-
-    uuid_byte_length = 36
-
-    n_tasks = len(tasks)
-    all_counts = cast(
-        list[int],
-        mx.distributed.all_gather(mx.array([n_tasks]), group=group).tolist(),
-    )
-    max_tasks = max(all_counts)
-    world_size: int = 1 if group is None else group.size()
-
-    if max_tasks == 0:
-        return [], []
-
-    padded = [encode_task_id(task.task_id) for task in tasks] + [
-        [0] * uuid_byte_length
-    ] * (max_tasks - n_tasks)
-
-    assert all(len(encoded_task_id) == uuid_byte_length for encoded_task_id in padded)
-
-    gathered = cast(
-        list[list[list[int]]],
-        mx.distributed.all_gather(mx.array(padded), group=group)
-        .reshape(world_size, max_tasks, -1)
-        .tolist(),
-    )
-    all_task_ids: list[list[TaskId]] = [
-        [decode_task_id(encoded_task_id) for encoded_task_id in rank_tasks[:count]]
-        for rank_tasks, count in zip(gathered, all_counts, strict=True)
-    ]
-
-    agreed_ids = set[TaskId].intersection(*(set(tids) for tids in all_task_ids))
-
-    local_tasks = {task.task_id: task for task in tasks}
-    agreed = [local_tasks[tid] for tid in sorted(agreed_ids)]
-    different = [task for task in tasks if task.task_id not in agreed_ids]
-    return agreed, different

src/exo/worker/runner/bootstrap.py

@@ -1,5 +1,4 @@
 import os
-import resource
 
 import loguru
 
@@ -22,9 +21,6 @@ def entrypoint(
     global logger
     logger = _logger
 
-    soft, hard = resource.getrlimit(resource.RLIMIT_NOFILE)
-    resource.setrlimit(resource.RLIMIT_NOFILE, (min(max(soft, 2048), hard), hard))
-
     fast_synch_override = os.environ.get("EXO_FAST_SYNCH")
     if fast_synch_override != "off":
         os.environ["MLX_METAL_FAST_SYNCH"] = "1"

src/exo/worker/runner/image_models/runner.py

@@ -1,4 +1,5 @@
 import base64
+import resource
 import time
 from typing import TYPE_CHECKING, Literal
 
@@ -20,7 +21,6 @@ from exo.shared.types.events import (
     TracesCollected,
 )
 from exo.shared.types.tasks import (
-    CANCEL_ALL_TASKS,
     ConnectToGroup,
     ImageEdits,
     ImageGeneration,
@@ -195,6 +195,9 @@ class Runner:
         self.cancel_receiver = cancel_receiver
         self.bound_instance = bound_instance
 
+        soft, hard = resource.getrlimit(resource.RLIMIT_NOFILE)
+        resource.setrlimit(resource.RLIMIT_NOFILE, (min(max(soft, 2048), hard), hard))
+
         self.instance, self.runner_id, self.shard_metadata = (
             bound_instance.instance,
             bound_instance.bound_runner_id,
@@ -241,11 +244,11 @@ class Runner:
                 if task.task_id in self.seen:
                     logger.warning("repeat task - potential error")
                 self.seen.add(task.task_id)
-                self.cancelled_tasks.discard(CANCEL_ALL_TASKS)
+                self.cancelled_tasks.discard(TaskId("CANCEL_CURRENT_TASK"))
                 self.send_task_status(task, TaskStatus.Running)
                 self.handle_task(task)
                 was_cancelled = (task.task_id in self.cancelled_tasks) or (
-                    CANCEL_ALL_TASKS in self.cancelled_tasks
+                    TaskId("CANCEL_CURRENT_TASK") in self.cancelled_tasks
                 )
                 if not was_cancelled:
                     self.send_task_status(task, TaskStatus.Complete)

src/exo/worker/runner/llm_inference/batch_generator.py

@@ -1,24 +1,24 @@
 import itertools
+import math
 import time
 from abc import ABC, abstractmethod
 from collections import deque
 from collections.abc import Generator, Iterable
 from dataclasses import dataclass, field
+from typing import cast
 
 import mlx.core as mx
 from mlx_lm.tokenizer_utils import TokenizerWrapper
 
-from exo.shared.constants import EXO_MAX_CONCURRENT_REQUESTS
 from exo.shared.types.chunks import ErrorChunk, PrefillProgressChunk
 from exo.shared.types.common import ModelId
 from exo.shared.types.events import ChunkGenerated, Event
 from exo.shared.types.mlx import Model
-from exo.shared.types.tasks import CANCEL_ALL_TASKS, TaskId, TextGeneration
+from exo.shared.types.tasks import TaskId, TextGeneration
 from exo.shared.types.text_generation import TextGenerationTaskParams
 from exo.shared.types.worker.runner_response import GenerationResponse, ToolCallResponse
 from exo.utils.channels import MpReceiver, MpSender
 from exo.worker.engines.mlx.cache import KVPrefixCache
-from exo.worker.engines.mlx.generator.batch_generate import ExoBatchGenerator
 from exo.worker.engines.mlx.generator.generate import (
     PrefillCancelled,
     mlx_generate,
@@ -26,7 +26,6 @@ from exo.worker.engines.mlx.generator.generate import (
 )
 from exo.worker.engines.mlx.utils_mlx import (
     apply_chat_template,
-    mx_all_gather_tasks,
     mx_any,
 )
 from exo.worker.runner.bootstrap import logger
@@ -59,14 +58,6 @@ class GeneratorQueue[T]:
 
 
 class InferenceGenerator(ABC):
-    _cancelled_tasks: set[TaskId]
-
-    def should_cancel(self, task_id: TaskId) -> bool:
-        return (
-            task_id in self._cancelled_tasks
-            or CANCEL_ALL_TASKS in self._cancelled_tasks
-        )
-
     @abstractmethod
     def warmup(self) -> None: ...
 
@@ -124,8 +115,6 @@ class SequentialGenerator(InferenceGenerator):
 
     _cancelled_tasks: set[TaskId] = field(default_factory=set, init=False)
     _maybe_queue: list[TextGeneration] = field(default_factory=list, init=False)
-    _maybe_cancel: list[TextGeneration] = field(default_factory=list, init=False)
-    _all_tasks: dict[TaskId, TextGeneration] = field(default_factory=dict, init=False)
     _queue: deque[TextGeneration] = field(default_factory=deque, init=False)
     _active: (
         tuple[
@@ -141,19 +130,37 @@ class SequentialGenerator(InferenceGenerator):
     ) = field(default=None, init=False)
 
     def warmup(self):
-        self.check_for_cancel_every = warmup_inference(
+        logger.info(f"warming up inference for instance: {self.model_id}")
+
+        t = time.monotonic()
+        toks = warmup_inference(
             model=self.model,
             tokenizer=self.tokenizer,
             group=self.group,
-            model_id=self.model_id,
+        )
+        logger.info(f"warmed up by generating {toks} tokens")
+        check_for_cancel_every = min(
+            math.ceil(toks / min(time.monotonic() - t, 0.001)), 100
+        )
+        if self.group is not None:
+            self.check_for_cancel_every = int(
+                mx.max(
+                    mx.distributed.all_gather(
+                        mx.array([check_for_cancel_every]),
+                        group=self.group,
+                    )
+                ).item()
+            )
+
+        logger.info(
+            f"runner checking for cancellation every {check_for_cancel_every} tokens"
         )
 
     def submit(
         self,
         task: TextGeneration,
     ) -> None:
-        self._cancelled_tasks.discard(CANCEL_ALL_TASKS)
-        self._all_tasks[task.task_id] = task
+        self._cancelled_tasks.discard(TaskId("CANCEL_CURRENT_TASK"))
         self._maybe_queue.append(task)
 
     def agree_on_tasks(self) -> None:
@@ -162,23 +169,6 @@ class SequentialGenerator(InferenceGenerator):
         self._queue.extend(task for task in self._maybe_queue if task in agreed)
         self._maybe_queue = [task for task in self._maybe_queue if task in different]
 
-    def agree_on_cancellations(self) -> None:
-        """Agree between all ranks about which tasks to cancel."""
-        has_cancel_all = False
-        for task_id in self.cancel_receiver.collect():
-            if task_id == CANCEL_ALL_TASKS:
-                has_cancel_all = True
-                continue
-            if task_id in self._all_tasks:
-                self._maybe_cancel.append(self._all_tasks[task_id])
-
-        if mx_any(has_cancel_all, self.group):
-            self._cancelled_tasks.add(CANCEL_ALL_TASKS)
-
-        agreed, different = mx_all_gather_tasks(self._maybe_cancel, self.group)
-        self._cancelled_tasks.update(task.task_id for task in agreed)
-        self._maybe_cancel = list(different)
-
     def step(
         self,
     ) -> Iterable[
@@ -221,19 +211,15 @@ class SequentialGenerator(InferenceGenerator):
             self._send_error(task, e)
             raise
         queue = GeneratorQueue[GenerationResponse]()
-
-        if task.task_params.bench:
-            output_generator = queue.gen()
-        else:
-            output_generator = apply_all_parsers(
-                queue.gen(),
-                apply_chat_template(self.tokenizer, task.task_params),
-                self.tool_parser,
-                self.tokenizer,
-                type(self.model),
-                self.model_id,
-                task.task_params.tools,
-            )
+        output_generator = apply_all_parsers(
+            queue.gen(),
+            apply_chat_template(self.tokenizer, task.task_params),
+            self.tool_parser,
+            self.tokenizer,
+            type(self.model),
+            self.model_id,
+            task.task_params.tools,
+        )
         self._active = (task, mlx_gen, queue, output_generator)
 
     def _send_error(self, task: TextGeneration, e: Exception) -> None:
@@ -267,8 +253,11 @@ class SequentialGenerator(InferenceGenerator):
                 )
 
         def distributed_prompt_progress_callback() -> None:
-            self.agree_on_cancellations()
-            if self.should_cancel(task.task_id):
+            self._cancelled_tasks.update(self.cancel_receiver.collect())
+            want_to_cancel = (task.task_id in self._cancelled_tasks) or (
+                TaskId("CANCEL_CURRENT_TASK") in self._cancelled_tasks
+            )
+            if mx_any(want_to_cancel, self.group):
                 raise PrefillCancelled()
 
             self.agree_on_tasks()
@@ -280,8 +269,11 @@ class SequentialGenerator(InferenceGenerator):
             tokens_since_cancel_check += 1
             if tokens_since_cancel_check >= self.check_for_cancel_every:
                 tokens_since_cancel_check = 0
-                self.agree_on_cancellations()
-                if self.should_cancel(task.task_id):
+                self._cancelled_tasks.update(self.cancel_receiver.collect())
+                want_to_cancel = (task.task_id in self._cancelled_tasks) or (
+                    TaskId("CANCEL_CURRENT_TASK") in self._cancelled_tasks
+                )
+                if mx_any(want_to_cancel, self.group):
                     raise PrefillCancelled()
 
                 self.agree_on_tasks()
@@ -302,228 +294,53 @@ class SequentialGenerator(InferenceGenerator):
         del self.model, self.tokenizer, self.group
 
 
-@dataclass(eq=False)
-class BatchGenerator(InferenceGenerator):
-    model: Model
-    tokenizer: TokenizerWrapper
-    group: mx.distributed.Group | None
-    kv_prefix_cache: KVPrefixCache | None
-    tool_parser: ToolParser | None
-    model_id: ModelId
-    device_rank: int
-    cancel_receiver: MpReceiver[TaskId]
-    event_sender: MpSender[Event]
-    check_for_cancel_every: int = 50
+def mx_all_gather_tasks(
+    tasks: list[TextGeneration],
+    group: mx.distributed.Group | None,
+) -> tuple[list[TextGeneration], list[TextGeneration]]:
+    def encode_task_id(task_id: TaskId) -> list[int]:
+        utf8_task_id = task_id.encode()
+        return [
+            int.from_bytes(utf8_task_id[i : i + 1]) for i in range(len(utf8_task_id))
+        ]
 
-    _cancelled_tasks: set[TaskId] = field(default_factory=set, init=False)
-    _maybe_queue: list[TextGeneration] = field(default_factory=list, init=False)
-    _maybe_cancel: list[TextGeneration] = field(default_factory=list, init=False)
-    _all_tasks: dict[TaskId, TextGeneration] = field(default_factory=dict, init=False)
-    _queue: deque[TextGeneration] = field(default_factory=deque, init=False)
-    _mlx_gen: ExoBatchGenerator = field(init=False)
-    _active_tasks: dict[
-        int,
-        tuple[
-            TextGeneration,
-            GeneratorQueue[GenerationResponse],
-            Generator[GenerationResponse | ToolCallResponse | None],
-        ],
-    ] = field(default_factory=dict, init=False)
-
-    def __post_init__(self) -> None:
-        self._mlx_gen = ExoBatchGenerator(
-            model=self.model,
-            tokenizer=self.tokenizer,
-            group=self.group,
-            kv_prefix_cache=self.kv_prefix_cache,
+    def decode_task_id(encoded_task_id: list[int]) -> TaskId:
+        return TaskId(
+            bytes.decode(b"".join((x).to_bytes(length=1) for x in encoded_task_id))
         )
 
-    def warmup(self):
-        self.check_for_cancel_every = warmup_inference(
-            model=self.model,
-            tokenizer=self.tokenizer,
-            group=self.group,
-            model_id=self.model_id,
-        )
+    uuid_byte_length = 36
 
-    def submit(
-        self,
-        task: TextGeneration,
-    ) -> None:
-        self._cancelled_tasks.discard(CANCEL_ALL_TASKS)
-        self._all_tasks[task.task_id] = task
-        self._maybe_queue.append(task)
+    n_tasks = len(tasks)
+    all_counts = cast(
+        list[int],
+        mx.distributed.all_gather(mx.array([n_tasks]), group=group).tolist(),
+    )
+    max_tasks = max(all_counts)
+    world_size: int = 1 if group is None else group.size()
 
-    def agree_on_tasks(self) -> None:
-        """Agree between all ranks about the task ordering (some may have received in different order or not at all)."""
-        agreed, different = mx_all_gather_tasks(self._maybe_queue, self.group)
-        self._queue.extend(task for task in self._maybe_queue if task in agreed)
-        self._maybe_queue = [task for task in self._maybe_queue if task in different]
+    if max_tasks == 0:
+        return [], []
 
-    def agree_on_cancellations(self) -> None:
-        """Agree between all ranks about which tasks to cancel."""
-        has_cancel_all = False
-        for task_id in self.cancel_receiver.collect():
-            if task_id == CANCEL_ALL_TASKS:
-                has_cancel_all = True
-                continue
-            if task_id in self._all_tasks:
-                self._maybe_cancel.append(self._all_tasks[task_id])
+    padded = [encode_task_id(task.task_id) for task in tasks] + [
+        [0] * uuid_byte_length
+    ] * (max_tasks - n_tasks)
+    gathered = cast(
+        list[list[list[int]]],
+        mx.distributed.all_gather(mx.array(padded), group=group)
+        .reshape(world_size, max_tasks, -1)
+        .tolist(),
+    )
+    all_task_ids: list[list[TaskId]] = [
+        [decode_task_id(encoded_task_id) for encoded_task_id in rank_tasks[:count]]
+        for rank_tasks, count in zip(gathered, all_counts, strict=True)
+    ]
 
-        if mx_any(has_cancel_all, self.group):
-            self._cancelled_tasks.add(CANCEL_ALL_TASKS)
+    agreed_ids: set[TaskId] = set(all_task_ids[0])
+    for rank_tasks in all_task_ids[1:]:
+        agreed_ids &= set(rank_tasks)
 
-        agreed, different = mx_all_gather_tasks(self._maybe_cancel, self.group)
-        self._cancelled_tasks.update(task.task_id for task in agreed)
-        self._maybe_cancel = list(different)
-
-    def step(
-        self,
-    ) -> Iterable[
-        tuple[TaskId, GenerationResponse | ToolCallResponse | Cancelled | Finished]
-    ]:
-        if not self._queue:
-            self.agree_on_tasks()
-
-        # Submit any queued tasks to the engine
-        while self._queue and len(self._active_tasks) < EXO_MAX_CONCURRENT_REQUESTS:
-            task = self._queue.popleft()
-            try:
-                uid = self._start_task(task)
-            except PrefillCancelled:
-                continue
-            except Exception as e:
-                self._send_error(task, e)
-                raise
-
-            queue = GeneratorQueue[GenerationResponse]()
-            if task.task_params.bench:
-                output_generator = queue.gen()
-            else:
-                output_generator = apply_all_parsers(
-                    queue.gen(),
-                    apply_chat_template(self.tokenizer, task.task_params),
-                    self.tool_parser,
-                    self.tokenizer,
-                    type(self.model),
-                    self.model_id,
-                    task.task_params.tools,
-                )
-            self._active_tasks[uid] = (task, queue, output_generator)
-
-        if not self._mlx_gen.has_work:
-            return self._apply_cancellations()
-
-        results = self._mlx_gen.step()
-
-        output: list[
-            tuple[TaskId, GenerationResponse | ToolCallResponse | Cancelled | Finished]
-        ] = []
-        for uid, response in results:
-            if uid not in self._active_tasks:
-                # should we error here?
-                logger.warning(f"{uid=} not found in active tasks")
-                continue
-
-            task, queue, output_generator = self._active_tasks[uid]
-            queue.push(response)
-            parsed = next(output_generator)
-
-            if parsed is not None:
-                output.append((task.task_id, parsed))
-
-            if response.finish_reason is not None:
-                output.append((task.task_id, Finished()))
-                del self._active_tasks[uid]
-
-        return itertools.chain(output, self._apply_cancellations())
-
-    def _apply_cancellations(
-        self,
-    ) -> list[tuple[TaskId, Cancelled]]:
-        if not self._cancelled_tasks:
-            return []
-
-        cancel_all = CANCEL_ALL_TASKS in self._cancelled_tasks
-
-        uids_to_cancel: list[int] = []
-        results: list[tuple[TaskId, Cancelled]] = []
-
-        for uid, (task, _, _) in list(self._active_tasks.items()):
-            if task.task_id in self._cancelled_tasks or cancel_all:
-                uids_to_cancel.append(uid)
-                results.append((task.task_id, Cancelled()))
-                del self._active_tasks[uid]
-
-        if uids_to_cancel:
-            self._mlx_gen.cancel(uids_to_cancel)
-
-        already_cancelled = {tid for tid, _ in results}
-        for tid in self._cancelled_tasks:
-            if tid != CANCEL_ALL_TASKS and tid not in already_cancelled:
-                results.append((tid, Cancelled()))
-
-        self._cancelled_tasks.clear()
-        return results
-
-    def _send_error(self, task: TextGeneration, e: Exception) -> None:
-        if self.device_rank == 0:
-            self.event_sender.send(
-                ChunkGenerated(
-                    command_id=task.command_id,
-                    chunk=ErrorChunk(
-                        model=self.model_id,
-                        finish_reason="error",
-                        error_message=str(e),
-                    ),
-                )
-            )
-
-    def _start_task(self, task: TextGeneration) -> int:
-        _check_for_debug_prompts(task.task_params)
-        prompt = apply_chat_template(self.tokenizer, task.task_params)
-
-        def on_prefill_progress(processed: int, total: int) -> None:
-            if self.device_rank == 0:
-                self.event_sender.send(
-                    ChunkGenerated(
-                        command_id=task.command_id,
-                        chunk=PrefillProgressChunk(
-                            model=self.model_id,
-                            processed_tokens=processed,
-                            total_tokens=total,
-                        ),
-                    )
-                )
-
-        def distributed_prompt_progress_callback() -> None:
-            self.agree_on_cancellations()
-            if self.should_cancel(task.task_id):
-                raise PrefillCancelled()
-
-            self.agree_on_tasks()
-
-        tokens_since_cancel_check = self.check_for_cancel_every
-
-        def on_generation_token() -> None:
-            nonlocal tokens_since_cancel_check
-            tokens_since_cancel_check += 1
-            if tokens_since_cancel_check >= self.check_for_cancel_every:
-                tokens_since_cancel_check = 0
-                self.agree_on_cancellations()
-                if self.should_cancel(task.task_id):
-                    self._cancelled_tasks.add(task.task_id)
-
-                self.agree_on_tasks()
-
-        return self._mlx_gen.submit(
-            task_params=task.task_params,
-            prompt=prompt,
-            on_prefill_progress=on_prefill_progress,
-            distributed_prompt_progress_callback=distributed_prompt_progress_callback,
-            on_generation_token=on_generation_token,
-        )
-
-    def close(self) -> None:
-        self._mlx_gen.close()
-        del self.model, self.tokenizer, self.group
+    local_tasks = {task.task_id: task for task in tasks}
+    agreed = [local_tasks[tid] for tid in sorted(agreed_ids)]
+    different = [task for task in tasks if task.task_id not in agreed_ids]
+    return agreed, different

src/exo/worker/runner/llm_inference/model_output_parsers.py

@@ -21,7 +21,8 @@ from exo.worker.engines.mlx.utils_mlx import (
     detect_thinking_prompt_suffix,
 )
 from exo.worker.runner.bootstrap import logger
-from exo.worker.runner.llm_inference.tool_parsers import ToolParser
+
+from .tool_parsers import ToolParser
 
 
 @cache
@@ -44,8 +45,7 @@ def apply_all_parsers(
     if tokenizer.has_thinking:
         mlx_generator = parse_thinking_models(
             mlx_generator,
-            tokenizer.think_start,
-            tokenizer.think_end,
+            tokenizer,
             starts_in_thinking=detect_thinking_prompt_suffix(prompt, tokenizer),
         )
 
@@ -116,9 +116,6 @@ def parse_gpt_oss(
         if current_tool_name is not None:
             if delta:
                 tool_arg_parts.append(delta)
-            if response.finish_reason is not None:
-                yield response.model_copy(update={"text": "".join(tool_arg_parts)})
-                tool_arg_parts = []
             continue
 
         if ch == "analysis" and not thinking:
@@ -300,8 +297,7 @@ def _could_be_dsml_prefix(text: str) -> bool:
 
 def parse_thinking_models(
     responses: Generator[GenerationResponse | None],
-    think_start: str | None,
-    think_end: str | None,
+    tokenizer: TokenizerWrapper,
     starts_in_thinking: bool = True,
 ) -> Generator[GenerationResponse | None]:
     """Route thinking tokens via is_thinking flag.
@@ -309,23 +305,25 @@ def parse_thinking_models(
     Swallows think tag tokens, sets is_thinking on all others.
     Always yields tokens with finish_reason to avoid hanging the chunk stream.
     """
-    is_thinking = starts_in_thinking
+    in_thinking = starts_in_thinking
     for response in responses:
         if response is None:
             yield None
             continue
-        if response.finish_reason is not None:
-            yield response.model_copy(update={"is_thinking": False})
-            continue
 
-        if response.text == think_start:
-            is_thinking = True
-            continue
-        if response.text == think_end:
-            is_thinking = False
-            continue
+        is_think_tag = (
+            tokenizer.think_end is not None and response.text == tokenizer.think_end
+        ) or (
+            tokenizer.think_start is not None and response.text == tokenizer.think_start
+        )
 
-        yield response.model_copy(update={"is_thinking": is_thinking})
+        if is_think_tag:
+            in_thinking = response.text != tokenizer.think_end
+            # Never swallow finish_reason — the chunk stream needs it to terminate.
+            if response.finish_reason is not None:
+                yield response.model_copy(update={"text": "", "is_thinking": False})
+            continue
+        yield response.model_copy(update={"is_thinking": in_thinking})
 
 
 def parse_tool_calls(
@@ -339,41 +337,42 @@ def parse_tool_calls(
         if response is None:
             yield None
             continue
-
         if not in_tool_call and response.text.startswith(tool_parser.start_parsing):
             in_tool_call = True
 
-        if not in_tool_call:
-            yield response
-            continue
+        if in_tool_call:
+            tool_call_text_parts.append(response.text)
+            if response.text.endswith(tool_parser.end_parsing):
+                # parse the actual tool calls from the tool call text
+                parsed = tool_parser.parse("".join(tool_call_text_parts).strip(), tools)
+                logger.info(f"parsed {tool_call_text_parts=} into {parsed=}")
+                if parsed is not None:
+                    yield ToolCallResponse(
+                        tool_calls=parsed, usage=response.usage, stats=response.stats
+                    )
+                else:
+                    logger.warning(
+                        f"tool call parsing failed for text {''.join(tool_call_text_parts)}"
+                    )
+                    response.text = "".join(tool_call_text_parts)
+                    yield response
 
-        tool_call_text_parts.append(response.text)
-        if response.text.endswith(tool_parser.end_parsing):
-            # parse the actual tool calls from the tool call text
-            combined = "".join(tool_call_text_parts)
-            parsed = tool_parser.parse(combined.strip(), tools=tools)
-            logger.info(f"parsed {tool_call_text_parts=} into {parsed=}")
-            in_tool_call = False
-            tool_call_text_parts = []
-
-            if parsed is None:
-                logger.warning(f"tool call parsing failed for text {combined}")
-                yield response.model_copy(update={"text": combined})
+                in_tool_call = False
+                tool_call_text_parts = []
                 continue
 
-            yield ToolCallResponse(
-                tool_calls=parsed, usage=response.usage, stats=response.stats
-            )
-            continue
+            if response.finish_reason is not None:
+                logger.info(
+                    "tool call parsing interrupted, yield partial tool call as text"
+                )
+                response = response.model_copy(
+                    update={
+                        "text": "".join(tool_call_text_parts),
+                        "token": 0,
+                    }
+                )
+                yield response
 
-        if response.finish_reason is not None:
-            logger.info(
-                "tool call parsing interrupted, yield partial tool call as text"
-            )
-            response = response.model_copy(
-                update={
-                    "text": "".join(tool_call_text_parts),
-                    "token": 0,
-                }
-            )
+        else:
+            # fallthrough
             yield response

src/exo/worker/runner/llm_inference/runner.py

@@ -1,4 +1,4 @@
-import os
+import resource
 import time
 from dataclasses import dataclass
 from enum import Enum
@@ -59,13 +59,12 @@ from exo.worker.engines.mlx.utils_mlx import (
 )
 from exo.worker.runner.bootstrap import logger
 from exo.worker.runner.llm_inference.batch_generator import (
-    BatchGenerator,
     InferenceGenerator,
     SequentialGenerator,
 )
 
 from .batch_generator import Cancelled, Finished
-from .tool_parsers import make_mlx_parser
+from .tool_parsers import ToolParser, make_mlx_parser
 
 
 class ExitCode(str, Enum):
@@ -86,6 +85,9 @@ class Runner:
         self.cancel_receiver = cancel_receiver
         self.bound_instance = bound_instance
 
+        soft, hard = resource.getrlimit(resource.RLIMIT_NOFILE)
+        resource.setrlimit(resource.RLIMIT_NOFILE, (min(max(soft, 2048), hard), hard))
+
         self.instance, self.runner_id, self.shard_metadata = (
             self.bound_instance.instance,
             self.bound_instance.bound_runner_id,
@@ -203,6 +205,16 @@ class Runner:
                         on_layer_loaded=on_layer_loaded,
                     )
                 )
+                logger.info(
+                    f"model has_tool_calling={self.generator.tokenizer.has_tool_calling} using tokens {self.generator.tokenizer.tool_call_start}, {self.generator.tokenizer.tool_call_end}"
+                )
+                tok = self.generator.tokenizer
+                if tok.tool_call_start and tok.tool_call_end and tok.tool_parser:  # pyright: ignore[reportAny]
+                    self.generator.tool_parser = make_mlx_parser(
+                        tok.tool_call_start,
+                        tok.tool_call_end,
+                        tok.tool_parser,  # pyright: ignore[reportAny]
+                    )
 
                 self.generator = self.generator.build()
 
@@ -288,7 +300,7 @@ class Runner:
                         )
 
             for task_id in finished:
-                self.active_tasks.pop(task_id, None)
+                del self.active_tasks[task_id]
 
             try:
                 task = self.task_receiver.receive_nowait()
@@ -378,7 +390,9 @@ class Builder:
     cancel_receiver: MpReceiver[TaskId]
     inference_model: Model | None = None
     tokenizer: TokenizerWrapper | None = None
+    tool_parser: ToolParser | None = None
     group: mx.distributed.Group | None = None
+    kv_prefix_cache: KVPrefixCache | None = None
 
     def build(
         self,
@@ -387,46 +401,14 @@ class Builder:
         assert self.inference_model
         assert self.tokenizer
 
-        tool_parser = None
-        logger.info(
-            f"model has_tool_calling={self.tokenizer.has_tool_calling} using tokens {self.tokenizer.tool_call_start}, {self.tokenizer.tool_call_end}"
-        )
-        if (
-            self.tokenizer.tool_call_start
-            and self.tokenizer.tool_call_end
-            and self.tokenizer.tool_parser  # type: ignore
-        ):
-            tool_parser = make_mlx_parser(
-                self.tokenizer.tool_call_start,
-                self.tokenizer.tool_call_end,
-                self.tokenizer.tool_parser,  # type: ignore
-            )
-
-        kv_prefix_cache = KVPrefixCache(self.group)
-
-        device_rank = 0 if self.group is None else self.group.rank()
-        if os.environ.get("EXO_NO_BATCH"):
-            logger.info("using SequentialGenerator (batching disabled)")
-            return SequentialGenerator(
-                model=self.inference_model,
-                tokenizer=self.tokenizer,
-                group=self.group,
-                tool_parser=tool_parser,
-                kv_prefix_cache=kv_prefix_cache,
-                model_id=self.model_id,
-                device_rank=device_rank,
-                cancel_receiver=self.cancel_receiver,
-                event_sender=self.event_sender,
-            )
-        logger.info("using BatchGenerator")
-        return BatchGenerator(
+        return SequentialGenerator(
             model=self.inference_model,
             tokenizer=self.tokenizer,
             group=self.group,
-            tool_parser=tool_parser,
-            kv_prefix_cache=kv_prefix_cache,
+            tool_parser=self.tool_parser,
+            kv_prefix_cache=self.kv_prefix_cache,
             model_id=self.model_id,
-            device_rank=device_rank,
+            device_rank=0 if self.group is None else self.group.rank(),
             cancel_receiver=self.cancel_receiver,
             event_sender=self.event_sender,
         )

src/exo/worker/runner/runner_supervisor.py

@@ -21,7 +21,6 @@ from exo.shared.types.events import (
     TaskStatusUpdated,
 )
 from exo.shared.types.tasks import (
-    CANCEL_ALL_TASKS,
     ImageEdits,
     ImageGeneration,
     Task,
@@ -126,7 +125,7 @@ class RunnerSupervisor:
         with contextlib.suppress(ClosedResourceError):
             self._event_sender.close()
         with contextlib.suppress(ClosedResourceError):
-            self._cancel_sender.send(CANCEL_ALL_TASKS)
+            self._cancel_sender.send(TaskId("CANCEL_CURRENT_TASK"))
         with contextlib.suppress(ClosedResourceError):
             self._cancel_sender.close()
         self.runner_process.join(5)

src/exo/worker/tests/unittests/test_mlx/test_batch_vs_generate.py

@@ -1,389 +0,0 @@
-import copy
-import gc
-import json
-import shutil
-import tempfile
-from pathlib import Path
-from typing import Any, cast
-
-import mlx.core as mx
-import pytest
-from mlx_lm.tokenizer_utils import TokenizerWrapper
-
-from exo.shared.types.common import ModelId
-from exo.shared.types.mlx import KVCacheType, Model
-from exo.shared.types.text_generation import InputMessage, TextGenerationTaskParams
-from exo.worker.engines.mlx.cache import CacheSnapshot, KVPrefixCache, cache_length
-from exo.worker.engines.mlx.generator.batch_generate import ExoBatchGenerator
-from exo.worker.engines.mlx.generator.generate import mlx_generate
-from exo.worker.engines.mlx.utils_mlx import (
-    apply_chat_template,
-    load_tokenizer_for_model_id,
-)
-
-from .test_prefix_cache_architectures import (
-    ARCHITECTURES,
-    ArchSpec,
-    _arch_available,  # pyright: ignore[reportPrivateUsage]
-    _build_model,  # pyright: ignore[reportPrivateUsage]
-    _copy_tokenizer,  # pyright: ignore[reportPrivateUsage]
-    _find_snapshot,  # pyright: ignore[reportPrivateUsage]
-    _reduce_config,  # pyright: ignore[reportPrivateUsage]
-)
-
-
-def _make_task(
-    content: str = "Hello, what is 2+2?",
-    max_tokens: int = 10,
-    seed: int = 42,
-) -> TextGenerationTaskParams:
-    return TextGenerationTaskParams(
-        model=ModelId("test"),
-        input=[InputMessage(role="user", content=content)],
-        max_output_tokens=max_tokens,
-        temperature=0.7,
-        seed=seed,
-    )
-
-
-# ── Helpers ──────────────────────────────────────────────────────────────── #
-
-
-def _collect_mlx_generate(
-    model: Model,
-    tokenizer: TokenizerWrapper,
-    task: TextGenerationTaskParams,
-    kv_prefix_cache: KVPrefixCache | None,
-) -> list[int]:
-    """Run mlx_generate and collect output token IDs."""
-    prompt = apply_chat_template(tokenizer=tokenizer, task_params=task)
-    tokens: list[int] = []
-    for resp in mlx_generate(
-        model=model,
-        tokenizer=tokenizer,
-        task=task,
-        prompt=prompt,
-        kv_prefix_cache=kv_prefix_cache,
-        group=None,
-    ):
-        tokens.append(resp.token)
-        if resp.finish_reason is not None:
-            break
-    return tokens
-
-
-def _collect_batch_generate(
-    model: Model,
-    tokenizer: TokenizerWrapper,
-    task_params: TextGenerationTaskParams,
-    kv_prefix_cache: KVPrefixCache | None,
-) -> list[int]:
-    """Run ExoBatchGenerator and collect raw output token IDs"""
-    exo_gen = ExoBatchGenerator(
-        model=model,
-        tokenizer=tokenizer,
-        group=None,
-        kv_prefix_cache=kv_prefix_cache,
-    )
-
-    prompt = apply_chat_template(tokenizer=tokenizer, task_params=task_params)
-    exo_gen.submit(task_params=task_params, prompt=prompt)
-
-    tokens: list[int] = []
-    while exo_gen.has_work:
-        results = exo_gen.step()
-        for _uid, response in results:
-            tokens.append(response.token)
-
-    exo_gen.close()
-    return tokens
-
-
-def _assert_state_equal(sa: object, sb: object, label: str) -> None:
-    """Compare two state items, handling both plain arrays and tuples of arrays (CacheList)."""
-    if isinstance(sa, tuple):
-        assert isinstance(sb, tuple), f"{label}: type mismatch"
-        for k, (arr_a, arr_b) in enumerate(
-            zip(
-                cast(tuple[mx.array, ...], sa),
-                cast(tuple[mx.array, ...], sb),
-                strict=True,
-            )
-        ):
-            a_f = mx.array(arr_a).astype(mx.float32)
-            b_f = mx.array(arr_b).astype(mx.float32)
-            if a_f.size == 0:
-                assert b_f.size == 0, f"{label}[{k}]: size mismatch"
-                continue
-            diff = float(mx.max(mx.abs(a_f - b_f)).item())
-            assert diff == 0.0, f"{label}[{k}]: max diff {diff}"
-    else:
-        sa_f = mx.array(cast(mx.array, sa)).astype(mx.float32)
-        sb_f = mx.array(cast(mx.array, sb)).astype(mx.float32)
-        if sa_f.size == 0:
-            assert sb_f.size == 0, f"{label}: size mismatch"
-            return
-        diff = float(mx.max(mx.abs(sa_f - sb_f)).item())
-        assert diff == 0.0, f"{label}: max diff {diff}"
-
-
-def _compare_cache_arrays(
-    cache_a: KVCacheType,
-    cache_b: KVCacheType,
-    label: str = "",
-) -> None:
-    """Assert two KV caches have identical array values."""
-    assert len(cache_a) == len(cache_b), (
-        f"{label}Cache layer count: {len(cache_a)} vs {len(cache_b)}"
-    )
-    for i, (a, b) in enumerate(zip(cache_a, cache_b, strict=True)):
-        assert type(a) is type(b), (
-            f"{label}Layer {i}: type {type(a).__name__} vs {type(b).__name__}"
-        )
-        states_a = a.state
-        states_b = b.state
-        assert len(states_a) == len(states_b), (
-            f"{label}Layer {i}: state count {len(states_a)} vs {len(states_b)}"
-        )
-        for j, (sa, sb) in enumerate(zip(states_a, states_b, strict=True)):
-            if sa is None and sb is None:
-                continue
-            assert sa is not None and sb is not None, (
-                f"{label}Layer {i}, state {j}: one is None"
-            )
-            _assert_state_equal(sa, sb, f"{label}Layer {i}, state {j}")
-
-
-def _safe_state(cache: object) -> list[object]:
-    """Safely access .state on a cache object. Returns [] if uninitialized."""
-    # RotatingKVCache.state crashes when keys is None (uninitialized)
-    if getattr(cache, "keys", _SENTINEL) is None:
-        return []
-    try:
-        return list(cache.state)  # type: ignore[union-attr]
-    except (AttributeError, TypeError):
-        return []
-
-
-_SENTINEL = object()
-
-
-def _compare_snapshots(
-    snaps_a: list[CacheSnapshot] | None,
-    snaps_b: list[CacheSnapshot] | None,
-    label: str = "",
-) -> None:
-    """Assert two snapshot lists are identical."""
-    if snaps_a is None:
-        assert snaps_b is None, f"{label}One side has snapshots, other doesn't"
-        return
-    assert snaps_b is not None, f"{label}One side has snapshots, other doesn't"
-    assert len(snaps_a) == len(snaps_b), (
-        f"{label}Snapshot count: {len(snaps_a)} vs {len(snaps_b)}"
-    )
-    for k, (sa, sb) in enumerate(zip(snaps_a, snaps_b, strict=True)):
-        assert sa.token_count == sb.token_count, (
-            f"{label}Snapshot {k} token_count: {sa.token_count} vs {sb.token_count}"
-        )
-        for layer_i, (s1, s2) in enumerate(zip(sa.states, sb.states, strict=True)):
-            if s1 is None and s2 is None:
-                continue
-            assert s1 is not None and s2 is not None, (
-                f"{label}Snapshot {k}, layer {layer_i}: one state is None"
-            )
-            state_a = _safe_state(s1)
-            state_b = _safe_state(s2)
-            if not state_a and not state_b:
-                continue
-            assert len(state_a) == len(state_b), (
-                f"{label}Snapshot {k}, layer {layer_i}: state length mismatch"
-            )
-            for st_j, (arr_a, arr_b) in enumerate(zip(state_a, state_b, strict=True)):
-                if arr_a is None and arr_b is None:
-                    continue
-                assert arr_a is not None and arr_b is not None
-                _assert_state_equal(
-                    arr_a,
-                    arr_b,
-                    f"{label}Snapshot {k}, layer {layer_i}, state {st_j}",
-                )
-
-
-# ── Test class ────────────────────────────────────────────────────────────── #
-
-
-@pytest.mark.slow
-class TestBatchVsGenerate:
-    """Verify BatchGenerator matches mlx_generate for output tokens and prefix cache."""
-
-    @pytest.fixture(autouse=True)
-    def _cleanup(self):
-        yield
-        mx.clear_cache()
-        gc.collect()
-
-    @pytest.mark.parametrize(
-        "spec",
-        ARCHITECTURES,
-        ids=[a.name for a in ARCHITECTURES],
-    )
-    def test_same_output_and_cache(self, spec: ArchSpec) -> None:
-        if not _arch_available(spec):
-            pytest.skip(f"Model {spec.hub_name} not cached locally")
-
-        snapshot = _find_snapshot(spec.hub_name)
-        assert snapshot is not None
-
-        tmpdir = Path(tempfile.mkdtemp(prefix=f"exo_batchtest_{spec.name}_"))
-        try:
-            # Build reduced config
-            with open(snapshot / "config.json") as f:
-                cfg = cast(dict[str, Any], json.load(f))
-            reduced = _reduce_config(copy.deepcopy(cfg))
-            (tmpdir / "config.json").write_text(json.dumps(reduced))
-
-            # Copy tokenizer
-            tok_src = snapshot
-            if spec.tokenizer_hub is not None:
-                alt = _find_snapshot(spec.tokenizer_hub)
-                if alt is not None:
-                    tok_src = alt
-            _copy_tokenizer(tok_src, tmpdir)
-
-            # Load tokenizer, build model with random weights
-            model_id = ModelId(f"mlx-community/{spec.hub_name}")
-            tokenizer = load_tokenizer_for_model_id(model_id, tmpdir)
-            mx.random.seed(0)
-            model = _build_model(spec.module, reduced)
-
-            task = _make_task()
-
-            # ── Run mlx_generate path ──
-            # Seed is set inside mlx_generate/ExoBatchGenerator.submit from task.seed
-            kv_mlx = KVPrefixCache(None)
-            mlx_tokens = _collect_mlx_generate(model, tokenizer, task, kv_mlx)
-
-            # ── Run batch generator path ──
-            kv_batch = KVPrefixCache(None)
-            batch_tokens = _collect_batch_generate(model, tokenizer, task, kv_batch)
-
-            # ── Compare output tokens ──
-            assert len(mlx_tokens) > 0, "mlx_generate produced no tokens"
-            assert len(batch_tokens) > 0, "BatchGenerator produced no tokens"
-            assert mlx_tokens == batch_tokens, (
-                f"[{spec.name}] Token mismatch:\n"
-                f"  mlx_generate:    {mlx_tokens}\n"
-                f"  BatchGenerator:  {batch_tokens}"
-            )
-
-            # ── Compare prefix cache KV arrays ──
-            assert len(kv_mlx.caches) == 1, "mlx_generate didn't save to prefix cache"
-            assert len(kv_batch.caches) == 1, (
-                "BatchGenerator didn't save to prefix cache"
-            )
-
-            _compare_cache_arrays(
-                kv_mlx.caches[0],
-                kv_batch.caches[0],
-                label=f"[{spec.name}] ",
-            )
-
-            # ── Compare cache lengths ──
-            mlx_len = cache_length(kv_mlx.caches[0])
-            batch_len = cache_length(kv_batch.caches[0])
-            assert mlx_len == batch_len, (
-                f"[{spec.name}] Cache length: mlx={mlx_len} vs batch={batch_len}"
-            )
-
-            # ── Compare snapshots ──
-            _compare_snapshots(
-                kv_mlx._snapshots[0],  # pyright: ignore[reportPrivateUsage]
-                kv_batch._snapshots[0],  # pyright: ignore[reportPrivateUsage]
-                label=f"[{spec.name}] ",
-            )
-
-        finally:
-            shutil.rmtree(tmpdir, ignore_errors=True)
-
-    @pytest.mark.parametrize(
-        "spec",
-        ARCHITECTURES,
-        ids=[a.name for a in ARCHITECTURES],
-    )
-    def test_concurrent_batch_completes(self, spec: ArchSpec) -> None:
-        """Two requests processed concurrently must both complete without
-        crashing and produce non-empty output.
-
-        Note: batch decode logits are NOT bit-exact with sequential because
-        Metal's matmul kernel picks different reduction tiling for B=1 vs B=2
-        when L=1 (decode step). This introduces sub-ULP float16 diffs in
-        gate_proj/down_proj/lm_head which swiglu amplifies by |up_values|.
-        With random weights these accumulate into argmax flips; with trained
-        weights the diffs are absorbed and output matches exactly (verified
-        with real Llama-3.2-1B-Instruct-4bit weights).
-        """
-        if not _arch_available(spec):
-            pytest.skip(f"Model {spec.hub_name} not cached locally")
-
-        snapshot = _find_snapshot(spec.hub_name)
-        assert snapshot is not None
-
-        tmpdir = Path(tempfile.mkdtemp(prefix=f"exo_concurrent_{spec.name}_"))
-        try:
-            with open(snapshot / "config.json") as f:
-                cfg = cast(dict[str, Any], json.load(f))
-            reduced = _reduce_config(copy.deepcopy(cfg))
-            (tmpdir / "config.json").write_text(json.dumps(reduced))
-
-            tok_src = snapshot
-            if spec.tokenizer_hub is not None:
-                alt = _find_snapshot(spec.tokenizer_hub)
-                if alt is not None:
-                    tok_src = alt
-            _copy_tokenizer(tok_src, tmpdir)
-
-            model_id = ModelId(f"mlx-community/{spec.hub_name}")
-            tokenizer = load_tokenizer_for_model_id(model_id, tmpdir)
-            mx.random.seed(0)
-            model = _build_model(spec.module, reduced)
-
-            # Two different prompts → different prompt lengths.
-            task_a = _make_task(content="Hello, what is 2+2?", seed=42)
-            task_a = task_a.model_copy(update={"temperature": 0.0})
-            task_b = _make_task(
-                content="Write a short poem about the ocean and the sky.",
-                seed=99,
-            )
-            task_b = task_b.model_copy(update={"temperature": 0.0})
-
-            # ── Concurrent: submit both to one ExoBatchGenerator ──
-            exo_gen = ExoBatchGenerator(
-                model=model,
-                tokenizer=tokenizer,
-                group=None,
-                kv_prefix_cache=None,
-            )
-
-            prompt_a = apply_chat_template(tokenizer=tokenizer, task_params=task_a)
-            prompt_b = apply_chat_template(tokenizer=tokenizer, task_params=task_b)
-            uid_a = exo_gen.submit(task_params=task_a, prompt=prompt_a)
-            uid_b = exo_gen.submit(task_params=task_b, prompt=prompt_b)
-
-            batch_tokens: dict[int, list[int]] = {uid_a: [], uid_b: []}
-            finished: set[int] = set()
-            while exo_gen.has_work:
-                results = exo_gen.step()
-                for uid, response in results:
-                    batch_tokens[uid].append(response.token)
-                    if response.finish_reason is not None:
-                        finished.add(uid)
-
-            exo_gen.close()
-
-            # ── Verify both completed ──
-            assert len(batch_tokens[uid_a]) > 0, "No tokens for task A"
-            assert len(batch_tokens[uid_b]) > 0, "No tokens for task B"
-            assert uid_a in finished, "Task A never finished"
-            assert uid_b in finished, "Task B never finished"
-        finally:
-            shutil.rmtree(tmpdir, ignore_errors=True)

src/exo/worker/tests/unittests/test_mlx/test_prefix_cache_architectures.py

@@ -183,8 +183,6 @@ ARCHITECTURES: list[ArchSpec] = [
     ArchSpec("gpt_oss", "gpt-oss-20b-MXFP4-Q8", "gpt_oss"),
     ArchSpec("step3p5", "Step-3.5-Flash-4bit", "step3p5"),
     ArchSpec("kimi_k25", "Kimi-K2.5", "kimi_k25"),
-    ArchSpec("qwen3_5", "Qwen3.5-2B-MLX-8bit", "qwen3_5"),
-    ArchSpec("qwen3_5_moe", "Qwen3.5-35B-A3B-4bit", "qwen3_5_moe"),
 ]
 
 

src/exo/worker/tests/unittests/test_runner/test_event_ordering.py

@@ -134,47 +134,11 @@ def patch_out_mlx(monkeypatch: pytest.MonkeyPatch):
     monkeypatch.setattr(
         mlx_model_output_parsers, "detect_thinking_prompt_suffix", make_nothin(False)
     )
-    monkeypatch.setattr(mlx_batch_generator, "ExoBatchGenerator", FakeExoBatchGenerator)
 
+    def fake_generate(*_1: object, **_2: object):
+        yield GenerationResponse(token=0, text="hi", finish_reason="stop", usage=None)
 
-class FakeExoBatchGenerator:
-    def __init__(self, *_args: object, **_kwargs: object) -> None:
-        self._uid_counter = 0
-        self._pending: dict[int, GenerationResponse] = {}
-
-    @property
-    def has_work(self) -> bool:
-        return bool(self._pending)
-
-    def submit(
-        self,
-        task_params: object = None,
-        prompt: object = None,
-        on_prefill_progress: object = None,
-        distributed_prompt_progress_callback: object = None,
-        on_generation_token: object = None,
-    ) -> int:
-        uid = self._uid_counter
-        self._uid_counter += 1
-        self._pending[uid] = GenerationResponse(
-            text="hi",
-            token=0,
-            finish_reason="stop",
-            usage=None,
-        )
-        return uid
-
-    def step(self) -> list[tuple[int, GenerationResponse]]:
-        results = list(self._pending.items())
-        self._pending.clear()
-        return results
-
-    def cancel(self, uids: list[int]) -> None:
-        for uid in uids:
-            self._pending.pop(uid, None)
-
-    def close(self) -> None:
-        pass
+    monkeypatch.setattr(mlx_batch_generator, "mlx_generate", fake_generate)
 
 
 # Use a fake event_sender to remove test flakiness.
@@ -201,17 +165,6 @@ class MockTokenizer:
     tool_call_end = None
     has_tool_calling = False
     has_thinking = False
-    think_start = None
-    think_end = None
-    eos_token_ids: list[int] = []
-
-    @staticmethod
-    def decode(_tokens: list[int]) -> str:
-        return "hi"
-
-    @staticmethod
-    def encode(_text: str, add_special_tokens: bool = True) -> list[int]:
-        return [0]
 
 
 class MockGroup:

src/exo/worker/tests/unittests/test_runner/test_parse_gpt_oss.py

@@ -1,6 +1,5 @@
 from collections.abc import Generator
 
-from exo.shared.types.api import FinishReason
 from exo.shared.types.worker.runner_response import (
     GenerationResponse,
     ToolCallResponse,
@@ -84,7 +83,6 @@ THINKING_THEN_TOOL_TOKENS: list[tuple[int, str]] = [
 
 def _make_gen_responses(
     tokens: list[tuple[int, str]],
-    last_finish_reason: FinishReason = "stop",
 ) -> list[GenerationResponse]:
     """Build GenerationResponse list from (token_id, text) pairs."""
     responses: list[GenerationResponse] = []
@@ -94,7 +92,7 @@ def _make_gen_responses(
             GenerationResponse(
                 text=text,
                 token=tid,
-                finish_reason=last_finish_reason if is_last else None,
+                finish_reason="stop" if is_last else None,
                 usage=None,
             )
         )
@@ -103,12 +101,11 @@ def _make_gen_responses(
 
 def _collect(
     tokens: list[tuple[int, str]],
-    last_finish_reason: FinishReason = "stop",
 ) -> list[GenerationResponse | ToolCallResponse]:
     """Feed tokens through parse_gpt_oss and collect all yielded responses."""
 
     def _gen() -> Generator[GenerationResponse, None, None]:
-        yield from _make_gen_responses(tokens, last_finish_reason)
+        yield from _make_gen_responses(tokens)
 
     return list(x for x in parse_gpt_oss(_gen()) if x is not None)
 
@@ -174,80 +171,3 @@ class TestParseGptOssThinkingThenToolCall:
         tc = _get_tool_call(results)
         assert tc.tool_calls[0].name == "get_current_weather"
         assert "Tokyo" in tc.tool_calls[0].arguments
-
-
-# fmt: off
-# Truncated tool call: recipient + channel + message + partial args, no <|call|>
-TRUNCATED_TOOL_CALL_TOKENS: list[tuple[int, str]] = [
-    (316,    " to"),
-    (28,     "="),
-    (44580,  "functions"),
-    (775,    ".get"),
-    (23981,  "_current"),
-    (170154, "_weather"),
-    (_CHANNEL, "<|channel|>"),
-    (12606,  "comment"),
-    (815,    "ary"),
-    (5701,   " json"),
-    (_MESSAGE, "<|message|>"),
-    (10848,  '{"'),
-    (7693,   "location"),
-    (1243,   '":'),
-    (392,    ' "'),
-    (173844, "Tokyo"),
-    # No <|call|> — generation truncated here
-]
-
-# Plain text tokens (no tool call)
-PLAIN_TEXT_TOKENS: list[tuple[int, str]] = [
-    (_CHANNEL, "<|channel|>"),
-    (35644,  "analysis"),
-    (_MESSAGE, "<|message|>"),
-    (12845,  "Let"),
-    (668,    " me"),
-    (2411,   " think"),
-    (1078,   " about"),
-    (495,    " this"),
-    (13,     "."),
-    (_END,   "<|end|>"),
-    (_START, "<|start|>"),
-    (_ASSISTANT, "assistant"),
-    (_CHANNEL, "<|channel|>"),
-    (12606,  "comment"),
-    (815,    "ary"),
-    (_MESSAGE, "<|message|>"),
-    (9906,   "Hello"),
-    (14,     ","),
-    (2989,   " world"),
-]
-# fmt: on
-
-
-class TestParseGptOssMaxTokensTruncation:
-    """Truncated tool calls must still yield finish_reason."""
-
-    def test_truncated_tool_call_yields_finish_reason(self):
-        results = _collect(TRUNCATED_TOOL_CALL_TOKENS, last_finish_reason="length")
-        gen_responses = [r for r in results if isinstance(r, GenerationResponse)]
-        finish_reasons = [
-            r.finish_reason for r in gen_responses if r.finish_reason is not None
-        ]
-        assert "length" in finish_reasons
-
-    def test_truncated_tool_call_emits_partial_args(self):
-        results = _collect(TRUNCATED_TOOL_CALL_TOKENS, last_finish_reason="length")
-        gen_responses = [r for r in results if isinstance(r, GenerationResponse)]
-        last = [r for r in gen_responses if r.finish_reason is not None][-1]
-        assert len(last.text) > 0
-
-    def test_truncated_plain_text_still_works(self):
-        results = _collect(PLAIN_TEXT_TOKENS, last_finish_reason="length")
-        gen_responses = [r for r in results if isinstance(r, GenerationResponse)]
-        finish_reasons = [
-            r.finish_reason for r in gen_responses if r.finish_reason is not None
-        ]
-        assert "length" in finish_reasons
-        # Verify non-empty text was yielded (delta text differs from raw token text
-        # due to Harmony encoding, so we just check something was emitted)
-        all_text = "".join(r.text for r in gen_responses)
-        assert len(all_text) > 0

uv.lock

@@ -2,10 +2,8 @@ version = 1
 revision = 3
 requires-python = ">=3.13"
 resolution-markers = [
-    "python_full_version >= '3.14' and sys_platform == 'darwin'",
-    "python_full_version < '3.14' and sys_platform == 'darwin'",
-    "python_full_version >= '3.14' and sys_platform == 'linux'",
-    "python_full_version < '3.14' and sys_platform == 'linux'",
+    "sys_platform == 'darwin'",
+    "sys_platform == 'linux'",
 ]
 supported-markers = [
     "sys_platform == 'darwin'",
@@ -22,15 +20,6 @@ members = [
     "exo-pyo3-bindings",
 ]
 
-[[package]]
-name = "absl-py"
-version = "2.4.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/64/c7/8de93764ad66968d19329a7e0c147a2bb3c7054c554d4a119111b8f9440f/absl_py-2.4.0.tar.gz", hash = "sha256:8c6af82722b35cf71e0f4d1d47dcaebfff286e27110a99fc359349b247dfb5d4", size = 116543, upload-time = "2026-01-28T10:17:05.322Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/18/a6/907a406bb7d359e6a63f99c313846d9eec4f7e6f7437809e03aa00fa3074/absl_py-2.4.0-py3-none-any.whl", hash = "sha256:88476fd881ca8aab94ffa78b7b6c632a782ab3ba1cd19c9bd423abc4fb4cd28d", size = 135750, upload-time = "2026-01-28T10:17:04.19Z" },
-]
-
 [[package]]
 name = "aiofiles"
 version = "25.1.0"
@@ -150,15 +139,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
 ]
 
-[[package]]
-name = "antlr4-python3-runtime"
-version = "4.11.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a4/1b/59dc12d9816edee8be6a166be7c220910ff18cce2ded9877a08b27396a83/antlr4-python3-runtime-4.11.0.tar.gz", hash = "sha256:6a46d4f6033c8d7e53c8975cee5d83b3ba1b48157f6beb09a4965062dacfe2e0", size = 116951, upload-time = "2022-09-04T19:49:27.321Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/37/f3/2cab1ffe441ffcc4605bf638f524fed86db6699a25d04bbecb5bfdde372b/antlr4_python3_runtime-4.11.0-py3-none-any.whl", hash = "sha256:f523f91387283045f129c343b363a8dda3a07eea62721b8eda95f2d8b817b656", size = 144189, upload-time = "2022-09-04T19:49:25.198Z" },
-]
-
 [[package]]
 name = "anyio"
 version = "4.11.0"
@@ -232,15 +212,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" },
 ]
 
-[[package]]
-name = "chardet"
-version = "5.2.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f3/0d/f7b6ab21ec75897ed80c17d79b15951a719226b9fababf1e40ea74d69079/chardet-5.2.0.tar.gz", hash = "sha256:1b3b6ff479a8c414bc3fa2c0852995695c4a026dcd6d0633b2dd092ca39c1cf7", size = 2069618, upload-time = "2023-08-01T19:23:02.662Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/38/6f/f5fbc992a329ee4e0f288c1fe0e2ad9485ed064cac731ed2fe47dcc38cbf/chardet-5.2.0-py3-none-any.whl", hash = "sha256:e1cf59446890a00105fe7b7912492ea04b6e6f06d4b742b2c788469e34c82970", size = 199385, upload-time = "2023-08-01T19:23:00.661Z" },
-]
-
 [[package]]
 name = "charset-normalizer"
 version = "3.4.4"
@@ -285,15 +256,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
 ]
 
-[[package]]
-name = "colorama"
-version = "0.4.6"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
-]
-
 [[package]]
 name = "contourpy"
 version = "1.3.3"
@@ -390,53 +352,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" },
 ]
 
-[[package]]
-name = "dataproperty"
-version = "1.1.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "mbstrdecoder", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "typepy", extra = ["datetime"], marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/0b/81/8c8b64ae873cb9014815214c07b63b12e3b18835780fb342223cfe3fe7d8/dataproperty-1.1.0.tar.gz", hash = "sha256:b038437a4097d1a1c497695c3586ea34bea67fdd35372b9a50f30bf044d77d04", size = 42574, upload-time = "2024-12-31T14:37:26.033Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/21/c2/e12e95e289e6081a40454199ab213139ef16a528c7c86432de545b05a23a/DataProperty-1.1.0-py3-none-any.whl", hash = "sha256:c61fcb2e2deca35e6d1eb1f251a7f22f0dcde63e80e61f0cc18c19f42abfd25b", size = 27581, upload-time = "2024-12-31T14:37:22.657Z" },
-]
-
-[[package]]
-name = "datasets"
-version = "4.6.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "dill", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "filelock", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "fsspec", extra = ["http"], marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "httpx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "huggingface-hub", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "multiprocess", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "packaging", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "pandas", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "pyarrow", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "pyyaml", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "requests", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "tqdm", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "xxhash", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/d7/94/eb81c6fe32e9b6ef92223141b5a553aeff2e9456968424a8533cbe88f476/datasets-4.6.1.tar.gz", hash = "sha256:140ce500bc41939ff6ce995702d66b1f4b2ee7f117bb9b07512fab6804d4070a", size = 593865, upload-time = "2026-02-27T23:26:49.482Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/37/f0/99fe6eb530c7ee9ee1faee48059eb8a6437f80c893a496b98a78864e0fc6/datasets-4.6.1-py3-none-any.whl", hash = "sha256:f53228e6dadc9f837037b1bf3051d7d8c054abbb3eb29f1f022926e08090e0da", size = 520667, upload-time = "2026-02-27T23:26:46.855Z" },
-]
-
-[[package]]
-name = "dill"
-version = "0.4.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/12/80/630b4b88364e9a8c8c5797f4602d0f76ef820909ee32f0bacb9f90654042/dill-0.4.0.tar.gz", hash = "sha256:0633f1d2df477324f53a895b02c901fb961bdbf65a17122586ea7019292cbcf0", size = 186976, upload-time = "2025-04-16T00:41:48.867Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/50/3d/9373ad9c56321fdab5b41197068e1d8c25883b3fea29dd361f9b55116869/dill-0.4.0-py3-none-any.whl", hash = "sha256:44f54bf6412c2c8464c14e8243eb163690a9800dbe2c367330883b19c7561049", size = 119668, upload-time = "2025-04-16T00:41:47.671Z" },
-]
-
 [[package]]
 name = "docutils"
 version = "0.22.4"
@@ -446,28 +361,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/02/10/5da547df7a391dcde17f59520a231527b8571e6f46fc8efb02ccb370ab12/docutils-0.22.4-py3-none-any.whl", hash = "sha256:d0013f540772d1420576855455d050a2180186c91c15779301ac2ccb3eeb68de", size = 633196, upload-time = "2025-12-18T19:00:18.077Z" },
 ]
 
-[[package]]
-name = "evaluate"
-version = "0.4.6"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "datasets", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "dill", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "fsspec", extra = ["http"], marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "huggingface-hub", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "multiprocess", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "packaging", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "pandas", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "requests", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "tqdm", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "xxhash", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/ad/d0/0c17a8e6e8dc7245f22dea860557c32bae50fc4d287ae030cb0e8ab8720f/evaluate-0.4.6.tar.gz", hash = "sha256:e07036ca12b3c24331f83ab787f21cc2dbf3631813a1631e63e40897c69a3f21", size = 65716, upload-time = "2025-09-18T13:06:30.581Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3e/af/3e990d8d4002bbc9342adb4facd59506e653da93b2417de0fa6027cb86b1/evaluate-0.4.6-py3-none-any.whl", hash = "sha256:bca85bc294f338377b7ac2f861e21c308b11b2a285f510d7d5394d5df437db29", size = 84069, upload-time = "2025-09-18T13:06:29.265Z" },
-]
-
 [[package]]
 name = "exo"
 version = "0.3.68"
@@ -525,7 +418,7 @@ requires-dist = [
     { name = "mflux", specifier = "==0.15.5" },
     { name = "mlx", marker = "sys_platform == 'darwin'", git = "https://github.com/rltakashige/mlx-jaccl-fix-small-recv.git?branch=address-rdma-gpu-locks" },
     { name = "mlx", extras = ["cpu"], marker = "sys_platform == 'linux'", specifier = "==0.30.6" },
-    { name = "mlx-lm", git = "https://github.com/rltakashige/mlx-lm?branch=leo%2Feval-left-padding-in-batched-rotation" },
+    { name = "mlx-lm", git = "https://github.com/ml-explore/mlx-lm?rev=834fac934c4e04de9b3d723e2b9287a2c60cfd4a" },
     { name = "msgspec", specifier = ">=0.19.0" },
     { name = "openai-harmony", specifier = ">=0.0.8" },
     { name = "pillow", specifier = ">=11.0,<12.0" },
@@ -554,15 +447,10 @@ name = "exo-bench"
 version = "0.1.0"
 source = { editable = "bench" }
 dependencies = [
-    { name = "datasets", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "httpx", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "huggingface-hub", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "human-eval", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "jinja2", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "lm-eval", extra = ["api", "math"], marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "loguru", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "math-verify", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "protobuf", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "tiktoken", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "transformers", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
@@ -570,15 +458,10 @@ dependencies = [
 
 [package.metadata]
 requires-dist = [
-    { name = "datasets", specifier = ">=2.0.0" },
     { name = "httpx", specifier = ">=0.27.0" },
     { name = "huggingface-hub", specifier = ">=0.33.4" },
-    { name = "human-eval", specifier = ">=1.0.3" },
     { name = "jinja2", specifier = ">=3.1.0" },
-    { name = "lm-eval", extras = ["api", "math"], specifier = ">=0.4.0" },
     { name = "loguru", specifier = ">=0.7.3" },
-    { name = "math-verify", specifier = ">=0.7.0" },
-    { name = "numpy", specifier = ">=1.24.0" },
     { name = "protobuf", specifier = ">=5.29.0" },
     { name = "tiktoken", specifier = ">=0.12.0" },
     { name = "transformers", specifier = ">=5.0.0" },
@@ -586,7 +469,7 @@ requires-dist = [
 
 [[package]]
 name = "exo-pyo3-bindings"
-version = "0.2.1"
+version = "0.2.0"
 source = { editable = "rust/exo_pyo3_bindings" }
 
 [package.dev-dependencies]
@@ -629,18 +512,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b5/36/7fb70f04bf00bc646cd5bb45aa9eddb15e19437a28b8fb2b4a5249fac770/filelock-3.20.3-py3-none-any.whl", hash = "sha256:4b0dda527ee31078689fc205ec4f1c1bf7d56cf88b6dc9426c4f230e46c2dce1", size = 16701, upload-time = "2026-01-09T17:55:04.334Z" },
 ]
 
-[[package]]
-name = "fire"
-version = "0.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "termcolor", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/c0/00/f8d10588d2019d6d6452653def1ee807353b21983db48550318424b5ff18/fire-0.7.1.tar.gz", hash = "sha256:3b208f05c736de98fb343310d090dcc4d8c78b2a89ea4f32b837c586270a9cbf", size = 88720, upload-time = "2025-08-16T20:20:24.175Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e5/4c/93d0f85318da65923e4b91c1c2ff03d8a458cbefebe3bc612a6693c7906d/fire-0.7.1-py3-none-any.whl", hash = "sha256:e43fd8a5033a9001e7e2973bab96070694b9f12f2e0ecf96d4683971b5ab1882", size = 115945, upload-time = "2025-08-16T20:20:22.87Z" },
-]
-
 [[package]]
 name = "fonttools"
 version = "4.61.1"
@@ -738,11 +609,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/01/c9/97cc5aae1648dcb851958a3ddf73ccd7dbe5650d95203ecb4d7720b4cdbf/fsspec-2026.1.0-py3-none-any.whl", hash = "sha256:cb76aa913c2285a3b49bdd5fc55b1d7c708d7208126b60f2eb8194fe1b4cbdcc", size = 201838, upload-time = "2026-01-09T15:21:34.041Z" },
 ]
 
-[package.optional-dependencies]
-http = [
-    { name = "aiohttp", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-
 [[package]]
 name = "h11"
 version = "0.16.0"
@@ -852,20 +718,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/90/fb/cb8fe5f71d5622427f20bcab9e06a696a5aaf21bfe7bd0a8a0c63c88abf5/huggingface_hub-1.3.1-py3-none-any.whl", hash = "sha256:efbc7f3153cb84e2bb69b62ed90985e21ecc9343d15647a419fc0ee4b85f0ac3", size = 533351, upload-time = "2026-01-09T14:08:14.519Z" },
 ]
 
-[[package]]
-name = "human-eval"
-version = "1.0.3"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "fire", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "tqdm", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/0a/4b/44832f60f8fb14257019084412229a2ed48e34acd0d9d3f8198196d02dd7/human-eval-1.0.3.tar.gz", hash = "sha256:03ee63d3fbbb6fecbc5dfae58381fc655004ad86caafeb141ca2169c63648766", size = 54651, upload-time = "2023-07-24T18:45:58.99Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c0/af/85d39b927626279710c27c37cc6ea16257b2035a314ad6a3277c6dc15e82/human_eval-1.0.3-py3-none-any.whl", hash = "sha256:b4e2844c8655a2db4780f6092834cb6ab15c130c56ba0516b15028ccc413dbce", size = 52282, upload-time = "2023-07-24T18:45:57.386Z" },
-]
-
 [[package]]
 name = "hypercorn"
 version = "0.18.0"
@@ -974,27 +826,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" },
 ]
 
-[[package]]
-name = "joblib"
-version = "1.5.3"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/41/f2/d34e8b3a08a9cc79a50b2208a93dce981fe615b64d5a4d4abee421d898df/joblib-1.5.3.tar.gz", hash = "sha256:8561a3269e6801106863fd0d6d84bb737be9e7631e33aaed3fb9ce5953688da3", size = 331603, upload-time = "2025-12-15T08:41:46.427Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7b/91/984aca2ec129e2757d1e4e3c81c3fcda9d0f85b74670a094cc443d9ee949/joblib-1.5.3-py3-none-any.whl", hash = "sha256:5fc3c5039fc5ca8c0276333a188bbd59d6b7ab37fe6632daa76bc7f9ec18e713", size = 309071, upload-time = "2025-12-15T08:41:44.973Z" },
-]
-
-[[package]]
-name = "jsonlines"
-version = "4.0.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "attrs", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/35/87/bcda8e46c88d0e34cad2f09ee2d0c7f5957bccdb9791b0b934ec84d84be4/jsonlines-4.0.0.tar.gz", hash = "sha256:0c6d2c09117550c089995247f605ae4cf77dd1533041d366351f6f298822ea74", size = 11359, upload-time = "2023-09-01T12:34:44.187Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f8/62/d9ba6323b9202dd2fe166beab8a86d29465c41a0288cbe229fac60c1ab8d/jsonlines-4.0.0-py3-none-any.whl", hash = "sha256:185b334ff2ca5a91362993f42e83588a360cf95ce4b71a73548502bda52a7c55", size = 8701, upload-time = "2023-09-01T12:34:42.563Z" },
-]
-
 [[package]]
 name = "keyring"
 version = "25.7.0"
@@ -1063,64 +894,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/64/ad/53bd6b22fa1917746096b6240dd0c546020e358506e8503dce57f3cdcd9a/kiwisolver-1.4.10rc0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:acc08f93b36220a6baa7df3428cb8847b27717db9be4295c0b1571d040c77327", size = 2391902, upload-time = "2025-08-10T20:22:12.421Z" },
 ]
 
-[[package]]
-name = "latex2sympy2-extended"
-version = "1.11.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "antlr4-python3-runtime", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "sympy", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/30/75/456da2da05f6380ea96e6ea804ab2c03e41fc3ed80052307fe8efe6ea20e/latex2sympy2_extended-1.11.0.tar.gz", hash = "sha256:9695657c81b50abba2636638638618db59f4663ed2a4a12d62cef74a40e28fec", size = 207023, upload-time = "2026-01-10T01:43:21.319Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e9/61/f75cd1fa54d8434276126034aed54dd120747de9a8fa013cdd79545ccbeb/latex2sympy2_extended-1.11.0-py3-none-any.whl", hash = "sha256:aebb77d52ce269e25028e4bea89ddb14d242ba36bcf7b636496fb5fd9728d234", size = 209050, upload-time = "2026-01-10T01:43:19.458Z" },
-]
-
-[package.optional-dependencies]
-antlr4-11-0 = [
-    { name = "antlr4-python3-runtime", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-
-[[package]]
-name = "lm-eval"
-version = "0.4.11"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "datasets", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "dill", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "evaluate", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "jinja2", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "jsonlines", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "more-itertools", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "pytablewriter", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "rouge-score", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "sacrebleu", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "scikit-learn", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "sqlitedict", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "word2number", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "zstandard", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/18/40/ad60ae17f97902ba4ee67914a94c159552f8643fb4598d1d2430a571f0a2/lm_eval-0.4.11.tar.gz", hash = "sha256:a3891d6d0b4ad17892f2ca1046094554ce3ab6cb522759e4a453858e45649916", size = 3246509, upload-time = "2026-02-13T20:22:59.494Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/df/b3/8c2923ad4c4d911307e20ab9c7d7869d3811b5a76fe6dbe53678aafbeb04/lm_eval-0.4.11-py3-none-any.whl", hash = "sha256:9c9945475a715558649a38ffcb90f46e7bd23a849524a5e838f249161b030517", size = 8744826, upload-time = "2026-02-13T20:22:56.317Z" },
-]
-
-[package.optional-dependencies]
-api = [
-    { name = "aiohttp", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "requests", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "tenacity", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "tiktoken", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "tqdm", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-math = [
-    { name = "antlr4-python3-runtime", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "math-verify", extra = ["antlr4-11-0"], marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "sympy", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-
 [[package]]
 name = "loguru"
 version = "0.7.3"
@@ -1130,59 +903,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl", hash = "sha256:31a33c10c8e1e10422bfd431aeb5d351c7cf7fa671e3c4df004162264b28220c", size = 61595, upload-time = "2024-12-06T11:20:54.538Z" },
 ]
 
-[[package]]
-name = "lxml"
-version = "6.0.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/aa/88/262177de60548e5a2bfc46ad28232c9e9cbde697bd94132aeb80364675cb/lxml-6.0.2.tar.gz", hash = "sha256:cd79f3367bd74b317dda655dc8fcfa304d9eb6e4fb06b7168c5cf27f96e0cd62", size = 4073426, upload-time = "2025-09-22T04:04:59.287Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/53/fd/4e8f0540608977aea078bf6d79f128e0e2c2bba8af1acf775c30baa70460/lxml-6.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:9b33d21594afab46f37ae58dfadd06636f154923c4e8a4d754b0127554eb2e77", size = 8648494, upload-time = "2025-09-22T04:01:54.242Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/f4/2a94a3d3dfd6c6b433501b8d470a1960a20ecce93245cf2db1706adf6c19/lxml-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6c8963287d7a4c5c9a432ff487c52e9c5618667179c18a204bdedb27310f022f", size = 4661146, upload-time = "2025-09-22T04:01:56.282Z" },
-    { url = "https://files.pythonhosted.org/packages/25/2e/4efa677fa6b322013035d38016f6ae859d06cac67437ca7dc708a6af7028/lxml-6.0.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1941354d92699fb5ffe6ed7b32f9649e43c2feb4b97205f75866f7d21aa91452", size = 4946932, upload-time = "2025-09-22T04:01:58.989Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/0f/526e78a6d38d109fdbaa5049c62e1d32fdd70c75fb61c4eadf3045d3d124/lxml-6.0.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bb2f6ca0ae2d983ded09357b84af659c954722bbf04dea98030064996d156048", size = 5100060, upload-time = "2025-09-22T04:02:00.812Z" },
-    { url = "https://files.pythonhosted.org/packages/81/76/99de58d81fa702cc0ea7edae4f4640416c2062813a00ff24bd70ac1d9c9b/lxml-6.0.2-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb2a12d704f180a902d7fa778c6d71f36ceb7b0d317f34cdc76a5d05aa1dd1df", size = 5019000, upload-time = "2025-09-22T04:02:02.671Z" },
-    { url = "https://files.pythonhosted.org/packages/b5/35/9e57d25482bc9a9882cb0037fdb9cc18f4b79d85df94fa9d2a89562f1d25/lxml-6.0.2-cp313-cp313-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:6ec0e3f745021bfed19c456647f0298d60a24c9ff86d9d051f52b509663feeb1", size = 5348496, upload-time = "2025-09-22T04:02:04.904Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/8e/cb99bd0b83ccc3e8f0f528e9aa1f7a9965dfec08c617070c5db8d63a87ce/lxml-6.0.2-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:846ae9a12d54e368933b9759052d6206a9e8b250291109c48e350c1f1f49d916", size = 5643779, upload-time = "2025-09-22T04:02:06.689Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/34/9e591954939276bb679b73773836c6684c22e56d05980e31d52a9a8deb18/lxml-6.0.2-cp313-cp313-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ef9266d2aa545d7374938fb5c484531ef5a2ec7f2d573e62f8ce722c735685fd", size = 5244072, upload-time = "2025-09-22T04:02:08.587Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/27/b29ff065f9aaca443ee377aff699714fcbffb371b4fce5ac4ca759e436d5/lxml-6.0.2-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:4077b7c79f31755df33b795dc12119cb557a0106bfdab0d2c2d97bd3cf3dffa6", size = 4718675, upload-time = "2025-09-22T04:02:10.783Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/9f/f756f9c2cd27caa1a6ef8c32ae47aadea697f5c2c6d07b0dae133c244fbe/lxml-6.0.2-cp313-cp313-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a7c5d5e5f1081955358533be077166ee97ed2571d6a66bdba6ec2f609a715d1a", size = 5255171, upload-time = "2025-09-22T04:02:12.631Z" },
-    { url = "https://files.pythonhosted.org/packages/61/46/bb85ea42d2cb1bd8395484fd72f38e3389611aa496ac7772da9205bbda0e/lxml-6.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:8f8d0cbd0674ee89863a523e6994ac25fd5be9c8486acfc3e5ccea679bad2679", size = 5057175, upload-time = "2025-09-22T04:02:14.718Z" },
-    { url = "https://files.pythonhosted.org/packages/95/0c/443fc476dcc8e41577f0af70458c50fe299a97bb6b7505bb1ae09aa7f9ac/lxml-6.0.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:2cbcbf6d6e924c28f04a43f3b6f6e272312a090f269eff68a2982e13e5d57659", size = 4785688, upload-time = "2025-09-22T04:02:16.957Z" },
-    { url = "https://files.pythonhosted.org/packages/48/78/6ef0b359d45bb9697bc5a626e1992fa5d27aa3f8004b137b2314793b50a0/lxml-6.0.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:dfb874cfa53340009af6bdd7e54ebc0d21012a60a4e65d927c2e477112e63484", size = 5660655, upload-time = "2025-09-22T04:02:18.815Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/ea/e1d33808f386bc1339d08c0dcada6e4712d4ed8e93fcad5f057070b7988a/lxml-6.0.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:fb8dae0b6b8b7f9e96c26fdd8121522ce5de9bb5538010870bd538683d30e9a2", size = 5247695, upload-time = "2025-09-22T04:02:20.593Z" },
-    { url = "https://files.pythonhosted.org/packages/4f/47/eba75dfd8183673725255247a603b4ad606f4ae657b60c6c145b381697da/lxml-6.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:358d9adae670b63e95bc59747c72f4dc97c9ec58881d4627fe0120da0f90d314", size = 5269841, upload-time = "2025-09-22T04:02:22.489Z" },
-    { url = "https://files.pythonhosted.org/packages/03/15/d4a377b385ab693ce97b472fe0c77c2b16ec79590e688b3ccc71fba19884/lxml-6.0.2-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:b0c732aa23de8f8aec23f4b580d1e52905ef468afb4abeafd3fec77042abb6fe", size = 8659801, upload-time = "2025-09-22T04:02:30.113Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/e8/c128e37589463668794d503afaeb003987373c5f94d667124ffd8078bbd9/lxml-6.0.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4468e3b83e10e0317a89a33d28f7aeba1caa4d1a6fd457d115dd4ffe90c5931d", size = 4659403, upload-time = "2025-09-22T04:02:32.119Z" },
-    { url = "https://files.pythonhosted.org/packages/00/ce/74903904339decdf7da7847bb5741fc98a5451b42fc419a86c0c13d26fe2/lxml-6.0.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:abd44571493973bad4598a3be7e1d807ed45aa2adaf7ab92ab7c62609569b17d", size = 4966974, upload-time = "2025-09-22T04:02:34.155Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/d3/131dec79ce61c5567fecf82515bd9bc36395df42501b50f7f7f3bd065df0/lxml-6.0.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:370cd78d5855cfbffd57c422851f7d3864e6ae72d0da615fca4dad8c45d375a5", size = 5102953, upload-time = "2025-09-22T04:02:36.054Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/ea/a43ba9bb750d4ffdd885f2cd333572f5bb900cd2408b67fdda07e85978a0/lxml-6.0.2-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:901e3b4219fa04ef766885fb40fa516a71662a4c61b80c94d25336b4934b71c0", size = 5055054, upload-time = "2025-09-22T04:02:38.154Z" },
-    { url = "https://files.pythonhosted.org/packages/60/23/6885b451636ae286c34628f70a7ed1fcc759f8d9ad382d132e1c8d3d9bfd/lxml-6.0.2-cp314-cp314-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:a4bf42d2e4cf52c28cc1812d62426b9503cdb0c87a6de81442626aa7d69707ba", size = 5352421, upload-time = "2025-09-22T04:02:40.413Z" },
-    { url = "https://files.pythonhosted.org/packages/48/5b/fc2ddfc94ddbe3eebb8e9af6e3fd65e2feba4967f6a4e9683875c394c2d8/lxml-6.0.2-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2c7fdaa4d7c3d886a42534adec7cfac73860b89b4e5298752f60aa5984641a0", size = 5673684, upload-time = "2025-09-22T04:02:42.288Z" },
-    { url = "https://files.pythonhosted.org/packages/29/9c/47293c58cc91769130fbf85531280e8cc7868f7fbb6d92f4670071b9cb3e/lxml-6.0.2-cp314-cp314-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:98a5e1660dc7de2200b00d53fa00bcd3c35a3608c305d45a7bbcaf29fa16e83d", size = 5252463, upload-time = "2025-09-22T04:02:44.165Z" },
-    { url = "https://files.pythonhosted.org/packages/9b/da/ba6eceb830c762b48e711ded880d7e3e89fc6c7323e587c36540b6b23c6b/lxml-6.0.2-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:dc051506c30b609238d79eda75ee9cab3e520570ec8219844a72a46020901e37", size = 4698437, upload-time = "2025-09-22T04:02:46.524Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/24/7be3f82cb7990b89118d944b619e53c656c97dc89c28cfb143fdb7cd6f4d/lxml-6.0.2-cp314-cp314-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8799481bbdd212470d17513a54d568f44416db01250f49449647b5ab5b5dccb9", size = 5269890, upload-time = "2025-09-22T04:02:48.812Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/bd/dcfb9ea1e16c665efd7538fc5d5c34071276ce9220e234217682e7d2c4a5/lxml-6.0.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9261bb77c2dab42f3ecd9103951aeca2c40277701eb7e912c545c1b16e0e4917", size = 5097185, upload-time = "2025-09-22T04:02:50.746Z" },
-    { url = "https://files.pythonhosted.org/packages/21/04/a60b0ff9314736316f28316b694bccbbabe100f8483ad83852d77fc7468e/lxml-6.0.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:65ac4a01aba353cfa6d5725b95d7aed6356ddc0a3cd734de00124d285b04b64f", size = 4745895, upload-time = "2025-09-22T04:02:52.968Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/bd/7d54bd1846e5a310d9c715921c5faa71cf5c0853372adf78aee70c8d7aa2/lxml-6.0.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:b22a07cbb82fea98f8a2fd814f3d1811ff9ed76d0fc6abc84eb21527596e7cc8", size = 5695246, upload-time = "2025-09-22T04:02:54.798Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/32/5643d6ab947bc371da21323acb2a6e603cedbe71cb4c99c8254289ab6f4e/lxml-6.0.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:d759cdd7f3e055d6bc8d9bec3ad905227b2e4c785dc16c372eb5b5e83123f48a", size = 5260797, upload-time = "2025-09-22T04:02:57.058Z" },
-    { url = "https://files.pythonhosted.org/packages/33/da/34c1ec4cff1eea7d0b4cd44af8411806ed943141804ac9c5d565302afb78/lxml-6.0.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:945da35a48d193d27c188037a05fec5492937f66fb1958c24fc761fb9d40d43c", size = 5277404, upload-time = "2025-09-22T04:02:58.966Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/5c/42c2c4c03554580708fc738d13414801f340c04c3eff90d8d2d227145275/lxml-6.0.2-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:6162a86d86893d63084faaf4ff937b3daea233e3682fb4474db07395794fa80d", size = 8910380, upload-time = "2025-09-22T04:03:01.645Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/4f/12df843e3e10d18d468a7557058f8d3733e8b6e12401f30b1ef29360740f/lxml-6.0.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:414aaa94e974e23a3e92e7ca5b97d10c0cf37b6481f50911032c69eeb3991bba", size = 4775632, upload-time = "2025-09-22T04:03:03.814Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/0c/9dc31e6c2d0d418483cbcb469d1f5a582a1cd00a1f4081953d44051f3c50/lxml-6.0.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:48461bd21625458dd01e14e2c38dd0aea69addc3c4f960c30d9f59d7f93be601", size = 4975171, upload-time = "2025-09-22T04:03:05.651Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/2b/9b870c6ca24c841bdd887504808f0417aa9d8d564114689266f19ddf29c8/lxml-6.0.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:25fcc59afc57d527cfc78a58f40ab4c9b8fd096a9a3f964d2781ffb6eb33f4ed", size = 5110109, upload-time = "2025-09-22T04:03:07.452Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/0c/4f5f2a4dd319a178912751564471355d9019e220c20d7db3fb8307ed8582/lxml-6.0.2-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5179c60288204e6ddde3f774a93350177e08876eaf3ab78aa3a3649d43eb7d37", size = 5041061, upload-time = "2025-09-22T04:03:09.297Z" },
-    { url = "https://files.pythonhosted.org/packages/12/64/554eed290365267671fe001a20d72d14f468ae4e6acef1e179b039436967/lxml-6.0.2-cp314-cp314t-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:967aab75434de148ec80597b75062d8123cadf2943fb4281f385141e18b21338", size = 5306233, upload-time = "2025-09-22T04:03:11.651Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/31/1d748aa275e71802ad9722df32a7a35034246b42c0ecdd8235412c3396ef/lxml-6.0.2-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d100fcc8930d697c6561156c6810ab4a508fb264c8b6779e6e61e2ed5e7558f9", size = 5604739, upload-time = "2025-09-22T04:03:13.592Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/41/2c11916bcac09ed561adccacceaedd2bf0e0b25b297ea92aab99fd03d0fa/lxml-6.0.2-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2ca59e7e13e5981175b8b3e4ab84d7da57993eeff53c07764dcebda0d0e64ecd", size = 5225119, upload-time = "2025-09-22T04:03:15.408Z" },
-    { url = "https://files.pythonhosted.org/packages/99/05/4e5c2873d8f17aa018e6afde417c80cc5d0c33be4854cce3ef5670c49367/lxml-6.0.2-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:957448ac63a42e2e49531b9d6c0fa449a1970dbc32467aaad46f11545be9af1d", size = 4633665, upload-time = "2025-09-22T04:03:17.262Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/c9/dcc2da1bebd6275cdc723b515f93edf548b82f36a5458cca3578bc899332/lxml-6.0.2-cp314-cp314t-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b7fc49c37f1786284b12af63152fe1d0990722497e2d5817acfe7a877522f9a9", size = 5234997, upload-time = "2025-09-22T04:03:19.14Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/e2/5172e4e7468afca64a37b81dba152fc5d90e30f9c83c7c3213d6a02a5ce4/lxml-6.0.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e19e0643cc936a22e837f79d01a550678da8377d7d801a14487c10c34ee49c7e", size = 5090957, upload-time = "2025-09-22T04:03:21.436Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/b3/15461fd3e5cd4ddcb7938b87fc20b14ab113b92312fc97afe65cd7c85de1/lxml-6.0.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:1db01e5cf14345628e0cbe71067204db658e2fb8e51e7f33631f5f4735fefd8d", size = 4764372, upload-time = "2025-09-22T04:03:23.27Z" },
-    { url = "https://files.pythonhosted.org/packages/05/33/f310b987c8bf9e61c4dd8e8035c416bd3230098f5e3cfa69fc4232de7059/lxml-6.0.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:875c6b5ab39ad5291588aed6925fac99d0097af0dd62f33c7b43736043d4a2ec", size = 5634653, upload-time = "2025-09-22T04:03:25.767Z" },
-    { url = "https://files.pythonhosted.org/packages/70/ff/51c80e75e0bc9382158133bdcf4e339b5886c6ee2418b5199b3f1a61ed6d/lxml-6.0.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:cdcbed9ad19da81c480dfd6dd161886db6096083c9938ead313d94b30aadf272", size = 5233795, upload-time = "2025-09-22T04:03:27.62Z" },
-    { url = "https://files.pythonhosted.org/packages/56/4d/4856e897df0d588789dd844dbed9d91782c4ef0b327f96ce53c807e13128/lxml-6.0.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:80dadc234ebc532e09be1975ff538d154a7fa61ea5031c03d25178855544728f", size = 5257023, upload-time = "2025-09-22T04:03:30.056Z" },
-]
-
 [[package]]
 name = "macholib"
 version = "1.16.4"
@@ -1247,23 +967,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" },
 ]
 
-[[package]]
-name = "math-verify"
-version = "0.9.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "latex2sympy2-extended", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/4f/12/b8d13b581e110ac2f724a2351a8361a70fa36d057eb945d6379e8747c256/math_verify-0.9.0.tar.gz", hash = "sha256:45ac6c61344ba056b9e99a660a4bc8d044ed408f730aed68c60435aa5eec4645", size = 60329, upload-time = "2026-01-10T01:48:33.056Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/62/76/6b4969bccc842b6567f7e6ee015684b9428a9b7fcbdf479e73716f43597f/math_verify-0.9.0-py3-none-any.whl", hash = "sha256:3703e7c4885354027fa84409d762a596a2906d1fd4deb78361876bd905a76194", size = 29967, upload-time = "2026-01-10T01:48:31.674Z" },
-]
-
-[package.optional-dependencies]
-antlr4-11-0 = [
-    { name = "latex2sympy2-extended", extra = ["antlr4-11-0"], marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-
 [[package]]
 name = "matplotlib"
 version = "3.10.8"
@@ -1303,18 +1006,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/4d/4b/e7beb6bbd49f6bae727a12b270a2654d13c397576d25bd6786e47033300f/matplotlib-3.10.8-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:595ba4d8fe983b88f0eec8c26a241e16d6376fe1979086232f481f8f3f67494c", size = 9614011, upload-time = "2025-12-10T22:56:33.85Z" },
 ]
 
-[[package]]
-name = "mbstrdecoder"
-version = "1.1.4"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "chardet", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/31/ab/05ae008357c8bdb6245ebf8a101d99f26c096e0ea20800b318153da23796/mbstrdecoder-1.1.4.tar.gz", hash = "sha256:8105ef9cf6b7d7d69fe7fd6b68a2d8f281ca9b365d7a9b670be376b2e6c81b21", size = 14527, upload-time = "2025-01-18T10:07:31.089Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/30/ac/5ce64a1d4cce00390beab88622a290420401f1cabf05caf2fc0995157c21/mbstrdecoder-1.1.4-py3-none-any.whl", hash = "sha256:03dae4ec50ec0d2ff4743e63fdbd5e0022815857494d35224b60775d3d934a8c", size = 7933, upload-time = "2025-01-18T10:07:29.562Z" },
-]
-
 [[package]]
 name = "mdurl"
 version = "0.1.2"
@@ -1362,8 +1053,7 @@ name = "mlx"
 version = "0.30.6"
 source = { registry = "https://pypi.org/simple" }
 resolution-markers = [
-    "python_full_version >= '3.14' and sys_platform == 'linux'",
-    "python_full_version < '3.14' and sys_platform == 'linux'",
+    "sys_platform == 'linux'",
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/93/06/280f6f2ba80520a7109730425eda0d966658793aa0d02d8be8d351f75253/mlx-0.30.6-cp313-cp313-manylinux_2_35_aarch64.whl", hash = "sha256:67e6c9e30a9faeacc209917ef5523177cf9b086914b6b5d83ff886e4294b727d", size = 622011, upload-time = "2026-02-06T03:45:28.165Z" },
@@ -1385,8 +1075,7 @@ name = "mlx"
 version = "0.30.7.dev20260225+257d5692"
 source = { git = "https://github.com/rltakashige/mlx-jaccl-fix-small-recv.git?branch=address-rdma-gpu-locks#257d5692fc7af6bba3b8afaeb63c549b7d1e43d5" }
 resolution-markers = [
-    "python_full_version >= '3.14' and sys_platform == 'darwin'",
-    "python_full_version < '3.14' and sys_platform == 'darwin'",
+    "sys_platform == 'darwin'",
 ]
 
 [[package]]
@@ -1415,8 +1104,8 @@ wheels = [
 
 [[package]]
 name = "mlx-lm"
-version = "0.31.0"
-source = { git = "https://github.com/rltakashige/mlx-lm?branch=leo%2Feval-left-padding-in-batched-rotation#5e0c484cfb5c68d281a71409927ee1bb75adaae2" }
+version = "0.30.8"
+source = { git = "https://github.com/ml-explore/mlx-lm?rev=834fac934c4e04de9b3d723e2b9287a2c60cfd4a#834fac934c4e04de9b3d723e2b9287a2c60cfd4a" }
 dependencies = [
     { name = "jinja2", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "mlx", version = "0.30.7.dev20260225+257d5692", source = { git = "https://github.com/rltakashige/mlx-jaccl-fix-small-recv.git?branch=address-rdma-gpu-locks#257d5692fc7af6bba3b8afaeb63c549b7d1e43d5" }, marker = "sys_platform == 'darwin'" },
@@ -1540,23 +1229,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b7/da/7d22601b625e241d4f23ef1ebff8acfc60da633c9e7e7922e24d10f592b3/multidict-6.7.0-py3-none-any.whl", hash = "sha256:394fc5c42a333c9ffc3e421a4c85e08580d990e08b99f6bf35b4132114c5dcb3", size = 12317, upload-time = "2025-10-06T14:52:29.272Z" },
 ]
 
-[[package]]
-name = "multiprocess"
-version = "0.70.18"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "dill", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/72/fd/2ae3826f5be24c6ed87266bc4e59c46ea5b059a103f3d7e7eb76a52aeecb/multiprocess-0.70.18.tar.gz", hash = "sha256:f9597128e6b3e67b23956da07cf3d2e5cba79e2f4e0fba8d7903636663ec6d0d", size = 1798503, upload-time = "2025-04-17T03:11:27.742Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ba/d8/0cba6cf51a1a31f20471fbc823a716170c73012ddc4fb85d706630ed6e8f/multiprocess-0.70.18-py310-none-any.whl", hash = "sha256:60c194974c31784019c1f459d984e8f33ee48f10fcf42c309ba97b30d9bd53ea", size = 134948, upload-time = "2025-04-17T03:11:20.223Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/88/9039f2fed1012ef584751d4ceff9ab4a51e5ae264898f0b7cbf44340a859/multiprocess-0.70.18-py311-none-any.whl", hash = "sha256:5aa6eef98e691281b3ad923be2832bf1c55dd2c859acd73e5ec53a66aae06a1d", size = 144462, upload-time = "2025-04-17T03:11:21.657Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/b6/5f922792be93b82ec6b5f270bbb1ef031fd0622847070bbcf9da816502cc/multiprocess-0.70.18-py312-none-any.whl", hash = "sha256:9b78f8e5024b573730bfb654783a13800c2c0f2dfc0c25e70b40d184d64adaa2", size = 150287, upload-time = "2025-04-17T03:11:22.69Z" },
-    { url = "https://files.pythonhosted.org/packages/ee/25/7d7e78e750bc1aecfaf0efbf826c69a791d2eeaf29cf20cba93ff4cced78/multiprocess-0.70.18-py313-none-any.whl", hash = "sha256:871743755f43ef57d7910a38433cfe41319e72be1bbd90b79c7a5ac523eb9334", size = 151917, upload-time = "2025-04-17T03:11:24.044Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/c3/ca84c19bd14cdfc21c388fdcebf08b86a7a470ebc9f5c3c084fc2dbc50f7/multiprocess-0.70.18-py38-none-any.whl", hash = "sha256:dbf705e52a154fe5e90fb17b38f02556169557c2dd8bb084f2e06c2784d8279b", size = 132636, upload-time = "2025-04-17T03:11:24.936Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/28/dd72947e59a6a8c856448a5e74da6201cb5502ddff644fbc790e4bd40b9a/multiprocess-0.70.18-py39-none-any.whl", hash = "sha256:e78ca805a72b1b810c690b6b4cc32579eba34f403094bbbae962b7b5bf9dfcb8", size = 133478, upload-time = "2025-04-17T03:11:26.253Z" },
-]
-
 [[package]]
 name = "networkx"
 version = "3.6.1"
@@ -1593,21 +1265,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e2/c8/97a2d5f7a314cce2c5c49f30c6f161b7f3617960ade4bfc2fd1ee092cb20/nh3-0.3.2-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:91e9b001101fb4500a2aafe3e7c92928d85242d38bf5ac0aba0b7480da0a4cd6", size = 987439, upload-time = "2025-10-30T11:17:40.81Z" },
 ]
 
-[[package]]
-name = "nltk"
-version = "3.9.3"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "click", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "joblib", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "regex", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "tqdm", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/e1/8f/915e1c12df07c70ed779d18ab83d065718a926e70d3ea33eb0cd66ffb7c0/nltk-3.9.3.tar.gz", hash = "sha256:cb5945d6424a98d694c2b9a0264519fab4363711065a46aa0ae7a2195b92e71f", size = 2923673, upload-time = "2026-02-24T12:05:53.833Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c2/7e/9af5a710a1236e4772de8dfcc6af942a561327bb9f42b5b4a24d0cf100fd/nltk-3.9.3-py3-none-any.whl", hash = "sha256:60b3db6e9995b3dd976b1f0fa7dec22069b2677e759c28eb69b62ddd44870522", size = 1525385, upload-time = "2026-02-24T12:05:46.54Z" },
-]
-
 [[package]]
 name = "nodejs-wheel-binaries"
 version = "25.2.1rc0"
@@ -1879,51 +1536,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/40/35/ddf3a6e8fc754fb939e2ea36fde96c28189184d6115afcf60011bb438ae5/packaging-26.0rc1-py3-none-any.whl", hash = "sha256:ecf921b33c620e357b1eed2ac3bc6313b1582874b0282d0773b6797b79cb0786", size = 74021, upload-time = "2026-01-09T17:41:17.134Z" },
 ]
 
-[[package]]
-name = "pandas"
-version = "3.0.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "numpy", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "python-dateutil", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/0c/b28ed414f080ee0ad153f848586d61d1878f91689950f037f976ce15f6c8/pandas-3.0.1.tar.gz", hash = "sha256:4186a699674af418f655dbd420ed87f50d56b4cd6603784279d9eef6627823c8", size = 4641901, upload-time = "2026-02-17T22:20:16.434Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/0b/48/aad6ec4f8d007534c091e9a7172b3ec1b1ee6d99a9cbb936b5eab6c6cf58/pandas-3.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5272627187b5d9c20e55d27caf5f2cd23e286aba25cadf73c8590e432e2b7262", size = 10317509, upload-time = "2026-02-17T22:18:59.498Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/14/5990826f779f79148ae9d3a2c39593dc04d61d5d90541e71b5749f35af95/pandas-3.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:661e0f665932af88c7877f31da0dc743fe9c8f2524bdffe23d24fdcb67ef9d56", size = 9860561, upload-time = "2026-02-17T22:19:02.265Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/80/f01ff54664b6d70fed71475543d108a9b7c888e923ad210795bef04ffb7d/pandas-3.0.1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:75e6e292ff898679e47a2199172593d9f6107fd2dd3617c22c2946e97d5df46e", size = 10365506, upload-time = "2026-02-17T22:19:05.017Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/85/ab6d04733a7d6ff32bfc8382bf1b07078228f5d6ebec5266b91bfc5c4ff7/pandas-3.0.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1ff8cf1d2896e34343197685f432450ec99a85ba8d90cce2030c5eee2ef98791", size = 10873196, upload-time = "2026-02-17T22:19:07.204Z" },
-    { url = "https://files.pythonhosted.org/packages/48/a9/9301c83d0b47c23ac5deab91c6b39fd98d5b5db4d93b25df8d381451828f/pandas-3.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eca8b4510f6763f3d37359c2105df03a7a221a508f30e396a51d0713d462e68a", size = 11370859, upload-time = "2026-02-17T22:19:09.436Z" },
-    { url = "https://files.pythonhosted.org/packages/59/fe/0c1fc5bd2d29c7db2ab372330063ad555fb83e08422829c785f5ec2176ca/pandas-3.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:06aff2ad6f0b94a17822cf8b83bbb563b090ed82ff4fe7712db2ce57cd50d9b8", size = 11924584, upload-time = "2026-02-17T22:19:11.562Z" },
-    { url = "https://files.pythonhosted.org/packages/92/fa/423c89086cca1f039cf1253c3ff5b90f157b5b3757314aa635f6bf3e30aa/pandas-3.0.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:d54855f04f8246ed7b6fc96b05d4871591143c46c0b6f4af874764ed0d2d6f06", size = 10752673, upload-time = "2026-02-17T22:19:18.304Z" },
-    { url = "https://files.pythonhosted.org/packages/22/23/b5a08ec1f40020397f0faba72f1e2c11f7596a6169c7b3e800abff0e433f/pandas-3.0.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e1b677accee34a09e0dc2ce5624e4a58a1870ffe56fc021e9caf7f23cd7668f", size = 10404967, upload-time = "2026-02-17T22:19:20.726Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/81/94841f1bb4afdc2b52a99daa895ac2c61600bb72e26525ecc9543d453ebc/pandas-3.0.1-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a9cabbdcd03f1b6cd254d6dda8ae09b0252524be1592594c00b7895916cb1324", size = 10320575, upload-time = "2026-02-17T22:19:24.919Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/8b/2ae37d66a5342a83adadfd0cb0b4bf9c3c7925424dd5f40d15d6cfaa35ee/pandas-3.0.1-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ae2ab1f166668b41e770650101e7090824fd34d17915dd9cd479f5c5e0065e9", size = 10710921, upload-time = "2026-02-17T22:19:27.181Z" },
-    { url = "https://files.pythonhosted.org/packages/a2/61/772b2e2757855e232b7ccf7cb8079a5711becb3a97f291c953def15a833f/pandas-3.0.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6bf0603c2e30e2cafac32807b06435f28741135cb8697eae8b28c7d492fc7d76", size = 11334191, upload-time = "2026-02-17T22:19:29.411Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/08/b16c6df3ef555d8495d1d265a7963b65be166785d28f06a350913a4fac78/pandas-3.0.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6c426422973973cae1f4a23e51d4ae85974f44871b24844e4f7de752dd877098", size = 11782256, upload-time = "2026-02-17T22:19:32.34Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/8b/4bb774a998b97e6c2fd62a9e6cfdaae133b636fd1c468f92afb4ae9a447a/pandas-3.0.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:99d0f92ed92d3083d140bf6b97774f9f13863924cf3f52a70711f4e7588f9d0a", size = 10322465, upload-time = "2026-02-17T22:19:36.803Z" },
-    { url = "https://files.pythonhosted.org/packages/72/3a/5b39b51c64159f470f1ca3b1c2a87da290657ca022f7cd11442606f607d1/pandas-3.0.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:3b66857e983208654294bb6477b8a63dee26b37bdd0eb34d010556e91261784f", size = 9910632, upload-time = "2026-02-17T22:19:39.001Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/f7/b449ffb3f68c11da12fc06fbf6d2fa3a41c41e17d0284d23a79e1c13a7e4/pandas-3.0.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:56cf59638bf24dc9bdf2154c81e248b3289f9a09a6d04e63608c159022352749", size = 10440535, upload-time = "2026-02-17T22:19:41.157Z" },
-    { url = "https://files.pythonhosted.org/packages/55/77/6ea82043db22cb0f2bbfe7198da3544000ddaadb12d26be36e19b03a2dc5/pandas-3.0.1-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c1a9f55e0f46951874b863d1f3906dcb57df2d9be5c5847ba4dfb55b2c815249", size = 10893940, upload-time = "2026-02-17T22:19:43.493Z" },
-    { url = "https://files.pythonhosted.org/packages/03/30/f1b502a72468c89412c1b882a08f6eed8a4ee9dc033f35f65d0663df6081/pandas-3.0.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1849f0bba9c8a2fb0f691d492b834cc8dadf617e29015c66e989448d58d011ee", size = 11442711, upload-time = "2026-02-17T22:19:46.074Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/f0/ebb6ddd8fc049e98cabac5c2924d14d1dda26a20adb70d41ea2e428d3ec4/pandas-3.0.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c3d288439e11b5325b02ae6e9cc83e6805a62c40c5a6220bea9beb899c073b1c", size = 11963918, upload-time = "2026-02-17T22:19:48.838Z" },
-    { url = "https://files.pythonhosted.org/packages/66/fc/848bb6710bc6061cb0c5badd65b92ff75c81302e0e31e496d00029fe4953/pandas-3.0.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:58eeb1b2e0fb322befcf2bbc9ba0af41e616abadb3d3414a6bc7167f6cbfce32", size = 10772664, upload-time = "2026-02-17T22:19:55.806Z" },
-    { url = "https://files.pythonhosted.org/packages/69/5c/866a9bbd0f79263b4b0db6ec1a341be13a1473323f05c122388e0f15b21d/pandas-3.0.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:cd9af1276b5ca9e298bd79a26bda32fa9cc87ed095b2a9a60978d2ca058eaf87", size = 10421286, upload-time = "2026-02-17T22:19:58.091Z" },
-    { url = "https://files.pythonhosted.org/packages/51/a4/2058fb84fb1cfbfb2d4a6d485e1940bb4ad5716e539d779852494479c580/pandas-3.0.1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:94f87a04984d6b63788327cd9f79dda62b7f9043909d2440ceccf709249ca988", size = 10342050, upload-time = "2026-02-17T22:20:01.376Z" },
-    { url = "https://files.pythonhosted.org/packages/22/1b/674e89996cc4be74db3c4eb09240c4bb549865c9c3f5d9b086ff8fcfbf00/pandas-3.0.1-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:85fe4c4df62e1e20f9db6ebfb88c844b092c22cd5324bdcf94bfa2fc1b391221", size = 10740055, upload-time = "2026-02-17T22:20:04.328Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/f8/e954b750764298c22fa4614376531fe63c521ef517e7059a51f062b87dca/pandas-3.0.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:331ca75a2f8672c365ae25c0b29e46f5ac0c6551fdace8eec4cd65e4fac271ff", size = 11357632, upload-time = "2026-02-17T22:20:06.647Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/02/c6e04b694ffd68568297abd03588b6d30295265176a5c01b7459d3bc35a3/pandas-3.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:15860b1fdb1973fffade772fdb931ccf9b2f400a3f5665aef94a00445d7d8dd5", size = 11810974, upload-time = "2026-02-17T22:20:08.946Z" },
-]
-
-[[package]]
-name = "pathvalidate"
-version = "3.3.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/fa/2a/52a8da6fe965dea6192eb716b357558e103aea0a1e9a8352ad575a8406ca/pathvalidate-3.3.1.tar.gz", hash = "sha256:b18c07212bfead624345bb8e1d6141cdcf15a39736994ea0b94035ad2b1ba177", size = 63262, upload-time = "2025-06-15T09:07:20.736Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/70/875f4a23bfc4731703a5835487d0d2fb999031bd415e7d17c0ae615c18b7/pathvalidate-3.3.1-py3-none-any.whl", hash = "sha256:5263baab691f8e1af96092fa5137ee17df5bdfbd6cff1fcac4d6ef4bc2e1735f", size = 24305, upload-time = "2025-06-15T09:07:19.117Z" },
-]
-
 [[package]]
 name = "piexif"
 version = "1.1.3"
@@ -1994,15 +1606,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
 ]
 
-[[package]]
-name = "portalocker"
-version = "3.2.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/5e/77/65b857a69ed876e1951e88aaba60f5ce6120c33703f7cb61a3c894b8c1b6/portalocker-3.2.0.tar.gz", hash = "sha256:1f3002956a54a8c3730586c5c77bf18fae4149e07eaf1c29fc3faf4d5a3f89ac", size = 95644, upload-time = "2025-06-14T13:20:40.03Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/4b/a6/38c8e2f318bf67d338f4d629e93b0b4b9af331f455f0390ea8ce4a099b26/portalocker-3.2.0-py3-none-any.whl", hash = "sha256:3cdc5f565312224bc570c49337bd21428bba0ef363bbcf58b9ef4a9f11779968", size = 22424, upload-time = "2025-06-14T13:20:38.083Z" },
-]
-
 [[package]]
 name = "priority"
 version = "2.0.0"
@@ -2104,38 +1707,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/1c/15/dd6fd869753ce82ff64dcbc18356093471a5a5adf4f77ed1f805d473d859/psutil-7.2.1-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:99a4cd17a5fdd1f3d014396502daa70b5ec21bf4ffe38393e152f8e449757d67", size = 147402, upload-time = "2025-12-29T08:26:39.21Z" },
 ]
 
-[[package]]
-name = "pyarrow"
-version = "23.0.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/88/22/134986a4cc224d593c1afde5494d18ff629393d74cc2eddb176669f234a4/pyarrow-23.0.1.tar.gz", hash = "sha256:b8c5873e33440b2bc2f4a79d2b47017a89c5a24116c055625e6f2ee50523f019", size = 1167336, upload-time = "2026-02-16T10:14:12.39Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/47/10/2cbe4c6f0fb83d2de37249567373d64327a5e4d8db72f486db42875b08f6/pyarrow-23.0.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:6b8fda694640b00e8af3c824f99f789e836720aa8c9379fb435d4c4953a756b8", size = 34210066, upload-time = "2026-02-16T10:10:45.487Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/4f/679fa7e84dadbaca7a65f7cdba8d6c83febbd93ca12fa4adf40ba3b6362b/pyarrow-23.0.1-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:8ff51b1addc469b9444b7c6f3548e19dc931b172ab234e995a60aea9f6e6025f", size = 35825526, upload-time = "2026-02-16T10:10:52.266Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/63/d2747d930882c9d661e9398eefc54f15696547b8983aaaf11d4a2e8b5426/pyarrow-23.0.1-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:71c5be5cbf1e1cb6169d2a0980850bccb558ddc9b747b6206435313c47c37677", size = 44473279, upload-time = "2026-02-16T10:11:01.557Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/93/10a48b5e238de6d562a411af6467e71e7aedbc9b87f8d3a35f1560ae30fb/pyarrow-23.0.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:9b6f4f17b43bc39d56fec96e53fe89d94bac3eb134137964371b45352d40d0c2", size = 47585798, upload-time = "2026-02-16T10:11:09.401Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/20/476943001c54ef078dbf9542280e22741219a184a0632862bca4feccd666/pyarrow-23.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9fc13fc6c403d1337acab46a2c4346ca6c9dec5780c3c697cf8abfd5e19b6b37", size = 48179446, upload-time = "2026-02-16T10:11:17.781Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/b6/5dd0c47b335fcd8edba9bfab78ad961bd0fd55ebe53468cc393f45e0be60/pyarrow-23.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5c16ed4f53247fa3ffb12a14d236de4213a4415d127fe9cebed33d51671113e2", size = 50623972, upload-time = "2026-02-16T10:11:26.185Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/8e/38749c4b1303e6ae76b3c80618f84861ae0c55dd3c2273842ea6f8258233/pyarrow-23.0.1-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:29f7f7419a0e30264ea261fdc0e5fe63ce5a6095003db2945d7cd78df391a7e1", size = 34471544, upload-time = "2026-02-16T10:11:32.535Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/73/f237b2bc8c669212f842bcfd842b04fc8d936bfc9d471630569132dc920d/pyarrow-23.0.1-cp313-cp313t-macosx_12_0_x86_64.whl", hash = "sha256:33d648dc25b51fd8055c19e4261e813dfc4d2427f068bcecc8b53d01b81b0500", size = 35949911, upload-time = "2026-02-16T10:11:39.813Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/86/b912195eee0903b5611bf596833def7d146ab2d301afeb4b722c57ffc966/pyarrow-23.0.1-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:cd395abf8f91c673dd3589cadc8cc1ee4e8674fa61b2e923c8dd215d9c7d1f41", size = 44520337, upload-time = "2026-02-16T10:11:47.764Z" },
-    { url = "https://files.pythonhosted.org/packages/69/c2/f2a717fb824f62d0be952ea724b4f6f9372a17eed6f704b5c9526f12f2f1/pyarrow-23.0.1-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:00be9576d970c31defb5c32eb72ef585bf600ef6d0a82d5eccaae96639cf9d07", size = 47548944, upload-time = "2026-02-16T10:11:56.607Z" },
-    { url = "https://files.pythonhosted.org/packages/84/a7/90007d476b9f0dc308e3bc57b832d004f848fd6c0da601375d20d92d1519/pyarrow-23.0.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c2139549494445609f35a5cda4eb94e2c9e4d704ce60a095b342f82460c73a83", size = 48236269, upload-time = "2026-02-16T10:12:04.47Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/3f/b16fab3e77709856eb6ac328ce35f57a6d4a18462c7ca5186ef31b45e0e0/pyarrow-23.0.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:7044b442f184d84e2351e5084600f0d7343d6117aabcbc1ac78eb1ae11eb4125", size = 50604794, upload-time = "2026-02-16T10:12:11.797Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/1b/6da9a89583ce7b23ac611f183ae4843cd3a6cf54f079549b0e8c14031e73/pyarrow-23.0.1-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:5df1161da23636a70838099d4aaa65142777185cc0cdba4037a18cee7d8db9ca", size = 34238755, upload-time = "2026-02-16T10:12:32.819Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/b5/d58a241fbe324dbaeb8df07be6af8752c846192d78d2272e551098f74e88/pyarrow-23.0.1-cp314-cp314-macosx_12_0_x86_64.whl", hash = "sha256:fa8e51cb04b9f8c9c5ace6bab63af9a1f88d35c0d6cbf53e8c17c098552285e1", size = 35847826, upload-time = "2026-02-16T10:12:38.949Z" },
-    { url = "https://files.pythonhosted.org/packages/54/a5/8cbc83f04aba433ca7b331b38f39e000efd9f0c7ce47128670e737542996/pyarrow-23.0.1-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:0b95a3994f015be13c63148fef8832e8a23938128c185ee951c98908a696e0eb", size = 44536859, upload-time = "2026-02-16T10:12:45.467Z" },
-    { url = "https://files.pythonhosted.org/packages/36/2e/c0f017c405fcdc252dbccafbe05e36b0d0eb1ea9a958f081e01c6972927f/pyarrow-23.0.1-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:4982d71350b1a6e5cfe1af742c53dfb759b11ce14141870d05d9e540d13bc5d1", size = 47614443, upload-time = "2026-02-16T10:12:55.525Z" },
-    { url = "https://files.pythonhosted.org/packages/af/6b/2314a78057912f5627afa13ba43809d9d653e6630859618b0fd81a4e0759/pyarrow-23.0.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c250248f1fe266db627921c89b47b7c06fee0489ad95b04d50353537d74d6886", size = 48232991, upload-time = "2026-02-16T10:13:04.729Z" },
-    { url = "https://files.pythonhosted.org/packages/40/f2/1bcb1d3be3460832ef3370d621142216e15a2c7c62602a4ea19ec240dd64/pyarrow-23.0.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5f4763b83c11c16e5f4c15601ba6dfa849e20723b46aa2617cb4bffe8768479f", size = 50645077, upload-time = "2026-02-16T10:13:14.147Z" },
-    { url = "https://files.pythonhosted.org/packages/b5/78/07f67434e910a0f7323269be7bfbf58699bd0c1d080b18a1ab49ba943fe8/pyarrow-23.0.1-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:17cd28e906c18af486a499422740298c52d7c6795344ea5002a7720b4eadf16d", size = 34488692, upload-time = "2026-02-16T10:13:21.541Z" },
-    { url = "https://files.pythonhosted.org/packages/50/76/34cf7ae93ece1f740a04910d9f7e80ba166b9b4ab9596a953e9e62b90fe1/pyarrow-23.0.1-cp314-cp314t-macosx_12_0_x86_64.whl", hash = "sha256:76e823d0e86b4fb5e1cf4a58d293036e678b5a4b03539be933d3b31f9406859f", size = 35964383, upload-time = "2026-02-16T10:13:28.63Z" },
-    { url = "https://files.pythonhosted.org/packages/46/90/459b827238936d4244214be7c684e1b366a63f8c78c380807ae25ed92199/pyarrow-23.0.1-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:a62e1899e3078bf65943078b3ad2a6ddcacf2373bc06379aac61b1e548a75814", size = 44538119, upload-time = "2026-02-16T10:13:35.506Z" },
-    { url = "https://files.pythonhosted.org/packages/28/a1/93a71ae5881e99d1f9de1d4554a87be37da11cd6b152239fb5bd924fdc64/pyarrow-23.0.1-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:df088e8f640c9fae3b1f495b3c64755c4e719091caf250f3a74d095ddf3c836d", size = 47571199, upload-time = "2026-02-16T10:13:42.504Z" },
-    { url = "https://files.pythonhosted.org/packages/88/a3/d2c462d4ef313521eaf2eff04d204ac60775263f1fb08c374b543f79f610/pyarrow-23.0.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:46718a220d64677c93bc243af1d44b55998255427588e400677d7192671845c7", size = 48259435, upload-time = "2026-02-16T10:13:49.226Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/f1/11a544b8c3d38a759eb3fbb022039117fd633e9a7b19e4841cc3da091915/pyarrow-23.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a09f3876e87f48bc2f13583ab551f0379e5dfb83210391e68ace404181a20690", size = 50629149, upload-time = "2026-02-16T10:13:57.238Z" },
-]
-
 [[package]]
 name = "pycparser"
 version = "2.23"
@@ -2258,24 +1829,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/8b/40/2614036cdd416452f5bf98ec037f38a1afb17f327cb8e6b652d4729e0af8/pyparsing-3.3.1-py3-none-any.whl", hash = "sha256:023b5e7e5520ad96642e2c6db4cb683d3970bd640cdf7115049a6e9c3682df82", size = 121793, upload-time = "2025-12-23T03:14:02.103Z" },
 ]
 
-[[package]]
-name = "pytablewriter"
-version = "1.2.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "dataproperty", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "mbstrdecoder", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "pathvalidate", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "setuptools", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "tabledata", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "tcolorpy", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "typepy", extra = ["datetime"], marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f6/a1/617730f290f04d347103ab40bf67d317df6691b14746f6e1ea039fb57062/pytablewriter-1.2.1.tar.gz", hash = "sha256:7bd0f4f397e070e3b8a34edcf1b9257ccbb18305493d8350a5dbc9957fced959", size = 619241, upload-time = "2025-01-01T15:37:00.04Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/21/4c/c199512f01c845dfe5a7840ab3aae6c60463b5dc2a775be72502dfd9170a/pytablewriter-1.2.1-py3-none-any.whl", hash = "sha256:e906ff7ff5151d70a5f66e0f7b75642a7f2dce8d893c265b79cc9cf6bc04ddb4", size = 91083, upload-time = "2025-01-01T15:36:55.63Z" },
-]
-
 [[package]]
 name = "pytest"
 version = "9.0.2"
@@ -2336,15 +1889,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/aa/76/03af049af4dcee5d27442f71b6924f01f3efb5d2bd34f23fcd563f2cc5f5/python_multipart-0.0.21-py3-none-any.whl", hash = "sha256:cf7a6713e01c87aa35387f4774e812c4361150938d20d232800f75ffcf266090", size = 24541, upload-time = "2025-12-17T09:24:21.153Z" },
 ]
 
-[[package]]
-name = "pytz"
-version = "2026.1.post1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/56/db/b8721d71d945e6a8ac63c0fc900b2067181dbb50805958d4d4661cf7d277/pytz-2026.1.post1.tar.gz", hash = "sha256:3378dde6a0c3d26719182142c56e60c7f9af7e968076f31aae569d72a0358ee1", size = 321088, upload-time = "2026-03-03T07:47:50.683Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/10/99/781fe0c827be2742bcc775efefccb3b048a3a9c6ce9aec0cbf4a101677e5/pytz-2026.1.post1-py2.py3-none-any.whl", hash = "sha256:f2fd16142fda348286a75e1a524be810bb05d444e5a081f37f7affc635035f7a", size = 510489, upload-time = "2026-03-03T07:47:49.167Z" },
-]
-
 [[package]]
 name = "pyyaml"
 version = "6.0.3"
@@ -2489,18 +2033,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/25/7a/b0178788f8dc6cafce37a212c99565fa1fe7872c70c6c9c1e1a372d9d88f/rich-14.2.0-py3-none-any.whl", hash = "sha256:76bc51fe2e57d2b1be1f96c524b890b816e334ab4c1e45888799bfaab0021edd", size = 243393, upload-time = "2025-10-09T14:16:51.245Z" },
 ]
 
-[[package]]
-name = "rouge-score"
-version = "0.1.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "absl-py", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "nltk", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "six", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/e2/c5/9136736c37022a6ad27fea38f3111eb8f02fe75d067f9a985cc358653102/rouge_score-0.1.2.tar.gz", hash = "sha256:c7d4da2683e68c9abf0135ef915d63a46643666f848e558a1b9f7ead17ff0f04", size = 17400, upload-time = "2022-07-22T22:46:22.909Z" }
-
 [[package]]
 name = "ruff"
 version = "0.14.11"
@@ -2544,23 +2076,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/4f/ef/c9199e4b6336ee5a9f1979c11b5779c5cf9ab6f8386e0b9a96c8ffba7009/rustworkx-0.17.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:48784a673cf8d04f3cd246fa6b53fd1ccc4d83304503463bd561c153517bccc1", size = 2302783, upload-time = "2025-08-13T01:43:42.073Z" },
 ]
 
-[[package]]
-name = "sacrebleu"
-version = "2.6.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "colorama", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "lxml", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "portalocker", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "regex", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "tabulate", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/d3/ed/d7acddcff74d690c56fe26a1f7828bdde548262828d0743414ea916c40c1/sacrebleu-2.6.0.tar.gz", hash = "sha256:91499b6cd46138d95154fff1e863c2f9be57e82f0c719d8dd718d0006cf6c566", size = 1893419, upload-time = "2026-01-12T17:17:20.799Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/06/f2/6c90ccf3ad1d09a7d662a405b274f3c93b92df59c8d6a025d26aaf34d302/sacrebleu-2.6.0-py3-none-any.whl", hash = "sha256:3edc1531575cfe4ad04ce53491a9307e234af1c3f805a1f491cbec844229a8a8", size = 100785, upload-time = "2026-01-12T17:17:18.868Z" },
-]
-
 [[package]]
 name = "safetensors"
 version = "0.7.0"
@@ -2581,79 +2096,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/4a/d8/0c8a7dc9b41dcac53c4cbf9df2b9c83e0e0097203de8b37a712b345c0be5/safetensors-0.7.0-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b0f6d66c1c538d5a94a73aa9ddca8ccc4227e6c9ff555322ea40bdd142391dd4", size = 677368, upload-time = "2025-11-19T15:18:41.627Z" },
 ]
 
-[[package]]
-name = "scikit-learn"
-version = "1.8.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "joblib", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "numpy", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "scipy", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "threadpoolctl", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/0e/d4/40988bf3b8e34feec1d0e6a051446b1f66225f8529b9309becaeef62b6c4/scikit_learn-1.8.0.tar.gz", hash = "sha256:9bccbb3b40e3de10351f8f5068e105d0f4083b1a65fa07b6634fbc401a6287fd", size = 7335585, upload-time = "2025-12-10T07:08:53.618Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/03/aa/e22e0768512ce9255eba34775be2e85c2048da73da1193e841707f8f039c/scikit_learn-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0d6ae97234d5d7079dc0040990a6f7aeb97cb7fa7e8945f1999a429b23569e0a", size = 8513770, upload-time = "2025-12-10T07:08:03.251Z" },
-    { url = "https://files.pythonhosted.org/packages/58/37/31b83b2594105f61a381fc74ca19e8780ee923be2d496fcd8d2e1147bd99/scikit_learn-1.8.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:edec98c5e7c128328124a029bceb09eda2d526997780fef8d65e9a69eead963e", size = 8044458, upload-time = "2025-12-10T07:08:05.336Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/5a/3f1caed8765f33eabb723596666da4ebbf43d11e96550fb18bdec42b467b/scikit_learn-1.8.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:74b66d8689d52ed04c271e1329f0c61635bcaf5b926db9b12d58914cdc01fe57", size = 8610341, upload-time = "2025-12-10T07:08:07.732Z" },
-    { url = "https://files.pythonhosted.org/packages/38/cf/06896db3f71c75902a8e9943b444a56e727418f6b4b4a90c98c934f51ed4/scikit_learn-1.8.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8fdf95767f989b0cfedb85f7ed8ca215d4be728031f56ff5a519ee1e3276dc2e", size = 8900022, upload-time = "2025-12-10T07:08:09.862Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/7d/a630359fc9dcc95496588c8d8e3245cc8fd81980251079bc09c70d41d951/scikit_learn-1.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:7cc267b6108f0a1499a734167282c00c4ebf61328566b55ef262d48e9849c735", size = 8826045, upload-time = "2025-12-10T07:08:15.215Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/56/a0c86f6930cfcd1c7054a2bc417e26960bb88d32444fe7f71d5c2cfae891/scikit_learn-1.8.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:fe1c011a640a9f0791146011dfd3c7d9669785f9fed2b2a5f9e207536cf5c2fd", size = 8420324, upload-time = "2025-12-10T07:08:17.561Z" },
-    { url = "https://files.pythonhosted.org/packages/46/1e/05962ea1cebc1cf3876667ecb14c283ef755bf409993c5946ade3b77e303/scikit_learn-1.8.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72358cce49465d140cc4e7792015bb1f0296a9742d5622c67e31399b75468b9e", size = 8680651, upload-time = "2025-12-10T07:08:19.952Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/56/a85473cd75f200c9759e3a5f0bcab2d116c92a8a02ee08ccd73b870f8bb4/scikit_learn-1.8.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:80832434a6cc114f5219211eec13dcbc16c2bac0e31ef64c6d346cde3cf054cb", size = 8925045, upload-time = "2025-12-10T07:08:22.11Z" },
-    { url = "https://files.pythonhosted.org/packages/24/05/1af2c186174cc92dcab2233f327336058c077d38f6fe2aceb08e6ab4d509/scikit_learn-1.8.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:c22a2da7a198c28dd1a6e1136f19c830beab7fdca5b3e5c8bba8394f8a5c45b3", size = 8528667, upload-time = "2025-12-10T07:08:27.541Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/25/01c0af38fe969473fb292bba9dc2b8f9b451f3112ff242c647fee3d0dfe7/scikit_learn-1.8.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:6b595b07a03069a2b1740dc08c2299993850ea81cce4fe19b2421e0c970de6b7", size = 8066524, upload-time = "2025-12-10T07:08:29.822Z" },
-    { url = "https://files.pythonhosted.org/packages/be/ce/a0623350aa0b68647333940ee46fe45086c6060ec604874e38e9ab7d8e6c/scikit_learn-1.8.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:29ffc74089f3d5e87dfca4c2c8450f88bdc61b0fc6ed5d267f3988f19a1309f6", size = 8657133, upload-time = "2025-12-10T07:08:31.865Z" },
-    { url = "https://files.pythonhosted.org/packages/b8/cb/861b41341d6f1245e6ca80b1c1a8c4dfce43255b03df034429089ca2a2c5/scikit_learn-1.8.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fb65db5d7531bccf3a4f6bec3462223bea71384e2cda41da0f10b7c292b9e7c4", size = 8923223, upload-time = "2025-12-10T07:08:34.166Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/d1/ef294ca754826daa043b2a104e59960abfab4cf653891037d19dd5b6f3cf/scikit_learn-1.8.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:4511be56637e46c25721e83d1a9cea9614e7badc7040c4d573d75fbe257d6fd7", size = 8848305, upload-time = "2025-12-10T07:08:41.013Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/e2/b1f8b05138ee813b8e1a4149f2f0d289547e60851fd1bb268886915adbda/scikit_learn-1.8.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:a69525355a641bf8ef136a7fa447672fb54fe8d60cab5538d9eb7c6438543fb9", size = 8432257, upload-time = "2025-12-10T07:08:42.873Z" },
-    { url = "https://files.pythonhosted.org/packages/26/11/c32b2138a85dcb0c99f6afd13a70a951bfdff8a6ab42d8160522542fb647/scikit_learn-1.8.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c2656924ec73e5939c76ac4c8b026fc203b83d8900362eb2599d8aee80e4880f", size = 8678673, upload-time = "2025-12-10T07:08:45.362Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/57/51f2384575bdec454f4fe4e7a919d696c9ebce914590abf3e52d47607ab8/scikit_learn-1.8.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15fc3b5d19cc2be65404786857f2e13c70c83dd4782676dd6814e3b89dc8f5b9", size = 8922467, upload-time = "2025-12-10T07:08:47.408Z" },
-]
-
-[[package]]
-name = "scipy"
-version = "1.17.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "numpy", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", hash = "sha256:95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0", size = 30573822, upload-time = "2026-02-23T00:26:24.851Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/76/27/07ee1b57b65e92645f219b37148a7e7928b82e2b5dbeccecb4dff7c64f0b/scipy-1.17.1-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:5e3c5c011904115f88a39308379c17f91546f77c1667cea98739fe0fccea804c", size = 31590199, upload-time = "2026-02-23T00:19:17.192Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/ae/db19f8ab842e9b724bf5dbb7db29302a91f1e55bc4d04b1025d6d605a2c5/scipy-1.17.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:6fac755ca3d2c3edcb22f479fceaa241704111414831ddd3bc6056e18516892f", size = 28154001, upload-time = "2026-02-23T00:19:22.241Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/58/3ce96251560107b381cbd6e8413c483bbb1228a6b919fa8652b0d4090e7f/scipy-1.17.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:7ff200bf9d24f2e4d5dc6ee8c3ac64d739d3a89e2326ba68aaf6c4a2b838fd7d", size = 20325719, upload-time = "2026-02-23T00:19:26.329Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/83/15087d945e0e4d48ce2377498abf5ad171ae013232ae31d06f336e64c999/scipy-1.17.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:4b400bdc6f79fa02a4d86640310dde87a21fba0c979efff5248908c6f15fad1b", size = 22683595, upload-time = "2026-02-23T00:19:30.304Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/e0/e58fbde4a1a594c8be8114eb4aac1a55bcd6587047efc18a61eb1f5c0d30/scipy-1.17.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2b64ca7d4aee0102a97f3ba22124052b4bd2152522355073580bf4845e2550b6", size = 32896429, upload-time = "2026-02-23T00:19:35.536Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/5f/f17563f28ff03c7b6799c50d01d5d856a1d55f2676f537ca8d28c7f627cd/scipy-1.17.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:581b2264fc0aa555f3f435a5944da7504ea3a065d7029ad60e7c3d1ae09c5464", size = 35203952, upload-time = "2026-02-23T00:19:42.259Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/a5/9afd17de24f657fdfe4df9a3f1ea049b39aef7c06000c13db1530d81ccca/scipy-1.17.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:beeda3d4ae615106d7094f7e7cef6218392e4465cc95d25f900bebabfded0950", size = 34979063, upload-time = "2026-02-23T00:19:47.547Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/13/88b1d2384b424bf7c924f2038c1c409f8d88bb2a8d49d097861dd64a57b2/scipy-1.17.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6609bc224e9568f65064cfa72edc0f24ee6655b47575954ec6339534b2798369", size = 37598449, upload-time = "2026-02-23T00:19:53.238Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/6b/17787db8b8114933a66f9dcc479a8272e4b4da75fe03b0c282f7b0ade8cd/scipy-1.17.1-cp313-cp313t-macosx_10_14_x86_64.whl", hash = "sha256:d59c30000a16d8edc7e64152e30220bfbd724c9bbb08368c054e24c651314f0a", size = 31936708, upload-time = "2026-02-23T00:19:58.694Z" },
-    { url = "https://files.pythonhosted.org/packages/38/2e/524405c2b6392765ab1e2b722a41d5da33dc5c7b7278184a8ad29b6cb206/scipy-1.17.1-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:010f4333c96c9bb1a4516269e33cb5917b08ef2166d5556ca2fd9f082a9e6ea0", size = 28570135, upload-time = "2026-02-23T00:20:03.934Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/c3/5bd7199f4ea8556c0c8e39f04ccb014ac37d1468e6cfa6a95c6b3562b76e/scipy-1.17.1-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:2ceb2d3e01c5f1d83c4189737a42d9cb2fc38a6eeed225e7515eef71ad301dce", size = 20741977, upload-time = "2026-02-23T00:20:07.935Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/b8/8ccd9b766ad14c78386599708eb745f6b44f08400a5fd0ade7cf89b6fc93/scipy-1.17.1-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:844e165636711ef41f80b4103ed234181646b98a53c8f05da12ca5ca289134f6", size = 23029601, upload-time = "2026-02-23T00:20:12.161Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/a0/3cb6f4d2fb3e17428ad2880333cac878909ad1a89f678527b5328b93c1d4/scipy-1.17.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:158dd96d2207e21c966063e1635b1063cd7787b627b6f07305315dd73d9c679e", size = 33019667, upload-time = "2026-02-23T00:20:17.208Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/c3/2d834a5ac7bf3a0c806ad1508efc02dda3c8c61472a56132d7894c312dea/scipy-1.17.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:74cbb80d93260fe2ffa334efa24cb8f2f0f622a9b9febf8b483c0b865bfb3475", size = 35264159, upload-time = "2026-02-23T00:20:23.087Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/77/d3ed4becfdbd217c52062fafe35a72388d1bd82c2d0ba5ca19d6fcc93e11/scipy-1.17.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:dbc12c9f3d185f5c737d801da555fb74b3dcfa1a50b66a1a93e09190f41fab50", size = 35102771, upload-time = "2026-02-23T00:20:28.636Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/12/d19da97efde68ca1ee5538bb261d5d2c062f0c055575128f11a2730e3ac1/scipy-1.17.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:94055a11dfebe37c656e70317e1996dc197e1a15bbcc351bcdd4610e128fe1ca", size = 37665910, upload-time = "2026-02-23T00:20:34.743Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/83/333afb452af6f0fd70414dc04f898647ee1423979ce02efa75c3b0f2c28e/scipy-1.17.1-cp314-cp314-macosx_10_14_x86_64.whl", hash = "sha256:a48a72c77a310327f6a3a920092fa2b8fd03d7deaa60f093038f22d98e096717", size = 31584510, upload-time = "2026-02-23T00:21:01.015Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/a6/d05a85fd51daeb2e4ea71d102f15b34fedca8e931af02594193ae4fd25f7/scipy-1.17.1-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:45abad819184f07240d8a696117a7aacd39787af9e0b719d00285549ed19a1e9", size = 28170131, upload-time = "2026-02-23T00:21:05.888Z" },
-    { url = "https://files.pythonhosted.org/packages/db/7b/8624a203326675d7746a254083a187398090a179335b2e4a20e2ddc46e83/scipy-1.17.1-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:3fd1fcdab3ea951b610dc4cef356d416d5802991e7e32b5254828d342f7b7e0b", size = 20342032, upload-time = "2026-02-23T00:21:09.904Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/35/2c342897c00775d688d8ff3987aced3426858fd89d5a0e26e020b660b301/scipy-1.17.1-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:7bdf2da170b67fdf10bca777614b1c7d96ae3ca5794fd9587dce41eb2966e866", size = 22678766, upload-time = "2026-02-23T00:21:14.313Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/f2/7cdb8eb308a1a6ae1e19f945913c82c23c0c442a462a46480ce487fdc0ac/scipy-1.17.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:adb2642e060a6549c343603a3851ba76ef0b74cc8c079a9a58121c7ec9fe2350", size = 32957007, upload-time = "2026-02-23T00:21:19.663Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/2e/7eea398450457ecb54e18e9d10110993fa65561c4f3add5e8eccd2b9cd41/scipy-1.17.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eee2cfda04c00a857206a4330f0c5e3e56535494e30ca445eb19ec624ae75118", size = 35221333, upload-time = "2026-02-23T00:21:25.278Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/77/5b8509d03b77f093a0d52e606d3c4f79e8b06d1d38c441dacb1e26cacf46/scipy-1.17.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d2650c1fb97e184d12d8ba010493ee7b322864f7d3d00d3f9bb97d9c21de4068", size = 35042066, upload-time = "2026-02-23T00:21:31.358Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/df/18f80fb99df40b4070328d5ae5c596f2f00fffb50167e31439e932f29e7d/scipy-1.17.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:08b900519463543aa604a06bec02461558a6e1cef8fdbb8098f77a48a83c8118", size = 37612763, upload-time = "2026-02-23T00:21:37.247Z" },
-    { url = "https://files.pythonhosted.org/packages/96/ad/f8c414e121f82e02d76f310f16db9899c4fcde36710329502a6b2a3c0392/scipy-1.17.1-cp314-cp314t-macosx_10_14_x86_64.whl", hash = "sha256:1cc682cea2ae55524432f3cdff9e9a3be743d52a7443d0cba9017c23c87ae2f6", size = 31949750, upload-time = "2026-02-23T00:21:42.289Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/b0/c741e8865d61b67c81e255f4f0a832846c064e426636cd7de84e74d209be/scipy-1.17.1-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:2040ad4d1795a0ae89bfc7e8429677f365d45aa9fd5e4587cf1ea737f927b4a1", size = 28585858, upload-time = "2026-02-23T00:21:47.706Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/1b/3985219c6177866628fa7c2595bfd23f193ceebbe472c98a08824b9466ff/scipy-1.17.1-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:131f5aaea57602008f9822e2115029b55d4b5f7c070287699fe45c661d051e39", size = 20757723, upload-time = "2026-02-23T00:21:52.039Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/19/2a04aa25050d656d6f7b9e7b685cc83d6957fb101665bfd9369ca6534563/scipy-1.17.1-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:9cdc1a2fcfd5c52cfb3045feb399f7b3ce822abdde3a193a6b9a60b3cb5854ca", size = 23043098, upload-time = "2026-02-23T00:21:56.185Z" },
-    { url = "https://files.pythonhosted.org/packages/86/f1/3383beb9b5d0dbddd030335bf8a8b32d4317185efe495374f134d8be6cce/scipy-1.17.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e3dcd57ab780c741fde8dc68619de988b966db759a3c3152e8e9142c26295ad", size = 33030397, upload-time = "2026-02-23T00:22:01.404Z" },
-    { url = "https://files.pythonhosted.org/packages/41/68/8f21e8a65a5a03f25a79165ec9d2b28c00e66dc80546cf5eb803aeeff35b/scipy-1.17.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a9956e4d4f4a301ebf6cde39850333a6b6110799d470dbbb1e25326ac447f52a", size = 35281163, upload-time = "2026-02-23T00:22:07.024Z" },
-    { url = "https://files.pythonhosted.org/packages/84/8d/c8a5e19479554007a5632ed7529e665c315ae7492b4f946b0deb39870e39/scipy-1.17.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:a4328d245944d09fd639771de275701ccadf5f781ba0ff092ad141e017eccda4", size = 35116291, upload-time = "2026-02-23T00:22:12.585Z" },
-    { url = "https://files.pythonhosted.org/packages/52/52/e57eceff0e342a1f50e274264ed47497b59e6a4e3118808ee58ddda7b74a/scipy-1.17.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a77cbd07b940d326d39a1d1b37817e2ee4d79cb30e7338f3d0cddffae70fcaa2", size = 37682317, upload-time = "2026-02-23T00:22:18.513Z" },
-]
-
 [[package]]
 name = "secretstorage"
 version = "3.5.0"
@@ -2731,12 +2173,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },
 ]
 
-[[package]]
-name = "sqlitedict"
-version = "2.1.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/12/9a/7620d1e9dcb02839ed6d4b14064e609cdd7a8ae1e47289aa0456796dd9ca/sqlitedict-2.1.0.tar.gz", hash = "sha256:03d9cfb96d602996f1d4c2db2856f1224b96a9c431bdd16e78032a72940f9e8c", size = 21846, upload-time = "2022-12-03T13:39:13.102Z" }
-
 [[package]]
 name = "starlette"
 version = "0.50.0"
@@ -2761,64 +2197,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" },
 ]
 
-[[package]]
-name = "tabledata"
-version = "1.3.4"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "dataproperty", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "typepy", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/b2/35/171c8977162f1163368406deddde4c59673b62bd0cb2f34948a02effb075/tabledata-1.3.4.tar.gz", hash = "sha256:e9649cab129d718f3bff4150083b77f8a78c30f6634a30caf692b10fdc60cb97", size = 25074, upload-time = "2024-12-31T14:12:31.198Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/08/64/fa4160151976ee4b2cf0c1217a99443ffaeb991956feddfeac9eee9952f8/tabledata-1.3.4-py3-none-any.whl", hash = "sha256:1f56e433bfdeb89f4487abfa48c4603a3b07c5d3a3c7e05ff73dd018c24bd0d4", size = 11820, upload-time = "2024-12-31T14:12:28.584Z" },
-]
-
-[[package]]
-name = "tabulate"
-version = "0.10.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/46/58/8c37dea7bbf769b20d58e7ace7e5edfe65b849442b00ffcdd56be88697c6/tabulate-0.10.0.tar.gz", hash = "sha256:e2cfde8f79420f6deeffdeda9aaec3b6bc5abce947655d17ac662b126e48a60d", size = 91754, upload-time = "2026-03-04T18:55:34.402Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/99/55/db07de81b5c630da5cbf5c7df646580ca26dfaefa593667fc6f2fe016d2e/tabulate-0.10.0-py3-none-any.whl", hash = "sha256:f0b0622e567335c8fabaaa659f1b33bcb6ddfe2e496071b743aa113f8774f2d3", size = 39814, upload-time = "2026-03-04T18:55:31.284Z" },
-]
-
-[[package]]
-name = "tcolorpy"
-version = "0.1.7"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/80/cc/44f2d81d8f9093aad81c3467a5bf5718d2b5f786e887b6e4adcfc17ec6b9/tcolorpy-0.1.7.tar.gz", hash = "sha256:0fbf6bf238890bbc2e32662aa25736769a29bf6d880328f310c910a327632614", size = 299437, upload-time = "2024-12-29T15:24:23.847Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/05/a2/ed023f2edd1e011b4d99b6727bce8253842d66c3fbf9ed0a26fc09a92571/tcolorpy-0.1.7-py3-none-any.whl", hash = "sha256:26a59d52027e175a37e0aba72efc99dda43f074db71f55b316d3de37d3251378", size = 8096, upload-time = "2024-12-29T15:24:21.33Z" },
-]
-
-[[package]]
-name = "tenacity"
-version = "9.1.4"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/47/c6/ee486fd809e357697ee8a44d3d69222b344920433d3b6666ccd9b374630c/tenacity-9.1.4.tar.gz", hash = "sha256:adb31d4c263f2bd041081ab33b498309a57c77f9acf2db65aadf0898179cf93a", size = 49413, upload-time = "2026-02-07T10:45:33.841Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d7/c1/eb8f9debc45d3b7918a32ab756658a0904732f75e555402972246b0b8e71/tenacity-9.1.4-py3-none-any.whl", hash = "sha256:6095a360c919085f28c6527de529e76a06ad89b23659fa881ae0649b867a9d55", size = 28926, upload-time = "2026-02-07T10:45:32.24Z" },
-]
-
-[[package]]
-name = "termcolor"
-version = "3.3.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/46/79/cf31d7a93a8fdc6aa0fbb665be84426a8c5a557d9240b6239e9e11e35fc5/termcolor-3.3.0.tar.gz", hash = "sha256:348871ca648ec6a9a983a13ab626c0acce02f515b9e1983332b17af7979521c5", size = 14434, upload-time = "2025-12-29T12:55:21.882Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/33/d1/8bb87d21e9aeb323cc03034f5eaf2c8f69841e40e4853c2627edf8111ed3/termcolor-3.3.0-py3-none-any.whl", hash = "sha256:cf642efadaf0a8ebbbf4bc7a31cec2f9b5f21a9f726f4ccbb08192c9c26f43a5", size = 7734, upload-time = "2025-12-29T12:55:20.718Z" },
-]
-
-[[package]]
-name = "threadpoolctl"
-version = "3.6.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b7/4d/08c89e34946fce2aec4fbb45c9016efd5f4d7f24af8e5d93296e935631d8/threadpoolctl-3.6.0.tar.gz", hash = "sha256:8ab8b4aa3491d812b623328249fab5302a68d2d71745c8a4c719a2fcaba9f44e", size = 21274, upload-time = "2025-03-13T13:49:23.031Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", hash = "sha256:43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb", size = 18638, upload-time = "2025-03-13T13:49:21.846Z" },
-]
-
 [[package]]
 name = "tiktoken"
 version = "0.12.0"
@@ -3001,25 +2379,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/3a/7a/882d99539b19b1490cac5d77c67338d126e4122c8276bf640e411650c830/twine-6.2.0-py3-none-any.whl", hash = "sha256:418ebf08ccda9a8caaebe414433b0ba5e25eb5e4a927667122fbe8f829f985d8", size = 42727, upload-time = "2025-09-04T15:43:15.994Z" },
 ]
 
-[[package]]
-name = "typepy"
-version = "1.3.4"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "mbstrdecoder", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/79/59/4c39942077d7de285f762a91024dbda731be693591732977358f77d120fb/typepy-1.3.4.tar.gz", hash = "sha256:89c1f66de6c6133209c43a94d23431d320ba03ef5db18f241091ea594035d9de", size = 39558, upload-time = "2024-12-29T09:18:15.774Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ee/31/e393c3830bdedd01735bd195c85ac3034b6bcaf6c18142bab60a4047ca36/typepy-1.3.4-py3-none-any.whl", hash = "sha256:d5ed3e0c7f49521bff0603dd08cf8d453371cf68d65a29d3d0038552ccc46e2e", size = 31449, upload-time = "2024-12-29T09:18:13.135Z" },
-]
-
-[package.optional-dependencies]
-datetime = [
-    { name = "packaging", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "python-dateutil", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "pytz", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-
 [[package]]
 name = "typer-slim"
 version = "0.21.1"
@@ -3072,12 +2431,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
 ]
 
-[[package]]
-name = "word2number"
-version = "1.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/4a/29/a31940c848521f0725f0df6b25dca8917f13a2025b0e8fcbe5d0457e45e6/word2number-1.1.zip", hash = "sha256:70e27a5d387f67b04c71fbb7621c05930b19bfd26efd6851e6e0f9969dcde7d0", size = 9723, upload-time = "2017-06-02T15:45:14.488Z" }
-
 [[package]]
 name = "wsproto"
 version = "1.3.2"
@@ -3090,62 +2443,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a4/f5/10b68b7b1544245097b2a1b8238f66f2fc6dcaeb24ba5d917f52bd2eed4f/wsproto-1.3.2-py3-none-any.whl", hash = "sha256:61eea322cdf56e8cc904bd3ad7573359a242ba65688716b0710a5eb12beab584", size = 24405, upload-time = "2025-11-20T18:18:00.454Z" },
 ]
 
-[[package]]
-name = "xxhash"
-version = "3.6.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/02/84/30869e01909fb37a6cc7e18688ee8bf1e42d57e7e0777636bd47524c43c7/xxhash-3.6.0.tar.gz", hash = "sha256:f0162a78b13a0d7617b2845b90c763339d1f1d82bb04a4b07f4ab535cc5e05d6", size = 85160, upload-time = "2025-10-02T14:37:08.097Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/33/76/35d05267ac82f53ae9b0e554da7c5e281ee61f3cad44c743f0fcd354f211/xxhash-3.6.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:599e64ba7f67472481ceb6ee80fa3bd828fd61ba59fb11475572cc5ee52b89ec", size = 32738, upload-time = "2025-10-02T14:34:55.839Z" },
-    { url = "https://files.pythonhosted.org/packages/31/a8/3fbce1cd96534a95e35d5120637bf29b0d7f5d8fa2f6374e31b4156dd419/xxhash-3.6.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7d8b8aaa30fca4f16f0c84a5c8d7ddee0e25250ec2796c973775373257dde8f1", size = 30821, upload-time = "2025-10-02T14:34:57.219Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/ea/d387530ca7ecfa183cb358027f1833297c6ac6098223fd14f9782cd0015c/xxhash-3.6.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d597acf8506d6e7101a4a44a5e428977a51c0fadbbfd3c39650cca9253f6e5a6", size = 194127, upload-time = "2025-10-02T14:34:59.21Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/0c/71435dcb99874b09a43b8d7c54071e600a7481e42b3e3ce1eb5226a5711a/xxhash-3.6.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:858dc935963a33bc33490128edc1c12b0c14d9c7ebaa4e387a7869ecc4f3e263", size = 212975, upload-time = "2025-10-02T14:35:00.816Z" },
-    { url = "https://files.pythonhosted.org/packages/84/7a/c2b3d071e4bb4a90b7057228a99b10d51744878f4a8a6dd643c8bd897620/xxhash-3.6.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba284920194615cb8edf73bf52236ce2e1664ccd4a38fdb543506413529cc546", size = 212241, upload-time = "2025-10-02T14:35:02.207Z" },
-    { url = "https://files.pythonhosted.org/packages/81/5f/640b6eac0128e215f177df99eadcd0f1b7c42c274ab6a394a05059694c5a/xxhash-3.6.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b54219177f6c6674d5378bd862c6aedf64725f70dd29c472eaae154df1a2e89", size = 445471, upload-time = "2025-10-02T14:35:03.61Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/1e/3c3d3ef071b051cc3abbe3721ffb8365033a172613c04af2da89d5548a87/xxhash-3.6.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:42c36dd7dbad2f5238950c377fcbf6811b1cdb1c444fab447960030cea60504d", size = 193936, upload-time = "2025-10-02T14:35:05.013Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/bd/4a5f68381939219abfe1c22a9e3a5854a4f6f6f3c4983a87d255f21f2e5d/xxhash-3.6.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f22927652cba98c44639ffdc7aaf35828dccf679b10b31c4ad72a5b530a18eb7", size = 210440, upload-time = "2025-10-02T14:35:06.239Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/37/b80fe3d5cfb9faff01a02121a0f4d565eb7237e9e5fc66e73017e74dcd36/xxhash-3.6.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b45fad44d9c5c119e9c6fbf2e1c656a46dc68e280275007bbfd3d572b21426db", size = 197990, upload-time = "2025-10-02T14:35:07.735Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/fd/2c0a00c97b9e18f72e1f240ad4e8f8a90fd9d408289ba9c7c495ed7dc05c/xxhash-3.6.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:6f2580ffab1a8b68ef2b901cde7e55fa8da5e4be0977c68f78fc80f3c143de42", size = 210689, upload-time = "2025-10-02T14:35:09.438Z" },
-    { url = "https://files.pythonhosted.org/packages/93/86/5dd8076a926b9a95db3206aba20d89a7fc14dd5aac16e5c4de4b56033140/xxhash-3.6.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:40c391dd3cd041ebc3ffe6f2c862f402e306eb571422e0aa918d8070ba31da11", size = 414068, upload-time = "2025-10-02T14:35:11.162Z" },
-    { url = "https://files.pythonhosted.org/packages/af/3c/0bb129170ee8f3650f08e993baee550a09593462a5cddd8e44d0011102b1/xxhash-3.6.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f205badabde7aafd1a31e8ca2a3e5a763107a71c397c4481d6a804eb5063d8bd", size = 191495, upload-time = "2025-10-02T14:35:12.971Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/30/25e5321c8732759e930c555176d37e24ab84365482d257c3b16362235212/xxhash-3.6.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a42e633d75cdad6d625434e3468126c73f13f7584545a9cf34e883aa1710e702", size = 32956, upload-time = "2025-10-02T14:35:17.413Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/3c/0573299560d7d9f8ab1838f1efc021a280b5ae5ae2e849034ef3dee18810/xxhash-3.6.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:568a6d743219e717b07b4e03b0a828ce593833e498c3b64752e0f5df6bfe84db", size = 31072, upload-time = "2025-10-02T14:35:18.844Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/1c/52d83a06e417cd9d4137722693424885cc9878249beb3a7c829e74bf7ce9/xxhash-3.6.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bec91b562d8012dae276af8025a55811b875baace6af510412a5e58e3121bc54", size = 196409, upload-time = "2025-10-02T14:35:20.31Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/8e/c6d158d12a79bbd0b878f8355432075fc82759e356ab5a111463422a239b/xxhash-3.6.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78e7f2f4c521c30ad5e786fdd6bae89d47a32672a80195467b5de0480aa97b1f", size = 215736, upload-time = "2025-10-02T14:35:21.616Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/68/c4c80614716345d55071a396cf03d06e34b5f4917a467faf43083c995155/xxhash-3.6.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3ed0df1b11a79856df5ffcab572cbd6b9627034c1c748c5566fa79df9048a7c5", size = 214833, upload-time = "2025-10-02T14:35:23.32Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/e9/ae27c8ffec8b953efa84c7c4a6c6802c263d587b9fc0d6e7cea64e08c3af/xxhash-3.6.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0e4edbfc7d420925b0dd5e792478ed393d6e75ff8fc219a6546fb446b6a417b1", size = 448348, upload-time = "2025-10-02T14:35:25.111Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/6b/33e21afb1b5b3f46b74b6bd1913639066af218d704cc0941404ca717fc57/xxhash-3.6.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fba27a198363a7ef87f8c0f6b171ec36b674fe9053742c58dd7e3201c1ab30ee", size = 196070, upload-time = "2025-10-02T14:35:26.586Z" },
-    { url = "https://files.pythonhosted.org/packages/96/b6/fcabd337bc5fa624e7203aa0fa7d0c49eed22f72e93229431752bddc83d9/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:794fe9145fe60191c6532fa95063765529770edcdd67b3d537793e8004cabbfd", size = 212907, upload-time = "2025-10-02T14:35:28.087Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/d3/9ee6160e644d660fcf176c5825e61411c7f62648728f69c79ba237250143/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:6105ef7e62b5ac73a837778efc331a591d8442f8ef5c7e102376506cb4ae2729", size = 200839, upload-time = "2025-10-02T14:35:29.857Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/98/e8de5baa5109394baf5118f5e72ab21a86387c4f89b0e77ef3e2f6b0327b/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:f01375c0e55395b814a679b3eea205db7919ac2af213f4a6682e01220e5fe292", size = 213304, upload-time = "2025-10-02T14:35:31.222Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/1d/71056535dec5c3177eeb53e38e3d367dd1d16e024e63b1cee208d572a033/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:d706dca2d24d834a4661619dcacf51a75c16d65985718d6a7d73c1eeeb903ddf", size = 416930, upload-time = "2025-10-02T14:35:32.517Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/6c/5cbde9de2cd967c322e651c65c543700b19e7ae3e0aae8ece3469bf9683d/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5f059d9faeacd49c0215d66f4056e1326c80503f51a1532ca336a385edadd033", size = 193787, upload-time = "2025-10-02T14:35:33.827Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/5e/0138bc4484ea9b897864d59fce9be9086030825bc778b76cb5a33a906d37/xxhash-3.6.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:a40a3d35b204b7cc7643cbcf8c9976d818cb47befcfac8bbefec8038ac363f3e", size = 32754, upload-time = "2025-10-02T14:35:38.245Z" },
-    { url = "https://files.pythonhosted.org/packages/18/d7/5dac2eb2ec75fd771957a13e5dda560efb2176d5203f39502a5fc571f899/xxhash-3.6.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a54844be970d3fc22630b32d515e79a90d0a3ddb2644d8d7402e3c4c8da61405", size = 30846, upload-time = "2025-10-02T14:35:39.6Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/71/8bc5be2bb00deb5682e92e8da955ebe5fa982da13a69da5a40a4c8db12fb/xxhash-3.6.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:016e9190af8f0a4e3741343777710e3d5717427f175adfdc3e72508f59e2a7f3", size = 194343, upload-time = "2025-10-02T14:35:40.69Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/3b/52badfb2aecec2c377ddf1ae75f55db3ba2d321c5e164f14461c90837ef3/xxhash-3.6.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4f6f72232f849eb9d0141e2ebe2677ece15adfd0fa599bc058aad83c714bb2c6", size = 213074, upload-time = "2025-10-02T14:35:42.29Z" },
-    { url = "https://files.pythonhosted.org/packages/a2/2b/ae46b4e9b92e537fa30d03dbc19cdae57ed407e9c26d163895e968e3de85/xxhash-3.6.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:63275a8aba7865e44b1813d2177e0f5ea7eadad3dd063a21f7cf9afdc7054063", size = 212388, upload-time = "2025-10-02T14:35:43.929Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/80/49f88d3afc724b4ac7fbd664c8452d6db51b49915be48c6982659e0e7942/xxhash-3.6.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cd01fa2aa00d8b017c97eb46b9a794fbdca53fc14f845f5a328c71254b0abb7", size = 445614, upload-time = "2025-10-02T14:35:45.216Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/ba/603ce3961e339413543d8cd44f21f2c80e2a7c5cfe692a7b1f2cccf58f3c/xxhash-3.6.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0226aa89035b62b6a86d3c68df4d7c1f47a342b8683da2b60cedcddb46c4d95b", size = 194024, upload-time = "2025-10-02T14:35:46.959Z" },
-    { url = "https://files.pythonhosted.org/packages/78/d1/8e225ff7113bf81545cfdcd79eef124a7b7064a0bba53605ff39590b95c2/xxhash-3.6.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c6e193e9f56e4ca4923c61238cdaced324f0feac782544eb4c6d55ad5cc99ddd", size = 210541, upload-time = "2025-10-02T14:35:48.301Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/58/0f89d149f0bad89def1a8dd38feb50ccdeb643d9797ec84707091d4cb494/xxhash-3.6.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:9176dcaddf4ca963d4deb93866d739a343c01c969231dbe21680e13a5d1a5bf0", size = 198305, upload-time = "2025-10-02T14:35:49.584Z" },
-    { url = "https://files.pythonhosted.org/packages/11/38/5eab81580703c4df93feb5f32ff8fa7fe1e2c51c1f183ee4e48d4bb9d3d7/xxhash-3.6.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c1ce4009c97a752e682b897aa99aef84191077a9433eb237774689f14f8ec152", size = 210848, upload-time = "2025-10-02T14:35:50.877Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/6b/953dc4b05c3ce678abca756416e4c130d2382f877a9c30a20d08ee6a77c0/xxhash-3.6.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:8cb2f4f679b01513b7adbb9b1b2f0f9cdc31b70007eaf9d59d0878809f385b11", size = 414142, upload-time = "2025-10-02T14:35:52.15Z" },
-    { url = "https://files.pythonhosted.org/packages/08/a9/238ec0d4e81a10eb5026d4a6972677cbc898ba6c8b9dbaec12ae001b1b35/xxhash-3.6.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:653a91d7c2ab54a92c19ccf43508b6a555440b9be1bc8be553376778be7f20b5", size = 191547, upload-time = "2025-10-02T14:35:53.547Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/db/0e99732ed7f64182aef4a6fb145e1a295558deec2a746265dcdec12d191e/xxhash-3.6.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c5294f596a9017ca5a3e3f8884c00b91ab2ad2933cf288f4923c3fd4346cf3d4", size = 32955, upload-time = "2025-10-02T14:35:58.267Z" },
-    { url = "https://files.pythonhosted.org/packages/55/f4/2a7c3c68e564a099becfa44bb3d398810cc0ff6749b0d3cb8ccb93f23c14/xxhash-3.6.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1cf9dcc4ab9cff01dfbba78544297a3a01dafd60f3bde4e2bfd016cf7e4ddc67", size = 31072, upload-time = "2025-10-02T14:35:59.382Z" },
-    { url = "https://files.pythonhosted.org/packages/c6/d9/72a29cddc7250e8a5819dad5d466facb5dc4c802ce120645630149127e73/xxhash-3.6.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:01262da8798422d0685f7cef03b2bd3f4f46511b02830861df548d7def4402ad", size = 196579, upload-time = "2025-10-02T14:36:00.838Z" },
-    { url = "https://files.pythonhosted.org/packages/63/93/b21590e1e381040e2ca305a884d89e1c345b347404f7780f07f2cdd47ef4/xxhash-3.6.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:51a73fb7cb3a3ead9f7a8b583ffd9b8038e277cdb8cb87cf890e88b3456afa0b", size = 215854, upload-time = "2025-10-02T14:36:02.207Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/b8/edab8a7d4fa14e924b29be877d54155dcbd8b80be85ea00d2be3413a9ed4/xxhash-3.6.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b9c6df83594f7df8f7f708ce5ebeacfc69f72c9fbaaababf6cf4758eaada0c9b", size = 214965, upload-time = "2025-10-02T14:36:03.507Z" },
-    { url = "https://files.pythonhosted.org/packages/27/67/dfa980ac7f0d509d54ea0d5a486d2bb4b80c3f1bb22b66e6a05d3efaf6c0/xxhash-3.6.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:627f0af069b0ea56f312fd5189001c24578868643203bca1abbc2c52d3a6f3ca", size = 448484, upload-time = "2025-10-02T14:36:04.828Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/63/8ffc2cc97e811c0ca5d00ab36604b3ea6f4254f20b7bc658ca825ce6c954/xxhash-3.6.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:aa912c62f842dfd013c5f21a642c9c10cd9f4c4e943e0af83618b4a404d9091a", size = 196162, upload-time = "2025-10-02T14:36:06.182Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/77/07f0e7a3edd11a6097e990f6e5b815b6592459cb16dae990d967693e6ea9/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:b465afd7909db30168ab62afe40b2fcf79eedc0b89a6c0ab3123515dc0df8b99", size = 213007, upload-time = "2025-10-02T14:36:07.733Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/d8/bc5fa0d152837117eb0bef6f83f956c509332ce133c91c63ce07ee7c4873/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:a881851cf38b0a70e7c4d3ce81fc7afd86fbc2a024f4cfb2a97cf49ce04b75d3", size = 200956, upload-time = "2025-10-02T14:36:09.106Z" },
-    { url = "https://files.pythonhosted.org/packages/26/a5/d749334130de9411783873e9b98ecc46688dad5db64ca6e04b02acc8b473/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9b3222c686a919a0f3253cfc12bb118b8b103506612253b5baeaac10d8027cf6", size = 213401, upload-time = "2025-10-02T14:36:10.585Z" },
-    { url = "https://files.pythonhosted.org/packages/89/72/abed959c956a4bfc72b58c0384bb7940663c678127538634d896b1195c10/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:c5aa639bc113e9286137cec8fadc20e9cd732b2cc385c0b7fa673b84fc1f2a93", size = 417083, upload-time = "2025-10-02T14:36:12.276Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/b3/62fd2b586283b7d7d665fb98e266decadf31f058f1cf6c478741f68af0cb/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5c1343d49ac102799905e115aee590183c3921d475356cb24b4de29a4bc56518", size = 193913, upload-time = "2025-10-02T14:36:14.025Z" },
-]
-
 [[package]]
 name = "yarl"
 version = "1.22.0"