add new status code for refund not ready

.env.example

@@ -2,9 +2,6 @@
 UPSTREAM_BASE_URL=https://api.openai.com/v1
 UPSTREAM_API_KEY=your-upstream-api-key
 
-# Tinfoil (confidential inference enclaves, EHBP)
-# TINFOIL_API_KEY=your-tinfoil-api-key
-
 # ADMIN_PASSWORD=secure-admin-password
 
 # Database

.gitignore

@@ -16,9 +16,6 @@ dist/
 *.db-shm
 *.db-wal
 .*wallet.sqlite3
-.wallet/
-AGENTS.md
-TEST_SUITE_OVERVIEW.md
 *models.json
 .cashu
 .relay
@@ -41,4 +38,3 @@ proof_backups
 
 *.todo
 ui_out
-.worktrees

Dockerfile.full

@@ -7,7 +7,7 @@ WORKDIR /app/ui
 RUN corepack enable pnpm && corepack prepare pnpm@10.15.0 --activate
 
 # Copy UI source
-COPY ui/package.json ui/pnpm-lock.yaml* ui/pnpm-workspace.yaml* ./
+COPY ui/package.json ui/pnpm-lock.yaml* ./
 RUN pnpm install --frozen-lockfile
 
 COPY ui/ ./

compose.yml

@@ -13,7 +13,6 @@ services:
       - ./ui_out:/output:z
     command:
       ["sh", "-c", "mkdir -p /output && cp -r /app/built/. /output/ && echo 'UI build copied to mounted volume' && ls -la /output/ && echo 'UI built and ready' && tail -f /dev/null"]
-    restart: unless-stopped
 
   routstr:
     build: .
@@ -32,7 +31,6 @@ services:
       - 8000:8000
     extra_hosts: # Needed to access locally running models
       - "host.docker.internal:host-gateway"
-    restart: unless-stopped
 
   tor:
     image: ghcr.io/hundehausen/tor-hidden-service:latest
@@ -43,7 +41,6 @@ services:
       - HS_ROUTER=routstr:8000:80
     depends_on:
       - routstr
-    restart: unless-stopped
 
 volumes:
   tor-data:

docs/api/errors.md

@@ -113,109 +113,42 @@ All errors follow a consistent JSON structure:
 **Status:** 402  
 **Resolution:** Top up API key balance
 
-### Cashu Token Redemption Errors
-
-These errors are returned when a Cashu token you pay with cannot be redeemed.
-They apply to every endpoint that accepts a token:
-
-- **Per-request payment** via the `X-Cashu` header (chat completions + Responses API).
-- **API key top-up** via `POST /v1/wallet/topup`.
-- **Minting an API key** from a token sent in `Authorization: Bearer <cashu-token>`.
-
-All three share one classifier, so the same failure yields the same HTTP status
-and sanitized message everywhere. Structured error envelopes (`X-Cashu` and
-`Authorization: Bearer <cashu-token>`) also expose the same `type` and `code` —
-branch on `type` (or `code` for finer granularity). `POST /v1/wallet/topup`
-keeps its existing plain-string `detail` envelope, so branch on status there.
-
-| `type` | Status | `code` | Retryable | Meaning |
-|--------|--------|--------|-----------|---------|
-| `token_already_spent` | 400 | `cashu_token_already_spent` | No | The token was already redeemed. |
-| `invalid_token` | 400 | `invalid_cashu_token` | No | The token is malformed or cannot be decoded. |
-| `mint_error` | 422 | `cashu_token_swap_fees_exceed_amount` | No | Token value is too small to cover the mint's swap/melt fees. |
-| `mint_error` | 422 | `cashu_foreign_mint_swap_failed` | No | Swapping the token from a foreign mint to the primary mint failed. |
-| `mint_unreachable` | 503 | `cashu_mint_unreachable` | **Yes** | The mint could not be reached (DNS failure, refused/reset connection, timeout). The token is fine — retry once the mint recovers. |
-| `cashu_error` | 400 | `cashu_token_redemption_failed` | No | The token could not be redeemed for another expected reason. |
-| `cashu_error` | 400 | `cashu_token_zero_value` | No | The token redeemed to zero (empty/dust token, or value fully consumed by fees). |
-| `token_consumed` | 500 | `cashu_token_consumed` | No | The token was **spent** (melted/redeemed) but crediting it then failed. Do not retry — the token is gone; contact support to reconcile. |
-| `api_error` | 500 | `internal_error` | Maybe | Unexpected server-side fault during redemption. |
-
-!!! important "Retry only `mint_unreachable`"
-    Only `mint_unreachable` (503) means the same token will work again later —
-    everything else is a permanent property of the token and must not be
-    blindly retried. Use exponential backoff for the 503. In particular, a
-    `token_consumed` 500 means the mint already spent the token, so a retry
-    would fail as `token_already_spent`.
-
-#### Mint Unreachable (retryable)
+#### Invalid Token
 
 ```json
 {
   "error": {
-    "type": "mint_unreachable",
-    "message": "Cashu mint is unreachable",
-    "code": "cashu_mint_unreachable"
+    "type": "payment_error",
+    "message": "Invalid Cashu token",
+    "code": "invalid_token",
+    "details": {
+      "reason": "Token already spent"
+    }
   }
 }
 ```
 
-**Status:** 503
+**Status:** 400  
+**Resolution:** Use a valid, unspent token
 
-**Resolution:** The token is valid — the mint is temporarily down. Retry with
-backoff, or pay with a token from a different mint.
-
-#### Token Already Spent
+#### Mint Unavailable
 
 ```json
 {
   "error": {
-    "type": "token_already_spent",
-    "message": "Cashu token already spent",
-    "code": "cashu_token_already_spent"
+    "type": "payment_error",
+    "message": "Cannot connect to Cashu mint",
+    "code": "mint_unavailable",
+    "details": {
+      "mint_url": "https://mint.example.com",
+      "retry_after": 60
+    }
   }
 }
 ```
 
-**Status:** 400
-
-**Resolution:** Use a fresh, unspent token. Do not retry with the same token.
-
-#### Response envelope differs by endpoint
-
-The `error` object above is identical everywhere, but the surrounding envelope
-depends on how you paid:
-
-- **`X-Cashu` header payments** (chat + Responses API) return the object at the
-  top level, alongside a `request_id`:
-
-  ```json
-  {
-    "error": { "type": "mint_unreachable", "message": "Cashu mint is unreachable", "code": "cashu_mint_unreachable" },
-    "request_id": "req-abc123"
-  }
-  ```
-
-  The original token is echoed back in the `X-Cashu` **response header only when
-  it is still spendable** (e.g. `mint_unreachable`, `invalid_cashu_token`, fee
-  errors) so you can recover/retry it. It is **not** echoed for spent/consumed
-  tokens (`cashu_token_already_spent`, `cashu_token_consumed`,
-  `cashu_token_zero_value`, `internal_error`) — retrying those can never succeed.
-
-- **`Authorization: Bearer <cashu-token>`** (API key minting) wraps it in
-  FastAPI's `detail` field:
-
-  ```json
-  { "detail": { "error": { "type": "mint_unreachable", "message": "Cashu mint is unreachable", "code": "cashu_mint_unreachable" } } }
-  ```
-
-- **`POST /v1/wallet/topup`** returns a plain string message under `detail` —
-  it carries the shared HTTP **status** and **message** (e.g. `503` for an
-  unreachable mint) but not the structured `type`/`code`, so branch on the
-  status code here:
-
-  ```json
-  { "detail": "Cashu mint is unreachable" }
-  ```
+**Status:** 503  
+**Resolution:** Try again later or use different mint
 
 ### Validation Errors
 
@@ -414,7 +347,7 @@ class ErrorHandler:
         'rate_limit',
         'upstream_timeout',
         'model_overloaded',
-        'cashu_mint_unreachable'
+        'mint_unavailable'
     }
     
     # Errors requiring user action

docs/ehbp-proxy-support.md

@@ -1,150 +0,0 @@
-# EHBP Proxy Support for Tinfoil Models
-
-## Problem
-
-The SDK's `SecureClient.fetch` encrypts request bodies with HPKE (EHBP protocol)
-and sends them to the Routstr provider. The Routstr proxy had no EHBP handling:
-
-1. It tried to `json.loads()` the binary HPKE-sealed body → failed with a 400
-2. The upstream PPQ.AI public endpoint (`/v1/chat/completions`) doesn't speak
-   EHBP, so the response had no `Ehbp-Response-Nonce` header
-3. `SecureClient` threw `Missing Ehbp-Response-Nonce header` because it expects
-   every response from an EHBP-configured `baseURL` to carry that header
-
-## Root cause
-
-PPQ.AI exposes EHBP-aware inference at `/private/`, separate from the public
-`/v1/` endpoint. The Routstr proxy was forwarding to `/v1/` (the public
-endpoint) instead of `/private/` (the enclave endpoint). The public endpoint
-can't decrypt the body, returns a normal HTTP response, and the SDK can't
-decrypt it because there's no nonce header.
-
-The PPQ private-mode proxy (`ppq-private-mode-proxy/lib/proxy.ts`) shows the
-correct pattern: `SecureClient` talks to `api.ppq.ai/private/v1/chat/completions`,
-which decrypts inside the attested enclave and returns an EHBP-encrypted
-response with the `Ehbp-Response-Nonce` header.
-
-## What was changed
-
-### `routstr/proxy.py`
-
-Detects EHBP requests by checking for the `Ehbp-Encapsulated-Key` header (set
-by the EHBP transport on every encrypted request). For EHBP requests:
-
-- Skips JSON body parsing (the body is binary ciphertext, not JSON)
-- Reads the model ID from the `X-Routstr-Model` header (set by the SDK) instead
-  of from `body.model`
-- Routes through new `forward_ehbp_request` (bearer auth) and
-  `forward_ehbp_x_cashu_request` (x-cashu auth) methods
-- Skips reactive 400 param correction (can't parse encrypted response body)
-- Still charges the user via `pay_for_request` (uses `max_cost_for_model` from
-  the model registry, not the body)
-
-### `routstr/upstream/base.py`
-
-Keeps EHBP as an explicit opt-in provider capability instead of making every
-upstream provider appear EHBP-capable:
-
-- `supports_ehbp = False` by default
-- `get_ehbp_forwarding_target(path, model_obj)` raises `NotImplementedError`
-  unless a provider opts in and returns a provider-specific EHBP target
-
-The actual EHBP forwarding logic does **not** live in `base.py`.
-
-### `routstr/upstream/ehbp.py`
-
-Contains the shared opaque EHBP transport and billing helpers:
-
-- `EHBPForwardingTarget` — provider-specific target URL plus extra headers
-- `forward_ehbp_request()` — forwards the encrypted body, captures Tinfoil
-  usage from a response header or streaming HTTP trailer, and finalizes bearer
-  billing at actual cost (falling back to max cost when usage is unavailable)
-- `forward_ehbp_x_cashu_request()` — redeems the Cashu token, refunds the full
-  token on upstream failure, and refunds the difference between the redeemed
-  amount and actual cost (or max cost when usage is unavailable)
-
-### Provider support
-
-EHBP is currently enabled only for `TinfoilUpstreamProvider`. It forwards to
-Tinfoil's attested enclave and requests `X-Tinfoil-Usage-Metrics` for billing.
-PPQ.AI retains its private-target implementation, but `supports_ehbp = False`
-until it has a provider-specific trusted usage/model-binding strategy.
-
-## Why it's done this way
-
-The proxy is a **blind relay** for EHBP requests. It cannot decrypt the body
-(only the attested enclave can), so it must:
-
-1. Get the model ID from a header, not the body
-2. Forward the raw bytes without parsing or transformation
-3. Stream the response back without SSE/cost parsing
-4. Pass through EHBP protocol headers (`Ehbp-Encapsulated-Key` on request,
-   `Ehbp-Response-Nonce` on response)
-
-Cost tracking happens at the proxy level. Routstr reserves or redeems up to
-`max_cost_for_model`, then Tinfoil's out-of-band usage header/trailer allows it
-to finalize at actual token cost. If trusted usage is missing or invalid, the
-proxy safely falls back to max-cost billing.
-
-## End-to-end flow
-
-```
-SDK                                  Routstr Proxy                    PPQ.AI /private/
-  │                                       │                                │
-  │── X-Routstr-Model: tinfoil-kimi-k2-6 ─│                                │
-  │── Ehbp-Encapsulated-Key: <hex> ───────│                                │
-  │── Authorization: Bearer <cashu> ──────│                                │
-  │── body = HPKE-encrypted(kimi-k2-6) ───│                                │
-  │                                       │                                │
-  │                                  detects Ehbp-Encapsulated-Key         │
-  │                                  reads model from X-Routstr-Model      │
-  │                                  does billing/routing                  │
-  │                                       │                                │
-  │                                  adds X-Private-Model: private/kimi-k2-6
-  │                                  forwards raw body to /private/v1/...  │
-  │                                       │──────────────────────────────▶│
-  │                                       │                          enclave decrypts
-  │                                       │                          runs inference
-  │                                       │◀── Ehbp-Response-Nonce ──────│
-  │                                       │◀── encrypted response ────────│
-  │                                       │                                │
-  │                                  streams response back untouched       │
-  │◀── encrypted response ────────────────│                                │
-  │                                        │                                │
-  SecureClient reads nonce, decrypts       │                                │
-  SDK SSE processing sees plaintext        │                                │
-```
-
-## Model ID mapping
-
-Three parties see three different model IDs:
-
-| Party | Header/Body | Value | Source |
-|---|---|---|---|
-| Routstr proxy | `X-Routstr-Model` header | `tinfoil-kimi-k2-6` | SDK sends full caller-facing id |
-| Tinfoil usage metrics | `model` field | `kimi-k2-6` | Enclave reports the model actually served |
-| Tinfoil enclave | `body.model` (encrypted) | `kimi-k2-6` | SDK strips `tinfoil-` prefix before encryption |
-
-## Implementation status
-
-A dedicated `TinfoilUpstreamProvider` (`routstr/upstream/tinfoil.py`) now
-implements the direct blind-upstream pattern described above. The shared EHBP
-helpers in `routstr/upstream/ehbp.py` were extended to:
-
-- Request usage metrics via `X-Tinfoil-Request-Usage-Metrics: true`.
-- Parse `X-Tinfoil-Usage-Metrics` from the response header (non-streaming) or
-  HTTP trailer (streaming).
-- Override the forwarding URL with a validated `X-Tinfoil-Enclave-Url` when the
-  SDK sends it.
-- Finalize bearer billing with the dedicated EHBP actual-cost finalizer.
-- Compute X-Cashu refunds from actual cost instead of max cost.
-
-See `docs/tinfoil-direct-integration.md` for the full implementation notes.
-
-## Verification status
-
-Unit coverage includes usage parsing, target validation, HTTP trailer capture,
-response-size limits, and bearer payment finalization. End-to-end requests have
-verified both non-streaming usage headers and streaming usage trailers against
-Tinfoil. SDK behavior on proxy-generated non-2xx responses without an
-`Ehbp-Response-Nonce` still merits explicit end-to-end coverage.

docs/tinfoil-direct-integration.md

@@ -1,493 +0,0 @@
-# Tinfoil / PPQ Private-Mode Integration Notes
-
-This document summarizes the current options for integrating Tinfoil/PPQ private models with Routstr, based on the EHBP work in this branch and local testing against `ppq-private-mode-proxy`.
-
-## Background
-
-PPQ private models run behind a Tinfoil/EHBP flow:
-
-- Request bodies are HPKE-encrypted by a Tinfoil client.
-- The PPQ `/private/` endpoint routes ciphertext to the attested enclave.
-- The enclave decrypts, runs inference, and returns an encrypted response.
-- The caller's Tinfoil client decrypts the response locally.
-
-The PPQ private-mode proxy (`~/projects/ppq-private-mode-proxy`) uses this pattern with the JavaScript `tinfoil` SDK:
-
-```ts
-import { SecureClient } from "tinfoil";
-
-const apiBase = "https://api.ppq.ai";
-
-const client = new SecureClient({
-  baseURL: `${apiBase}/private/`,
-  attestationBundleURL: `${apiBase}/private`,
-  transport: "ehbp",
-});
-
-await client.ready();
-
-const response = await client.fetch(`${apiBase}/private/v1/chat/completions`, {
-  method: "POST",
-  headers: {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${process.env.PPQ_API_KEY}`,
-    "X-Private-Model": "private/gpt-oss-120b",
-    "x-query-source": "api",
-  },
-  body: JSON.stringify({
-    model: "gpt-oss-120b", // enclave-internal model id
-    messages: [{ role: "user", content: "Hello" }],
-  }),
-});
-
-const json = await response.json();
-console.log(json.usage);
-```
-
-`X-Private-Model` carries the PPQ-facing private model id, while the encrypted JSON body uses the enclave-internal model id without the `private/` prefix.
-
-## PPQ private model pricing
-
-PPQ exposes private model pricing through:
-
-```text
-GET https://api.ppq.ai/v1/models?type=all
-```
-
-Filter models whose IDs start with `private/`.
-
-Example private pricing observed:
-
-| Model | Input USD / 1M tokens | Output USD / 1M tokens |
-|---|---:|---:|
-| `private/gpt-oss-120b` | `0.79125` | `1.31875` |
-| `private/llama3-3-70b` | `1.84625` | `2.90125` |
-| `private/qwen3-vl-30b` | `1.31875` | `4.22` |
-| `private/glm-5-2` | `1.5825` | `5.53875` |
-| `private/gemma4-31b` | `0.47475` | `1.055` |
-| `private/kimi-k2-6` | `1.5825` | `5.53875` |
-
-The `ppq-private-mode-proxy` commit `ba984214793d3bca0f7d046b6955d42abc1c6843` changed OpenClaw display metadata to align with a 5% API margin. The live PPQ model endpoint returns the more precise rates above, which already include that margin.
-
-Actual PPQ private billing is:
-
-```text
-price_usd =
-  input_tokens  * input_per_1M_tokens  / 1_000_000
-+ output_tokens * output_per_1M_tokens / 1_000_000
-```
-
-A test request to `private/gpt-oss-120b` produced:
-
-```json
-{
-  "input_count": 74,
-  "output_count": 3,
-  "price_in_usd": 0.00006250875
-}
-```
-
-which exactly matches:
-
-```text
-74 * 0.79125 / 1_000_000 + 3 * 1.31875 / 1_000_000
-= 0.00006250875 USD
-```
-
-## Integration architectures
-
-There are three materially different ways Routstr could integrate Tinfoil/PPQ private inference.
-
-## Option A: User integrates Tinfoil directly
-
-```text
-User app / SDK
-  -> Tinfoil SecureClient / TinfoilAI
-    -> EHBP-encrypted request
-      -> Tinfoil/PPQ private enclave
-```
-
-Properties:
-
-- Best privacy for the user.
-- Routstr is not in the request path.
-- User's client encrypts requests and decrypts responses.
-- Usage is visible to the user's app after decryption.
-- Billing is handled directly by Tinfoil/PPQ.
-
-Example with Tinfoil's OpenAI-compatible client:
-
-```ts
-import { TinfoilAI } from "tinfoil";
-
-const client = new TinfoilAI({
-  apiKey: process.env.TINFOIL_API_KEY,
-  transport: "ehbp",
-});
-
-const res = await client.chat.completions.create({
-  model: "llama3-3-70b",
-  messages: [{ role: "user", content: "Hello" }],
-});
-
-console.log(res.choices[0].message.content);
-console.log(res.usage);
-```
-
-This is not a Routstr marketplace flow unless Routstr only acts as discovery/UI around direct Tinfoil/PPQ usage.
-
-## Option B: Routstr integrates Tinfoil as an upstream client
-
-```text
-User -> Routstr plaintext request
-  -> Routstr Tinfoil SecureClient encrypts to PPQ/Tinfoil
-    -> PPQ private enclave
-  -> Routstr receives decrypted response
-  -> Routstr bills from decrypted usage
-  -> Routstr returns plaintext response to user
-```
-
-Properties:
-
-- Easier exact billing.
-- Routstr can read the decrypted OpenAI response and `usage` object.
-- Routstr can charge exact PPQ token pricing.
-- Privacy is different: the user sends plaintext to Routstr, and Routstr sees prompts/responses.
-- End-to-end encryption is only Routstr-to-enclave, not user-to-enclave.
-
-This should be considered a separate product/provider mode, not the same as an end-to-end private relay.
-
-Practical implementation options:
-
-1. Run a Node sidecar that uses the `tinfoil` npm package and expose it as a local HTTP upstream to Routstr.
-2. Port EHBP client behavior to Python.
-3. Reuse or adapt `ppq-private-mode-proxy` as a local upstream.
-
-A Node sidecar is probably the quickest implementation path because `ppq-private-mode-proxy` already demonstrates the full flow.
-
-## Option C: Routstr uses Tinfoil as a direct blind upstream
-
-This is the current branch's design intent and is likely the best fit if Tinfoil/PPQ exposes usage metadata headers:
-
-```text
-User Tinfoil SecureClient
-  -> encrypted request body
-    -> Routstr proxy
-      -> Tinfoil/PPQ private API
-         with X-Tinfoil-Request-Usage-Metrics: true
-        -> PPQ private enclave
-      <- encrypted response
-         plus X-Tinfoil-Usage-Metrics / cost headers
-    <- Routstr proxy
-  -> user decrypts response
-```
-
-In this mode Routstr is still a normal upstream proxy from the user's point of view, but the upstream is Tinfoil/PPQ private inference and the body remains opaque to Routstr.
-
-Properties:
-
-- Strongest privacy with Routstr in the path.
-- Routstr never sees plaintext prompt or plaintext response.
-- Routstr can authenticate and route based on plaintext headers.
-- Routstr should request Tinfoil usage metadata by adding `X-Tinfoil-Request-Usage-Metrics: true` to the upstream request.
-- Tinfoil documents `X-Tinfoil-Usage-Metrics` as an upstream response header for non-streaming requests.
-- For streaming requests, Tinfoil documents `X-Tinfoil-Usage-Metrics` as an HTTP trailer available only after the response body completes.
-- If Tinfoil/PPQ returns `X-Tinfoil-Usage-Metrics` or a cost header on the encrypted response, Routstr can bill exactly without decrypting the body.
-- If usage is only present inside the encrypted response body, Routstr still cannot read it and exact billing is not possible without a separate metadata path.
-
-This is the only architecture that preserves end-to-end encryption from the user to the PPQ/Tinfoil enclave while still letting Routstr mediate payment. The key requirement is that usage/cost metadata must be returned outside the encrypted body, ideally as a response header available before body streaming begins.
-
-## Current Routstr problem
-
-The current EHBP implementation charges successful EHBP requests at `max_cost_for_model` because Routstr cannot decrypt the response body:
-
-```text
-successful EHBP request -> charge full reserved max cost
-```
-
-That is incorrect for PPQ private models. Max cost should be only a reservation/solvency ceiling. Final charge should use actual PPQ private token pricing.
-
-Desired behavior:
-
-```text
-reserve max cost
-forward encrypted request
-obtain actual usage/cost metadata
-finalize actual cost
-refund/release the difference
-```
-
-## Usage/cost metadata requirement
-
-For blind-relay exact billing, PPQ should return one of the following outside the encrypted response body:
-
-```http
-X-PPQ-Cost-USD: 0.00006250875
-```
-
-or:
-
-```http
-X-Private-Usage-Metrics: input=74,output=3
-```
-
-or:
-
-```http
-X-Tinfoil-Usage-Metrics: prompt=74,completion=3,total=77
-```
-
-Tinfoil proxy documentation references a usage-metrics flow where a proxy can request usage via:
-
-```http
-X-Tinfoil-Request-Usage-Metrics: true
-```
-
-and read usage from:
-
-```http
-X-Tinfoil-Usage-Metrics
-```
-
-Docs/example references:
-
-- https://docs.tinfoil.sh/guides/proxy-server
-- https://github.com/tinfoilsh/encrypted-request-proxy-example
-
-During local PPQ testing, PPQ responses included this CORS exposure header:
-
-```http
-Access-Control-Expose-Headers: Ehbp-Response-Nonce, X-Private-Usage-Metrics, X-Encrypted-Usage-Metrics, X-Tinfoil-Usage-Metrics
-```
-
-However, the actual tested non-streaming response did not include any of these usage headers, even when `X-Tinfoil-Request-Usage-Metrics: true` was sent.
-
-The decrypted body did include normal OpenAI usage, but only the decrypting Tinfoil client can see that body.
-
-## Query-history fallback
-
-PPQ's query history endpoint exposes actual usage and cost:
-
-```text
-GET https://api.ppq.ai/queries/history?page=1&page_count=...
-```
-
-A record includes:
-
-```json
-{
-  "timestamp": "...",
-  "model": "private/gpt-oss-120b",
-  "input_count": 74,
-  "output_count": 3,
-  "price_in_usd": 0.00006250875,
-  "query_type": "chat_completion",
-  "query_source": "api"
-}
-```
-
-This could be used as a fallback, but it is less robust than response headers/trailers because matching a request to a history row can be race-prone under concurrency. It would need a reliable request identifier or metadata field that PPQ stores in history.
-
-## Recommended Routstr direction
-
-Use Tinfoil/PPQ as a direct blind upstream and have Routstr explicitly request usage metadata:
-
-```text
-User encrypts body
-Routstr reserves max cost
-Routstr forwards encrypted body to Tinfoil/PPQ /private/
-Routstr includes X-Tinfoil-Request-Usage-Metrics: true
-Tinfoil/PPQ returns X-Tinfoil-Usage-Metrics as a response header for non-streaming,
-or as an HTTP trailer after the body completes for streaming
-Routstr finalizes exact charge
-User decrypts encrypted response
-```
-
-This preserves both:
-
-- privacy: Routstr cannot read prompts/responses;
-- exact billing: Routstr can charge actual PPQ private model cost, assuming Tinfoil/PPQ returns usage/cost metadata outside the encrypted body.
-
-Implementation steps:
-
-1. Update PPQ model fetching to include private models:
-
-   ```text
-   GET https://api.ppq.ai/v1/models?type=all
-   ```
-
-2. Register `private/*` models and any Routstr-facing aliases with correct `forwarded_model_id`.
-
-3. Keep max-cost reservation for bearer keys and X-Cashu solvency checks.
-
-4. Add parsing support for possible usage/cost headers:
-
-   ```http
-   X-PPQ-Cost-USD
-   X-Private-Usage-Metrics
-   X-Tinfoil-Usage-Metrics
-   X-Encrypted-Usage-Metrics
-   ```
-
-5. Finalize by actual cost instead of max cost:
-
-   ```text
-   actual_msats = ceil((actual_usd / sats_usd_price()) * 1000)
-   actual_msats = max(actual_msats, settings.min_request_msat)
-   actual_msats = min(actual_msats, reserved_msats)
-   ```
-
-   or, if only token counts are available:
-
-   ```text
-   actual_usd =
-     input_tokens  * input_per_1M_tokens  / 1_000_000
-   + output_tokens * output_per_1M_tokens / 1_000_000
-   ```
-
-6. If usage/cost metadata is missing, choose an explicit policy:
-
-   - fail closed and refund/revert;
-   - query PPQ history as a fallback;
-   - fallback to max-cost billing only if explicitly configured and clearly disclosed.
-
-Silent max-cost billing should not be the default for PPQ private requests.
-
-## X-Cashu consideration
-
-For bearer-auth requests, finalization can happen after the response stream completes if usage is delivered as a trailer.
-
-For `X-Cashu`, Routstr needs to return the refund token in the response headers. If usage/cost is only available after consuming the encrypted response stream, Routstr may need to buffer EHBP responses before sending them to the client so it can compute the refund amount first.
-
-Possible approaches:
-
-1. Prefer a non-trailer response header with actual cost, available before streaming body starts.
-2. Buffer EHBP X-Cashu responses and then return `X-Cashu` refund.
-3. Introduce a later/refund-claim mechanism, which would be a larger protocol change.
-
-## Summary
-
-- PPQ private models are billed per actual input/output tokens.
-- Private model rates are available from `GET /v1/models?type=all`.
-- Current Routstr EHBP billing at max cost is wrong for PPQ private models.
-- Direct Tinfoil integration inside Routstr would enable exact usage billing but would make Routstr see plaintext.
-- A blind EHBP relay preserves privacy but requires PPQ/Tinfoil to expose usage/cost in plaintext headers/trailers.
-- The preferred solution is to keep Routstr blind and have PPQ return billing metadata outside the encrypted body.
-
-## Implementation status
-
-Direct Tinfoil upstream integration is implemented in `routstr/upstream/tinfoil.py`
-and `routstr/upstream/ehbp.py`.
-
-### What was built
-
-- `TinfoilUpstreamProvider` (`provider_type = "tinfoil"`):
-  - Base URL: `https://inference.tinfoil.sh`
-  - Fetches models from the public `GET /v1/models` endpoint (no auth needed).
-  - Parses Tinfoil's pricing (`inputTokenPricePer1M`, `outputTokenPricePer1M`,
-    `requestPrice`) into the standard `Model`/`Pricing` schema.
-  - `supports_ehbp = True` — acts as a blind EHBP relay.
-  - `get_ehbp_forwarding_target()` returns a target that includes
-    `X-Tinfoil-Request-Usage-Metrics: true`.
-  - `forward_get_request()` proxies `/attestation` to `https://atc.tinfoil.sh/attestation`
-    so the SDK can fetch attestation bundles through Routstr.
-  - Registered in `routstr/upstream/__init__.py` and seeded from
-    `TINFOIL_API_KEY` env var.
-
-- `routstr/upstream/ehbp.py`:
-  - `parse_tinfoil_usage_metrics()` parses
-    `prompt=N,completion=N[,total=N][,model=<name>]` into an OpenAI-style
-    usage dict. The `model` field (added in tinfoilsh/confidential-model-router
-    PR #385) is extracted as a string.
-  - `_resolve_ehbp_target_url()` overrides the forwarding URL with
-    `X-Tinfoil-Enclave-Url` when the SDK sends it.
-  - `_strip_proxy_headers()` removes `X-Routstr-Model`,
-    `X-Tinfoil-Enclave-Url`, and `X-Tinfoil-Request-Usage-Metrics` before
-    forwarding to the enclave.
-  - `_compute_ehbp_actual_cost()` converts the usage header into msats via
-    `calculate_cost()`, clamped to `[min_request_msat, max_cost_for_model]`.
-    When the header's `model=<name>` differs from the requested model, the
-    actual served model's pricing is used for cost calculation.
-  - `forward_ehbp_request()` (bearer auth): if `X-Tinfoil-Usage-Metrics` is
-    present in the response header, finalizes with `adjust_payment_for_tokens()`
-    for exact billing; otherwise falls back to max-cost. Billing uses the
-    actual served model when it differs from the requested one.
-  - `forward_ehbp_x_cashu_request()`: if usage is available, computes the
-    refund from actual cost instead of max cost, using the actual served
-    model's pricing when applicable.
-
-- `routstr/proxy.py`: `/attestation` and `/tee/attestation` paths are forwarded
-  to Tinfoil upstreams without model/cost/auth lookups.
-
-### Billing behavior
-
-| Request shape | Usage source | Billing |
-|---|---|---|
-| Bearer, non-streaming | `X-Tinfoil-Usage-Metrics` response header | Exact token cost via `adjust_payment_for_tokens` |
-| Bearer, streaming | `X-Tinfoil-Usage-Metrics` HTTP trailer | Exact token cost (h11 captures trailers) |
-| Bearer, no usage header/trailer | N/A | Max-cost fallback |
-| X-Cashu, non-streaming | `X-Tinfoil-Usage-Metrics` response header | Refund = `redeemed - actual_cost` |
-| X-Cashu, streaming | `X-Tinfoil-Usage-Metrics` HTTP trailer | Refund = `redeemed - actual_cost` (h11 captures trailers) |
-| X-Cashu, no usage header/trailer | N/A | Refund = `redeemed - max_cost` |
-
-### Cost response headers
-
-Since EHBP response bodies are opaque encrypted blobs, per-request cost cannot
-be injected into the JSON body (as done in the normal proxy flow). Instead,
-Routstr returns cost info as response headers:
-
-| Header | Auth | Description |
-|---|---|---|
-| `X-Routstr-Cost-Msats` | Bearer, X-Cashu | Total msats charged for this request |
-| `X-Routstr-Cost-Usd` | Bearer | USD equivalent of the charge |
-| `X-Routstr-Input-Cost-Msats` | Bearer, X-Cashu | msats attributed to input tokens |
-| `X-Routstr-Output-Cost-Msats` | Bearer, X-Cashu | msats attributed to output tokens |
-
-The client/Tinfoil SDK can read these headers from the HTTP response without
-needing to decrypt the body.
-
-### Setup
-
-```bash
-TINFOIL_API_KEY=your-tinfoil-api-key
-```
-
-The provider is auto-seeded on first startup.
-
-### Usage metrics header format
-
-Tinfoil returns usage metrics in the `X-Tinfoil-Usage-Metrics` response header
-(non-streaming) or HTTP trailer (streaming) when `X-Tinfoil-Request-Usage-Metrics:
-true` is sent. As of tinfoilsh/confidential-model-router PR #385, the format is:
-
-```
-prompt=<prompt_tokens>,completion=<completion_tokens>,total=<total_tokens>,model=<served_model>
-```
-
-The `model` field carries the actual model name served by the enclave.
-Routstr uses this to:
-
-- Verify the served model matches the expected upstream model. The comparison
-  uses ``model_obj.forwarded_model_id`` (the actual upstream ID, e.g.
-  ``glm-5-2``) rather than ``model_obj.id`` (the client-facing alias, e.g.
-  ``tinfoil-glm-5-2``), so aliased models don't trigger a spurious mismatch.
-- When they genuinely differ (Tinfoil served a different upstream model than
-  expected), look up the actual served model's pricing and use it for billing.
-  The reverse lookup uses ``get_model_instance``, which resolves
-  ``forwarded_model_id`` values registered as routable aliases.
-- Log the discrepancy for observability.
-
-If the actual model is not found in Routstr's model registry, billing falls
-back to the requested model's pricing.
-
-### What still needs verification
-
-- ~~End-to-end test with a real Tinfoil SDK client against a Routstr node with
-  `TINFOIL_API_KEY` set.~~ Verified: both non-streaming (header) and streaming
-  (trailer) responses include `model=<name>`.
-- Streaming trailer capture is implemented by buffering the encrypted response
-  in `forward_with_trailer()` and then using the dedicated EHBP payment
-  finalizers for bearer and X-Cashu requests. This provides actual-cost billing
-  today, at the cost of full time-to-last-byte latency for streaming responses.
-- Whether Tinfoil's `/v1/responses` endpoint also returns usage metrics
-  headers or trailers.

pyproject.toml

@@ -10,7 +10,6 @@ dependencies = [
     "aiosqlite>=0.20",
     "sqlmodel>=0.0.24",
     "httpx[socks]>=0.25.2",
-    "h11>=0.14",
     "greenlet>=3.2.1",
     "alembic>=1.13",
     "python-json-logger>=2.0.0",

routstr/algorithm.py

@@ -86,8 +86,8 @@ def get_provider_penalty(provider: "BaseUpstreamProvider") -> float:
 
 def create_model_mappings(
     upstreams: list["BaseUpstreamProvider"],
-    overrides_by_key: dict[tuple[str, int], tuple],
-    disabled_model_keys: set[tuple[str, int]],
+    overrides_by_id: dict[str, tuple],
+    disabled_model_ids: set[str],
 ) -> tuple[
     dict[str, "Model"], dict[str, list["BaseUpstreamProvider"]], dict[str, "Model"]
 ]:
@@ -107,9 +107,8 @@ def create_model_mappings(
 
     Args:
         upstreams: List of all upstream provider instances
-        overrides_by_key: Dict of model overrides from database
-            {(model_id_lower, upstream_provider_id): (ModelRow, fee)}
-        disabled_model_keys: Set of provider-scoped model keys that should be excluded
+        overrides_by_id: Dict of model overrides from database {model_id: (ModelRow, fee)}
+        disabled_model_ids: Set of model IDs that should be excluded
 
     Returns:
         Tuple of (model_instances, provider_map, unique_models)
@@ -180,22 +179,14 @@ def create_model_mappings(
         """Process all models from a given provider."""
         upstream_prefix = getattr(upstream, "upstream_name", None)
         provider_key = get_provider_identity(upstream)
-        upstream_db_id = getattr(upstream, "db_id", None)
 
         for model in upstream.get_cached_models():
-            model_key = (
-                (model.id.lower(), upstream_db_id)
-                if isinstance(upstream_db_id, int)
-                else None
-            )
-            if not model.enabled or (
-                model_key is not None and model_key in disabled_model_keys
-            ):
+            if not model.enabled or model.id in disabled_model_ids:
                 continue
 
-            # Apply overrides only for this provider's model row.
-            if model_key is not None and model_key in overrides_by_key:
-                override_row, provider_fee = overrides_by_key[model_key]
+            # Apply overrides if present
+            if model.id in overrides_by_id:
+                override_row, provider_fee = overrides_by_id[model.id]
                 model_to_use = _row_to_model(
                     override_row, apply_provider_fee=True, provider_fee=provider_fee
                 )
@@ -246,10 +237,13 @@ def create_model_mappings(
 
     # Include enabled DB overrides even when provider discovery misses models.
     # This is important for deployment-based providers like Azure.
-    for (model_id, upstream_provider_id), override_data in overrides_by_key.items():
-        if (model_id, upstream_provider_id) in disabled_model_keys:
+    for model_id, override_data in overrides_by_id.items():
+        if model_id in disabled_model_ids:
             continue
         override_row, provider_fee = override_data
+        upstream_provider_id = getattr(override_row, "upstream_provider_id", None)
+        if not isinstance(upstream_provider_id, int):
+            continue
 
         upstream_for_override = providers_by_db_id.get(upstream_provider_id)
         if upstream_for_override is None:

routstr/auth.py

@@ -20,11 +20,7 @@ from .payment.cost_calculation import (
     MaxCostData,
     calculate_cost,
 )
-from .wallet import (
-    classify_redemption_error,
-    credit_balance,
-    deserialize_token_from_string,
-)
+from .wallet import credit_balance, deserialize_token_from_string
 
 logger = get_logger(__name__)
 payments_logger = get_logger("routstr.payments")
@@ -82,37 +78,6 @@ async def check_and_reset_limit(key: ApiKey, session: AsyncSession) -> bool:
     return False
 
 
-def redemption_error_to_http_exception(error: Exception) -> HTTPException:
-    """Map a Cashu token redemption failure to a sanitized client-facing error.
-
-    Thin wrapper over the shared :func:`classify_redemption_error` so the bearer
-    path stays identical to the X-Cashu and top-up paths.
-    """
-    classified = classify_redemption_error(error)
-    if classified is None:
-        return HTTPException(
-            status_code=500,
-            detail={
-                "error": {
-                    "message": "Internal error during token redemption",
-                    "type": "api_error",
-                    "code": "internal_error",
-                }
-            },
-        )
-    error_type, status_code, message, error_code = classified
-    return HTTPException(
-        status_code=status_code,
-        detail={
-            "error": {
-                "message": message,
-                "type": error_type,
-                "code": error_code,
-            }
-        },
-    )
-
-
 async def validate_bearer_key(
     bearer_key: str,
     session: AsyncSession,
@@ -251,17 +216,7 @@ async def validate_bearer_key(
 
         try:
             hashed_key = hashlib.sha256(bearer_key.encode()).hexdigest()
-            try:
-                token_obj = deserialize_token_from_string(bearer_key)
-            except Exception as decode_error:
-                # A malformed token is a bad token (400 invalid_cashu_token via
-                # the shared taxonomy), not an auth failure (401) — otherwise it
-                # would fall through to the generic "Invalid API key" handler.
-                raise redemption_error_to_http_exception(
-                    ValueError(
-                        f"Invalid Cashu token: could not decode token ({decode_error})"
-                    )
-                ) from decode_error
+            token_obj = deserialize_token_from_string(bearer_key)
             logger.debug(
                 "Generated token hash", extra={"hash_preview": hashed_key[:16] + "..."}
             )
@@ -379,32 +334,19 @@ async def validate_bearer_key(
                         "error_type": type(credit_error).__name__,
                     },
                 )
-                await session.rollback()
-                raise redemption_error_to_http_exception(credit_error) from credit_error
+                raise credit_error
 
             if msats <= 0:
                 logger.error(
                     "Token redemption returned zero or negative amount",
                     extra={"msats": msats, "key_hash": hashed_key[:8] + "..."},
                 )
-                # Defense-in-depth: credit_balance already raises
-                # ValueError("Redeemed token amount must be positive…") before
-                # returning (wallet.py), so this branch is only reachable if a
-                # zero/negative row was somehow persisted; drop it so we never
-                # leave an orphan zero-balance key. Reuse the shared taxonomy
-                # (cashu_error) so the envelope matches the mapper above.
+                # Defense-in-depth: credit_balance now refuses to commit on a
+                # zero/negative redemption, but if a row was nonetheless
+                # persisted, drop it so we never leave an orphan zero-balance key.
                 await session.delete(new_key)
                 await session.commit()
-                raise HTTPException(
-                    status_code=400,
-                    detail={
-                        "error": {
-                            "message": "Failed to redeem Cashu token: token yielded no value",
-                            "type": "cashu_error",
-                            "code": "cashu_token_zero_value",
-                        }
-                    },
-                )
+                raise Exception("Token redemption failed")
 
             await session.refresh(new_key)
             await session.commit()
@@ -437,7 +379,7 @@ async def validate_bearer_key(
                 status_code=401,
                 detail={
                     "error": {
-                        "message": "Invalid or expired Cashu key",
+                        "message": f"Invalid or expired Cashu key: {str(e)}",
                         "type": "invalid_request_error",
                         "code": "invalid_api_key",
                     }

routstr/balance.py

@@ -15,21 +15,12 @@ from .core.db import (
     AsyncSession,
     CashuTransaction,
     get_session,
-)
-from .core.db import (
-    store_cashu_transaction_with_retry as store_cashu_transaction,
+    store_cashu_transaction,
 )
 from .core.logging import get_logger
 from .core.settings import settings
 from .lightning import lightning_router
-from .wallet import (
-    classify_redemption_error,
-    credit_balance,
-    is_mint_connection_error,
-    recieve_token,
-    send_to_lnurl,
-    send_token,
-)
+from .wallet import credit_balance, recieve_token, send_to_lnurl, send_token
 
 router = APIRouter()
 balance_router = APIRouter(prefix="/v1/balance")
@@ -165,18 +156,30 @@ async def topup_wallet_endpoint(
         raise HTTPException(status_code=400, detail="Invalid token format")
     try:
         amount_msats = await credit_balance(cashu_token, billing_key, session)
-    except Exception as e:
-        # Shared taxonomy so top-up matches the bearer/X-Cashu paths (503 for an
-        # unreachable mint, 422 for fee/swap failures, 400 for token faults).
-        classified = classify_redemption_error(e)
-        if classified is None:
-            logger.error(
-                "topup_wallet_endpoint: unhandled error",
-                extra={"error": str(e), "error_type": type(e).__name__},
+    except ValueError as e:
+        error_msg = str(e)
+        if "already spent" in error_msg.lower():
+            raise HTTPException(status_code=400, detail="Token already spent")
+        elif "invalid" in error_msg.lower() or "decode" in error_msg.lower():
+            raise HTTPException(status_code=400, detail="Invalid token format")
+        elif "insufficient" in error_msg.lower() or "melt fee" in error_msg.lower():
+            raise HTTPException(
+                status_code=400,
+                detail=f"Token value is too small to cover swap fees. {error_msg}",
             )
-            raise HTTPException(status_code=500, detail="Internal server error")
-        _type, status_code, message, _code = classified
-        raise HTTPException(status_code=status_code, detail=message)
+        elif "failed to melt" in error_msg.lower():
+            raise HTTPException(
+                status_code=400,
+                detail=f"Failed to swap foreign mint token. {error_msg}",
+            )
+        else:
+            raise HTTPException(status_code=400, detail=f"Failed to redeem token: {error_msg}")
+    except Exception as e:
+        logger.error(
+            "topup_wallet_endpoint: unhandled error",
+            extra={"error": str(e), "error_type": type(e).__name__},
+        )
+        raise HTTPException(status_code=500, detail="Internal server error")
     return {"msats": amount_msats}
 
 
@@ -256,11 +259,26 @@ async def refund_wallet_endpoint(
             )
         )
         in_tx = in_tx_result.first()
+        cashu_fingerprint = hashlib.sha256(x_cashu.encode()).hexdigest()[:16]
         if in_tx is None:
+            logger.info(
+                "refund_wallet_endpoint: x-cashu inbound transaction not found",
+                extra={"cashu_fingerprint": cashu_fingerprint},
+            )
             raise HTTPException(status_code=404, detail="Refund not found")
 
         # Use the request_id to find the associated "out" (refund) transaction
         if in_tx.request_id is None:
+            logger.info(
+                "refund_wallet_endpoint: x-cashu inbound transaction has no request_id",
+                extra={
+                    "cashu_fingerprint": cashu_fingerprint,
+                    "cashu_transaction_id": in_tx.id,
+                    "amount": in_tx.amount,
+                    "unit": in_tx.unit,
+                    "mint_url": in_tx.mint_url,
+                },
+            )
             raise HTTPException(status_code=404, detail="Refund not found")
 
         out_tx_result = await session.exec(
@@ -271,21 +289,33 @@ async def refund_wallet_endpoint(
         )
         out_tx = out_tx_result.first()
         if out_tx is None:
-            # The "in" row exists with a request_id, but the "out" (refund)
-            # row hasn't been written yet — the upstream request is still in
-            # flight and the refund will be minted once it completes. Tell the
-            # client to retry instead of 404ing permanently (race condition
-            # where /v1/wallet/refund is polled before the refund exists).
-            logger.debug(
-                "refund_wallet_endpoint: refund pending (in row exists, out row not yet created)",
-                extra={"request_id": in_tx.request_id},
+            logger.info(
+                "refund_wallet_endpoint: x-cashu refund transaction not ready",
+                extra={
+                    "cashu_fingerprint": cashu_fingerprint,
+                    "cashu_transaction_id": in_tx.id,
+                    "refund_request_id": in_tx.request_id,
+                    "amount": in_tx.amount,
+                    "unit": in_tx.unit,
+                    "mint_url": in_tx.mint_url,
+                    "age_seconds": max(0, int(time.time()) - in_tx.created_at),
+                },
             )
             raise HTTPException(
                 status_code=425,
-                detail="Refund is pending; retry shortly.",
-                headers={"Retry-After": "2"},
+                detail="Refund not ready. Retry later.",
+                headers={"Retry-After": "5"},
             )
         if out_tx.swept:
+            logger.info(
+                "refund_wallet_endpoint: x-cashu refund transaction already swept",
+                extra={
+                    "cashu_fingerprint": cashu_fingerprint,
+                    "cashu_transaction_id": in_tx.id,
+                    "refund_transaction_id": out_tx.id,
+                    "refund_request_id": in_tx.request_id,
+                },
+            )
             raise HTTPException(status_code=410, detail="Refund has been swept")
 
         out_tx.collected = True
@@ -451,10 +481,14 @@ async def refund_wallet_endpoint(
                 "has_refund_address": bool(key.refund_address),
             },
         )
-        if is_mint_connection_error(e):
-            raise HTTPException(status_code=503, detail="Mint service unavailable")
+        if (
+            "mint" in error_msg.lower()
+            or "connection" in error_msg.lower()
+            or "ConnectError" in str(type(e))
+        ):
+            raise HTTPException(status_code=503, detail=f"Mint service unavailable: {error_msg}")
         else:
-            raise HTTPException(status_code=500, detail="Refund failed")
+            raise HTTPException(status_code=500, detail=f"Refund failed: {error_msg}")
 
     await _refund_cache_set(bearer_value, result)
 

routstr/core/admin.py

@@ -29,9 +29,6 @@ from .db import (
     UpstreamProviderRow,
     create_session,
 )
-from .db import (
-    store_cashu_transaction_with_retry as store_cashu_transaction,
-)
 from .log_manager import log_manager
 from .logging import get_logger
 from .provider_slugs import allocate_unique_provider_slug
@@ -414,11 +411,12 @@ async def withdraw(
     # Get wallet and check balance
     from .settings import settings as global_settings
 
-    effective_mint = withdraw_request.mint_url or global_settings.primary_mint
-    wallet = await get_wallet(effective_mint, withdraw_request.unit)
+    wallet = await get_wallet(
+        withdraw_request.mint_url or global_settings.primary_mint, withdraw_request.unit
+    )
     proofs = get_proofs_per_mint_and_unit(
         wallet,
-        effective_mint,
+        withdraw_request.mint_url or global_settings.primary_mint,
         withdraw_request.unit,
         not_reserved=True,
     )
@@ -434,27 +432,8 @@ async def withdraw(
         raise HTTPException(status_code=400, detail="Insufficient wallet balance")
 
     token = await send_token(
-        withdraw_request.amount, withdraw_request.unit, effective_mint
+        withdraw_request.amount, withdraw_request.unit, withdraw_request.mint_url
     )
-    try:
-        await store_cashu_transaction(
-            token=token,
-            amount=withdraw_request.amount,
-            unit=withdraw_request.unit,
-            mint_url=effective_mint,
-            typ="out",
-            collected=False,
-            source="admin",
-        )
-    except Exception:
-        logger.critical(
-            "Admin withdrawal token issued without a persisted audit record",
-            extra={
-                "amount": withdraw_request.amount,
-                "unit": withdraw_request.unit,
-                "mint_url": effective_mint,
-            },
-        )
     return {"token": token}
 
 

routstr/core/db.py

@@ -1,5 +1,3 @@
-import asyncio
-import hashlib
 import os
 import pathlib
 import sqlite3
@@ -12,7 +10,7 @@ from alembic import command
 from alembic.config import Config
 from alembic.util.exc import CommandError
 from sqlalchemy import UniqueConstraint, delete
-from sqlalchemy.exc import IntegrityError, OperationalError
+from sqlalchemy.exc import OperationalError
 from sqlalchemy.ext.asyncio.engine import create_async_engine
 from sqlalchemy.orm import aliased
 from sqlmodel import Field, Relationship, SQLModel, col, func, select, update
@@ -289,13 +287,10 @@ async def store_cashu_transaction(
     created_at: int | None = None,
     source: str = "x-cashu",
     api_key_hashed_key: str | None = None,
-    transaction_id: str | None = None,
-    log_failure: bool = True,
-) -> bool:
+) -> None:
     try:
         async with create_session() as session:
             tx = CashuTransaction(
-                id=transaction_id or uuid.uuid4().hex,
                 token=token,
                 amount=amount,
                 unit=unit,
@@ -309,93 +304,11 @@ async def store_cashu_transaction(
             )
             session.add(tx)
             await session.commit()
-    except Exception:
-        if log_failure:
-            logger.critical(
-                "Failed to store Cashu transaction",
-                extra={"type": typ, "request_id": request_id, "source": source},
-                exc_info=True,
-            )
-        raise
-    return True
-
-
-async def _cashu_transaction_exists(transaction_id: str) -> bool:
-    async with create_session() as session:
-        return await session.get(CashuTransaction, transaction_id) is not None
-
-
-async def store_cashu_transaction_with_retry(
-    token: str,
-    amount: int,
-    unit: str,
-    mint_url: str | None = None,
-    typ: str = "out",
-    request_id: str | None = None,
-    collected: bool = False,
-    created_at: int | None = None,
-    source: str = "x-cashu",
-    api_key_hashed_key: str | None = None,
-    max_attempts: int = 3,
-) -> bool:
-    """Retry a critical Cashu transaction write with bounded backoff."""
-    transaction_id = hashlib.sha256(f"{typ}\0{token}".encode()).hexdigest()
-    last_error: Exception | None = None
-    for attempt in range(1, max_attempts + 1):
-        try:
-            return await store_cashu_transaction(
-                token=token,
-                amount=amount,
-                unit=unit,
-                mint_url=mint_url,
-                typ=typ,
-                request_id=request_id,
-                collected=collected,
-                created_at=created_at,
-                source=source,
-                api_key_hashed_key=api_key_hashed_key,
-                transaction_id=transaction_id,
-                log_failure=False,
-            )
-        except IntegrityError as error:
-            try:
-                if await _cashu_transaction_exists(transaction_id):
-                    return True
-            except Exception as lookup_error:
-                last_error = lookup_error
-            else:
-                last_error = error
-        except Exception as error:
-            last_error = error
-
-        if last_error is not None:
-            if attempt == max_attempts:
-                break
-            delay = 0.25 * (2 ** (attempt - 1))
-            logger.warning(
-                "Cashu transaction storage failed; retrying",
-                extra={
-                    "type": typ,
-                    "request_id": request_id,
-                    "attempt": attempt,
-                    "max_attempts": max_attempts,
-                    "retry_delay_seconds": delay,
-                },
-            )
-            await asyncio.sleep(delay)
-
-    logger.critical(
-        "Cashu transaction storage failed after bounded retries",
-        extra={
-            "type": typ,
-            "request_id": request_id,
-            "attempts": max_attempts,
-            "error": str(last_error),
-        },
-    )
-    if last_error is None:
-        raise RuntimeError("Cashu transaction storage failed without an exception")
-    raise last_error
+    except Exception as e:
+        logger.warning(
+            f"Failed to store cashu transaction: {e} (type={typ})",
+            extra={"error": str(e), "type": typ},
+        )
 
 
 class UpstreamProviderRow(SQLModel, table=True):  # type: ignore

routstr/core/main.py

@@ -257,20 +257,7 @@ app.add_middleware(
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
-    expose_headers=[
-        "x-routstr-request-id",
-        "x-cashu",
-        "x-routstr-cost-msats",
-        "x-routstr-cost-usd",
-        "x-routstr-input-cost-msats",
-        "x-routstr-output-cost-msats",
-        # EHBP (Tinfoil) protocol headers must be exposed so browser clients
-        # can detect and decrypt encrypted responses. Without these, the
-        # browser hides them via CORS and the SDK treats the response as a
-        # plaintext proxy error, returning raw ciphertext.
-        "Ehbp-Response-Nonce",
-        "Ehbp-Encapsulated-Key",
-    ],
+    expose_headers=["x-routstr-request-id", "x-cashu"],
 )
 
 # Add logging middleware

routstr/payment/cost_calculation.py

@@ -157,16 +157,11 @@ async def calculate_cost(
                 },
             )
         try:
-            cost_details = usage_data.get("cost_details", {})
-            if not isinstance(cost_details, dict):
-                cost_details = {}
             input_usd = _coerce_usd(
-                cost_details.get("input_cost")
-                or cost_details.get("upstream_inference_prompt_cost")
+                usage_data.get("cost_details", {}).get("input_cost", 0)
             )
             output_usd = _coerce_usd(
-                cost_details.get("output_cost")
-                or cost_details.get("upstream_inference_completions_cost")
+                usage_data.get("cost_details", {}).get("output_cost", 0)
             )
             return _calculate_from_usd_cost(
                 usd_cost,
@@ -264,17 +259,7 @@ def _coerce_usd(value: object) -> float:
 def _resolve_usd_cost(usage_data: dict, response_data: dict) -> float:
     """Resolve USD cost with clear priority order.
 
-    Priority:
-
-    1. ``cost_details.total_cost``
-    2. ``cost_details.upstream_inference_cost`` (BYOK — see below)
-    3. ``total_cost`` → ``cost`` (in both usage and response)
-
-    **BYOK path (PPQ.AI):** when ``is_byok`` is true the ``usage.cost`` field
-    is only a small (~5 %) routing fee, not the inference cost.  The real cost
-    lives in ``cost_details.upstream_inference_cost`` and the provider's
-    balance is debited by ``upstream_inference_cost + byok_fee``.  Billing just
-    the fee under-charges by ~20×.
+    Priority: cost_details.total_cost → total_cost → cost (in both usage and response).
     """
     cost_details = usage_data.get("cost_details")
     if isinstance(cost_details, dict):
@@ -282,18 +267,6 @@ def _resolve_usd_cost(usage_data: dict, response_data: dict) -> float:
         if cost > 0:
             return cost
 
-        # PPQ.AI BYOK: upstream_inference_cost is the real inference cost;
-        # usage.cost is only a ~5 % BYOK routing fee.  Bill the sum — what PPQ
-        # actually deducts from the balance.  For non-BYOK providers (e.g.
-        # OpenRouter) usage.cost already equals upstream_inference_cost, so we
-        # fall through to the normal ``cost`` lookup below.
-        upstream_cost = _coerce_usd(
-            cost_details.get("upstream_inference_cost")
-        )
-        if upstream_cost > 0 and usage_data.get("is_byok"):
-            byok_fee = _coerce_usd(usage_data.get("cost"))
-            return upstream_cost + byok_fee
-
     for source in [usage_data, response_data]:
         if not isinstance(source, dict):
             continue
@@ -308,92 +281,54 @@ def _resolve_usd_cost(usage_data: dict, response_data: dict) -> float:
 def _get_pricing_rates(
     response_data: dict,
 ) -> tuple[float, float, float, float] | None:
-    """Get configured rates, falling back to LiteLLM's model cost map.
+    """Get model-based pricing rates or None if using fixed pricing.
 
-    Returns: (input_rate, output_rate, cache_read_rate, cache_write_rate).
-    ``None`` means configured fixed pricing should be used by the caller.
+    Returns: (input_rate, output_rate, cache_read_rate, cache_write_rate)
     """
-    if settings.fixed_pricing and (
-        settings.fixed_per_1k_input_tokens
-        or settings.fixed_per_1k_output_tokens
-    ):
+    if settings.fixed_pricing:
         return None
 
     from ..proxy import get_model_instance
-    from .models import litellm_cost_entry
 
     response_model = response_data.get("model", "")
     model_obj = get_model_instance(response_model)
 
-    if model_obj and model_obj.sats_pricing:
-        try:
-            mspp = float(model_obj.sats_pricing.prompt)
-            mspc = float(model_obj.sats_pricing.completion)
-            mscr = float(model_obj.sats_pricing.input_cache_read or 0)
-            mscw = float(model_obj.sats_pricing.input_cache_write or 0)
+    if not model_obj:
+        logger.error("Invalid model in response", extra={"response_model": response_model})
+        raise ValueError(f"Invalid model: {response_model}")
 
-            mspp_1k = mspp * 1_000_000.0
-            mspc_1k = mspc * 1_000_000.0
-            mscr_1k = mscr * 1_000_000.0 if mscr > 0 else mspp_1k
-            mscw_1k = mscw * 1_000_000.0 if mscw > 0 else mspp_1k
-            source = "configured"
-        except Exception as e:
-            logger.error("Invalid pricing data", extra={"error": str(e)})
-            raise ValueError("Invalid pricing data") from e
-    else:
-        pricing_model = (
-            model_obj.forwarded_model_id if model_obj else None
-        ) or response_model
-        pricing = litellm_cost_entry(pricing_model)
-        if pricing is None:
-            logger.error(
-                "Model pricing not found in configured models or LiteLLM",
-                extra={
-                    "response_model": response_model,
-                    "pricing_model": pricing_model,
-                },
-            )
-            raise ValueError(f"Pricing not found for model: {response_model}")
+    if not model_obj.sats_pricing:
+        logger.error(
+            "Model pricing not defined",
+            extra={"model": response_model, "model_id": response_model},
+        )
+        raise ValueError("Model pricing not defined")
 
-        input_usd = _coerce_usd(pricing.get("input_cost_per_token"))
-        output_usd = _coerce_usd(pricing.get("output_cost_per_token"))
-        if input_usd <= 0 or output_usd <= 0:
-            raise ValueError(f"Incomplete LiteLLM pricing for model: {pricing_model}")
+    try:
+        mspp = float(model_obj.sats_pricing.prompt)
+        mspc = float(model_obj.sats_pricing.completion)
+        mscr = float(model_obj.sats_pricing.input_cache_read or 0)
+        mscw = float(model_obj.sats_pricing.input_cache_write or 0)
 
-        provider_fee = _resolve_provider_fee(response_model)
-        usd_per_sat = sats_usd_price()
-        mspp_1k = input_usd * provider_fee * 1_000_000.0 / usd_per_sat
-        mspc_1k = output_usd * provider_fee * 1_000_000.0 / usd_per_sat
-        cache_read_usd = _coerce_usd(
-            pricing.get("cache_read_input_token_cost")
-        )
-        cache_write_usd = _coerce_usd(
-            pricing.get("cache_creation_input_token_cost")
-        )
-        mscr_1k = (
-            cache_read_usd * provider_fee * 1_000_000.0 / usd_per_sat
-            if cache_read_usd > 0
-            else mspp_1k
-        )
-        mscw_1k = (
-            cache_write_usd * provider_fee * 1_000_000.0 / usd_per_sat
-            if cache_write_usd > 0
-            else mspp_1k
-        )
-        source = "litellm"
+        mspp_1k = mspp * 1_000_000.0
+        mspc_1k = mspc * 1_000_000.0
+        mscr_1k = mscr * 1_000_000.0 if mscr > 0 else mspp_1k
+        mscw_1k = mscw * 1_000_000.0 if mscw > 0 else mspp_1k
 
-    logger.info(
-        "Applied model-specific pricing",
-        extra={
-            "model": response_model,
-            "pricing_source": source,
-            "input_price_msats_per_1k": mspp_1k,
-            "output_price_msats_per_1k": mspc_1k,
-            "cache_read_price_msats_per_1k": mscr_1k,
-            "cache_write_price_msats_per_1k": mscw_1k,
-        },
-    )
-    return mspp_1k, mspc_1k, mscr_1k, mscw_1k
+        logger.info(
+            "Applied model-specific pricing",
+            extra={
+                "model": response_model,
+                "input_price_msats_per_1k": mspp_1k,
+                "output_price_msats_per_1k": mspc_1k,
+                "cache_read_price_msats_per_1k": mscr_1k,
+                "cache_write_price_msats_per_1k": mscw_1k,
+            },
+        )
+        return mspp_1k, mspc_1k, mscr_1k, mscw_1k
+    except Exception as e:
+        logger.error("Invalid pricing data", extra={"error": str(e)})
+        raise ValueError("Invalid pricing data") from e
 
 
 def _resolve_provider_fee(model_id: str) -> float:
@@ -432,12 +367,8 @@ def _calculate_from_usd_cost(
     cost_in_msats = math.ceil(cost_in_sats * 1000)
 
     if input_usd > 0 or output_usd > 0:
-        # The total is the authoritative billed amount. Allocating that integer
-        # total proportionally avoids losing sub-millisatoshi remainders when
-        # input and output components are each truncated independently.
-        component_usd = input_usd + output_usd
-        input_msats = math.floor(cost_in_msats * input_usd / component_usd)
-        output_msats = cost_in_msats - input_msats
+        input_msats = int((input_usd * sats_per_usd) * 1000)
+        output_msats = int((output_usd * sats_per_usd) * 1000)
     else:
         effective_input_tokens = (
             input_tokens + cache_read_tokens + cache_creation_tokens

routstr/payment/lnurl.py

@@ -1,17 +1,11 @@
 from __future__ import annotations
 
-import asyncio
 import math
 from typing import TypedDict
 
 import httpx
 from cashu.wallet.wallet import Proof, Wallet
 
-# The Cashu library issues POST /v1/melt/bolt11 with timeout=None, so a hung or
-# very slow mint can block a melt (and any caller, e.g. the payout loop)
-# indefinitely. Bound it here so callers fail instead of hanging forever.
-MELT_TIMEOUT_SECONDS = 60
-
 try:
     from bech32 import bech32_decode, convertbits  # type: ignore
 except ModuleNotFoundError:  # pragma: no cover – allow runtime miss
@@ -226,18 +220,10 @@ async def raw_send_to_lnurl(
     if amount:
         proofs, _ = await wallet.select_to_send(proofs, amount, set_reserved=True)
 
-    try:
-        _ = await asyncio.wait_for(
-            wallet.melt(
-                proofs=proofs,
-                invoice=bolt11_invoice,
-                fee_reserve_sat=melt_quote_resp.fee_reserve,
-                quote_id=melt_quote_resp.quote,
-            ),
-            timeout=MELT_TIMEOUT_SECONDS,
-        )
-    except asyncio.TimeoutError as e:
-        raise LNURLError(
-            f"Melt timed out after {MELT_TIMEOUT_SECONDS}s (mint unresponsive)"
-        ) from e
+    _ = await wallet.melt(
+        proofs=proofs,
+        invoice=bolt11_invoice,
+        fee_reserve_sat=melt_quote_resp.fee_reserve,
+        quote_id=melt_quote_resp.quote,
+    )
     return final_amount

routstr/proxy.py

@@ -29,7 +29,6 @@ from .payment.helpers import (
 )
 from .payment.models import Model
 from .upstream import BaseUpstreamProvider
-from .upstream.ehbp import forward_ehbp_request, forward_ehbp_x_cashu_request
 from .upstream.helpers import init_upstreams
 from .upstream.request_correction import correct_request, extract_error_message
 
@@ -105,34 +104,6 @@ def get_unique_models() -> list[Model]:
     return list(_unique_models.values())
 
 
-def _is_tinfoil_attestation_path(path: str) -> bool:
-    """Return True for exact Tinfoil attestation routes, with optional slash."""
-    return path in {
-        "attestation",
-        "attestation/",
-        "tee/attestation",
-        "tee/attestation/",
-    }
-
-
-def _select_unauthenticated_get_upstreams(
-    path: str, upstreams: list[BaseUpstreamProvider]
-) -> list[BaseUpstreamProvider]:
-    """Select upstream candidates for unauthenticated GET bypass paths.
-
-    Tinfoil attestation endpoints are provider-specific. Trying every enabled
-    upstream can return an unrelated provider's 404 before Tinfoil is reached,
-    so route those paths only to Tinfoil providers.
-    """
-    if _is_tinfoil_attestation_path(path):
-        return [
-            upstream
-            for upstream in upstreams
-            if getattr(upstream, "provider_type", None) == "tinfoil"
-        ]
-    return upstreams
-
-
 async def refresh_model_maps() -> None:
     """Refresh global model and provider maps using the cost-based algorithm."""
     from sqlalchemy.orm import selectinload
@@ -147,23 +118,22 @@ async def refresh_model_maps() -> None:
         result = await session.exec(query)
         provider_rows = result.all()
 
-    overrides_by_key: dict[tuple[str, int], tuple[ModelRow, float]] = {}
-    disabled_model_keys: set[tuple[str, int]] = set()
+    overrides_by_id: dict[str, tuple[ModelRow, float]] = {}
+    disabled_model_ids: set[str] = set()
 
     for provider in provider_rows:
         if not provider.enabled:
             continue
         for model in provider.models:
-            model_key = (model.id.lower(), model.upstream_provider_id)
             if model.enabled:
-                overrides_by_key[model_key] = (model, provider.provider_fee)
+                overrides_by_id[model.id] = (model, provider.provider_fee)
             else:
-                disabled_model_keys.add(model_key)
+                disabled_model_ids.add(model.id)
 
     _model_instances, _provider_map, _unique_models = create_model_mappings(
         upstreams=_upstreams,
-        overrides_by_key=overrides_by_key,
-        disabled_model_keys=disabled_model_keys,
+        overrides_by_id=overrides_by_id,
+        disabled_model_ids=disabled_model_ids,
     )
 
 
@@ -196,7 +166,6 @@ _API_PATH_PREFIXES = (
     "moderations",
     "providers",
     "tee/",
-    "attestation",
 )
 
 
@@ -215,54 +184,20 @@ async def proxy(
 
     is_responses_api = path.startswith("v1/responses") or path.startswith("responses")
     request_body = await request.body()
+    request_body_dict = parse_request_body_json(request_body, path)
 
-    # EHBP (Encrypted HTTP Body Protocol) requests carry an Ehbp-Encapsulated-Key
-    # header and a binary HPKE-sealed body. The proxy cannot parse the body to
-    # extract the model id, so the SDK sends it in X-Routstr-Model. Forward the
-    # raw encrypted body to the upstream's /private/ endpoint and stream the
-    # encrypted response back untouched — the SDK's SecureClient decrypts it.
-    is_ehbp = "ehbp-encapsulated-key" in headers
-    if is_ehbp:
-        request_body_dict = {}
-        model_id = headers.get("x-routstr-model", "")
-        if not model_id:
-            return create_error_response(
-                "invalid_request",
-                "EHBP request missing X-Routstr-Model header",
-                400,
-                request=request,
-            )
-    else:
-        request_body_dict = parse_request_body_json(request_body, path)
-        if is_responses_api:
-            model_id = extract_model_from_responses_request(request_body_dict)
-        else:
-            model_id = request_body_dict.get("model", "unknown")
-
-    # Exact Tinfoil attestation GET routes don't map to models — forward
-    # without model/cost/auth lookups. Do not prefix-match here: paths such as
-    # /attestationjunk must continue through normal authentication.
-    if request.method == "GET" and _is_tinfoil_attestation_path(path):
-        selected_upstreams = _select_unauthenticated_get_upstreams(path, _upstreams)
-        if not selected_upstreams:
-            return create_error_response(
-                "upstream_error",
-                "No upstream available for unauthenticated GET path",
-                502,
-                request=request,
-            )
-
+    # /tee/* GET requests (e.g. attestation) don't map to models — just
+    # forward to all enabled upstreams without model/cost/auth lookups.
+    if request.method == "GET" and path.startswith("tee/"):
+        all_upstreams = _upstreams
         last_error_response = None
-        for i, upstream in enumerate(selected_upstreams):
+        for i, upstream in enumerate(all_upstreams):
             try:
                 headers = upstream.prepare_headers(dict(request.headers))
                 response = await upstream.forward_get_request(request, path, headers)
-                if (
-                    response.status_code in [502, 429]
-                    and i < len(selected_upstreams) - 1
-                ):
+                if response.status_code in [502, 429] and i < len(all_upstreams) - 1:
                     logger.warning(
-                        "Upstream %s returned %s for unauthenticated GET %s, trying next",
+                        "Upstream %s returned %s for tee GET %s, trying next",
                         upstream.provider_type,
                         response.status_code,
                         path,
@@ -271,18 +206,23 @@ async def proxy(
                 return response
             except UpstreamError as e:
                 logger.warning(
-                    "Upstream %s failed for unauthenticated GET %s: %s",
+                    "Upstream %s failed for tee GET %s: %s",
                     upstream.provider_type,
                     path,
                     e,
                 )
-                if i == len(selected_upstreams) - 1:
+                if i == len(all_upstreams) - 1:
                     last_error_response = create_upstream_error_response(e, request)
                 continue
         return last_error_response or create_error_response(
             "upstream_error", "All upstreams failed", 502, request=request
         )
 
+    if is_responses_api:
+        model_id = extract_model_from_responses_request(request_body_dict)
+    else:
+        model_id = request_body_dict.get("model", "unknown")
+
     model_obj = get_model_instance(model_id)
 
     if not model_obj:
@@ -299,16 +239,6 @@ async def proxy(
             request=request,
         )
 
-    if is_ehbp:
-        upstreams = [upstream for upstream in upstreams if upstream.supports_ehbp]
-        if not upstreams:
-            return create_error_response(
-                "unsupported_request",
-                f"No EHBP-capable provider found for model '{model_id}'",
-                400,
-                request=request,
-            )
-
     # todo figure out cost calculation since fallback provider is usually not the same price
     # Use first provider for initial checks/cost calculation
     # primary_upstream = upstreams[0]
@@ -328,23 +258,7 @@ async def proxy(
         last_error = None
         for i, upstream in enumerate(upstreams):
             try:
-                if is_ehbp:
-                    if not upstream.supports_ehbp:
-                        logger.warning(
-                            "Upstream %s does not support EHBP for model=%s",
-                            upstream.provider_type,
-                            model_id,
-                        )
-                        continue
-                    return await forward_ehbp_x_cashu_request(
-                        request=request,
-                        x_cashu_token=x_cashu,
-                        path=path,
-                        max_cost_for_model=max_cost_for_model,
-                        model_obj=model_obj,
-                        upstream=upstream,
-                    )
-                elif is_responses_api:
+                if is_responses_api:
                     return await upstream.handle_x_cashu_responses(
                         request, x_cashu, path, max_cost_for_model, model_obj
                     )
@@ -433,7 +347,7 @@ async def proxy(
             "upstream_error", "All upstreams failed", 502, request=request
         )
 
-    if is_ehbp or request_body_dict:
+    if request_body_dict:
         await pay_for_request(key, max_cost_for_model, session)
 
     # Tracks request params already removed in response to upstream rejections,
@@ -447,29 +361,7 @@ async def proxy(
         try:
             while True:
                 try:
-                    if is_ehbp:
-                        if not upstream.supports_ehbp:
-                            logger.warning(
-                                "Upstream %s does not support EHBP for model=%s",
-                                upstream.provider_type,
-                                model_id,
-                            )
-                            raise UpstreamError(
-                                f"Provider {upstream.provider_type} does not support EHBP",
-                                status_code=400,
-                            )
-                        response = await forward_ehbp_request(
-                            request=request,
-                            path=path,
-                            headers=headers,
-                            request_body=request_body,
-                            upstream=upstream,
-                            key=key,
-                            max_cost_for_model=max_cost_for_model,
-                            session=session,
-                            model_obj=model_obj,
-                        )
-                    elif is_responses_api:
+                    if is_responses_api:
                         response = await upstream.forward_responses_request(
                             request,
                             path,
@@ -514,7 +406,7 @@ async def proxy(
                 # When the upstream 400s naming such a param, strip it from the
                 # body and retry the SAME upstream. ``already_stripped`` bounds
                 # this to one retry per distinct param so it always terminates.
-                if response.status_code == 400 and not is_ehbp:
+                if response.status_code == 400:
                     correction = correct_request(
                         request_body,
                         extract_error_message(response),

routstr/upstream/__init__.py

@@ -11,7 +11,6 @@ from .openrouter import OpenRouterUpstreamProvider
 from .perplexity import PerplexityUpstreamProvider
 from .ppqai import PPQAIUpstreamProvider
 from .routstr import RoutstrUpstreamProvider
-from .tinfoil import TinfoilUpstreamProvider
 from .xai import XAIUpstreamProvider
 
 upstream_provider_classes: list[type[BaseUpstreamProvider]] = [
@@ -27,7 +26,6 @@ upstream_provider_classes: list[type[BaseUpstreamProvider]] = [
     PerplexityUpstreamProvider,
     PPQAIUpstreamProvider,
     RoutstrUpstreamProvider,
-    TinfoilUpstreamProvider,
     XAIUpstreamProvider,
 ]
 """List of all upstream classes"""

routstr/upstream/auto_topup.py

@@ -4,14 +4,7 @@ import json
 from sqlmodel import select
 
 from ..core import get_logger
-from ..core.db import (
-    CashuTransaction,
-    UpstreamProviderRow,
-    create_session,
-)
-from ..core.db import (
-    store_cashu_transaction_with_retry as store_cashu_transaction,
-)
+from ..core.db import UpstreamProviderRow, create_session
 from ..wallet import send_token
 from .routstr import RoutstrUpstreamProvider
 
@@ -130,6 +123,7 @@ async def _check_and_topup(row: UpstreamProviderRow) -> None:
         },
     )
 
+    print(amount, mint_url)
     try:
         token = await send_token(amount, "sat", mint_url)
     except Exception as e:
@@ -144,23 +138,6 @@ async def _check_and_topup(row: UpstreamProviderRow) -> None:
         )
         return
 
-    try:
-        await store_cashu_transaction(
-            token=token,
-            amount=amount,
-            unit="sat",
-            mint_url=mint_url,
-            typ="out",
-            collected=False,
-            source="auto_topup",
-        )
-    except Exception:
-        logger.critical(
-            "Aborting auto top-up because its cashu token could not be persisted",
-            extra={"provider_id": row.id, "mint_url": mint_url},
-        )
-        return
-
     result = await provider.topup(token)
 
     if "error" in result:
@@ -172,26 +149,6 @@ async def _check_and_topup(row: UpstreamProviderRow) -> None:
             },
         )
     else:
-        async with create_session() as session:
-            transaction = (
-                await session.exec(
-                    select(CashuTransaction).where(
-                        CashuTransaction.token == token,
-                        CashuTransaction.type == "out",
-                        CashuTransaction.source == "auto_topup",
-                    )
-                )
-            ).first()
-            if transaction is None:
-                logger.critical(
-                    "Completed auto top-up transaction is missing from the database",
-                    extra={"provider_id": row.id, "mint_url": mint_url},
-                )
-            else:
-                transaction.collected = True
-                session.add(transaction)
-                await session.commit()
-
         logger.info(
             "Auto top-up completed successfully",
             extra={

routstr/upstream/base.py

@@ -4,7 +4,6 @@ import asyncio
 import json
 import math
 import traceback
-import typing
 import uuid
 from collections.abc import AsyncGenerator, AsyncIterator, Iterator
 from typing import Any, Mapping, Self, cast
@@ -21,9 +20,7 @@ from ..core.db import (
     AsyncSession,
     UpstreamProviderRow,
     create_session,
-)
-from ..core.db import (
-    store_cashu_transaction_with_retry as store_cashu_transaction,
+    store_cashu_transaction,
 )
 from ..core.exceptions import UpstreamError
 from ..core.redaction import redact_org_ids
@@ -43,12 +40,7 @@ from ..payment.models import (
     list_models,
 )
 from ..payment.price import sats_usd_price
-from ..wallet import (
-    SPENT_TOKEN_CODES,
-    classify_redemption_error,
-    recieve_token,
-    send_token,
-)
+from ..wallet import recieve_token, send_token
 from . import messages_dispatch
 from .cache_breakpoints import (
     inject_anthropic_cache_breakpoints,
@@ -58,9 +50,6 @@ from .count_tokens import count_tokens_locally
 from .litellm_routing import detect_litellm_prefix
 from .rate_limit import UPSTREAM_RATE_LIMIT, classify_rate_limit
 
-if typing.TYPE_CHECKING:
-    from .ehbp import ConfidentialInferenceProfile, EHBPForwardingTarget
-
 logger = get_logger(__name__)
 
 
@@ -2851,26 +2840,6 @@ class BaseUpstreamProvider:
             # Don't revert here — proxy.py owns payment revert to avoid double-revert
             raise UpstreamError("An unexpected server error occurred", status_code=500)
 
-    supports_ehbp: bool = False
-
-    def get_confidential_inference_profile(self) -> "ConfidentialInferenceProfile | None":
-        """Return provider policy for encrypted/confidential inference forwarding."""
-        return None
-
-    def get_ehbp_forwarding_target(
-        self, path: str, model_obj: Model
-    ) -> "EHBPForwardingTarget":
-        """Return the EHBP forwarding target for this provider.
-
-        Providers must explicitly opt in by setting ``supports_ehbp = True``
-        and overriding this method. Most upstreams do not accept EHBP-encrypted
-        request bodies, so the base provider intentionally does not provide a
-        default endpoint.
-        """
-        raise NotImplementedError(
-            f"Provider {self.provider_type} does not support EHBP forwarding"
-        )
-
     async def forward_responses_request(
         self,
         request: Request,
@@ -4012,19 +3981,9 @@ class BaseUpstreamProvider:
             },
         )
 
-        redeemed = False
         try:
             headers = dict(request.headers)
             amount, unit, mint = await recieve_token(x_cashu_token)
-            # Reject a zero/negative redemption (empty/dust token, or a value
-            # fully consumed by fees) before marking the token redeemed, so it
-            # classifies as cashu_token_zero_value like the bearer/top-up paths
-            # rather than being forwarded as a free request.
-            if amount <= 0:
-                raise ValueError(
-                    f"Redeemed token amount must be positive, got {amount} {unit}"
-                )
-            redeemed = True
             headers = self.prepare_headers(dict(request.headers))
 
             request_id = getattr(request.state, "request_id", None)
@@ -4068,37 +4027,40 @@ class BaseUpstreamProvider:
                 },
             )
 
-            # Post-redemption the token is spent; a forwarding failure must not
-            # be reported as a retryable redemption error (see handle_x_cashu).
-            if redeemed:
+            # Use same error handling as regular X-Cashu
+            if "already spent" in error_message.lower():
                 return create_error_response(
-                    "upstream_error",
-                    "Payment succeeded but the upstream request failed",
-                    502,
+                    "token_already_spent",
+                    "The provided CASHU token has already been spent",
+                    400,
                     request=request,
-                    code="upstream_request_failed",
+                    token=x_cashu_token,
                 )
 
-            classified = classify_redemption_error(e)
-            if classified is None:
+            if "invalid token" in error_message.lower():
                 return create_error_response(
-                    "api_error",
-                    "Internal error during token redemption",
-                    500,
+                    "invalid_token",
+                    "The provided CASHU token is invalid",
+                    400,
                     request=request,
-                    code="internal_error",
+                    token=x_cashu_token,
                 )
-            error_type, status_code, message, error_code = classified
-            # Echo the token back only when it is still spendable, so clients
-            # can recover it; a spent/consumed token is never re-offered.
-            echo_token = None if error_code in SPENT_TOKEN_CODES else x_cashu_token
+
+            if "mint error" in error_message.lower():
+                return create_error_response(
+                    "mint_error",
+                    f"CASHU mint error: {error_message}",
+                    422,
+                    request=request,
+                    token=x_cashu_token,
+                )
+
             return create_error_response(
-                error_type,
-                message,
-                status_code,
+                "cashu_error",
+                f"CASHU token processing failed: {error_message}",
+                400,
                 request=request,
-                token=echo_token,
-                code=error_code,
+                token=x_cashu_token,
             )
 
     async def forward_x_cashu_responses_request(
@@ -4688,19 +4650,9 @@ class BaseUpstreamProvider:
             },
         )
 
-        redeemed = False
         try:
             headers = dict(request.headers)
             amount, unit, mint = await recieve_token(x_cashu_token)
-            # Reject a zero/negative redemption (empty/dust token, or a value
-            # fully consumed by fees) before marking the token redeemed, so it
-            # classifies as cashu_token_zero_value like the bearer/top-up paths
-            # rather than being forwarded as a free request.
-            if amount <= 0:
-                raise ValueError(
-                    f"Redeemed token amount must be positive, got {amount} {unit}"
-                )
-            redeemed = True
             headers = self.prepare_headers(dict(request.headers))
 
             request_id = getattr(request.state, "request_id", None)
@@ -4744,38 +4696,39 @@ class BaseUpstreamProvider:
                 },
             )
 
-            # Once redeemed the token is spent, so a later forwarding failure
-            # must not surface as a retryable mint_unreachable (spent-token retry
-            # bait). Redemption classification only applies while not redeemed.
-            if redeemed:
+            if "already spent" in error_message.lower():
                 return create_error_response(
-                    "upstream_error",
-                    "Payment succeeded but the upstream request failed",
-                    502,
+                    "token_already_spent",
+                    "The provided CASHU token has already been spent",
+                    400,
                     request=request,
-                    code="upstream_request_failed",
+                    token=x_cashu_token,
                 )
 
-            classified = classify_redemption_error(e)
-            if classified is None:
+            if "invalid token" in error_message.lower():
                 return create_error_response(
-                    "api_error",
-                    "Internal error during token redemption",
-                    500,
+                    "invalid_token",
+                    "The provided CASHU token is invalid",
+                    400,
                     request=request,
-                    code="internal_error",
+                    token=x_cashu_token,
                 )
-            error_type, status_code, message, error_code = classified
-            # Echo the token back only when it is still spendable, so clients
-            # can recover it; a spent/consumed token is never re-offered.
-            echo_token = None if error_code in SPENT_TOKEN_CODES else x_cashu_token
+
+            if "mint error" in error_message.lower():
+                return create_error_response(
+                    "mint_error",
+                    f"CASHU mint error: {error_message}",
+                    422,
+                    request=request,
+                    token=x_cashu_token,
+                )
+
             return create_error_response(
-                error_type,
-                message,
-                status_code,
+                "cashu_error",
+                f"CASHU token processing failed: {error_message}",
+                400,
                 request=request,
-                token=echo_token,
-                code=error_code,
+                token=x_cashu_token,
             )
 
     def _apply_provider_fee_to_model(self, model: Model) -> Model:

routstr/upstream/helpers.py

@@ -94,10 +94,12 @@ async def get_all_models_with_overrides(
         provider_result = await session.exec(select(UpstreamProviderRow))
         providers_by_id = {p.id: p for p in provider_result.all()}
 
-        overrides_by_key: dict[tuple[str, int], tuple[ModelRow, float]] = {
-            (row.id.lower(), row.upstream_provider_id): (
+        overrides_by_id: dict[str, tuple[ModelRow, float]] = {
+            row.id: (
                 row,
-                providers_by_id[row.upstream_provider_id].provider_fee,
+                providers_by_id[row.upstream_provider_id].provider_fee
+                if row.upstream_provider_id in providers_by_id
+                else 1.01,
             )
             for row in override_rows
             if row.upstream_provider_id is not None
@@ -105,28 +107,17 @@ async def get_all_models_with_overrides(
             and providers_by_id[row.upstream_provider_id].enabled
         }
 
-    all_models: dict[tuple[str, str], Model] = {}
+    all_models: dict[str, Model] = {}
 
     for upstream in upstreams:
-        upstream_db_id = getattr(upstream, "db_id", None)
-        provider_key = (
-            f"db:{upstream_db_id}"
-            if isinstance(upstream_db_id, int)
-            else f"{getattr(upstream, 'provider_type', '')}|{getattr(upstream, 'base_url', '')}"
-        )
         for model in upstream.get_cached_models():
-            model_key = (
-                (model.id.lower(), upstream_db_id)
-                if isinstance(upstream_db_id, int)
-                else None
-            )
-            if model_key is not None and model_key in overrides_by_key:
-                override_row, provider_fee = overrides_by_key[model_key]
-                all_models[(model.id.lower(), provider_key)] = _row_to_model(
+            if model.id in overrides_by_id:
+                override_row, provider_fee = overrides_by_id[model.id]
+                all_models[model.id] = _row_to_model(
                     override_row, apply_provider_fee=True, provider_fee=provider_fee
                 )
             elif model.enabled:
-                all_models[(model.id.lower(), provider_key)] = model
+                all_models[model.id] = model
 
     return list(all_models.values())
 
@@ -272,7 +263,6 @@ async def _seed_providers_from_settings(
         ("PERPLEXITY_API_KEY", "perplexity", None, None),
         ("FIREWORKS_API_KEY", "fireworks", None, None),
         ("XAI_API_KEY", "xai", None, None),
-        ("TINFOIL_API_KEY", "tinfoil", None, None),
     ]
 
     for env_key, provider_type, _, _ in env_mappings:

routstr/upstream/openrouter.py

@@ -1,3 +1,4 @@
+import json
 from typing import TYPE_CHECKING
 
 import httpx
@@ -18,6 +19,38 @@ class OpenRouterUpstreamProvider(BaseUpstreamProvider):
     supports_anthropic_messages = True
     litellm_provider_prefix = "openrouter/"
 
+    def prepare_request_body(
+        self, body: bytes | None, model_obj: Model
+    ) -> bytes | None:
+        """Set provider.require_parameters on tool-use requests.
+
+        Without it OpenRouter can route a tool call to an endpoint that doesn't
+        support function calling and 404 with "No endpoints found that support
+        tool use". We leave a client-supplied value untouched.
+        """
+        body = super().prepare_request_body(body, model_obj)
+        if not body:
+            return body
+
+        try:
+            data = json.loads(body)
+        except json.JSONDecodeError:
+            return body
+
+        if not isinstance(data, dict) or not data.get("tools"):
+            return body
+
+        provider = data.get("provider")
+        if not isinstance(provider, dict):
+            provider = {}
+
+        if "require_parameters" in provider:
+            return body
+
+        provider["require_parameters"] = True
+        data["provider"] = provider
+        return json.dumps(data).encode()
+
     def _apply_provider_field(self, response_json: object) -> None:
         """Stamp the ``provider`` field for OpenRouter responses.
 

routstr/upstream/ppqai.py

@@ -8,7 +8,6 @@ from pydantic.v1 import BaseModel, Field
 from ..core.logging import get_logger
 from ..payment.models import Architecture, Model, Pricing, async_fetch_openrouter_models
 from .base import BaseUpstreamProvider, TopupData
-from .ehbp import EHBPForwardingTarget
 
 if TYPE_CHECKING:
     from ..core.db import UpstreamProviderRow
@@ -40,10 +39,6 @@ class PPQAIUpstreamProvider(BaseUpstreamProvider):
     default_base_url = "https://api.ppq.ai"
     platform_url = "https://ppq.ai/api-docs"
     IGNORED_MODEL_IDS: list[str] = ["auto"]
-    # PPQ.AI has a private encrypted endpoint, but this proxy currently has no
-    # provider-attested usage extractor/model binding for it. Keep EHBP disabled
-    # until a ConfidentialInferenceProfile can bill it without max-cost fallback.
-    supports_ehbp = False
 
     def __init__(self, api_key: str, provider_fee: float = 1.0):
         super().__init__(
@@ -75,20 +70,6 @@ class PPQAIUpstreamProvider(BaseUpstreamProvider):
     def transform_model_name(self, model_id: str) -> str:
         return model_id
 
-    def get_ehbp_forwarding_target(
-        self, path: str, model_obj: Model
-    ) -> EHBPForwardingTarget:
-        """Return the PPQ.AI private enclave target for EHBP requests.
-
-        PPQ.AI exposes EHBP-aware inference under /private/v1/... separate
-        from the public /v1/... endpoint. The encrypted body remains opaque to
-        Routstr, so PPQ.AI also needs X-Private-Model for routing/billing.
-        """
-        return EHBPForwardingTarget(
-            url=f"{self.base_url.rstrip('/')}/private/{path.lstrip('/')}",
-            headers={"X-Private-Model": model_obj.forwarded_model_id or model_obj.id},
-        )
-
     @classmethod
     async def create_account_static(cls) -> dict[str, object]:
         """Create a new PPQ.AI account without requiring an instance.

routstr/upstream/tinfoil.py

@@ -1,236 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-import httpx
-from fastapi import Request
-from fastapi.responses import Response, StreamingResponse
-from pydantic.v1 import BaseModel
-
-from ..core.exceptions import UpstreamError
-from ..core.logging import get_logger
-from ..payment.models import Architecture, Model, Pricing
-from .base import BaseUpstreamProvider
-from .ehbp import (
-    _ENCLAVE_URL_HEADER,
-    _PROXY_ONLY_HEADERS,
-    _RESPONSE_USAGE_HEADER,
-    ConfidentialInferenceProfile,
-    EHBPForwardingTarget,
-)
-
-if TYPE_CHECKING:
-    from ..core.db import UpstreamProviderRow
-
-logger = get_logger(__name__)
-
-
-class TinfoilModelPricing(BaseModel):
-    inputTokenPricePer1M: float = 0.0
-    outputTokenPricePer1M: float = 0.0
-    requestPrice: float = 0.0
-
-
-class TinfoilModel(BaseModel):
-    id: str
-    context_window: int = 0
-    created: int = 0
-    multimodal: bool = False
-    reasoning: bool = False
-    tool_calling: bool = False
-    type: str = "chat"
-    pricing: TinfoilModelPricing = TinfoilModelPricing()
-    endpoints: list[str] = []
-
-
-class TinfoilUpstreamProvider(BaseUpstreamProvider):
-    """Direct upstream provider for the Tinfoil inference API.
-
-    Tinfoil hosts open-source models inside attested secure enclaves and exposes
-    an OpenAI-compatible API at ``https://inference.tinfoil.sh``. Request and
-    response bodies are encrypted end-to-end with EHBP (HPKE), so Routstr acts
-    as a blind relay: it forwards the opaque encrypted body, never sees
-    plaintext, and bills from the ``X-Tinfoil-Usage-Metrics`` header that
-    Tinfoil returns outside the encrypted body when
-    ``X-Tinfoil-Request-Usage-Metrics: true`` is set.
-    """
-
-    provider_type = "tinfoil"
-    default_base_url = "https://inference.tinfoil.sh"
-    platform_url = "https://docs.tinfoil.sh"
-    supports_ehbp = True
-    confidential_inference_profile = ConfidentialInferenceProfile(
-        usage_response_header=_RESPONSE_USAGE_HEADER,
-        client_target_url_header=_ENCLAVE_URL_HEADER,
-        allow_client_target_override=True,
-        proxy_only_headers=_PROXY_ONLY_HEADERS,
-    )
-
-    def __init__(self, api_key: str, provider_fee: float = 1.0):
-        super().__init__(
-            base_url=self.default_base_url,
-            api_key=api_key,
-            provider_fee=provider_fee,
-        )
-
-    @classmethod
-    def _build_from_row(
-        cls, provider_row: "UpstreamProviderRow"
-    ) -> "TinfoilUpstreamProvider":
-        return cls(
-            api_key=provider_row.api_key,
-            provider_fee=provider_row.provider_fee,
-        )
-
-    @classmethod
-    def get_provider_metadata(cls) -> dict[str, object]:
-        return {
-            "id": cls.provider_type,
-            "name": "Tinfoil",
-            "default_base_url": cls.default_base_url,
-            "fixed_base_url": True,
-            "platform_url": cls.platform_url,
-            "can_create_account": False,
-            "can_topup": False,
-            "can_show_balance": False,
-        }
-
-    def transform_model_name(self, model_id: str) -> str:
-        return model_id.removeprefix("tinfoil/")
-
-    def get_confidential_inference_profile(self) -> ConfidentialInferenceProfile:
-        return self.confidential_inference_profile
-
-    async def forward_get_request(
-        self,
-        request: Request,
-        path: str,
-        headers: dict,
-    ) -> Response | StreamingResponse:
-        """Handle Tinfoil-specific GET endpoints.
-
-        * ``/attestation`` (or ``/tee/attestation``): proxy to the Tinfoil ATC
-          (attestation bundle proxy) at ``https://atc.tinfoil.sh/attestation``.
-        * Other GETs: forward to the provider base URL
-          (``https://inference.tinfoil.sh``). ``X-Tinfoil-Enclave-Url`` is an
-          EHBP-only header used for encrypted POST requests and is not honored
-          for unencrypted GET requests.
-        """
-        clean_path = path.removeprefix("tee/").rstrip("/")
-        if clean_path == "attestation":
-            return await self._proxy_attestation(headers)
-        return await super().forward_get_request(request, path, headers)
-
-    async def _proxy_attestation(self, headers: dict) -> Response:
-        url = "https://atc.tinfoil.sh/attestation"
-        async with httpx.AsyncClient(
-            transport=httpx.AsyncHTTPTransport(retries=1),
-            timeout=30.0,
-        ) as client:
-            try:
-                resp = await client.get(
-                    url,
-                    headers={
-                        "Accept": headers.get("accept", "application/json"),
-                    },
-                )
-                response_headers = dict(resp.headers)
-                response_headers.pop("content-encoding", None)
-                response_headers.pop("content-length", None)
-                return Response(
-                    content=resp.content,
-                    status_code=resp.status_code,
-                    headers=response_headers,
-                )
-            except Exception as exc:
-                raise UpstreamError(
-                    f"Error fetching Tinfoil attestation: {type(exc).__name__}",
-                    status_code=502,
-                ) from exc
-
-    def get_ehbp_forwarding_target(
-        self, path: str, model_obj: Model
-    ) -> EHBPForwardingTarget:
-        """Return the Tinfoil enclave target for EHBP requests.
-
-        Requests usage metrics from the enclave so Routstr can bill exactly
-        without decrypting the response body. The actual forwarding URL is
-        overridden at dispatch time by ``X-Tinfoil-Enclave-Url`` when the SDK
-        sends it (see ``routstr/upstream/ehbp.py``).
-        """
-        return EHBPForwardingTarget(
-            url=f"{self.base_url.rstrip('/')}/{path.lstrip('/')}",
-            headers={"X-Tinfoil-Request-Usage-Metrics": "true"},
-            profile=self.confidential_inference_profile,
-        )
-
-    async def fetch_models(self) -> list[Model]:
-        """Fetch models from the public Tinfoil models endpoint.
-
-        ``GET /v1/models`` is unauthenticated and returns all available models
-        with their pricing in USD per 1M tokens.
-        """
-        url = f"{self.base_url}/v1/models"
-        try:
-            async with httpx.AsyncClient(timeout=30.0) as client:
-                response = await client.get(url)
-                response.raise_for_status()
-                data = response.json()
-                models_data = data.get("data", [])
-
-                models: list[Model] = []
-                for model_data in models_data:
-                    try:
-                        tf = TinfoilModel.parse_obj(model_data)
-                        input_price = tf.pricing.inputTokenPricePer1M
-                        output_price = tf.pricing.outputTokenPricePer1M
-                        request_price = tf.pricing.requestPrice
-
-                        modality = "text->text"
-                        input_modalities = ["text"]
-                        output_modalities = ["text"]
-                        if tf.multimodal:
-                            modality = "text->text+image"
-                            input_modalities = ["text", "image"]
-
-                        models.append(
-                            Model(
-                                id=tf.id,
-                                name=tf.id,
-                                created=tf.created,
-                                description=f"Tinfoil {tf.type} model",
-                                context_length=tf.context_window,
-                                architecture=Architecture(
-                                    modality=modality,
-                                    input_modalities=input_modalities,
-                                    output_modalities=output_modalities,
-                                    tokenizer="Unknown",
-                                    instruct_type=None,
-                                ),
-                                pricing=Pricing(
-                                    prompt=input_price / 1_000_000,
-                                    completion=output_price / 1_000_000,
-                                    request=request_price,
-                                    image=0.0,
-                                    web_search=0.0,
-                                    internal_reasoning=0.0,
-                                ),
-                            )
-                        )
-                    except Exception as e:
-                        logger.warning(
-                            "Failed to parse Tinfoil model",
-                            extra={
-                                "model_id": model_data.get("id", "unknown"),
-                                "error": str(e),
-                                "error_type": type(e).__name__,
-                            },
-                        )
-
-                return models
-        except Exception as e:
-            logger.error(
-                "Error fetching models from Tinfoil",
-                extra={"error": str(e), "error_type": type(e).__name__},
-            )
-            return []

routstr/upstream/tinfoil_trailer.py

@@ -1,189 +0,0 @@
-"""h11-based HTTP client for EHBP requests that captures HTTP trailers.
-
-httpx/httpcore silently discard HTTP trailers during chunked transfer
-decoding. Tinfoil returns ``X-Tinfoil-Usage-Metrics`` as a trailer on
-streaming responses, so we need a lower-level HTTP client that preserves
-trailers from the h11 ``EndOfMessage`` event.
-
-Because EHBP response bodies are opaque encrypted blobs, buffering the full
-response is acceptable — the client decrypts the complete body regardless of
-whether it arrived streamed or buffered.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import ssl
-from dataclasses import dataclass, field
-from urllib.parse import urlsplit
-
-import h11
-
-from ..core import get_logger
-
-logger = get_logger(__name__)
-
-_READ_BUFSIZE = 65536
-_DEFAULT_TIMEOUT_SECONDS = 30.0
-_DEFAULT_CLOSE_TIMEOUT_SECONDS = 1.0
-_DEFAULT_MAX_RESPONSE_BYTES = 25 * 1024 * 1024
-_HOP_BY_HOP_HEADERS = {
-    "connection",
-    "keep-alive",
-    "proxy-authenticate",
-    "proxy-authorization",
-    "te",
-    "trailer",
-    "transfer-encoding",
-    "upgrade",
-}
-
-
-@dataclass
-class TrailerResponse:
-    """Buffered HTTP response with optional trailer headers."""
-
-    status_code: int
-    headers: list[tuple[str, str]]
-    body: bytes
-    trailers: list[tuple[str, str]] = field(default_factory=list)
-
-
-def _get_header(headers: list[tuple[str, str]], name: str) -> str | None:
-    name_lower = name.lower()
-    for k, v in headers:
-        if k.lower() == name_lower:
-            return v
-    return None
-
-
-def _strip_hop_by_hop_headers(headers: dict[str, str]) -> dict[str, str]:
-    """Remove connection-specific headers before serializing a new request."""
-    connection_tokens: set[str] = set()
-    for key, value in headers.items():
-        if key.lower() == "connection":
-            connection_tokens.update(
-                token.strip().lower() for token in value.split(",") if token.strip()
-            )
-
-    excluded = _HOP_BY_HOP_HEADERS | connection_tokens
-    return {key: value for key, value in headers.items() if key.lower() not in excluded}
-
-
-async def forward_with_trailer(
-    *,
-    method: str,
-    url: str,
-    headers: dict[str, str],
-    body: bytes,
-    timeout_seconds: float = _DEFAULT_TIMEOUT_SECONDS,
-    max_response_bytes: int = _DEFAULT_MAX_RESPONSE_BYTES,
-    close_timeout_seconds: float = _DEFAULT_CLOSE_TIMEOUT_SECONDS,
-) -> TrailerResponse:
-    """Send an HTTP/1.1 request via h11 and capture HTTP trailers.
-
-    Returns a :class:`TrailerResponse` with the full buffered body and any
-    trailer headers from the ``EndOfMessage`` event.
-    """
-    parsed = urlsplit(url)
-    host = parsed.hostname
-    if not host:
-        raise ValueError(f"Invalid URL (no hostname): {url}")
-    port = parsed.port or 443
-    path = parsed.path or "/"
-    if parsed.query:
-        path = f"{path}?{parsed.query}"
-
-    # FastAPI has already decoded the incoming request body. Do not carry the
-    # original connection's framing or other hop-by-hop metadata into the new
-    # upstream connection.
-    headers = _strip_hop_by_hop_headers(headers)
-
-    ssl_ctx = ssl.create_default_context()
-    reader, writer = await asyncio.wait_for(
-        asyncio.open_connection(host, port, ssl=ssl_ctx),
-        timeout=timeout_seconds,
-    )
-
-    try:
-        # Build HTTP/1.1 request
-        header_lines = [f"{method} {path} HTTP/1.1"]
-        has_host = any(k.lower() == "host" for k in headers)
-        if not has_host:
-            header_lines.append(f"Host: {host}")
-        header_lines.append("Connection: close")
-
-        for key, value in headers.items():
-            if key.lower() == "host":
-                continue
-            header_lines.append(f"{key}: {value}")
-
-        if body and not any(k.lower() == "content-length" for k in headers):
-            header_lines.append(f"Content-Length: {len(body)}")
-
-        request_data = "\r\n".join(header_lines).encode() + b"\r\n\r\n"
-        if body:
-            request_data += body
-
-        writer.write(request_data)
-        await asyncio.wait_for(writer.drain(), timeout=timeout_seconds)
-
-        # Parse response with h11
-        conn = h11.Connection(h11.CLIENT)
-        status_code = 0
-        resp_headers: list[tuple[str, str]] = []
-        body_chunks: list[bytes] = []
-        body_size = 0
-        trailers: list[tuple[str, str]] = []
-
-        while True:
-            event = conn.next_event()
-
-            if event is h11.NEED_DATA:
-                data = await asyncio.wait_for(
-                    reader.read(_READ_BUFSIZE),
-                    timeout=timeout_seconds,
-                )
-                conn.receive_data(data if data else b"")
-                continue
-
-            if isinstance(event, h11.Response):
-                status_code = event.status_code
-                resp_headers = [(k.decode(), v.decode()) for k, v in event.headers]
-
-            elif isinstance(event, h11.Data):
-                body_size += len(event.data)
-                if body_size > max_response_bytes:
-                    raise ValueError(
-                        f"EHBP response exceeded {max_response_bytes} bytes"
-                    )
-                body_chunks.append(event.data)
-
-            elif isinstance(event, h11.EndOfMessage):
-                for k, v in event.headers:
-                    trailers.append((k.decode(), v.decode()))
-                break
-
-            elif isinstance(event, h11.PAUSED):
-                # Shouldn't happen for simple request/response, but break safely
-                logger.warning("h11 PAUSED event during EHBP response parsing")
-                break
-
-            elif isinstance(event, h11.ConnectionClosed):
-                break
-
-        return TrailerResponse(
-            status_code=status_code,
-            headers=resp_headers,
-            body=b"".join(body_chunks),
-            trailers=trailers,
-        )
-    finally:
-        writer.close()
-        if close_timeout_seconds > 0:
-            try:
-                await asyncio.wait_for(
-                    writer.wait_closed(), timeout=close_timeout_seconds
-                )
-            except Exception:
-                pass

routstr/wallet.py

@@ -1,11 +1,9 @@
 import asyncio
 import re
-import socket
 import time
 import typing
 from typing import TypedDict
 
-import httpx
 from cashu.core.base import Proof, Token
 from cashu.core.mint_info import MintInfo as _CashuMintInfo
 from cashu.wallet.helpers import deserialize_token_from_string
@@ -14,7 +12,7 @@ from pydantic_core import PydanticUndefined
 from sqlmodel import col, select, update
 
 from .core import db, get_logger
-from .core.db import store_cashu_transaction_with_retry as store_cashu_transaction
+from .core.db import store_cashu_transaction
 from .core.settings import settings
 from .payment.lnurl import raw_send_to_lnurl
 
@@ -33,149 +31,6 @@ _CashuMintInfo.model_rebuild(force=True)
 logger = get_logger(__name__)
 
 
-class MintConnectionError(Exception):
-    """The mint could not be reached (network transport failure).
-
-    Maps to a 503, not a 4xx: the token is fine, the mint is just unavailable.
-    """
-
-
-class TokenConsumedError(Exception):
-    """A failure that happened AFTER the token's proofs were spent (melt
-    succeeded, or redemption already returned) — e.g. minting on the primary
-    mint or the DB credit then failed.
-
-    Non-retryable: the same token will not work again. Seals the cause chain so
-    a transport error underneath is never re-surfaced as a retryable
-    mint_unreachable.
-    """
-
-
-# httpx base classes cover their subclasses. HTTPStatusError is excluded on
-# purpose — that means the mint answered, just with an error status.
-_TRANSPORT_EXC_TYPES: tuple[type[BaseException], ...] = (
-    httpx.NetworkError,
-    httpx.TimeoutException,
-    ConnectionError,  # refused/reset/aborted
-    socket.gaierror,  # DNS failure
-    asyncio.TimeoutError,
-)
-
-
-def is_mint_connection_error(error: BaseException) -> bool:
-    """True if ``error`` (or anything in its cause/context chain) is a mint
-    transport failure. Walks the chain because some sites re-raise transport
-    errors wrapped in ValueError/MintConnectionError; matches on TYPE, not text.
-    """
-    seen: set[int] = set()
-    current: BaseException | None = error
-    while current is not None and id(current) not in seen:
-        seen.add(id(current))
-        if isinstance(current, TokenConsumedError):
-            # Sealed: the token was already spent, so whatever transport error
-            # sits underneath must not make this look retryable.
-            return False
-        if isinstance(current, MintConnectionError):
-            return True
-        if isinstance(current, _TRANSPORT_EXC_TYPES):
-            return True
-        current = current.__cause__ or current.__context__
-    return False
-
-
-# Redemption ``code`` values whose token is spent/consumed/unusable — the
-# X-Cashu path must NOT echo the original token for these (echoing invites a
-# retry with a token that can never succeed again).
-SPENT_TOKEN_CODES: frozenset[str] = frozenset(
-    {
-        "cashu_token_already_spent",
-        "cashu_token_consumed",
-        "cashu_token_zero_value",
-        "internal_error",
-    }
-)
-
-
-def classify_redemption_error(
-    error: Exception,
-) -> tuple[str, int, str, str] | None:
-    """Map a token-redemption failure to ``(type, status, message, code)``.
-
-    Single source of truth for every endpoint that redeems a token (bearer,
-    X-Cashu, top-up) so the same failure yields the same taxonomy everywhere.
-    ``type`` and ``code`` are stable client contract; ``message`` is sanitized
-    (raw error text stays in logs). Returns None for an unclassified internal
-    fault — the caller emits a generic 500.
-    """
-    if isinstance(error, TokenConsumedError):
-        return (
-            "token_consumed",
-            500,
-            "Token was redeemed but could not be credited; do not retry",
-            "cashu_token_consumed",
-        )
-    if is_mint_connection_error(error):
-        return (
-            "mint_unreachable",
-            503,
-            "Cashu mint is unreachable",
-            "cashu_mint_unreachable",
-        )
-    lowered = str(error).lower()
-    if "already spent" in lowered:
-        return (
-            "token_already_spent",
-            400,
-            "Cashu token already spent",
-            "cashu_token_already_spent",
-        )
-    if (
-        "insufficient" in lowered
-        or "melt fee" in lowered
-        or "exceed token amount" in lowered
-        or "estimate fees" in lowered
-    ):
-        return (
-            "mint_error",
-            422,
-            "Token value is too small to cover swap fees",
-            "cashu_token_swap_fees_exceed_amount",
-        )
-    if "failed to melt" in lowered:
-        return (
-            "mint_error",
-            422,
-            "Failed to swap token from foreign mint",
-            "cashu_foreign_mint_swap_failed",
-        )
-    if ("invalid" in lowered or "decode" in lowered) and "token" in lowered:
-        # Anchored to "token" so internal faults whose text merely contains
-        # "invalid"/"decode" fall through to the 500 branch, not a token error.
-        return (
-            "invalid_token",
-            400,
-            "Invalid Cashu token",
-            "invalid_cashu_token",
-        )
-    if "must be positive" in lowered or "yielded no value" in lowered:
-        # Redeemed to <= 0 (empty/dust token, or value fully consumed by fees).
-        # Consumed, so non-retryable, but its own code — not the generic bucket.
-        return (
-            "cashu_error",
-            400,
-            "Failed to redeem Cashu token: token yielded no value",
-            "cashu_token_zero_value",
-        )
-    if isinstance(error, ValueError):
-        return (
-            "cashu_error",
-            400,
-            "Failed to redeem Cashu token",
-            "cashu_token_redemption_failed",
-        )
-    return None
-
-
 async def get_balance(unit: str) -> int:
     wallet = await get_wallet(settings.primary_mint, unit)
     return wallet.available_balance.amount
@@ -403,8 +258,6 @@ async def _calculate_swap_amount(
             "swap_to_primary_mint: fee estimation failed",
             extra={"error": str(e)},
         )
-        if is_mint_connection_error(e):
-            raise MintConnectionError("Cashu mint is unreachable") from e
         raise ValueError(f"Failed to estimate fees: {e}") from e
 
 
@@ -530,13 +383,6 @@ async def swap_to_primary_mint(
                 quote_id=melt_quote.quote,
             )
         except Exception as e:
-            # A down mint won't fix itself by retrying with a smaller amount.
-            if is_mint_connection_error(e):
-                logger.error(
-                    "swap_to_primary_mint: melt failed — mint unreachable",
-                    extra={"error": str(e), "foreign_mint": token_obj.mint},
-                )
-                raise MintConnectionError("Cashu mint is unreachable") from e
             shortfall = _melt_insufficient_shortfall(e)
             recomputed = 0
             if shortfall is not None:
@@ -612,21 +458,21 @@ async def swap_to_primary_mint(
                     # Recovery scan ran but did NOT restore the orphaned proofs
                     # (mint reports them as spent — they're stuck). Refuse to
                     # credit the API key balance for proofs we don't actually hold.
-                    raise TokenConsumedError(
+                    raise ValueError(
                         f"Swap recovery failed: mint signed outputs but proofs are "
                         f"unrecoverable (mint reports them spent). "
                         f"Expected {minted_amount}, recovered {balance_gained}. "
                         f"Local wallet DB ('.wallet/') state is corrupted — "
                         f"the counter for keyset is stuck at a bad index range."
                     )
-            except TokenConsumedError:
+            except ValueError:
                 raise
             except Exception as recovery_err:
                 logger.error(
                     "swap_to_primary_mint: recovery failed",
                     extra={"error": str(recovery_err)},
                 )
-                raise TokenConsumedError(
+                raise ValueError(
                     f"Mint on primary failed and recovery unsuccessful: {e}"
                 ) from e
         else:
@@ -639,10 +485,7 @@ async def swap_to_primary_mint(
                     "mint_quote_id": mint_quote.quote,
                 },
             )
-            # Foreign proofs already melted (spent) — non-retryable.
-            raise TokenConsumedError(
-                "Mint on primary failed after successful melt"
-            ) from e
+            raise
 
     logger.info(
         "swap_to_primary_mint: completed successfully",
@@ -700,33 +543,19 @@ async def credit_balance(
             extra={"old_balance": key.balance, "credit_amount": amount},
         )
 
-        # The token is already redeemed (spent) here, so any crediting failure
-        # is post-redemption and non-retryable — surface it as TokenConsumedError
-        # (a key that vanished mid-flight, or an unexpected DB fault), never a
-        # retryable/token-error taxonomy.
-        try:
-            # Atomic UPDATE to prevent race conditions during concurrent topups.
-            stmt = (
-                update(db.ApiKey)
-                .where(col(db.ApiKey.hashed_key) == key.hashed_key)
-                .values(balance=(db.ApiKey.balance) + amount)
-            )
-            result = await session.exec(stmt)  # type: ignore[call-overload]
-            # If pruning removed this key after redemption, do not commit a no-op
-            # balance update and pretend the top-up succeeded.
-            if (getattr(result, "rowcount", 0) or 0) == 0:
-                raise TokenConsumedError(
-                    "Token redeemed but the API key disappeared before the "
-                    "credit could be recorded"
-                )
-            await session.commit()
-            await session.refresh(key)
-        except TokenConsumedError:
-            raise
-        except Exception as db_error:
-            raise TokenConsumedError(
-                "Token redeemed but crediting the balance failed"
-            ) from db_error
+        # Use atomic SQL UPDATE to prevent race conditions during concurrent topups
+        stmt = (
+            update(db.ApiKey)
+            .where(col(db.ApiKey.hashed_key) == key.hashed_key)
+            .values(balance=(db.ApiKey.balance) + amount)
+        )
+        result = await session.exec(stmt)  # type: ignore[call-overload]
+        # If pruning removed this key after redemption, do not commit a no-op
+        # balance update and pretend the top-up succeeded.
+        if (getattr(result, "rowcount", 0) or 0) == 0:
+            raise ValueError("API key disappeared before credit could be recorded")
+        await session.commit()
+        await session.refresh(key)
 
         logger.info(
             "credit_balance: Balance updated successfully",
@@ -745,11 +574,11 @@ async def credit_balance(
             )
         except Exception:
             pass
-        else:
-            logger.debug(
-                "Cashu token successfully redeemed and stored",
-                extra={"amount": amount, "unit": unit, "mint_url": mint_url},
-            )
+
+        logger.debug(
+            "Cashu token successfully redeemed and stored",
+            extra={"amount": amount, "unit": unit, "mint_url": mint_url},
+        )
         return amount
     except Exception as e:
         logger.error(
@@ -919,132 +748,104 @@ async def fetch_all_balances(
 async def periodic_payout() -> None:
     while True:
         await asyncio.sleep(settings.payout_interval_seconds)
+        print(settings.payout_interval_seconds)
+        if not settings.receive_ln_address:
+            continue
         try:
-            if not settings.receive_ln_address:
-                continue
-
-            # Include the primary mint even if it is not listed in cashu_mints,
-            # matching fetch_all_balances(); otherwise primary-mint funds never
-            # auto-payout.
-            mint_urls: list[str] = list(settings.cashu_mints)
-            if settings.primary_mint and settings.primary_mint not in mint_urls:
-                mint_urls.append(settings.primary_mint)
-
             async with db.create_session() as session:
-                for mint_url in mint_urls:
+                for mint_url in settings.cashu_mints:
                     for unit in ["sat", "msat"]:
-                        # Isolate failures per mint/unit so one slow or failing
-                        # mint does not abort payout for every other mint/unit.
-                        try:
-                            wallet = await get_wallet(mint_url, unit)
-                            proofs = get_proofs_per_mint_and_unit(
-                                wallet, mint_url, unit, not_reserved=True
+                        wallet = await get_wallet(mint_url, unit)
+                        proofs = get_proofs_per_mint_and_unit(
+                            wallet, mint_url, unit, not_reserved=True
+                        )
+                        proofs = await slow_filter_spend_proofs(proofs, wallet)
+                        await asyncio.sleep(5)
+                        user_balance = await db.balances_for_mint_and_unit(
+                            session, mint_url, unit
+                        )
+                        if unit == "sat":
+                            user_balance = user_balance // 1000
+                        proofs_balance = sum(proof.amount for proof in proofs)
+                        available_balance = proofs_balance - user_balance
+                        # Threshold is configured in sats; convert for msat wallets.
+                        min_amount = (
+                            settings.min_payout_sat
+                            if unit == "sat"
+                            else settings.min_payout_sat * 1000
+                        )
+                        if available_balance > min_amount:
+                            amount_received = await raw_send_to_lnurl(
+                                wallet,
+                                proofs,
+                                settings.receive_ln_address,
+                                unit,
+                                amount=available_balance,
                             )
-                            proofs = await slow_filter_spend_proofs(proofs, wallet)
-                            await asyncio.sleep(5)
-                            user_balance = await db.balances_for_mint_and_unit(
-                                session, mint_url, unit
-                            )
-                            if unit == "sat":
-                                user_balance = user_balance // 1000
-                            proofs_balance = sum(proof.amount for proof in proofs)
-                            available_balance = proofs_balance - user_balance
-                            # Threshold is configured in sats; convert for msat wallets.
-                            min_amount = (
-                                settings.min_payout_sat
-                                if unit == "sat"
-                                else settings.min_payout_sat * 1000
-                            )
-                            if available_balance > min_amount:
-                                amount_received = await raw_send_to_lnurl(
-                                    wallet,
-                                    proofs,
-                                    settings.receive_ln_address,
-                                    unit,
-                                    amount=available_balance,
-                                )
-                                logger.info(
-                                    "Payout sent successfully",
-                                    extra={
-                                        "mint_url": mint_url,
-                                        "unit": unit,
-                                        "balance": available_balance,
-                                        "amount_received": amount_received,
-                                    },
-                                )
-                        except Exception as e:
-                            logger.error(
-                                f"Error sending payout: {type(e).__name__}",
+                            logger.info(
+                                "Payout sent successfully",
                                 extra={
-                                    "error": str(e),
                                     "mint_url": mint_url,
                                     "unit": unit,
+                                    "balance": available_balance,
+                                    "amount_received": amount_received,
                                 },
                             )
         except Exception as e:
             logger.error(
-                f"Error in periodic payout cycle: {type(e).__name__}",
+                f"Error sending payout: {type(e).__name__}",
                 extra={"error": str(e)},
             )
 
 
-async def _refund_sweep_once(cutoff: int) -> None:
-    async with db.create_session() as session:
-        stmt = select(db.CashuTransaction).where(
-            db.CashuTransaction.type == "out",
-            db.CashuTransaction.collected == False,  # noqa: E712
-            db.CashuTransaction.swept == False,  # noqa: E712
-            db.CashuTransaction.created_at < cutoff,
-        )
-        results = await session.exec(stmt)
-        refunds = results.all()
-
-        for refund in refunds:
-            try:
-                await recieve_token(refund.token)
-                refund.swept = True
-                session.add(refund)
-                logger.info(
-                    "Swept uncollected refund",
-                    extra={
-                        "id": refund.id,
-                        "amount": refund.amount,
-                        "unit": refund.unit,
-                    },
-                )
-            except Exception as e:
-                error_msg = str(e).lower()
-                if "already spent" in error_msg:
-                    refund.collected = True
-                    session.add(refund)
-                    logger.info(
-                        "Refund already spent (client collected), marking swept",
-                        extra={
-                            "id": refund.id,
-                        },
-                    )
-                else:
-                    logger.warning(
-                        "Failed to sweep refund",
-                        extra={
-                            "id": refund.id,
-                            "error": str(e),
-                        },
-                    )
-        await session.commit()
-
-
-async def refund_sweep_once() -> None:
-    """Sweep eligible uncollected refund tokens once."""
-    cutoff = int(time.time()) - settings.refund_sweep_ttl_seconds
-    await _refund_sweep_once(cutoff)
-
-
 async def periodic_refund_sweep() -> None:
     while True:
         await asyncio.sleep(60 * 60)  # every hour
         try:
-            await refund_sweep_once()
+            cutoff = int(time.time()) - settings.refund_sweep_ttl_seconds
+            async with db.create_session() as session:
+                stmt = select(db.CashuTransaction).where(
+                    db.CashuTransaction.type == "out",
+                    db.CashuTransaction.collected == False,  # noqa: E712
+                    db.CashuTransaction.swept == False,  # noqa: E712
+                    db.CashuTransaction.created_at < cutoff,
+                )
+                results = await session.exec(stmt)
+                refunds = results.all()
+
+                for refund in refunds:
+                    try:
+                        await recieve_token(refund.token)
+                        refund.swept = True
+                        session.add(refund)
+                        logger.info(
+                            "Swept uncollected refund",
+                            extra={
+                                "id": refund.id,
+                                "amount": refund.amount,
+                                "unit": refund.unit,
+                            },
+                        )
+                    except Exception as e:
+                        error_msg = str(e).lower()
+                        if "already spent" in error_msg:
+                            refund.collected = True
+                            session.add(refund)
+                            logger.info(
+                                "Refund already spent (client collected), marking swept",
+                                extra={
+                                    "id": refund.id,
+                                },
+                            )
+                        else:
+                            logger.warning(
+                                "Failed to sweep refund",
+                                extra={
+                                    "id": refund.id,
+                                    "error": str(e),
+                                },
+                            )
+                await session.commit()
         except Exception as e:
             logger.error(
                 "Error in periodic refund sweep",

tests/integration/test_swap_fee_retry.py

@@ -174,12 +174,12 @@ async def test_topup_retries_when_quote_fee_exceeds_estimate(
 
 @pytest.mark.integration
 @pytest.mark.asyncio
-async def test_topup_returns_422_when_retries_exhausted(
+async def test_topup_returns_400_when_retries_exhausted(
     authenticated_client: AsyncClient,
 ) -> None:
     """A mint that escalates fee_reserve on every re-quote (1 → 10 → 25 → 50)
-    exhausts the retry budget: clean 422 mint_error/too-small taxonomy, melt
-    never executed."""
+    exhausts the retry budget: clean 400 with an actionable message, melt never
+    executed."""
     mock_token, token_wallet, primary_wallet = _make_swap_mocks(
         1000, fee_reserves=[1, 10, 25, 50]
     )
@@ -188,7 +188,7 @@ async def test_topup_returns_422_when_retries_exhausted(
         authenticated_client, mock_token, token_wallet, primary_wallet
     )
 
-    assert response.status_code == 422
+    assert response.status_code == 400
     assert "too small to cover swap fees" in response.json()["detail"]
     assert token_wallet.melt_quote.call_count == 4  # estimation + 3 attempts
     token_wallet.melt.assert_not_called()

tests/integration/test_wallet_authentication.py

@@ -12,7 +12,10 @@ from sqlmodel import select
 
 from routstr.core.db import ApiKey
 
-from .utils import ResponseValidator
+from .utils import (
+    CashuTokenGenerator,
+    ResponseValidator,
+)
 
 
 @pytest.mark.integration
@@ -76,31 +79,29 @@ async def test_api_key_generation_invalid_token(
     # Capture initial state
     await db_snapshot.capture()
 
-    # Non-Cashu bearer values are invalid API keys (401). Malformed values that
-    # look like Cashu tokens use the shared Cashu taxonomy (400 invalid_token).
-    invalid_tokens: list[tuple[str, int, str | None]] = [
-        ("not-a-cashu-token", 401, None),
-        ("sk-not-a-real-api-key", 401, None),
-        ("cashuA", 400, "invalid_cashu_token"),
-        ("cashuA" + "x" * 1000, 400, "invalid_cashu_token"),
+    # Test various invalid tokens
+    invalid_tokens = [
+        CashuTokenGenerator.generate_invalid_token(),  # Malformed token
+        "not-a-cashu-token",  # Wrong format
+        "cashuA",  # Empty token
+        "cashuA" + "x" * 1000,  # Invalid base64
     ]
 
-    for invalid_token, expected_status, expected_code in invalid_tokens:
+    for invalid_token in invalid_tokens:
         integration_client.headers["Authorization"] = f"Bearer {invalid_token}"
         response = await integration_client.get("/v1/wallet/info")
 
-        assert response.status_code == expected_status, (
+        # Should fail with 401
+        assert response.status_code == 401, (
             f"Token {invalid_token[:20]}... should be invalid"
         )
 
         # Validate error response
         validator = ResponseValidator()
         error_validation = validator.validate_error_response(
-            response, expected_status=expected_status, expected_error_key="detail"
+            response, expected_status=401, expected_error_key="detail"
         )
         assert error_validation["valid"]
-        if expected_code is not None:
-            assert response.json()["detail"]["error"]["code"] == expected_code
 
     # Verify no database changes
     diff = await db_snapshot.diff()

tests/integration/test_wallet_refund.py

@@ -14,7 +14,6 @@ from httpx import AsyncClient
 from sqlmodel import select
 
 from routstr.core.db import ApiKey, CashuTransaction
-from routstr.wallet import MintConnectionError
 
 
 @pytest.mark.integration
@@ -504,19 +503,26 @@ async def test_mint_unavailability_handling(
 
     # The global mock in conftest.py is already in place,
     # so we need to temporarily modify it
-    raw_error = "Mint unavailable: Connection refused"
+    from unittest.mock import patch
 
-    # Make the send_token method raise a typed mint connection exception.
+    # Make the send_token method raise an exception
     with patch(
         "routstr.balance.send_token",
-        side_effect=MintConnectionError(raw_error),
+        side_effect=Exception("Mint unavailable: Connection refused"),
     ):
-        response = await authenticated_client.post("/v1/wallet/refund")
-        assert response.status_code == 503
-        assert response.json()["detail"] == "Mint service unavailable"
-        assert raw_error not in response.text
+        # The exception should propagate as a 503 error (Service Unavailable)
+        # But we need to handle it properly
+        try:
+            response = await authenticated_client.post("/v1/wallet/refund")
+            # If we get here, check the status code
+            assert response.status_code == 503
+            assert "Mint service unavailable" in response.json()["detail"]
+        except Exception as e:
+            # If the exception propagates, that's also a failure scenario
+            assert "Mint unavailable" in str(e)
 
         # Balance should remain unchanged (transaction should roll back)
+        # Note: Current implementation might not handle this perfectly
         wallet_response = await authenticated_client.get("/v1/wallet/")
         assert wallet_response.status_code == 200
         assert wallet_response.json()["balance"] == 10_000_000

tests/unit/test_admin_withdraw.py

@@ -1,82 +0,0 @@
-from types import SimpleNamespace
-from unittest.mock import AsyncMock, Mock
-
-import pytest
-
-from routstr.core import admin
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("requested_mint", [None, "https://secondary.example"])
-async def test_withdraw_uses_effective_mint_and_records_outgoing_transaction(
-    monkeypatch: pytest.MonkeyPatch, requested_mint: str | None
-) -> None:
-    primary_mint = "https://primary.example"
-    effective_mint = requested_mint or primary_mint
-    wallet = object()
-    proofs = [SimpleNamespace(amount=40), SimpleNamespace(amount=60)]
-    token = "cashuBoutgoing"
-
-    get_wallet = AsyncMock(return_value=wallet)
-    get_proofs = Mock(return_value=proofs)
-    filter_proofs = AsyncMock(return_value=proofs)
-    send_token = AsyncMock(return_value=token)
-    store_transaction = AsyncMock(return_value=True)
-
-    monkeypatch.setattr(admin, "get_wallet", get_wallet)
-    monkeypatch.setattr(admin, "get_proofs_per_mint_and_unit", get_proofs)
-    monkeypatch.setattr(admin, "slow_filter_spend_proofs", filter_proofs)
-    monkeypatch.setattr(admin, "send_token", send_token)
-    monkeypatch.setattr(admin, "store_cashu_transaction", store_transaction)
-    monkeypatch.setattr(admin.settings, "primary_mint", primary_mint)
-
-    result = await admin.withdraw(
-        Mock(),
-        admin.WithdrawRequest(amount=75, mint_url=requested_mint, unit="sat"),
-    )
-
-    assert result == {"token": token}
-    get_wallet.assert_awaited_once_with(effective_mint, "sat")
-    get_proofs.assert_called_once_with(wallet, effective_mint, "sat", not_reserved=True)
-    filter_proofs.assert_awaited_once_with(proofs, wallet)
-    send_token.assert_awaited_once_with(75, "sat", effective_mint)
-    store_transaction.assert_awaited_once_with(
-        token=token,
-        amount=75,
-        unit="sat",
-        mint_url=effective_mint,
-        typ="out",
-        collected=False,
-        source="admin",
-    )
-
-
-@pytest.mark.asyncio
-async def test_withdraw_returns_issued_token_when_audit_storage_fails(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    mint = "https://primary.example"
-    proofs = [SimpleNamespace(amount=100)]
-    token = "cashuBrecoverable"
-
-    monkeypatch.setattr(admin, "get_wallet", AsyncMock(return_value=object()))
-    monkeypatch.setattr(
-        admin, "get_proofs_per_mint_and_unit", Mock(return_value=proofs)
-    )
-    monkeypatch.setattr(
-        admin, "slow_filter_spend_proofs", AsyncMock(return_value=proofs)
-    )
-    monkeypatch.setattr(admin, "send_token", AsyncMock(return_value=token))
-    monkeypatch.setattr(
-        admin,
-        "store_cashu_transaction",
-        AsyncMock(side_effect=RuntimeError("database unavailable")),
-    )
-    critical = Mock()
-    monkeypatch.setattr(admin.logger, "critical", critical)
-    monkeypatch.setattr(admin.settings, "primary_mint", mint)
-
-    result = await admin.withdraw(Mock(), admin.WithdrawRequest(amount=75))
-
-    assert result == {"token": token}
-    critical.assert_called_once()

tests/unit/test_algorithm.py

@@ -137,8 +137,8 @@ def test_create_model_mappings_includes_db_override_for_missing_cached_model(
 
     model_instances, provider_map, unique_models = create_model_mappings(
         upstreams=[provider],
-        overrides_by_key={("azure/gpt-4o", 7): (override_row, 1.01)},
-        disabled_model_keys=set(),
+        overrides_by_id={"azure/gpt-4o": (override_row, 1.01)},
+        disabled_model_ids=set(),
     )
 
     assert "azure/gpt-4o" in model_instances
@@ -182,73 +182,11 @@ def test_create_model_mappings_dedupes_with_provider_identity_not_provider_type(
 
     _, provider_map, _ = create_model_mappings(
         upstreams=[provider_a, provider_b],
-        overrides_by_key={("azure/gpt-4o", 2): (override_row, 1.01)},
-        disabled_model_keys=set(),
+        overrides_by_id={"azure/gpt-4o": (override_row, 1.01)},
+        disabled_model_ids=set(),
     )
 
     providers_for_alias = provider_map["azure/gpt-4o"]
     assert provider_a in providers_for_alias
     assert provider_b in providers_for_alias
     assert len(providers_for_alias) == 2
-
-
-def test_create_model_mappings_applies_override_only_to_matching_provider(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """Same-id overrides must not add provider-specific aliases to other providers."""
-    provider_a_model = create_test_model("same-id", prompt_price=0.01)
-    provider_a = create_test_provider(
-        "provider-a",
-        "https://provider-a.example/v1",
-        db_id=1,
-        models=[provider_a_model],
-    )
-    provider_b_model = create_test_model("same-id", prompt_price=0.02)
-    provider_b = create_test_provider(
-        "provider-b",
-        "https://provider-b.example/v1",
-        db_id=2,
-        models=[provider_b_model],
-    )
-
-    override_model = create_test_model("same-id", prompt_price=0.001)
-    override_model.alias_ids = ["provider-b-only"]
-    override_row = SimpleNamespace(id="same-id", upstream_provider_id=2, enabled=True)
-
-    def fake_row_to_model(*args, **kwargs) -> Model:  # type: ignore[no-untyped-def]
-        return override_model
-
-    monkeypatch.setattr("routstr.payment.models._row_to_model", fake_row_to_model)
-
-    _, provider_map, _ = create_model_mappings(
-        upstreams=[provider_a, provider_b],
-        overrides_by_key={("same-id", 2): (override_row, 1.01)},
-        disabled_model_keys=set(),
-    )
-
-    assert provider_map["provider-b-only"] == [provider_b]
-    assert set(provider_map["same-id"]) == {provider_a, provider_b}
-
-
-def test_create_model_mappings_disables_only_matching_provider() -> None:
-    """Disabled overrides are scoped to the provider row, not the shared model id."""
-    provider_a = create_test_provider(
-        "provider-a",
-        "https://provider-a.example/v1",
-        db_id=1,
-        models=[create_test_model("same-id")],
-    )
-    provider_b = create_test_provider(
-        "provider-b",
-        "https://provider-b.example/v1",
-        db_id=2,
-        models=[create_test_model("same-id")],
-    )
-
-    _, provider_map, _ = create_model_mappings(
-        upstreams=[provider_a, provider_b],
-        overrides_by_key={},
-        disabled_model_keys={("same-id", 2)},
-    )
-
-    assert provider_map["same-id"] == [provider_a]

tests/unit/test_auth_cashu.py

@@ -1,9 +1,8 @@
 import hashlib
 from types import SimpleNamespace
-from typing import AsyncGenerator, cast
+from typing import AsyncGenerator
 from unittest.mock import AsyncMock, patch
 
-import httpx
 import pytest
 from fastapi import HTTPException
 from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
@@ -13,19 +12,6 @@ from sqlmodel.ext.asyncio.session import AsyncSession
 
 from routstr.auth import validate_bearer_key
 from routstr.core.db import ApiKey
-from routstr.wallet import MintConnectionError
-
-
-def _value_error_wrapping_transport() -> ValueError:
-    """A ValueError re-raised ``from`` a real httpx transport error, mirroring
-    ``wallet.py`` wrapping a connection failure. The sanitized classifier must
-    still see the mint-unreachable signal through the ``__cause__`` chain."""
-    try:
-        raise httpx.ConnectError("All connection attempts failed")
-    except httpx.ConnectError as exc:
-        err = ValueError("Failed to estimate fees: connection failed")
-        err.__cause__ = exc
-        return err
 
 
 def _make_engine() -> AsyncEngine:
@@ -71,223 +57,3 @@ async def test_failed_first_cashu_redemption_rolls_back_empty_api_key(
             await validate_bearer_key(token, session)
 
     assert await session.get(ApiKey, hashed_key) is None
-
-
-@pytest.mark.parametrize(
-    ("error", "expected_status", "expected_type", "expected_message", "expected_code"),
-    [
-        (
-            ValueError("Mint Error: Token already spent. (Code: 11001)"),
-            400,
-            "token_already_spent",
-            "Cashu token already spent",
-            "cashu_token_already_spent",
-        ),
-        (
-            # Raw httpx transport error propagated unwrapped from cashu.
-            httpx.ConnectError("All connection attempts failed"),
-            503,
-            "mint_unreachable",
-            "Cashu mint is unreachable",
-            "cashu_mint_unreachable",
-        ),
-        (
-            # Typed error raised by wallet.py at a wrap site.
-            MintConnectionError("connect to http://mint:3338 refused"),
-            503,
-            "mint_unreachable",
-            "Cashu mint is unreachable",
-            "cashu_mint_unreachable",
-        ),
-        (
-            # ValueError wrapping the httpx error in its __cause__ chain.
-            _value_error_wrapping_transport(),
-            503,
-            "mint_unreachable",
-            "Cashu mint is unreachable",
-            "cashu_mint_unreachable",
-        ),
-        (
-            # asyncio.TimeoutError is builtin TimeoutError on 3.11+.
-            TimeoutError("Timed out connecting to Cashu mint http://mint:3338"),
-            503,
-            "mint_unreachable",
-            "Cashu mint is unreachable",
-            "cashu_mint_unreachable",
-        ),
-        (
-            ValueError(
-                "Token amount (5 sat) is insufficient to cover melt fees. "
-                "Needed: 7 sat (amount: 5 + fee: 1 + input_fees: 1)"
-            ),
-            422,
-            "mint_error",
-            "Token value is too small to cover swap fees",
-            "cashu_token_swap_fees_exceed_amount",
-        ),
-        (
-            ValueError(
-                "Failed to estimate fees: Fees (7 sat) exceed token amount (5 sat)"
-            ),
-            422,
-            "mint_error",
-            "Token value is too small to cover swap fees",
-            "cashu_token_swap_fees_exceed_amount",
-        ),
-        (
-            ValueError(
-                "Failed to melt token from foreign mint http://foreign:3338: boom"
-            ),
-            422,
-            "mint_error",
-            "Failed to swap token from foreign mint",
-            "cashu_foreign_mint_swap_failed",
-        ),
-        (
-            ValueError("could not decode token"),
-            400,
-            "invalid_token",
-            "Invalid Cashu token",
-            "invalid_cashu_token",
-        ),
-        (
-            ValueError("some unexpected wallet condition"),
-            400,
-            "cashu_error",
-            "Failed to redeem Cashu token",
-            "cashu_token_redemption_failed",
-        ),
-        (
-            ValueError("Redeemed token amount must be positive, got 0 msats"),
-            400,
-            "cashu_error",
-            "Failed to redeem Cashu token: token yielded no value",
-            "cashu_token_zero_value",
-        ),
-    ],
-)
-@pytest.mark.asyncio
-async def test_redemption_failure_returns_sanitized_error(
-    session: AsyncSession,
-    error: Exception,
-    expected_status: int,
-    expected_type: str,
-    expected_message: str,
-    expected_code: str,
-) -> None:
-    """Redemption failures reuse the shared X-Cashu taxonomy (carried in
-    ``type``), expose stable sanitized messages and granular machine-readable
-    ``code`` values, and leave no orphan ApiKey row."""
-    token = "cashuAredemption_fails_with_specific_error"
-    hashed_key = hashlib.sha256(token.encode()).hexdigest()
-    token_obj = SimpleNamespace(mint="http://mint:3338", unit="sat")
-
-    from routstr.core.settings import settings
-
-    with (
-        patch.object(settings, "cashu_mints", ["http://mint:3338"]),
-        patch("routstr.auth.deserialize_token_from_string", return_value=token_obj),
-        patch(
-            "routstr.auth.credit_balance",
-            new=AsyncMock(side_effect=error),
-        ),
-    ):
-        with pytest.raises(HTTPException) as exc_info:
-            await validate_bearer_key(token, session)
-
-    assert exc_info.value.status_code == expected_status
-    detail = cast(dict[str, dict[str, object]], exc_info.value.detail)
-    error_detail = detail["error"]
-    assert error_detail["type"] == expected_type
-    assert error_detail["code"] == expected_code
-    assert error_detail["message"] == expected_message
-    assert str(error) not in cast(str, error_detail["message"])
-    assert await session.get(ApiKey, hashed_key) is None
-
-
-@pytest.mark.asyncio
-async def test_unexpected_redemption_error_returns_internal_error(
-    session: AsyncSession,
-) -> None:
-    """Unexpected (non-wallet) failures surface as generic 500s without
-    leaking internal details, instead of masquerading as token errors."""
-    token = "cashuAredemption_fails_with_internal_error"
-    hashed_key = hashlib.sha256(token.encode()).hexdigest()
-    token_obj = SimpleNamespace(mint="http://mint:3338", unit="sat")
-
-    from routstr.core.settings import settings
-
-    with (
-        patch.object(settings, "cashu_mints", ["http://mint:3338"]),
-        patch("routstr.auth.deserialize_token_from_string", return_value=token_obj),
-        patch(
-            "routstr.auth.credit_balance",
-            new=AsyncMock(side_effect=RuntimeError("db exploded at /var/lib/secret")),
-        ),
-    ):
-        with pytest.raises(HTTPException) as exc_info:
-            await validate_bearer_key(token, session)
-
-    assert exc_info.value.status_code == 500
-    detail = cast(dict[str, dict[str, str]], exc_info.value.detail)
-    error_detail = detail["error"]
-    assert error_detail["code"] == "internal_error"
-    assert "/var/lib/secret" not in error_detail["message"]
-    assert await session.get(ApiKey, hashed_key) is None
-
-
-@pytest.mark.asyncio
-async def test_internal_error_with_invalid_keyword_does_not_masquerade(
-    session: AsyncSession,
-) -> None:
-    """A non-wallet fault whose text merely contains "invalid" (but not
-    "token") must fall through to a generic 500, not a 401 token error.
-
-    Guards the anchored `"invalid"/"decode"` + `"token"` gate against stdlib/
-    driver strings like "Invalid isoformat string" leaking as token errors."""
-    token = "cashuAinternal_fault_mentions_invalid"
-    hashed_key = hashlib.sha256(token.encode()).hexdigest()
-    token_obj = SimpleNamespace(mint="http://mint:3338", unit="sat")
-
-    from routstr.core.settings import settings
-
-    with (
-        patch.object(settings, "cashu_mints", ["http://mint:3338"]),
-        patch("routstr.auth.deserialize_token_from_string", return_value=token_obj),
-        patch(
-            "routstr.auth.credit_balance",
-            new=AsyncMock(
-                side_effect=RuntimeError("Invalid isoformat string: '2020-13-99'")
-            ),
-        ),
-    ):
-        with pytest.raises(HTTPException) as exc_info:
-            await validate_bearer_key(token, session)
-
-    assert exc_info.value.status_code == 500
-    detail = cast(dict[str, dict[str, str]], exc_info.value.detail)
-    assert detail["error"]["code"] == "internal_error"
-    assert await session.get(ApiKey, hashed_key) is None
-
-
-@pytest.mark.asyncio
-async def test_malformed_cashu_token_returns_400_invalid_token(
-    session: AsyncSession,
-) -> None:
-    """A malformed 'cashu...' token that fails to decode maps to 400
-    invalid_cashu_token (shared taxonomy), not the generic 401 invalid_api_key."""
-    token = "cashuAthis_is_not_a_valid_token"
-
-    with patch(
-        "routstr.auth.deserialize_token_from_string",
-        side_effect=ValueError("unable to decode token: bad base64"),
-    ):
-        with pytest.raises(HTTPException) as exc_info:
-            await validate_bearer_key(token, session)
-
-    assert exc_info.value.status_code == 400
-    detail = cast(dict[str, dict[str, str]], exc_info.value.detail)
-    assert detail["error"]["type"] == "invalid_token"
-    assert detail["error"]["code"] == "invalid_cashu_token"
-    # Raw decoder text must not leak to the client.
-    assert "base64" not in detail["error"]["message"]

tests/unit/test_auto_topup.py

@@ -1,143 +0,0 @@
-import json
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-
-from routstr.core.db import CashuTransaction
-from routstr.upstream.auto_topup import _check_and_topup
-
-
-def _row() -> MagicMock:
-    row = MagicMock()
-    row.id = "provider-1"
-    row.base_url = "https://provider.test"
-    row.api_key = "secret"
-    row.provider_settings = json.dumps(
-        {
-            "auto_topup": True,
-            "topup_threshold": 100,
-            "topup_amount_limit": 50,
-            "topup_mint_url": "https://mint.test",
-        }
-    )
-    return row
-
-
-class _Session:
-    def __init__(self, transaction: CashuTransaction) -> None:
-        self.transaction = transaction
-        self.commit = AsyncMock()
-
-    async def __aenter__(self) -> "_Session":
-        return self
-
-    async def __aexit__(self, *args: object) -> None:
-        return None
-
-    async def exec(self, query: object) -> MagicMock:
-        result = MagicMock()
-        result.first.return_value = self.transaction
-        return result
-
-    def add(self, transaction: CashuTransaction) -> None:
-        self.transaction = transaction
-
-
-@pytest.mark.asyncio
-async def test_auto_topup_persists_before_sending_and_marks_success_collected() -> None:
-    provider = MagicMock()
-    provider.get_balance = AsyncMock(return_value=0)
-    provider.topup = AsyncMock(return_value={"balance": 50})
-    transaction = CashuTransaction(
-        token="cashu-token", amount=50, unit="sat", source="auto_topup"
-    )
-    session = _Session(transaction)
-
-    with (
-        patch(
-            "routstr.upstream.auto_topup.RoutstrUpstreamProvider.from_db_row",
-            return_value=provider,
-        ),
-        patch(
-            "routstr.upstream.auto_topup.send_token",
-            AsyncMock(return_value="cashu-token"),
-        ),
-        patch(
-            "routstr.upstream.auto_topup.store_cashu_transaction",
-            AsyncMock(return_value=True),
-        ) as store,
-        patch("routstr.upstream.auto_topup.create_session", return_value=session),
-    ):
-        await _check_and_topup(_row())
-
-    store.assert_awaited_once_with(
-        token="cashu-token",
-        amount=50,
-        unit="sat",
-        mint_url="https://mint.test",
-        typ="out",
-        collected=False,
-        source="auto_topup",
-    )
-    provider.topup.assert_awaited_once_with("cashu-token")
-    assert transaction.collected is True
-    session.commit.assert_awaited_once()
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("outcome", [{"error": "rejected"}, RuntimeError("network")])
-async def test_auto_topup_failure_leaves_persisted_token_uncollected(
-    outcome: object,
-) -> None:
-    provider = MagicMock()
-    provider.get_balance = AsyncMock(return_value=0)
-    provider.topup = AsyncMock(
-        side_effect=outcome if isinstance(outcome, Exception) else None,
-        return_value=outcome,
-    )
-
-    with (
-        patch(
-            "routstr.upstream.auto_topup.RoutstrUpstreamProvider.from_db_row",
-            return_value=provider,
-        ),
-        patch(
-            "routstr.upstream.auto_topup.send_token",
-            AsyncMock(return_value="cashu-token"),
-        ),
-        patch(
-            "routstr.upstream.auto_topup.store_cashu_transaction",
-            AsyncMock(return_value=True),
-        ),
-        patch("routstr.upstream.auto_topup.create_session") as create_session,
-    ):
-        if isinstance(outcome, Exception):
-            with pytest.raises(RuntimeError):
-                await _check_and_topup(_row())
-        else:
-            await _check_and_topup(_row())
-
-    create_session.assert_not_called()
-
-
-@pytest.mark.asyncio
-async def test_auto_topup_does_not_send_untracked_token() -> None:
-    provider = MagicMock()
-    provider.get_balance = AsyncMock(return_value=0)
-    provider.topup = AsyncMock()
-    with (
-        patch(
-            "routstr.upstream.auto_topup.RoutstrUpstreamProvider.from_db_row",
-            return_value=provider,
-        ),
-        patch(
-            "routstr.upstream.auto_topup.send_token",
-            AsyncMock(return_value="cashu-token"),
-        ),
-        patch(
-            "routstr.upstream.auto_topup.store_cashu_transaction",
-            AsyncMock(side_effect=RuntimeError("database unavailable")),
-        ),
-    ):
-        await _check_and_topup(_row())
-    provider.topup.assert_not_awaited()

tests/unit/test_balance.py

@@ -1,13 +1,13 @@
 import json
 from unittest.mock import AsyncMock, MagicMock, patch
 
-import httpx
 import pytest
+from fastapi import HTTPException
 from fastapi.responses import JSONResponse
 
-from routstr.balance import refund_wallet_endpoint, topup_wallet_endpoint
+from routstr.balance import refund_wallet_endpoint
 from routstr.core.db import ApiKey, CashuTransaction
-from routstr.wallet import MintConnectionError, credit_balance
+from routstr.wallet import credit_balance
 
 
 def _make_cashu_tx(
@@ -89,8 +89,6 @@ async def test_refund_x_cashu_sat_unit() -> None:
 
 @pytest.mark.asyncio
 async def test_refund_x_cashu_not_found_raises_404() -> None:
-    from fastapi import HTTPException
-
     session = MagicMock()
     session.exec = AsyncMock(return_value=_exec_result(None))
 
@@ -105,67 +103,32 @@ async def test_refund_x_cashu_not_found_raises_404() -> None:
 
 
 @pytest.mark.asyncio
-async def test_refund_x_cashu_pending_raises_425() -> None:
-    """in row exists with a request_id but out row not yet created → 425.
-
-    This is the race condition where /v1/wallet/refund is polled while the
-    upstream request is still in flight. The endpoint must signal "retry"
-    rather than a permanent 404.
-    """
-    from fastapi import HTTPException
-
-    x_cashu_token = "cashuApending_token"
+async def test_refund_x_cashu_pending_out_tx_raises_425() -> None:
     in_tx = _make_cashu_tx(
-        token=x_cashu_token, amount=0, unit="msat", type="in", request_id="req-pending"
+        token="cashuApending_token",
+        amount=0,
+        unit="msat",
+        type="in",
+        request_id="req-pending",
     )
 
     session = MagicMock()
     session.exec = AsyncMock(side_effect=[_exec_result(in_tx), _exec_result(None)])
-    session.add = MagicMock()
-    session.commit = AsyncMock()
 
     with pytest.raises(HTTPException) as exc_info:
         await refund_wallet_endpoint(
             authorization="Bearer sk-somekey",
-            x_cashu=x_cashu_token,
+            x_cashu="cashuApending_token",
             session=session,
         )
 
     assert exc_info.value.status_code == 425
-    assert exc_info.value.headers == {"Retry-After": "2"}
-
-
-@pytest.mark.asyncio
-async def test_refund_x_cashu_in_tx_without_request_id_raises_404() -> None:
-    """in row exists but has no request_id (cannot link to a refund) → 404.
-
-    This is a genuine "no refund will ever exist" case, distinct from the
-    pending 425 path.
-    """
-    from fastapi import HTTPException
-
-    x_cashu_token = "cashuAnoreqid_token"
-    in_tx = _make_cashu_tx(
-        token=x_cashu_token, amount=0, unit="msat", type="in", request_id=None
-    )
-
-    session = MagicMock()
-    session.exec = AsyncMock(side_effect=[_exec_result(in_tx)])
-
-    with pytest.raises(HTTPException) as exc_info:
-        await refund_wallet_endpoint(
-            authorization="Bearer sk-somekey",
-            x_cashu=x_cashu_token,
-            session=session,
-        )
-
-    assert exc_info.value.status_code == 404
+    assert exc_info.value.detail == "Refund not ready. Retry later."
+    assert exc_info.value.headers == {"Retry-After": "5"}
 
 
 @pytest.mark.asyncio
 async def test_refund_x_cashu_swept_raises_410() -> None:
-    from fastapi import HTTPException
-
     in_tx = _make_cashu_tx(token="cashuAswept_token", amount=0, unit="msat", type="in", request_id="req-swept")
     out_tx = _make_cashu_tx(token="cashuAswept", amount=100, unit="msat", type="out", request_id="req-swept", swept=True)
 
@@ -398,10 +361,7 @@ async def test_apikey_refund_restores_balance_on_mint_failure() -> None:
 
     with (
         patch("routstr.balance.get_billing_key", AsyncMock(return_value=key)),
-        patch(
-            "routstr.balance.send_token",
-            AsyncMock(side_effect=MintConnectionError("raw mint outage detail")),
-        ),
+        patch("routstr.balance.send_token", AsyncMock(side_effect=Exception("mint down"))),
         patch("routstr.balance.store_cashu_transaction", AsyncMock()),
         patch("routstr.balance._refund_cache_get", AsyncMock(return_value=None)),
         patch("routstr.balance._refund_cache_set", AsyncMock()),
@@ -415,46 +375,10 @@ async def test_apikey_refund_restores_balance_on_mint_failure() -> None:
             )
 
     assert exc_info.value.status_code == 503
-    assert exc_info.value.detail == "Mint service unavailable"
-    assert "raw mint outage detail" not in exc_info.value.detail
     # Verify two exec calls: debit + restore
     assert session.exec.await_count == 2
 
 
-@pytest.mark.asyncio
-async def test_apikey_refund_generic_failure_is_sanitized_500() -> None:
-    """Unexpected send-side failures restore balance without leaking exception text."""
-    from fastapi import HTTPException
-
-    key = _make_api_key(balance=5000, refund_currency="sat")
-    raw_error = "database secret token raw-mint-response"
-
-    session = MagicMock()
-    session.get = AsyncMock(return_value=key)
-    session.exec = AsyncMock(side_effect=[_update_result(1), _update_result(1)])
-    session.commit = AsyncMock()
-
-    with (
-        patch("routstr.balance.get_billing_key", AsyncMock(return_value=key)),
-        patch("routstr.balance.send_token", AsyncMock(side_effect=RuntimeError(raw_error))),
-        patch("routstr.balance.store_cashu_transaction", AsyncMock()),
-        patch("routstr.balance._refund_cache_get", AsyncMock(return_value=None)),
-        patch("routstr.balance._refund_cache_set", AsyncMock()),
-        patch("routstr.balance.logger"),
-    ):
-        with pytest.raises(HTTPException) as exc_info:
-            await refund_wallet_endpoint(
-                authorization="Bearer sk-testhash",
-                x_cashu=None,
-                session=session,
-            )
-
-    assert exc_info.value.status_code == 500
-    assert exc_info.value.detail == "Refund failed"
-    assert raw_error not in exc_info.value.detail
-    assert session.exec.await_count == 2
-
-
 # ---------------------------------------------------------------------------
 # no-create guarantee: fresh Cashu/unknown sk- tokens must not create API keys
 # ---------------------------------------------------------------------------
@@ -499,190 +423,3 @@ async def test_refund_unknown_sk_bearer_returns_401() -> None:
 
     assert exc_info.value.status_code == 401
     session.get.assert_awaited_once()
-
-
-# --- Topup redemption error taxonomy (POST /v1/wallet/topup) ------------------
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    "error",
-    [
-        httpx.ConnectError("All connection attempts failed"),
-        MintConnectionError("connect to mint refused"),
-        TimeoutError("timed out connecting to mint"),
-    ],
-)
-async def test_topup_mint_unreachable_returns_503(error: Exception) -> None:
-    """A down mint must surface 503 (retryable), not 400 or 500 — the token is
-    fine, so the client should retry once the mint recovers."""
-    from fastapi import HTTPException
-
-    key = _make_api_key(balance=1000)
-    session = MagicMock()
-
-    with (
-        patch("routstr.balance.get_billing_key", AsyncMock(return_value=key)),
-        patch("routstr.balance.credit_balance", AsyncMock(side_effect=error)),
-    ):
-        with pytest.raises(HTTPException) as exc_info:
-            await topup_wallet_endpoint(
-                cashu_token="cashuAtoken", key=key, session=session
-            )
-
-    assert exc_info.value.status_code == 503
-    assert exc_info.value.detail == "Cashu mint is unreachable"
-
-
-@pytest.mark.asyncio
-async def test_topup_already_spent_still_returns_400() -> None:
-    """Regression: the mint-unreachable short-circuit must not swallow the
-    existing ValueError substring buckets."""
-    from fastapi import HTTPException
-
-    key = _make_api_key(balance=1000)
-    session = MagicMock()
-
-    with (
-        patch("routstr.balance.get_billing_key", AsyncMock(return_value=key)),
-        patch(
-            "routstr.balance.credit_balance",
-            AsyncMock(side_effect=ValueError("Token already spent")),
-        ),
-    ):
-        with pytest.raises(HTTPException) as exc_info:
-            await topup_wallet_endpoint(
-                cashu_token="cashuAtoken", key=key, session=session
-            )
-
-    assert exc_info.value.status_code == 400
-    assert exc_info.value.detail == "Cashu token already spent"
-
-
-@pytest.mark.asyncio
-async def test_topup_zero_value_returns_400_zero_value_message() -> None:
-    """A dust/zero redemption maps to the documented zero-value message, not the
-    generic redemption-failed one."""
-    from fastapi import HTTPException
-
-    key = _make_api_key(balance=1000)
-    session = MagicMock()
-
-    with (
-        patch("routstr.balance.get_billing_key", AsyncMock(return_value=key)),
-        patch(
-            "routstr.balance.credit_balance",
-            AsyncMock(
-                side_effect=ValueError("Redeemed token amount must be positive, got 0 msats")
-            ),
-        ),
-    ):
-        with pytest.raises(HTTPException) as exc_info:
-            await topup_wallet_endpoint(
-                cashu_token="cashuAtoken", key=key, session=session
-            )
-
-    assert exc_info.value.status_code == 400
-    assert exc_info.value.detail == "Failed to redeem Cashu token: token yielded no value"
-
-
-@pytest.mark.asyncio
-async def test_topup_token_consumed_returns_500() -> None:
-    """A post-redemption crediting failure (token spent) is a non-retryable 500,
-    not a 4xx that invites a retry."""
-    from fastapi import HTTPException
-
-    from routstr.wallet import TokenConsumedError
-
-    key = _make_api_key(balance=1000)
-    session = MagicMock()
-
-    with (
-        patch("routstr.balance.get_billing_key", AsyncMock(return_value=key)),
-        patch(
-            "routstr.balance.credit_balance",
-            AsyncMock(side_effect=TokenConsumedError("credit failed")),
-        ),
-    ):
-        with pytest.raises(HTTPException) as exc_info:
-            await topup_wallet_endpoint(
-                cashu_token="cashuAtoken", key=key, session=session
-            )
-
-    assert exc_info.value.status_code == 500
-    assert exc_info.value.detail == (
-        "Token was redeemed but could not be credited; do not retry"
-    )
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    ("error", "expected_status", "expected_detail"),
-    [
-        (
-            ValueError(
-                "Failed to estimate fees: Fees (7 sat) exceed token amount (5 sat)"
-            ),
-            422,
-            "Token value is too small to cover swap fees",
-        ),
-        (
-            ValueError(
-                "Token amount (5 sat) is insufficient to cover melt fees."
-            ),
-            422,
-            "Token value is too small to cover swap fees",
-        ),
-        (
-            ValueError("Failed to melt token from foreign mint http://m: boom"),
-            422,
-            "Failed to swap token from foreign mint",
-        ),
-    ],
-)
-async def test_topup_fee_and_swap_failures_return_422(
-    error: Exception, expected_status: int, expected_detail: str
-) -> None:
-    """Fee/swap failures map to 422 (shared taxonomy), matching the bearer and
-    X-Cashu paths — previously top-up flattened these to 400."""
-    from fastapi import HTTPException
-
-    key = _make_api_key(balance=1000)
-    session = MagicMock()
-
-    with (
-        patch("routstr.balance.get_billing_key", AsyncMock(return_value=key)),
-        patch("routstr.balance.credit_balance", AsyncMock(side_effect=error)),
-    ):
-        with pytest.raises(HTTPException) as exc_info:
-            await topup_wallet_endpoint(
-                cashu_token="cashuAtoken", key=key, session=session
-            )
-
-    assert exc_info.value.status_code == expected_status
-    assert exc_info.value.detail == expected_detail
-
-
-@pytest.mark.asyncio
-async def test_topup_unexpected_non_valueerror_returns_500() -> None:
-    """A non-ValueError, non-transport fault is an internal error (500), not a
-    sanitized 400 — the merged except must preserve this."""
-    from fastapi import HTTPException
-
-    key = _make_api_key(balance=1000)
-    session = MagicMock()
-
-    with (
-        patch("routstr.balance.get_billing_key", AsyncMock(return_value=key)),
-        patch(
-            "routstr.balance.credit_balance",
-            AsyncMock(side_effect=RuntimeError("db exploded")),
-        ),
-    ):
-        with pytest.raises(HTTPException) as exc_info:
-            await topup_wallet_endpoint(
-                cashu_token="cashuAtoken", key=key, session=session
-            )
-
-    assert exc_info.value.status_code == 500
-    assert exc_info.value.detail == "Internal server error"

tests/unit/test_cashu_transaction_storage_errors.py

@@ -1,56 +0,0 @@
-from unittest.mock import AsyncMock, patch
-
-import pytest
-
-from routstr.core.db import store_cashu_transaction
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    "error",
-    [
-        OSError("disk full"),
-        RuntimeError("connection lost"),
-        ConnectionRefusedError("database unavailable"),
-    ],
-)
-async def test_store_cashu_transaction_propagates_commit_errors(
-    error: Exception,
-) -> None:
-    session = AsyncMock()
-    session.commit.side_effect = error
-    session.__aenter__.return_value = session
-    session.__aexit__.return_value = None
-
-    with (
-        patch("routstr.core.db.create_session", return_value=session),
-        patch("routstr.core.db.logger.critical") as critical,
-    ):
-        with pytest.raises(type(error), match=str(error)):
-            await store_cashu_transaction(
-                token="cashuAtest",
-                amount=1_000,
-                unit="sat",
-                mint_url="https://mint.example",
-                typ="out",
-                request_id="request-1",
-            )
-
-    critical.assert_called_once()
-
-
-@pytest.mark.asyncio
-async def test_store_cashu_transaction_returns_true_after_commit() -> None:
-    session = AsyncMock()
-    session.__aenter__.return_value = session
-    session.__aexit__.return_value = None
-
-    with patch("routstr.core.db.create_session", return_value=session):
-        stored = await store_cashu_transaction(
-            token="cashuAtest",
-            amount=1_000,
-            unit="sat",
-        )
-
-    assert stored is True
-    session.commit.assert_awaited_once()

tests/unit/test_cashu_transaction_storage_retry.py

@@ -1,91 +0,0 @@
-from typing import Any
-from unittest.mock import AsyncMock, patch
-
-import pytest
-from sqlalchemy.ext.asyncio import create_async_engine
-from sqlmodel import SQLModel, select
-from sqlmodel.ext.asyncio.session import AsyncSession
-
-from routstr.core import db
-
-
-@pytest.mark.asyncio
-async def test_cashu_transaction_storage_retries_then_succeeds() -> None:
-    store = AsyncMock(side_effect=[OSError("database locked"), True])
-    sleep = AsyncMock()
-
-    with (
-        patch("routstr.core.db.store_cashu_transaction", store),
-        patch("routstr.core.db.asyncio.sleep", sleep),
-    ):
-        stored = await db.store_cashu_transaction_with_retry(
-            token="cashuAretry",
-            amount=100,
-            unit="sat",
-        )
-
-    assert stored is True
-    assert store.await_count == 2
-    sleep.assert_awaited_once_with(0.25)
-
-
-@pytest.mark.asyncio
-async def test_cashu_transaction_retry_is_idempotent_after_ambiguous_commit() -> None:
-    engine = create_async_engine("sqlite+aiosqlite://")
-    async with engine.begin() as connection:
-        await connection.run_sync(SQLModel.metadata.create_all)
-
-    original_store = db.store_cashu_transaction
-    attempts = 0
-
-    async def ambiguous_store(**kwargs: Any) -> bool:
-        nonlocal attempts
-        attempts += 1
-        stored = await original_store(**kwargs)
-        if attempts == 1:
-            raise OSError("connection dropped after commit")
-        return stored
-
-    with (
-        patch.object(db, "engine", engine),
-        patch("routstr.core.db.store_cashu_transaction", ambiguous_store),
-        patch("routstr.core.db.asyncio.sleep", AsyncMock()),
-    ):
-        stored = await db.store_cashu_transaction_with_retry(
-            token="cashuAambiguous",
-            amount=100,
-            unit="sat",
-        )
-
-        async with AsyncSession(engine) as session:
-            result = await session.exec(select(db.CashuTransaction))
-            transactions = result.all()
-
-    assert stored is True
-    assert attempts == 2
-    assert len(transactions) == 1
-    await engine.dispose()
-
-
-@pytest.mark.asyncio
-async def test_cashu_transaction_storage_raises_after_bounded_retries() -> None:
-    error = OSError("database unavailable")
-    store = AsyncMock(side_effect=error)
-    sleep = AsyncMock()
-
-    with (
-        patch("routstr.core.db.store_cashu_transaction", store),
-        patch("routstr.core.db.asyncio.sleep", sleep),
-        patch("routstr.core.db.logger.critical") as critical,
-    ):
-        with pytest.raises(OSError, match="database unavailable"):
-            await db.store_cashu_transaction_with_retry(
-                token="cashuAfail",
-                amount=100,
-                unit="sat",
-                max_attempts=3,
-            )
-
-    assert store.await_count == 3
-    assert [call.args[0] for call in sleep.await_args_list] == [0.25, 0.5]
-    critical.assert_called_once()

tests/unit/test_cost_calculation_caching.py

@@ -465,179 +465,9 @@ async def test_cache_read_only_usd_cost_response_is_billed(
     assert result.cache_read_input_tokens == 1000
 
 
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    ("total_cost", "input_cost", "output_cost", "expected_msats"),
-    [
-        (0.000471, 0.00023451, 0.00023649, 9420),
-        (0.00000004, 0.00000002, 0.00000002, 1),
-    ],
-)
-async def test_small_usd_cost_components_sum_to_rounded_total(
-    total_cost: float,
-    input_cost: float,
-    output_cost: float,
-    expected_msats: int,
-) -> None:
-    """Small USD component costs must retain every billed millisatoshi."""
-    response = {
-        "model": "gpt-4",
-        "usage": {
-            "prompt_tokens": 1,
-            "completion_tokens": 1,
-            "cost_details": {
-                "total_cost": total_cost,
-                "input_cost": input_cost,
-                "output_cost": output_cost,
-            },
-        },
-    }
-
-    result = await calculate_cost(response, max_cost=100000)
-
-    assert isinstance(result, CostData)
-    assert result.total_msats == expected_msats
-    assert result.input_msats + result.output_msats == result.total_msats
-
-
-@pytest.mark.asyncio
-async def test_openrouter_upstream_inference_cost_components_are_used() -> None:
-    """OpenRouter component aliases must determine the input/output split."""
-    response = {
-        "model": "gpt-4",
-        "usage": {
-            "prompt_tokens": 375,
-            "completion_tokens": 158,
-            "total_tokens": 533,
-            "cost": 0.00022354,
-            "is_byok": False,
-            "prompt_tokens_details": {
-                "cached_tokens": 286,
-                "cache_write_tokens": 0,
-            },
-            "cost_details": {
-                "upstream_inference_cost": 0.00022354,
-                "upstream_inference_prompt_cost": 0.00004974,
-                "upstream_inference_completions_cost": 0.0001738,
-            },
-            "completion_tokens_details": {"reasoning_tokens": 17},
-        },
-    }
-
-    result = await calculate_cost(response, max_cost=100000)
-
-    assert isinstance(result, CostData)
-    assert result.input_msats == 994
-    assert result.output_msats == 3477
-    assert result.input_msats + result.output_msats == result.total_msats == 4471
-
-
-# ============================================================================
-# PPQ.AI BYOK: upstream_inference_cost + BYOK fee billing
-#
-# PPQ.AI (bring-your-own-key) returns a small ~5 % BYOK routing fee in
-# ``usage.cost`` and the real inference cost in
-# ``cost_details.upstream_inference_cost``.  The old code billed only the fee,
-# under-charging by ~20×.  The fix bills ``upstream_inference_cost + byok_fee``
-# — what PPQ actually deducts from the balance.
-# Payload numbers are from a live ``glm-5.2-fast`` request (GitHub issue #615).
-# ============================================================================
-@pytest.mark.asyncio
-async def test_ppq_byok_bills_upstream_inference_cost_plus_fee() -> None:
-    """PPQ.AI BYOK must bill upstream_inference_cost + byok_fee, not just the
-    fee.  Mirrors the live request from GitHub issue #615."""
-    response = {
-        "model": "glm-5.2-fast",
-        "usage": {
-            "prompt_tokens": 164371,  # includes 159301 cached
-            "completion_tokens": 99,
-            "cost": 0.002260057305,  # ~5% BYOK routing fee
-            "is_byok": True,
-            "prompt_tokens_details": {"cached_tokens": 159301},
-            "cost_details": {
-                "upstream_inference_cost": 0.04475361,
-                "upstream_inference_prompt_cost": 0.04410021,
-                "upstream_inference_completions_cost": 0.0006534,
-            },
-        },
-    }
-    result = await calculate_cost(response, max_cost=100000)
-
-    assert isinstance(result, CostData)
-    # The fix bills upstream_inference_cost + byok_fee (~0.047 USD → ~940k
-    # msats), not the fee alone (~0.0023 USD → ~45k msats).  ~20× correction.
-    assert result.total_msats == 940274
-    assert result.input_msats + result.output_msats == result.total_msats
-    assert result.input_msats == 926546
-    assert result.output_msats == 13728
-    assert result.total_usd == pytest.approx(0.047013667305)
-    # Token normalisation (OpenAI dialect: cached included in prompt_tokens)
-    assert result.input_tokens == 5070  # 164371 - 159301
-    assert result.cache_read_input_tokens == 159301
-    assert result.output_tokens == 99
-
-
-@pytest.mark.asyncio
-async def test_ppq_byok_fee_only_would_undercharge() -> None:
-    """Sanity check: billing only usage.cost (the BYOK fee) under-charges by
-    ~20×.  This documents the regression the fix prevents."""
-    response = {
-        "model": "glm-5.2-fast",
-        "usage": {
-            "prompt_tokens": 164371,
-            "completion_tokens": 99,
-            "cost": 0.002260057305,  # BYOK fee only — no upstream_inference_cost
-            "is_byok": True,
-            "prompt_tokens_details": {"cached_tokens": 159301},
-        },
-    }
-    result = await calculate_cost(response, max_cost=100000)
-
-    assert isinstance(result, CostData)
-    # Without upstream_inference_cost, only the fee is billed — the old bug.
-    assert result.total_msats == 45202
-
-
 # ============================================================================
 # Test 13: Missing Usage Block
 # ============================================================================
-@pytest.mark.asyncio
-async def test_missing_upstream_cost_uses_litellm_model_pricing(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """Token usage without an upstream cost is priced from LiteLLM."""
-    monkeypatch.setattr(settings, "fixed_pricing", True)
-    monkeypatch.setattr(settings, "fixed_per_1k_input_tokens", 0)
-    monkeypatch.setattr(settings, "fixed_per_1k_output_tokens", 0)
-    monkeypatch.setattr(
-        "routstr.payment.models.litellm_cost_entry",
-        lambda model: {
-            "input_cost_per_token": 0.000001,
-            "output_cost_per_token": 0.000002,
-        },
-    )
-    response = {
-        "model": "priced-by-litellm",
-        "usage": {
-            "prompt_tokens": 90,
-            "completion_tokens": 80,
-            "total_tokens": 170,
-            "prompt_tokens_details": {"cached_tokens": 0},
-            "completion_tokens_details": {"reasoning_tokens": 74},
-            "prompt_cache_hit_tokens": 0,
-            "prompt_cache_miss_tokens": 90,
-        },
-    }
-
-    result = await calculate_cost(response, max_cost=10000)
-
-    assert isinstance(result, CostData)
-    assert not isinstance(result, MaxCostData)
-    assert result.input_msats == 1800
-    assert result.output_msats == 3200
-    assert result.input_msats + result.output_msats == result.total_msats == 5000
-
-
 @pytest.mark.asyncio
 async def test_missing_usage_block(mock_fixed_pricing: None) -> None:
     """When usage is missing, return MaxCostData with zero tokens."""

tests/unit/test_ehbp_finalize_payment.py

@@ -1,185 +0,0 @@
-from __future__ import annotations
-
-from typing import AsyncGenerator
-
-import pytest
-from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
-from sqlalchemy.pool import StaticPool
-from sqlmodel import SQLModel, select
-from sqlmodel.ext.asyncio.session import AsyncSession
-
-from routstr.core.db import ApiKey
-from routstr.upstream.ehbp import (
-    finalize_ehbp_actual_cost_payment,
-    finalize_ehbp_max_cost_payment,
-)
-
-
-def _make_engine() -> AsyncEngine:
-    return create_async_engine(
-        "sqlite+aiosqlite://",
-        poolclass=StaticPool,
-        connect_args={"check_same_thread": False},
-    )
-
-
-@pytest.fixture
-async def session(monkeypatch: pytest.MonkeyPatch) -> AsyncGenerator[AsyncSession, None]:
-    monkeypatch.setattr("routstr.upstream.ehbp.ROUTSTR_FEE_PERCENT", 0)
-    engine = _make_engine()
-    async with engine.begin() as conn:
-        await conn.run_sync(SQLModel.metadata.create_all)
-    db_session = AsyncSession(engine, expire_on_commit=False)
-    try:
-        yield db_session
-    finally:
-        await db_session.close()
-        await engine.dispose()
-
-
-async def _api_key(session: AsyncSession, hashed_key: str) -> ApiKey | None:
-    return (
-        await session.exec(select(ApiKey).where(ApiKey.hashed_key == hashed_key))
-    ).one_or_none()
-
-
-@pytest.mark.asyncio
-async def test_finalize_actual_cost_payment_updates_balance_and_releases_reserve(
-    session: AsyncSession,
-) -> None:
-    key = ApiKey(
-        hashed_key="ehbp-actual",
-        balance=10_000,
-        reserved_balance=3_000,
-        reserved_at=123,
-    )
-    session.add(key)
-    await session.commit()
-
-    await finalize_ehbp_actual_cost_payment(
-        key,
-        session,
-        reserved_cost_for_model=3_000,
-        model_id="tinfoil/model",
-        cost_info={
-            "total_msats": 1_200,
-            "input_tokens": 10,
-            "output_tokens": 20,
-            "input_msats": 500,
-            "output_msats": 700,
-        },
-    )
-
-    updated = await _api_key(session, "ehbp-actual")
-    assert updated is not None
-    assert updated.balance == 8_800
-    assert updated.reserved_balance == 0
-    assert updated.reserved_at is None
-    assert updated.total_spent == 1_200
-
-
-@pytest.mark.asyncio
-async def test_finalize_max_cost_payment_updates_parent_and_child_spend(
-    session: AsyncSession,
-) -> None:
-    parent = ApiKey(
-        hashed_key="ehbp-parent",
-        balance=10_000,
-        reserved_balance=3_000,
-        reserved_at=123,
-    )
-    child = ApiKey(
-        hashed_key="ehbp-child",
-        balance=0,
-        reserved_balance=3_000,
-        reserved_at=123,
-        parent_key_hash="ehbp-parent",
-    )
-    session.add(parent)
-    session.add(child)
-    await session.commit()
-
-    await finalize_ehbp_max_cost_payment(
-        child,
-        session,
-        max_cost_for_model=3_000,
-        model_id="tinfoil/model",
-    )
-
-    updated_parent = await _api_key(session, "ehbp-parent")
-    updated_child = await _api_key(session, "ehbp-child")
-    assert updated_parent is not None
-    assert updated_child is not None
-    assert updated_parent.balance == 7_000
-    assert updated_parent.reserved_balance == 0
-    assert updated_parent.reserved_at is None
-    assert updated_parent.total_spent == 3_000
-    assert updated_child.balance == 0
-    assert updated_child.reserved_balance == 0
-    assert updated_child.reserved_at is None
-    assert updated_child.total_spent == 3_000
-
-
-@pytest.mark.asyncio
-async def test_finalize_actual_cost_payment_rolls_back_when_parent_update_matches_no_rows(
-    session: AsyncSession,
-) -> None:
-    key = ApiKey(
-        hashed_key="ehbp-missing-parent",
-        balance=10_000,
-        reserved_balance=3_000,
-        reserved_at=123,
-    )
-    session.add(key)
-    await session.commit()
-    await session.delete(key)
-    await session.commit()
-
-    await finalize_ehbp_actual_cost_payment(
-        key,
-        session,
-        reserved_cost_for_model=3_000,
-        model_id="tinfoil/model",
-        cost_info={"total_msats": 1_200},
-    )
-
-    assert await _api_key(session, "ehbp-missing-parent") is None
-
-
-@pytest.mark.asyncio
-async def test_finalize_max_cost_payment_rolls_back_parent_when_child_update_matches_no_rows(
-    session: AsyncSession,
-) -> None:
-    parent = ApiKey(
-        hashed_key="ehbp-rollback-parent",
-        balance=10_000,
-        reserved_balance=3_000,
-        reserved_at=123,
-    )
-    child = ApiKey(
-        hashed_key="ehbp-missing-child",
-        balance=0,
-        reserved_balance=3_000,
-        reserved_at=123,
-        parent_key_hash="ehbp-rollback-parent",
-    )
-    session.add(parent)
-    session.add(child)
-    await session.commit()
-    await session.delete(child)
-    await session.commit()
-
-    await finalize_ehbp_max_cost_payment(
-        child,
-        session,
-        max_cost_for_model=3_000,
-        model_id="tinfoil/model",
-    )
-
-    updated_parent = await _api_key(session, "ehbp-rollback-parent")
-    assert updated_parent is not None
-    assert updated_parent.balance == 10_000
-    assert updated_parent.reserved_balance == 3_000
-    assert updated_parent.reserved_at == 123
-    assert updated_parent.total_spent == 0
-    assert await _api_key(session, "ehbp-missing-child") is None

tests/unit/test_lnurl_melt_timeout.py

@@ -1,74 +0,0 @@
-"""raw_send_to_lnurl() must not hang forever on an unresponsive mint.
-
-The Cashu library issues POST /v1/melt/bolt11 with timeout=None, so a hung
-mint would block the melt (and the payout loop) indefinitely. raw_send_to_lnurl
-now wraps wallet.melt() in asyncio.wait_for(MELT_TIMEOUT_SECONDS) and surfaces a
-timeout as LNURLError instead of hanging.
-"""
-
-import asyncio
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-
-from routstr.payment import lnurl
-from routstr.payment.lnurl import LNURLError, raw_send_to_lnurl
-
-
-@pytest.mark.asyncio
-async def test_raw_send_to_lnurl_times_out_on_hung_melt() -> None:
-    proofs = [MagicMock(amount=1000)]
-
-    wallet = MagicMock()
-    wallet.melt_quote = AsyncMock(return_value=MagicMock(fee_reserve=1, quote="q"))
-    wallet.select_to_send = AsyncMock(return_value=(proofs, None))
-
-    async def _hang(**kwargs: object) -> None:
-        await asyncio.sleep(5)  # far longer than the patched timeout
-
-    wallet.melt = AsyncMock(side_effect=_hang)
-
-    lnurl_data = {
-        "callback_url": "https://ln.tld/cb",
-        "min_sendable": 1_000,
-        "max_sendable": 100_000_000,
-    }
-
-    with patch.object(lnurl, "MELT_TIMEOUT_SECONDS", 0.05), patch(
-        "routstr.payment.lnurl.get_lnurl_data", AsyncMock(return_value=lnurl_data)
-    ), patch(
-        "routstr.payment.lnurl.get_lnurl_invoice",
-        AsyncMock(return_value=("lnbc1...", {})),
-    ):
-        with pytest.raises(LNURLError, match="Melt timed out"):
-            await raw_send_to_lnurl(wallet, proofs, "owner@ln.tld", "sat", amount=1000)
-
-
-@pytest.mark.asyncio
-async def test_raw_send_to_lnurl_succeeds_within_timeout() -> None:
-    """A prompt melt still returns the net amount, unaffected by the guard."""
-    proofs = [MagicMock(amount=1000)]
-
-    wallet = MagicMock()
-    wallet.melt_quote = AsyncMock(return_value=MagicMock(fee_reserve=1, quote="q"))
-    wallet.select_to_send = AsyncMock(return_value=(proofs, None))
-    wallet.melt = AsyncMock(return_value=MagicMock())
-
-    lnurl_data = {
-        "callback_url": "https://ln.tld/cb",
-        "min_sendable": 1_000,
-        "max_sendable": 100_000_000,
-    }
-
-    with patch.object(lnurl, "MELT_TIMEOUT_SECONDS", 5), patch(
-        "routstr.payment.lnurl.get_lnurl_data", AsyncMock(return_value=lnurl_data)
-    ), patch(
-        "routstr.payment.lnurl.get_lnurl_invoice",
-        AsyncMock(return_value=("lnbc1...", {})),
-    ):
-        paid = await raw_send_to_lnurl(
-            wallet, proofs, "owner@ln.tld", "sat", amount=1000
-        )
-
-    assert paid > 0
-    wallet.melt.assert_awaited_once()

tests/unit/test_messages_litellm_dispatch.py

@@ -11,7 +11,6 @@ import os
 from typing import Any, AsyncIterator
 from unittest.mock import AsyncMock, MagicMock, patch
 
-import httpx
 import pytest
 from fastapi.responses import Response, StreamingResponse
 
@@ -22,7 +21,6 @@ from routstr.core.db import ApiKey  # noqa: E402
 from routstr.payment.cost_calculation import CostData  # noqa: E402
 from routstr.payment.models import Architecture, Model, Pricing  # noqa: E402
 from routstr.upstream.base import BaseUpstreamProvider  # noqa: E402
-from routstr.wallet import MintConnectionError, TokenConsumedError  # noqa: E402
 
 # ---------------------------------------------------------------------------
 # Fixtures
@@ -1310,320 +1308,3 @@ async def test_dispatch_uses_url_detected_prefix_for_fireworks_custom_row() -> N
         "fireworks_ai/accounts/fireworks/models/glm-5"
     )
     assert captured_kwargs["api_base"] == "https://api.fireworks.ai/inference/v1"
-
-
-# ---------------------------------------------------------------------------
-# X-Cashu redemption error taxonomy (unreachable mint + string codes)
-# ---------------------------------------------------------------------------
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    "handler_name",
-    ["handle_x_cashu", "handle_x_cashu_responses"],
-)
-@pytest.mark.parametrize(
-    "error",
-    [
-        httpx.ConnectError("All connection attempts failed"),
-        MintConnectionError("Cashu mint is unreachable"),
-        TimeoutError("timed out connecting to mint"),
-    ],
-)
-async def test_x_cashu_mint_unreachable_returns_503(
-    handler_name: str, error: Exception
-) -> None:
-    """Both X-Cashu entrypoints classify a down mint as 503 mint_unreachable,
-    not a generic 400 cashu_error."""
-    provider = _make_provider()
-    model = _make_model()
-    request = _make_request()
-
-    with patch(
-        "routstr.upstream.base.recieve_token", new=AsyncMock(side_effect=error)
-    ):
-        handler = getattr(provider, handler_name)
-        response = await handler(
-            request=request,
-            x_cashu_token="cashuAtoken",
-            path="v1/chat/completions",
-            max_cost_for_model=10_000,
-            model_obj=model,
-        )
-
-    assert response.status_code == 503
-    body = json.loads(bytes(response.body))
-    assert body["error"]["type"] == "mint_unreachable"
-    assert body["error"]["message"] == "Cashu mint is unreachable"
-    assert body["error"]["code"] == "cashu_mint_unreachable"
-    if str(error) != body["error"]["message"]:
-        assert str(error) not in body["error"]["message"]
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    "handler_name",
-    ["handle_x_cashu", "handle_x_cashu_responses"],
-)
-@pytest.mark.parametrize(
-    (
-        "error",
-        "expected_status",
-        "expected_type",
-        "expected_message",
-        "expected_code",
-    ),
-    [
-        (
-            ValueError("Mint Error: Token already spent"),
-            400,
-            "token_already_spent",
-            "Cashu token already spent",
-            "cashu_token_already_spent",
-        ),
-        (
-            ValueError("invalid token: could not decode"),
-            400,
-            "invalid_token",
-            "Invalid Cashu token",
-            "invalid_cashu_token",
-        ),
-        (
-            # Fee/swap failures now map to a granular 422 on the X-Cashu path,
-            # matching the bearer path (previously flattened to 400).
-            ValueError(
-                "Failed to estimate fees: Fees (7 sat) exceed token amount (5 sat)"
-            ),
-            422,
-            "mint_error",
-            "Token value is too small to cover swap fees",
-            "cashu_token_swap_fees_exceed_amount",
-        ),
-        (
-            ValueError("Failed to melt token from foreign mint http://m: boom"),
-            422,
-            "mint_error",
-            "Failed to swap token from foreign mint",
-            "cashu_foreign_mint_swap_failed",
-        ),
-        (
-            ValueError("some unexpected wallet condition"),
-            400,
-            "cashu_error",
-            "Failed to redeem Cashu token",
-            "cashu_token_redemption_failed",
-        ),
-        (
-            # Non-ValueError faults are internal errors (500), not token errors.
-            RuntimeError("db exploded"),
-            500,
-            "api_error",
-            "Internal error during token redemption",
-            "internal_error",
-        ),
-    ],
-)
-async def test_x_cashu_error_code_is_stable_string(
-    handler_name: str,
-    error: Exception,
-    expected_status: int,
-    expected_type: str,
-    expected_message: str,
-    expected_code: str,
-) -> None:
-    """X-Cashu emits a stable string ``code`` on every branch, matching the
-    bearer path's taxonomy instead of an int HTTP status."""
-    provider = _make_provider()
-    model = _make_model()
-    request = _make_request()
-
-    with patch(
-        "routstr.upstream.base.recieve_token", new=AsyncMock(side_effect=error)
-    ):
-        handler = getattr(provider, handler_name)
-        response = await handler(
-            request=request,
-            x_cashu_token="cashuAtoken",
-            path="v1/chat/completions",
-            max_cost_for_model=10_000,
-            model_obj=model,
-        )
-
-    assert response.status_code == expected_status
-    body = json.loads(bytes(response.body))
-    assert body["error"]["type"] == expected_type
-    assert body["error"]["message"] == expected_message
-    assert body["error"]["code"] == expected_code
-    assert isinstance(body["error"]["code"], str)
-    if str(error) != expected_message:
-        assert str(error) not in body["error"]["message"]
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    ("handler_name", "forward_attr"),
-    [
-        ("handle_x_cashu", "forward_x_cashu_request"),
-        ("handle_x_cashu_responses", "forward_x_cashu_responses_request"),
-    ],
-)
-async def test_x_cashu_transport_error_after_redemption_is_not_retryable(
-    handler_name: str, forward_attr: str
-) -> None:
-    """A transport failure while forwarding (after the token is spent) maps to
-    502 upstream_error, never a retryable cashu_mint_unreachable."""
-    provider = _make_provider()
-    model = _make_model()
-    request = _make_request()
-
-    with (
-        patch(
-            "routstr.upstream.base.recieve_token",
-            new=AsyncMock(return_value=(5_000, "sat", "https://mint")),
-        ),
-        patch("routstr.upstream.base.store_cashu_transaction", new=AsyncMock()),
-        patch.object(
-            provider,
-            forward_attr,
-            new=AsyncMock(side_effect=httpx.ConnectError("upstream down")),
-        ),
-    ):
-        handler = getattr(provider, handler_name)
-        response = await handler(
-            request=request,
-            x_cashu_token="cashuAtoken",
-            path="v1/chat/completions",
-            max_cost_for_model=10_000,
-            model_obj=model,
-        )
-
-    assert response.status_code == 502
-    body = json.loads(bytes(response.body))
-    assert body["error"]["type"] == "upstream_error"
-    assert body["error"]["code"] != "cashu_mint_unreachable"
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    "handler_name",
-    ["handle_x_cashu", "handle_x_cashu_responses"],
-)
-async def test_x_cashu_token_consumed_returns_500_and_no_echo(
-    handler_name: str,
-) -> None:
-    """A post-redemption failure (token spent, crediting/minting failed) is a
-    non-retryable 500 token_consumed and must NOT echo the spent token back."""
-    provider = _make_provider()
-    model = _make_model()
-    request = _make_request()
-
-    with patch(
-        "routstr.upstream.base.recieve_token",
-        new=AsyncMock(side_effect=TokenConsumedError("credit failed")),
-    ):
-        handler = getattr(provider, handler_name)
-        response = await handler(
-            request=request,
-            x_cashu_token="cashuAtoken",
-            path="v1/chat/completions",
-            max_cost_for_model=10_000,
-            model_obj=model,
-        )
-
-    assert response.status_code == 500
-    body = json.loads(bytes(response.body))
-    assert body["error"]["type"] == "token_consumed"
-    assert body["error"]["code"] == "cashu_token_consumed"
-    assert "X-Cashu" not in response.headers
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    ("handler_name", "error", "echoed"),
-    [
-        # Spent token: must NOT be echoed.
-        ("handle_x_cashu", ValueError("Token already spent"), False),
-        ("handle_x_cashu_responses", ValueError("Token already spent"), False),
-        # Unspent but unreachable mint: echo so the client can retry the token.
-        ("handle_x_cashu", MintConnectionError("mint down"), True),
-        ("handle_x_cashu_responses", MintConnectionError("mint down"), True),
-        # Consumed token (post-redemption): must NOT be echoed.
-        ("handle_x_cashu", TokenConsumedError("credit failed"), False),
-        ("handle_x_cashu_responses", TokenConsumedError("credit failed"), False),
-    ],
-)
-async def test_x_cashu_echoes_token_only_when_recoverable(
-    handler_name: str, error: Exception, echoed: bool
-) -> None:
-    provider = _make_provider()
-    model = _make_model()
-    request = _make_request()
-
-    with patch(
-        "routstr.upstream.base.recieve_token", new=AsyncMock(side_effect=error)
-    ):
-        handler = getattr(provider, handler_name)
-        response = await handler(
-            request=request,
-            x_cashu_token="cashuAtoken",
-            path="v1/chat/completions",
-            max_cost_for_model=10_000,
-            model_obj=model,
-        )
-
-    if echoed:
-        assert response.headers.get("X-Cashu") == "cashuAtoken"
-    else:
-        assert "X-Cashu" not in response.headers
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    ("handler_name", "forward_attr"),
-    [
-        ("handle_x_cashu", "forward_x_cashu_request"),
-        ("handle_x_cashu_responses", "forward_x_cashu_responses_request"),
-    ],
-)
-@pytest.mark.parametrize("amount", [0, -5])
-async def test_x_cashu_zero_value_rejected_not_forwarded(
-    handler_name: str, forward_attr: str, amount: int
-) -> None:
-    """A token that redeems to <= 0 must be rejected as cashu_token_zero_value
-    (400) and NEVER forwarded as a free request — the X-Cashu path lacked the
-    guard that credit_balance has."""
-    provider = _make_provider()
-    model = _make_model()
-    request = _make_request()
-
-    with (
-        patch(
-            "routstr.upstream.base.recieve_token",
-            new=AsyncMock(return_value=(amount, "sat", "https://mint")),
-        ),
-        patch("routstr.upstream.base.store_cashu_transaction", new=AsyncMock()),
-        patch.object(
-            provider,
-            forward_attr,
-            new=AsyncMock(side_effect=AssertionError("must not forward a zero-value token")),
-        ),
-    ):
-        handler = getattr(provider, handler_name)
-        response = await handler(
-            request=request,
-            x_cashu_token="cashuAtoken",
-            path="v1/chat/completions",
-            max_cost_for_model=10_000,
-            model_obj=model,
-        )
-
-    assert response.status_code == 400
-    body = json.loads(bytes(response.body))
-    assert body["error"]["type"] == "cashu_error"
-    assert (
-        body["error"]["message"]
-        == "Failed to redeem Cashu token: token yielded no value"
-    )
-    assert body["error"]["code"] == "cashu_token_zero_value"
-    # Spent-to-zero token must not be echoed back for retry.
-    assert "X-Cashu" not in response.headers

tests/unit/test_periodic_payout.py

@@ -1,154 +0,0 @@
-"""Tests for periodic_payout() resilience fixes.
-
-Covers two regressions from the auto-payout / primary-mint audit
-(docs/auto-payout-primary-mint-failure-report.md):
-
-1. periodic_payout() must include settings.primary_mint even when it is not
-   listed in settings.cashu_mints, matching fetch_all_balances(); otherwise
-   primary-mint funds never auto-payout.
-2. A failure on one mint/unit must not abort payout for the remaining
-   mint/units in the same cycle (the try/except is now per mint/unit).
-"""
-
-from collections.abc import Callable, Coroutine
-from contextlib import asynccontextmanager
-from typing import Any
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-
-from routstr.wallet import periodic_payout
-
-# Sentinel interval used to break the otherwise-infinite payout loop after
-# exactly one full cycle.
-_INTERVAL = 987
-
-
-class _LoopBreak(Exception):
-    """Raised via the patched sleep to stop periodic_payout after one cycle."""
-
-
-@asynccontextmanager
-async def _fake_session():  # type: ignore[no-untyped-def]
-    yield MagicMock()
-
-
-def _one_cycle_sleep() -> Callable[[float], Coroutine[Any, Any, None]]:
-    """Return an async sleep stub that lets exactly one payout cycle run.
-
-    The top-of-loop sleep uses the sentinel interval; the second time it is
-    seen (start of the second cycle) we raise to break out. The inner
-    ``asyncio.sleep(5)`` pass-through is ignored.
-    """
-    seen = {"interval": 0}
-
-    async def _sleep(seconds: float) -> None:
-        if seconds == _INTERVAL:
-            seen["interval"] += 1
-            if seen["interval"] >= 2:
-                raise _LoopBreak()
-
-    return _sleep
-
-
-@pytest.mark.asyncio
-async def test_periodic_payout_includes_primary_mint_not_in_cashu_mints() -> None:
-    """primary_mint absent from cashu_mints is still paid out."""
-    from routstr.core.settings import settings
-
-    get_wallet = AsyncMock(return_value=MagicMock())
-    raw_send = AsyncMock(return_value=1000)
-
-    with patch.object(settings, "cashu_mints", []), patch.object(
-        settings, "primary_mint", "http://primary:3338"
-    ), patch.object(settings, "receive_ln_address", "owner@ln.tld"), patch.object(
-        settings, "payout_interval_seconds", _INTERVAL
-    ), patch.object(settings, "min_payout_sat", 10), patch(
-        "routstr.wallet.asyncio.sleep", _one_cycle_sleep()
-    ), patch("routstr.wallet.db.create_session", _fake_session), patch(
-        "routstr.wallet.get_wallet", get_wallet
-    ), patch(
-        "routstr.wallet.get_proofs_per_mint_and_unit",
-        MagicMock(return_value=[MagicMock(amount=100_000)]),
-    ), patch(
-        "routstr.wallet.slow_filter_spend_proofs",
-        AsyncMock(side_effect=lambda proofs, wallet: proofs),
-    ), patch(
-        "routstr.wallet.db.balances_for_mint_and_unit", AsyncMock(return_value=0)
-    ), patch("routstr.wallet.raw_send_to_lnurl", raw_send):
-        with pytest.raises(_LoopBreak):
-            await periodic_payout()
-
-    processed = {call.args[0] for call in get_wallet.await_args_list}
-    assert processed == {"http://primary:3338"}
-    assert raw_send.await_count >= 1
-
-
-@pytest.mark.asyncio
-async def test_periodic_payout_isolates_failing_mint() -> None:
-    """A failing mint does not prevent payout for the other mints."""
-    from routstr.core.settings import settings
-
-    async def _get_wallet(mint_url: str, unit: str) -> MagicMock:
-        if mint_url == "http://bad:3338":
-            raise RuntimeError("mint unreachable")
-        return MagicMock()
-
-    get_wallet = AsyncMock(side_effect=_get_wallet)
-    raw_send = AsyncMock(return_value=1000)
-
-    with patch.object(
-        settings, "cashu_mints", ["http://bad:3338", "http://good:3338"]
-    ), patch.object(settings, "primary_mint", "http://good:3338"), patch.object(
-        settings, "receive_ln_address", "owner@ln.tld"
-    ), patch.object(settings, "payout_interval_seconds", _INTERVAL), patch.object(
-        settings, "min_payout_sat", 10
-    ), patch("routstr.wallet.asyncio.sleep", _one_cycle_sleep()), patch(
-        "routstr.wallet.db.create_session", _fake_session
-    ), patch("routstr.wallet.get_wallet", get_wallet), patch(
-        "routstr.wallet.get_proofs_per_mint_and_unit",
-        MagicMock(return_value=[MagicMock(amount=100_000)]),
-    ), patch(
-        "routstr.wallet.slow_filter_spend_proofs",
-        AsyncMock(side_effect=lambda proofs, wallet: proofs),
-    ), patch(
-        "routstr.wallet.db.balances_for_mint_and_unit", AsyncMock(return_value=0)
-    ), patch("routstr.wallet.raw_send_to_lnurl", raw_send):
-        with pytest.raises(_LoopBreak):
-            await periodic_payout()
-
-    # The bad mint raised on get_wallet for both units, yet the good mint was
-    # still reached and paid out for both units — failures are isolated.
-    good_calls = [
-        c for c in get_wallet.await_args_list if c.args[0] == "http://good:3338"
-    ]
-    assert len(good_calls) == 2  # sat + msat
-    assert raw_send.await_count == 2  # good mint paid for both units
-
-
-@pytest.mark.asyncio
-async def test_periodic_payout_handles_session_creation_failure() -> None:
-    """A db.create_session failure is logged and the payout loop continues."""
-    from routstr.core.settings import settings
-
-    create_session = MagicMock(side_effect=RuntimeError("db unavailable"))
-    logger = MagicMock()
-
-    with patch.object(settings, "cashu_mints", ["http://mint:3338"]), patch.object(
-        settings, "primary_mint", "http://mint:3338"
-    ), patch.object(settings, "receive_ln_address", "owner@ln.tld"), patch.object(
-        settings, "payout_interval_seconds", _INTERVAL
-    ), patch(
-        "routstr.wallet.asyncio.sleep", _one_cycle_sleep()
-    ), patch(
-        "routstr.wallet.db.create_session", create_session
-    ), patch("routstr.wallet.logger", logger):
-        with pytest.raises(_LoopBreak):
-            await periodic_payout()
-
-    create_session.assert_called_once()
-    logger.error.assert_called_once()
-    message = logger.error.call_args.args[0]
-    extra = logger.error.call_args.kwargs["extra"]
-    assert message == "Error in periodic payout cycle: RuntimeError"
-    assert extra == {"error": "db unavailable"}

tests/unit/test_periodic_refund_sweep.py

@@ -1,126 +0,0 @@
-from contextlib import asynccontextmanager
-from typing import AsyncGenerator
-from unittest.mock import AsyncMock
-
-import pytest
-from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
-from sqlalchemy.pool import StaticPool
-from sqlmodel import SQLModel, select
-from sqlmodel.ext.asyncio.session import AsyncSession
-
-from routstr import wallet
-from routstr.core.db import CashuTransaction
-
-
-def _make_engine() -> AsyncEngine:
-    return create_async_engine(
-        "sqlite+aiosqlite://",
-        poolclass=StaticPool,
-        connect_args={"check_same_thread": False},
-    )
-
-
-@pytest.fixture
-async def refund_db(
-    monkeypatch: pytest.MonkeyPatch,
-) -> AsyncGenerator[AsyncEngine, None]:
-    engine = _make_engine()
-    async with engine.begin() as connection:
-        await connection.run_sync(SQLModel.metadata.create_all)
-
-    @asynccontextmanager
-    async def create_session() -> AsyncGenerator[AsyncSession, None]:
-        async with AsyncSession(engine, expire_on_commit=False) as session:
-            yield session
-
-    monkeypatch.setattr(wallet.db, "create_session", create_session)
-    try:
-        yield engine
-    finally:
-        await engine.dispose()
-
-
-async def _store(
-    engine: AsyncEngine,
-    *,
-    token: str,
-    created_at: int,
-    typ: str = "out",
-    collected: bool = False,
-    swept: bool = False,
-) -> None:
-    async with AsyncSession(engine, expire_on_commit=False) as session:
-        session.add(
-            CashuTransaction(
-                token=token,
-                amount=10,
-                unit="sat",
-                type=typ,
-                created_at=created_at,
-                collected=collected,
-                swept=swept,
-            )
-        )
-        await session.commit()
-
-
-async def _transactions(engine: AsyncEngine) -> dict[str, CashuTransaction]:
-    async with AsyncSession(engine, expire_on_commit=False) as session:
-        results = await session.exec(select(CashuTransaction))
-        return {transaction.token: transaction for transaction in results.all()}
-
-
-@pytest.mark.asyncio
-async def test_refund_sweep_only_processes_eligible_outbound_transactions(
-    refund_db: AsyncEngine, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    cutoff = 1_000
-    await _store(refund_db, token="eligible", created_at=cutoff - 1)
-    await _store(refund_db, token="too-new", created_at=cutoff)
-    await _store(
-        refund_db, token="collected", created_at=cutoff - 1, collected=True
-    )
-    await _store(refund_db, token="swept", created_at=cutoff - 1, swept=True)
-    await _store(refund_db, token="inbound", created_at=cutoff - 1, typ="in")
-    receive_token = AsyncMock()
-    monkeypatch.setattr(wallet, "recieve_token", receive_token)
-
-    await wallet._refund_sweep_once(cutoff)
-
-    receive_token.assert_awaited_once_with("eligible")
-    transactions = await _transactions(refund_db)
-    assert transactions["eligible"].swept is True
-    assert transactions["too-new"].swept is False
-    assert transactions["collected"].collected is True
-    assert transactions["collected"].swept is False
-    assert transactions["swept"].swept is True
-    assert transactions["inbound"].swept is False
-
-
-@pytest.mark.asyncio
-async def test_refund_sweep_persists_success_and_isolates_token_failures(
-    refund_db: AsyncEngine, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    cutoff = 1_000
-    for token in ("success", "already-spent", "temporary-failure"):
-        await _store(refund_db, token=token, created_at=cutoff - 1)
-
-    async def receive_token(token: str) -> None:
-        if token == "already-spent":
-            raise RuntimeError("Token already spent")
-        if token == "temporary-failure":
-            raise RuntimeError("mint unavailable")
-
-    receive = AsyncMock(side_effect=receive_token)
-    monkeypatch.setattr(wallet, "recieve_token", receive)
-
-    await wallet._refund_sweep_once(cutoff)
-
-    assert receive.await_count == 3
-    transactions = await _transactions(refund_db)
-    assert transactions["success"].swept is True
-    assert transactions["success"].collected is False
-    assert transactions["already-spent"].collected is True
-    assert transactions["already-spent"].swept is False
-    assert transactions["temporary-failure"].collected is False
-    assert transactions["temporary-failure"].swept is False

tests/unit/test_proxy_tinfoil_attestation_routing.py

@@ -1,141 +0,0 @@
-from __future__ import annotations
-
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-from fastapi import FastAPI
-from fastapi.responses import Response
-from httpx import ASGITransport, AsyncClient
-
-from routstr import proxy as proxy_module
-
-
-@pytest.fixture
-def proxy_app() -> FastAPI:
-    app = FastAPI()
-    app.include_router(proxy_module.proxy_router)
-    return app
-
-
-@pytest.mark.asyncio
-async def test_attestation_get_routes_directly_to_tinfoil_provider(
-    monkeypatch: pytest.MonkeyPatch, proxy_app: FastAPI
-) -> None:
-    non_tinfoil = MagicMock()
-    non_tinfoil.provider_type = "openai"
-    non_tinfoil.prepare_headers = MagicMock(return_value={})
-    non_tinfoil.forward_get_request = AsyncMock(
-        return_value=Response(status_code=404, content=b"wrong upstream")
-    )
-
-    tinfoil = MagicMock()
-    tinfoil.provider_type = "tinfoil"
-    tinfoil.prepare_headers = MagicMock(return_value={"accept": "application/json"})
-    tinfoil.forward_get_request = AsyncMock(
-        return_value=Response(status_code=200, content=b'{"attestation":true}')
-    )
-
-    monkeypatch.setattr(proxy_module, "_upstreams", [non_tinfoil, tinfoil])
-
-    async with AsyncClient(
-        transport=ASGITransport(app=proxy_app),  # type: ignore[arg-type]
-        base_url="http://test",
-    ) as client:
-        response = await client.get("/attestation")
-
-    assert response.status_code == 200
-    assert response.content == b'{"attestation":true}'
-    non_tinfoil.forward_get_request.assert_not_called()
-    tinfoil.forward_get_request.assert_awaited_once()
-
-
-@pytest.mark.asyncio
-async def test_tee_attestation_get_routes_directly_to_tinfoil_provider(
-    monkeypatch: pytest.MonkeyPatch, proxy_app: FastAPI
-) -> None:
-    non_tinfoil = MagicMock()
-    non_tinfoil.provider_type = "openrouter"
-    non_tinfoil.prepare_headers = MagicMock(return_value={})
-    non_tinfoil.forward_get_request = AsyncMock(
-        return_value=Response(status_code=404, content=b"wrong upstream")
-    )
-
-    tinfoil = MagicMock()
-    tinfoil.provider_type = "tinfoil"
-    tinfoil.prepare_headers = MagicMock(return_value={"accept": "application/json"})
-    tinfoil.forward_get_request = AsyncMock(
-        return_value=Response(status_code=200, content=b'{"tee":true}')
-    )
-
-    monkeypatch.setattr(proxy_module, "_upstreams", [non_tinfoil, tinfoil])
-
-    async with AsyncClient(
-        transport=ASGITransport(app=proxy_app),  # type: ignore[arg-type]
-        base_url="http://test",
-    ) as client:
-        response = await client.get("/tee/attestation")
-
-    assert response.status_code == 200
-    assert response.content == b'{"tee":true}'
-    non_tinfoil.forward_get_request.assert_not_called()
-    tinfoil.forward_get_request.assert_awaited_once()
-
-
-@pytest.mark.parametrize("path", ["attestation/", "tee/attestation/"])
-@pytest.mark.asyncio
-async def test_attestation_trailing_slash_routes_directly_to_tinfoil(
-    monkeypatch: pytest.MonkeyPatch, proxy_app: FastAPI, path: str
-) -> None:
-    tinfoil = MagicMock()
-    tinfoil.provider_type = "tinfoil"
-    tinfoil.prepare_headers = MagicMock(return_value={})
-    tinfoil.forward_get_request = AsyncMock(return_value=Response(status_code=200))
-    monkeypatch.setattr(proxy_module, "_upstreams", [tinfoil])
-
-    async with AsyncClient(
-        transport=ASGITransport(app=proxy_app),  # type: ignore[arg-type]
-        base_url="http://test",
-    ) as client:
-        response = await client.get(f"/{path}")
-
-    assert response.status_code == 200
-    tinfoil.forward_get_request.assert_awaited_once()
-
-
-@pytest.mark.parametrize("path", ["attestation/foo", "attestationjunk"])
-@pytest.mark.asyncio
-async def test_non_attestation_prefix_does_not_bypass_authentication(
-    monkeypatch: pytest.MonkeyPatch, proxy_app: FastAPI, path: str
-) -> None:
-    tinfoil = MagicMock()
-    tinfoil.provider_type = "tinfoil"
-    tinfoil.forward_get_request = AsyncMock()
-    monkeypatch.setattr(proxy_module, "_upstreams", [tinfoil])
-
-    async with AsyncClient(
-        transport=ASGITransport(app=proxy_app),  # type: ignore[arg-type]
-        base_url="http://test",
-    ) as client:
-        response = await client.get(f"/{path}")
-
-    assert response.status_code == 400
-    assert response.json()["error"]["type"] == "invalid_model"
-    tinfoil.forward_get_request.assert_not_awaited()
-
-
-def test_attestation_upstream_selection_is_tinfoil_only() -> None:
-    non_tinfoil = MagicMock(provider_type="openai")
-    tinfoil = MagicMock(provider_type="tinfoil")
-
-    assert proxy_module._select_unauthenticated_get_upstreams(
-        "attestation", [non_tinfoil, tinfoil]
-    ) == [tinfoil]
-    assert proxy_module._select_unauthenticated_get_upstreams(
-        "tee/attestation", [non_tinfoil, tinfoil]
-    ) == [tinfoil]
-    assert proxy_module._select_unauthenticated_get_upstreams(
-        "attestation/", [non_tinfoil, tinfoil]
-    ) == [tinfoil]
-    assert proxy_module._select_unauthenticated_get_upstreams(
-        "attestationjunk", [non_tinfoil, tinfoil]
-    ) == [non_tinfoil, tinfoil]

tests/unit/test_refund_sweep.py

@@ -1,118 +0,0 @@
-from collections.abc import AsyncIterator
-from pathlib import Path
-from unittest.mock import AsyncMock, patch
-
-import pytest
-from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
-from sqlmodel import SQLModel, select
-from sqlmodel.ext.asyncio.session import AsyncSession
-
-from routstr.core.db import CashuTransaction
-from routstr.wallet import refund_sweep_once
-
-
-@pytest.fixture
-async def session_factory(
-    tmp_path: Path,
-) -> AsyncIterator[async_sessionmaker[AsyncSession]]:
-    engine = create_async_engine(f"sqlite+aiosqlite:///{tmp_path / 'refunds.db'}")
-    async with engine.begin() as connection:
-        await connection.run_sync(SQLModel.metadata.create_all)
-    factory = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
-    yield factory
-    await engine.dispose()
-
-
-async def _insert(
-    factory: async_sessionmaker[AsyncSession], *rows: CashuTransaction
-) -> None:
-    async with factory() as session:
-        session.add_all(rows)
-        await session.commit()
-
-
-async def _load(
-    factory: async_sessionmaker[AsyncSession],
-) -> dict[str, CashuTransaction]:
-    async with factory() as session:
-        result = await session.exec(select(CashuTransaction))
-        return {row.token: row for row in result.all()}
-
-
-@pytest.mark.asyncio
-async def test_refund_sweep_only_processes_expired_eligible_outgoing_tokens(
-    session_factory: async_sessionmaker[AsyncSession],
-) -> None:
-    rows = [
-        CashuTransaction(
-            token="eligible", amount=1, unit="sat", type="out", created_at=800
-        ),
-        CashuTransaction(
-            token="fresh", amount=1, unit="sat", type="out", created_at=950
-        ),
-        CashuTransaction(
-            token="boundary", amount=1, unit="sat", type="out", created_at=900
-        ),
-        CashuTransaction(
-            token="collected",
-            amount=1,
-            unit="sat",
-            type="out",
-            created_at=800,
-            collected=True,
-        ),
-        CashuTransaction(
-            token="swept", amount=1, unit="sat", type="out", created_at=800, swept=True
-        ),
-        CashuTransaction(
-            token="incoming", amount=1, unit="sat", type="in", created_at=800
-        ),
-    ]
-    await _insert(session_factory, *rows)
-    receive = AsyncMock()
-    with (
-        patch("routstr.wallet.db.create_session", side_effect=session_factory),
-        patch("routstr.wallet.settings.refund_sweep_ttl_seconds", 100),
-        patch("routstr.wallet.time.time", return_value=1000),
-        patch("routstr.wallet.recieve_token", receive),
-    ):
-        await refund_sweep_once()
-
-    receive.assert_awaited_once_with("eligible")
-    loaded = await _load(session_factory)
-    assert loaded["eligible"].swept is True
-    assert loaded["fresh"].swept is False
-    assert loaded["boundary"].swept is False
-    assert loaded["collected"].swept is False
-    assert loaded["swept"].swept is True
-    assert loaded["incoming"].swept is False
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    ("error", "collected"),
-    [
-        (RuntimeError("token already spent"), True),
-        (RuntimeError("mint unavailable"), False),
-    ],
-)
-async def test_refund_sweep_records_terminal_but_not_transient_failures(
-    session_factory: async_sessionmaker[AsyncSession], error: Exception, collected: bool
-) -> None:
-    await _insert(
-        session_factory,
-        CashuTransaction(
-            token="refund", amount=1, unit="sat", type="out", created_at=800
-        ),
-    )
-    with (
-        patch("routstr.wallet.db.create_session", side_effect=session_factory),
-        patch("routstr.wallet.settings.refund_sweep_ttl_seconds", 100),
-        patch("routstr.wallet.time.time", return_value=1000),
-        patch("routstr.wallet.recieve_token", AsyncMock(side_effect=error)),
-    ):
-        await refund_sweep_once()
-
-    refund = (await _load(session_factory))["refund"]
-    assert refund.collected is collected
-    assert refund.swept is False

tests/unit/test_require_parameters.py

@@ -0,0 +1,95 @@
+import json
+import os
+
+os.environ.setdefault("UPSTREAM_BASE_URL", "http://test")
+os.environ.setdefault("UPSTREAM_API_KEY", "test")
+os.environ.setdefault("LIGHTNING_ADDRESS", "test@stm.to")
+
+from routstr.upstream import GenericUpstreamProvider
+from routstr.upstream.openrouter import OpenRouterUpstreamProvider
+
+
+def _model(model_id: str = "openai/gpt-4o"):  # type: ignore[no-untyped-def]
+    from routstr.payment.models import Architecture, Model, Pricing
+
+    return Model(
+        id=model_id,
+        name=model_id,
+        created=0,
+        description="",
+        context_length=128000,
+        architecture=Architecture(
+            modality="text->text",
+            input_modalities=["text"],
+            output_modalities=["text"],
+            tokenizer="GPT",
+            instruct_type=None,
+        ),
+        pricing=Pricing(prompt=0.0, completion=0.0),
+    )
+
+
+def _tool_body() -> dict:
+    return {
+        "model": "openai/gpt-4o",
+        "messages": [{"role": "user", "content": "What's the weather?"}],
+        "tools": [
+            {
+                "type": "function",
+                "function": {"name": "get_weather", "parameters": {}},
+            }
+        ],
+    }
+
+
+def _prepare(provider, body: dict) -> dict:  # type: ignore[no-untyped-def]
+    out = provider.prepare_request_body(json.dumps(body).encode(), _model())
+    assert out is not None
+    return json.loads(out)
+
+
+def test_injects_require_parameters_for_tool_request() -> None:
+    data = _prepare(OpenRouterUpstreamProvider(api_key="test"), _tool_body())
+    assert data["provider"]["require_parameters"] is True
+
+
+def test_generic_provider_on_openrouter_url_is_left_alone() -> None:
+    # Only OpenRouterUpstreamProvider injects; a generic provider pointed at the
+    # same base URL doesn't.
+    provider = GenericUpstreamProvider(base_url="https://openrouter.ai/api/v1")
+    data = _prepare(provider, _tool_body())
+    assert "provider" not in data
+
+
+def test_no_injection_without_tools() -> None:
+    body = {"model": "openai/gpt-4o", "messages": [{"role": "user", "content": "hi"}]}
+    data = _prepare(OpenRouterUpstreamProvider(api_key="test"), body)
+    assert "provider" not in data
+
+
+def test_empty_tools_list_does_not_inject() -> None:
+    body = _tool_body()
+    body["tools"] = []
+    data = _prepare(OpenRouterUpstreamProvider(api_key="test"), body)
+    assert "provider" not in data
+
+
+def test_direct_provider_does_not_inject() -> None:
+    provider = GenericUpstreamProvider(base_url="https://api.openai.com/v1")
+    data = _prepare(provider, _tool_body())
+    assert "provider" not in data
+
+
+def test_keeps_client_set_require_parameters() -> None:
+    body = _tool_body()
+    body["provider"] = {"require_parameters": False}
+    data = _prepare(OpenRouterUpstreamProvider(api_key="test"), body)
+    assert data["provider"]["require_parameters"] is False
+
+
+def test_preserves_other_provider_fields() -> None:
+    body = _tool_body()
+    body["provider"] = {"order": ["openai", "azure"]}
+    data = _prepare(OpenRouterUpstreamProvider(api_key="test"), body)
+    assert data["provider"]["order"] == ["openai", "azure"]
+    assert data["provider"]["require_parameters"] is True

tests/unit/test_tinfoil_integration.py

@@ -1,749 +0,0 @@
-"""Unit tests for Tinfoil direct integration.
-
-Covers the EHBP usage-metrics header parser, the proxy header stripping, the
-enclave URL override, and the TinfoilUpstreamProvider model fetching/forwarding
-target logic.
-"""
-
-from __future__ import annotations
-
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-
-from routstr.upstream.ehbp import (
-    _PROXY_ONLY_HEADERS,
-    _compute_ehbp_actual_cost,
-    _prepare_ehbp_upstream_headers,
-    _resolve_ehbp_target_url,
-    _strip_proxy_headers,
-    parse_tinfoil_usage_metrics,
-)
-from routstr.upstream.tinfoil import (
-    TinfoilModel,
-    TinfoilUpstreamProvider,
-)
-
-# ---------------------------------------------------------------------------
-# parse_tinfoil_usage_metrics
-# ---------------------------------------------------------------------------
-
-
-class TestParseTinfoilUsageMetrics:
-    def test_full_header(self) -> None:
-        result = parse_tinfoil_usage_metrics("prompt=67,completion=42,total=109")
-        assert result == {
-            "prompt_tokens": 67,
-            "completion_tokens": 42,
-            "total_tokens": 109,
-        }
-
-    def test_without_total(self) -> None:
-        result = parse_tinfoil_usage_metrics("prompt=10,completion=5")
-        assert result == {"prompt_tokens": 10, "completion_tokens": 5}
-
-    def test_none(self) -> None:
-        assert parse_tinfoil_usage_metrics(None) is None
-
-    def test_empty(self) -> None:
-        assert parse_tinfoil_usage_metrics("") is None
-
-    def test_malformed(self) -> None:
-        assert parse_tinfoil_usage_metrics("garbage") is None
-
-    def test_missing_completion(self) -> None:
-        assert parse_tinfoil_usage_metrics("prompt=10") is None
-
-    def test_extra_whitespace(self) -> None:
-        result = parse_tinfoil_usage_metrics(
-            "prompt = 100 , completion = 200 , total = 300"
-        )
-        assert result == {
-            "prompt_tokens": 100,
-            "completion_tokens": 200,
-            "total_tokens": 300,
-        }
-
-    def test_with_model_field(self) -> None:
-        result = parse_tinfoil_usage_metrics(
-            "prompt=42,completion=10,total=52,model=llama3-3-70b"
-        )
-        assert result == {
-            "prompt_tokens": 42,
-            "completion_tokens": 10,
-            "total_tokens": 52,
-            "model": "llama3-3-70b",
-        }
-
-    def test_with_model_no_total(self) -> None:
-        result = parse_tinfoil_usage_metrics(
-            "prompt=67,completion=42,model=gpt-oss-120b"
-        )
-        assert result == {
-            "prompt_tokens": 67,
-            "completion_tokens": 42,
-            "model": "gpt-oss-120b",
-        }
-
-    def test_model_with_dashes_and_numbers(self) -> None:
-        result = parse_tinfoil_usage_metrics(
-            "prompt=1,completion=1,total=2,model=kimi-k2-6"
-        )
-        assert result is not None
-        assert result["model"] == "kimi-k2-6"
-
-    def test_model_with_extra_fields(self) -> None:
-        result = parse_tinfoil_usage_metrics(
-            "prompt=69,completion=20,total=89,"
-            "cached_prompt_tokens=64,uncached_prompt_tokens=5,"
-            "model=kimi-k2-6"
-        )
-        assert result is not None
-        assert result["prompt_tokens"] == 69
-        assert result["completion_tokens"] == 20
-        assert result["total_tokens"] == 89
-        assert result["model"] == "kimi-k2-6"
-
-    def test_old_format_still_works(self) -> None:
-        """Headers without the model field (pre-PR #385) still parse."""
-        result = parse_tinfoil_usage_metrics(
-            "prompt=67,completion=42,total=109"
-        )
-        assert result == {
-            "prompt_tokens": 67,
-            "completion_tokens": 42,
-            "total_tokens": 109,
-        }
-        assert "model" not in result
-
-
-# ---------------------------------------------------------------------------
-# _strip_proxy_headers
-# ---------------------------------------------------------------------------
-
-
-class TestStripProxyHeaders:
-    def test_strips_all_proxy_only(self) -> None:
-        headers = {
-            "x-routstr-model": "tinfoil-llama3-3-70b",
-            "X-Tinfoil-Enclave-Url": "https://inference.tinfoil.sh",
-            "X-Tinfoil-Request-Usage-Metrics": "true",
-            "Authorization": "Bearer secret",
-            "Ehbp-Encapsulated-Key": "abc123",
-        }
-        clean = _strip_proxy_headers(headers)
-        assert "x-routstr-model" not in clean
-        assert "X-Tinfoil-Enclave-Url" not in clean
-        assert "X-Tinfoil-Request-Usage-Metrics" not in clean
-        assert clean["Authorization"] == "Bearer secret"
-        assert clean["Ehbp-Encapsulated-Key"] == "abc123"
-
-    def test_all_proxy_only_headers_covered(self) -> None:
-        assert _PROXY_ONLY_HEADERS == {
-            "x-routstr-model",
-            "x-tinfoil-enclave-url",
-            "x-tinfoil-request-usage-metrics",
-        }
-
-
-class TestPrepareEHBPUpstreamHeaders:
-    def test_strips_client_proxy_headers_before_merging_target_headers(self) -> None:
-        headers = {
-            "x-routstr-model": "tinfoil-llama3-3-70b",
-            "X-Tinfoil-Enclave-Url": "https://enclave.tinfoil.sh",
-            "X-Tinfoil-Request-Usage-Metrics": "false",
-            "Authorization": "Bearer upstream-key",
-            "Ehbp-Encapsulated-Key": "abc123",
-        }
-        target_headers = {"X-Tinfoil-Request-Usage-Metrics": "true"}
-
-        clean = _prepare_ehbp_upstream_headers(headers, target_headers)
-
-        assert "x-routstr-model" not in clean
-        assert "X-Tinfoil-Enclave-Url" not in clean
-        assert clean["Authorization"] == "Bearer upstream-key"
-        assert clean["Ehbp-Encapsulated-Key"] == "abc123"
-        assert clean["X-Tinfoil-Request-Usage-Metrics"] == "true"
-
-
-# ---------------------------------------------------------------------------
-# _resolve_ehbp_target_url
-# ---------------------------------------------------------------------------
-
-
-class TestResolveEhbpTargetUrl:
-    def test_override_with_enclave_url_for_tinfoil(self) -> None:
-        result = _resolve_ehbp_target_url(
-            "https://default.example.com/v1/chat/completions",
-            "v1/chat/completions",
-            {"X-Tinfoil-Enclave-Url": "https://enclave.tinfoil.sh"},
-            "tinfoil",
-        )
-        assert result == "https://enclave.tinfoil.sh/v1/chat/completions"
-
-    def test_override_lowercase_header_for_tinfoil(self) -> None:
-        result = _resolve_ehbp_target_url(
-            "https://default.example.com/v1/chat/completions",
-            "v1/chat/completions",
-            {"x-tinfoil-enclave-url": "https://enclave.tinfoil.sh"},
-            "tinfoil",
-        )
-        assert result == "https://enclave.tinfoil.sh/v1/chat/completions"
-
-    def test_no_override(self) -> None:
-        default = "https://inference.tinfoil.sh/v1/chat/completions"
-        result = _resolve_ehbp_target_url(
-            default,
-            "v1/chat/completions",
-            {},
-            "tinfoil",
-        )
-        assert result == default
-
-    def test_non_tinfoil_provider_ignores_enclave_url(self) -> None:
-        default = "https://api.ppq.ai/private/v1/chat/completions"
-        result = _resolve_ehbp_target_url(
-            default,
-            "v1/chat/completions",
-            {"X-Tinfoil-Enclave-Url": "https://enclave.tinfoil.sh"},
-            "ppqai",
-        )
-        assert result == default
-
-    @pytest.mark.parametrize(
-        "bad_url",
-        [
-            "http://enclave.tinfoil.sh",
-            "https://attacker.example",
-            "https://tinfoil.sh.attacker.example",
-            "https://127.0.0.1",
-            "https://enclave.tinfoil.sh:8443",
-            "https://user:pass@enclave.tinfoil.sh",
-        ],
-    )
-    def test_tinfoil_rejects_unsafe_enclave_url(self, bad_url: str) -> None:
-        from routstr.core.exceptions import UpstreamError
-
-        with pytest.raises(UpstreamError):
-            _resolve_ehbp_target_url(
-                "https://default.example.com/v1/chat/completions",
-                "v1/chat/completions",
-                {"X-Tinfoil-Enclave-Url": bad_url},
-                "tinfoil",
-            )
-
-
-# ---------------------------------------------------------------------------
-# _compute_ehbp_actual_cost
-# ---------------------------------------------------------------------------
-
-
-class TestComputeEhbpActualCost:
-    @pytest.mark.asyncio
-    async def test_no_usage_falls_back_to_max_cost(self) -> None:
-        model_obj = MagicMock()
-        model_obj.id = "llama3-3-70b"
-        model_obj.forwarded_model_id = "llama3-3-70b"
-        result = await _compute_ehbp_actual_cost(None, model_obj, 100_000)
-        assert result["total_msats"] == 100_000
-        assert result["input_tokens"] == 0
-        assert result["output_tokens"] == 0
-
-    @pytest.mark.asyncio
-    async def test_usage_parsed_and_clamped(self) -> None:
-        model_obj = MagicMock()
-        model_obj.id = "llama3-3-70b"
-        model_obj.forwarded_model_id = "llama3-3-70b"
-        # The actual cost from calculate_cost will be small; we just verify
-        # it's clamped to min_request_msat at minimum.
-        with patch(
-            "routstr.upstream.ehbp.calculate_cost",
-            new_callable=AsyncMock,
-        ) as mock_calc:
-            from routstr.payment.cost_calculation import CostData
-
-            mock_calc.return_value = CostData(
-                base_msats=0,
-                input_msats=10,
-                output_msats=20,
-                total_msats=30,
-                total_usd=0.0001,
-                input_tokens=67,
-                output_tokens=42,
-            )
-            result = await _compute_ehbp_actual_cost(
-                "prompt=67,completion=42,total=109",
-                model_obj,
-                100_000,
-            )
-            assert result["total_msats"] == 30
-            assert result["total_msats"] <= 100_000
-            assert result["input_tokens"] == 67
-            assert result["output_tokens"] == 42
-            assert result["total_tokens"] == 109
-            assert result["input_msats"] == 10
-            assert result["output_msats"] == 20
-
-    @pytest.mark.asyncio
-    async def test_max_cost_data_falls_back(self) -> None:
-        model_obj = MagicMock()
-        model_obj.id = "llama3-3-70b"
-        model_obj.forwarded_model_id = "llama3-3-70b"
-        with patch(
-            "routstr.upstream.ehbp.calculate_cost",
-            new_callable=AsyncMock,
-        ) as mock_calc:
-            from routstr.payment.cost_calculation import MaxCostData
-
-            mock_calc.return_value = MaxCostData(
-                base_msats=0,
-                input_msats=0,
-                output_msats=0,
-                total_msats=0,
-                total_usd=0.0,
-                input_tokens=0,
-                output_tokens=0,
-            )
-            result = await _compute_ehbp_actual_cost(
-                "prompt=0,completion=0",
-                model_obj,
-                50_000,
-            )
-            assert result["total_msats"] == 50_000
-            assert result["input_tokens"] == 0
-            assert result["output_tokens"] == 0
-
-    @pytest.mark.asyncio
-    async def test_model_match_no_actual_model_key(self) -> None:
-        """When the served model matches the requested one, no actual_model key."""
-        model_obj = MagicMock()
-        model_obj.id = "llama3-3-70b"
-        model_obj.forwarded_model_id = "llama3-3-70b"
-        with patch(
-            "routstr.upstream.ehbp.calculate_cost",
-            new_callable=AsyncMock,
-        ) as mock_calc:
-            from routstr.payment.cost_calculation import CostData
-
-            mock_calc.return_value = CostData(
-                base_msats=0,
-                input_msats=5,
-                output_msats=10,
-                total_msats=15,
-                total_usd=0.0,
-                input_tokens=42,
-                output_tokens=10,
-            )
-            result = await _compute_ehbp_actual_cost(
-                "prompt=42,completion=10,total=52,model=llama3-3-70b",
-                model_obj,
-                100_000,
-            )
-            assert "actual_model" not in result
-            # calculate_cost called with requested model
-            call_args = mock_calc.call_args
-            assert call_args[0][0]["model"] == "llama3-3-70b"
-
-    @pytest.mark.asyncio
-    async def test_alias_match_no_actual_model_key(self) -> None:
-        """When the served upstream model matches forwarded_model_id through
-        a client-facing alias, no actual_model key is set."""
-        model_obj = MagicMock()
-        model_obj.id = "tinfoil-glm-5-2"  # client-facing alias
-        model_obj.forwarded_model_id = "glm-5-2"  # actual upstream ID
-        with patch(
-            "routstr.upstream.ehbp.calculate_cost",
-            new_callable=AsyncMock,
-        ) as mock_calc:
-            from routstr.payment.cost_calculation import CostData
-
-            mock_calc.return_value = CostData(
-                base_msats=0,
-                input_msats=5,
-                output_msats=10,
-                total_msats=15,
-                total_usd=0.0,
-                input_tokens=42,
-                output_tokens=10,
-            )
-            # Tinfoil header returns the actual upstream model ID
-            result = await _compute_ehbp_actual_cost(
-                "prompt=42,completion=10,total=52,model=glm-5-2",
-                model_obj,
-                100_000,
-            )
-            assert "actual_model" not in result
-            # calculate_cost called with the client-facing model ID (whose
-            # pricing includes the correct upstream rates)
-            call_args = mock_calc.call_args
-            assert call_args[0][0]["model"] == "tinfoil-glm-5-2"
-
-    @pytest.mark.asyncio
-    async def test_real_mismatch_uses_actual_model_for_pricing(self) -> None:
-        """When the served model differs from the expected upstream model,
-        the actual model's pricing is used."""
-        model_obj = MagicMock()
-        model_obj.id = "tinfoil-gpt-oss-120b"  # client-facing alias
-        model_obj.forwarded_model_id = "gpt-oss-120b"  # expected upstream
-
-        actual_model_obj = MagicMock()
-        actual_model_obj.id = "tinfoil-llama3-3-70b"  # client-facing of actual
-        actual_model_obj.forwarded_model_id = "llama3-3-70b"
-
-        with patch(
-            "routstr.proxy.get_model_instance",
-            return_value=actual_model_obj,
-        ), patch(
-            "routstr.upstream.ehbp.calculate_cost",
-            new_callable=AsyncMock,
-        ) as mock_calc:
-            from routstr.payment.cost_calculation import CostData
-
-            mock_calc.return_value = CostData(
-                base_msats=0,
-                input_msats=20,
-                output_msats=40,
-                total_msats=60,
-                total_usd=0.0,
-                input_tokens=42,
-                output_tokens=10,
-            )
-            # Tinfoil served llama3-3-70b instead of gpt-oss-120b
-            result = await _compute_ehbp_actual_cost(
-                "prompt=42,completion=10,total=52,model=llama3-3-70b",
-                model_obj,
-                100_000,
-            )
-            assert result["actual_model"] == "llama3-3-70b"
-            assert result["total_msats"] == 60
-            # calculate_cost called with the actual model's client-facing ID
-            call_args = mock_calc.call_args
-            assert call_args[0][0]["model"] == "tinfoil-llama3-3-70b"
-
-    @pytest.mark.asyncio
-    async def test_model_mismatch_unknown_model_falls_back(self) -> None:
-        """When the served model is not in the registry, use requested model."""
-        model_obj = MagicMock()
-        model_obj.id = "gpt-oss-120b"
-        model_obj.forwarded_model_id = "gpt-oss-120b"
-
-        with patch(
-            "routstr.proxy.get_model_instance",
-            return_value=None,
-        ), patch(
-            "routstr.upstream.ehbp.calculate_cost",
-            new_callable=AsyncMock,
-        ) as mock_calc:
-            from routstr.payment.cost_calculation import CostData
-
-            mock_calc.return_value = CostData(
-                base_msats=0,
-                input_msats=5,
-                output_msats=10,
-                total_msats=15,
-                total_usd=0.0,
-                input_tokens=42,
-                output_tokens=10,
-            )
-            result = await _compute_ehbp_actual_cost(
-                "prompt=42,completion=10,total=52,model=nonexistent",
-                model_obj,
-                100_000,
-            )
-            assert "actual_model" not in result
-            # calculate_cost called with the requested model (fallback)
-            call_args = mock_calc.call_args
-            assert call_args[0][0]["model"] == "gpt-oss-120b"
-
-    @pytest.mark.asyncio
-    async def test_old_format_no_model_uses_requested(self) -> None:
-        """Old format without model field uses requested model for pricing."""
-        model_obj = MagicMock()
-        model_obj.id = "llama3-3-70b"
-        model_obj.forwarded_model_id = "llama3-3-70b"
-        with patch(
-            "routstr.upstream.ehbp.calculate_cost",
-            new_callable=AsyncMock,
-        ) as mock_calc:
-            from routstr.payment.cost_calculation import CostData
-
-            mock_calc.return_value = CostData(
-                base_msats=0,
-                input_msats=5,
-                output_msats=10,
-                total_msats=15,
-                total_usd=0.0,
-                input_tokens=67,
-                output_tokens=42,
-            )
-            result = await _compute_ehbp_actual_cost(
-                "prompt=67,completion=42,total=109",
-                model_obj,
-                100_000,
-            )
-            assert "actual_model" not in result
-            call_args = mock_calc.call_args
-            assert call_args[0][0]["model"] == "llama3-3-70b"
-
-    @pytest.mark.asyncio
-    async def test_case_insensitive_model_match(self) -> None:
-        """Casing differences between the header and forwarded_model_id
-        should not trigger a spurious mismatch."""
-        model_obj = MagicMock()
-        model_obj.id = "tinfoil-glm-5-2"
-        model_obj.forwarded_model_id = "glm-5-2"  # lowercase
-        with patch(
-            "routstr.proxy.get_model_instance"
-        ) as mock_get_model, patch(
-            "routstr.upstream.ehbp.calculate_cost",
-            new_callable=AsyncMock,
-        ) as mock_calc:
-            from routstr.payment.cost_calculation import CostData
-
-            mock_calc.return_value = CostData(
-                base_msats=0,
-                input_msats=5,
-                output_msats=10,
-                total_msats=15,
-                total_usd=0.0,
-                input_tokens=42,
-                output_tokens=10,
-            )
-            # Header returns uppercase — same model, different casing
-            result = await _compute_ehbp_actual_cost(
-                "prompt=42,completion=10,total=52,model=GLM-5-2",
-                model_obj,
-                100_000,
-            )
-            assert "actual_model" not in result
-            # No mismatch: requested model pricing used
-            call_args = mock_calc.call_args
-            assert call_args[0][0]["model"] == "tinfoil-glm-5-2"
-            mock_get_model.assert_not_called()
-
-    @pytest.mark.asyncio
-    async def test_date_versioned_alias_resolves_to_requested(self) -> None:
-        """When the served model is a date-versioned alias that resolves back
-        to the requested model, no mismatch is propagated."""
-        model_obj = MagicMock()
-        model_obj.id = "tinfoil-glm-5-2"
-        model_obj.forwarded_model_id = "glm-5-2"
-
-        resolved_model_obj = MagicMock()
-        resolved_model_obj.id = "other-provider-glm-5-2"
-        resolved_model_obj.forwarded_model_id = "glm-5-2"
-
-        with patch(
-            "routstr.proxy.get_model_instance",
-            return_value=resolved_model_obj,
-        ) as mock_get_model, patch(
-            "routstr.upstream.ehbp.calculate_cost",
-            new_callable=AsyncMock,
-        ) as mock_calc:
-            from routstr.payment.cost_calculation import CostData
-
-            mock_calc.return_value = CostData(
-                base_msats=0,
-                input_msats=5,
-                output_msats=10,
-                total_msats=15,
-                total_usd=0.0,
-                input_tokens=42,
-                output_tokens=10,
-            )
-            # Tinfoil returns a date-versioned ID with different casing.
-            result = await _compute_ehbp_actual_cost(
-                "prompt=42,completion=10,total=52,model=GLM-5-2-20260415",
-                model_obj,
-                100_000,
-            )
-            # Registry resolution, rather than unconditional suffix removal,
-            # establishes that this alias represents the expected model.
-            assert "actual_model" not in result
-            assert mock_calc.call_args[0][0]["model"] == "tinfoil-glm-5-2"
-            mock_get_model.assert_called_once_with("GLM-5-2-20260415")
-
-    @pytest.mark.asyncio
-    async def test_configured_date_version_is_preserved_as_identity(self) -> None:
-        """A date suffix in forwarded_model_id is meaningful and preserved."""
-        model_obj = MagicMock()
-        model_obj.id = "tinfoil-glm-5-2-20260415"
-        model_obj.forwarded_model_id = "glm-5-2-20260415"
-
-        with patch(
-            "routstr.proxy.get_model_instance"
-        ) as mock_get_model, patch(
-            "routstr.upstream.ehbp.calculate_cost",
-            new_callable=AsyncMock,
-        ) as mock_calc:
-            from routstr.payment.cost_calculation import CostData
-
-            mock_calc.return_value = CostData(
-                base_msats=0,
-                input_msats=5,
-                output_msats=10,
-                total_msats=15,
-                total_usd=0.0,
-                input_tokens=42,
-                output_tokens=10,
-            )
-            result = await _compute_ehbp_actual_cost(
-                "prompt=42,completion=10,total=52,model=GLM-5-2-20260415",
-                model_obj,
-                100_000,
-            )
-
-            assert "actual_model" not in result
-            assert (
-                mock_calc.call_args[0][0]["model"]
-                == "tinfoil-glm-5-2-20260415"
-            )
-            mock_get_model.assert_not_called()
-
-    @pytest.mark.asyncio
-    async def test_different_client_alias_same_upstream_identity(self) -> None:
-        """A global alias winner from another provider is not a failover when
-        its forwarded model ID matches the requested upstream identity."""
-        model_obj = MagicMock()
-        model_obj.id = "tinfoil-glm-5-2"
-        model_obj.forwarded_model_id = "glm-5-2"
-
-        resolved_model_obj = MagicMock()
-        resolved_model_obj.id = "other-provider-glm-5-2"
-        resolved_model_obj.forwarded_model_id = "GLM-5-2"
-
-        with patch(
-            "routstr.proxy.get_model_instance",
-            return_value=resolved_model_obj,
-        ) as mock_get_model, patch(
-            "routstr.upstream.ehbp.calculate_cost",
-            new_callable=AsyncMock,
-        ) as mock_calc:
-            from routstr.payment.cost_calculation import CostData
-
-            mock_calc.return_value = CostData(
-                base_msats=0,
-                input_msats=5,
-                output_msats=10,
-                total_msats=15,
-                total_usd=0.0,
-                input_tokens=42,
-                output_tokens=10,
-            )
-            result = await _compute_ehbp_actual_cost(
-                "prompt=42,completion=10,total=52,model=provider-alias",
-                model_obj,
-                100_000,
-            )
-
-            mock_get_model.assert_called_once_with("provider-alias")
-            assert "actual_model" not in result
-            assert mock_calc.call_args[0][0]["model"] == "tinfoil-glm-5-2"
-
-
-# ---------------------------------------------------------------------------
-# TinfoilUpstreamProvider
-# ---------------------------------------------------------------------------
-
-
-class TestTinfoilUpstreamProvider:
-    def test_provider_type_and_defaults(self) -> None:
-        assert TinfoilUpstreamProvider.provider_type == "tinfoil"
-        assert (
-            TinfoilUpstreamProvider.default_base_url
-            == "https://inference.tinfoil.sh"
-        )
-        assert TinfoilUpstreamProvider.supports_ehbp is True
-
-    def test_transform_model_name(self) -> None:
-        provider = TinfoilUpstreamProvider(api_key="test")
-        assert provider.transform_model_name("tinfoil/llama3-3-70b") == "llama3-3-70b"
-        assert provider.transform_model_name("llama3-3-70b") == "llama3-3-70b"
-
-    def test_get_ehbp_forwarding_target_includes_usage_header(self) -> None:
-        provider = TinfoilUpstreamProvider(api_key="test")
-        model_obj = MagicMock()
-        model_obj.id = "llama3-3-70b"
-        model_obj.forwarded_model_id = "llama3-3-70b"
-        target = provider.get_ehbp_forwarding_target("v1/chat/completions", model_obj)
-        assert (
-            target.headers["X-Tinfoil-Request-Usage-Metrics"] == "true"
-        )
-        assert "v1/chat/completions" in target.url
-
-    def test_get_provider_metadata(self) -> None:
-        meta = TinfoilUpstreamProvider.get_provider_metadata()
-        assert meta["id"] == "tinfoil"
-        assert meta["name"] == "Tinfoil"
-        assert meta["fixed_base_url"] is True
-
-    def test_tinfoil_model_pricing_parses(self) -> None:
-        data = {
-            "id": "llama3-3-70b",
-            "context_window": 128000,
-            "created": 1721764788,
-            "pricing": {
-                "inputTokenPricePer1M": 1.75,
-                "outputTokenPricePer1M": 2.75,
-                "requestPrice": 0,
-            },
-            "endpoints": ["/v1/chat/completions"],
-            "type": "chat",
-        }
-        tf = TinfoilModel.parse_obj(data)
-        assert tf.id == "llama3-3-70b"
-        assert tf.pricing.inputTokenPricePer1M == 1.75
-        assert tf.pricing.outputTokenPricePer1M == 2.75
-
-    @pytest.mark.asyncio
-    async def test_fetch_models_parses_response(self) -> None:
-        provider = TinfoilUpstreamProvider(api_key="test")
-        mock_response = MagicMock()
-        mock_response.status_code = 200
-        mock_response.raise_for_status = MagicMock()
-        mock_response.json.return_value = {
-            "data": [
-                {
-                    "id": "llama3-3-70b",
-                    "context_window": 128000,
-                    "created": 1721764788,
-                    "multimodal": False,
-                    "pricing": {
-                        "inputTokenPricePer1M": 1.75,
-                        "outputTokenPricePer1M": 2.75,
-                        "requestPrice": 0,
-                    },
-                    "endpoints": ["/v1/chat/completions"],
-                    "type": "chat",
-                }
-            ]
-        }
-
-        with patch("routstr.upstream.tinfoil.httpx.AsyncClient") as mock_client_cls:
-            mock_client = MagicMock()
-            mock_client.__aenter__ = AsyncMock(return_value=mock_client)
-            mock_client.__aexit__ = AsyncMock(return_value=None)
-            mock_client.get = AsyncMock(return_value=mock_response)
-            mock_client_cls.return_value = mock_client
-
-            models = await provider.fetch_models()
-
-        assert len(models) == 1
-        assert models[0].id == "llama3-3-70b"
-        assert models[0].pricing.prompt == 1.75 / 1_000_000
-        assert models[0].pricing.completion == 2.75 / 1_000_000
-        assert models[0].context_length == 128000
-
-    @pytest.mark.asyncio
-    async def test_fetch_models_handles_error(self) -> None:
-        provider = TinfoilUpstreamProvider(api_key="test")
-        with patch("routstr.upstream.tinfoil.httpx.AsyncClient") as mock_client_cls:
-            mock_client = MagicMock()
-            mock_client.__aenter__ = AsyncMock(return_value=mock_client)
-            mock_client.__aexit__ = AsyncMock(return_value=None)
-            mock_client.get = AsyncMock(side_effect=Exception("network error"))
-            mock_client_cls.return_value = mock_client
-
-            models = await provider.fetch_models()
-
-        assert models == []

tests/unit/test_tinfoil_trailer.py

@@ -1,138 +0,0 @@
-from __future__ import annotations
-
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-
-from routstr.upstream.tinfoil_trailer import forward_with_trailer
-
-
-class FakeReader:
-    def __init__(self, chunks: list[bytes]) -> None:
-        self._chunks = chunks
-
-    async def read(self, _size: int) -> bytes:
-        if self._chunks:
-            return self._chunks.pop(0)
-        return b""
-
-
-class FakeWriter:
-    def __init__(self) -> None:
-        self.written = b""
-        self.drain = AsyncMock()
-        self.wait_closed = AsyncMock()
-        self.close = MagicMock()
-
-    def write(self, data: bytes) -> None:
-        self.written += data
-
-
-@pytest.mark.asyncio
-async def test_forward_with_trailer_captures_usage_trailer(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    response = (
-        b"HTTP/1.1 200 OK\r\n"
-        b"Transfer-Encoding: chunked\r\n"
-        b"Trailer: X-Tinfoil-Usage-Metrics\r\n"
-        b"\r\n"
-        b"5\r\nhello\r\n"
-        b"0\r\n"
-        b"X-Tinfoil-Usage-Metrics: prompt=1,completion=2,total=3\r\n"
-        b"\r\n"
-    )
-    reader = FakeReader([response])
-    writer = FakeWriter()
-    open_connection = AsyncMock(return_value=(reader, writer))
-    monkeypatch.setattr(
-        "routstr.upstream.tinfoil_trailer.asyncio.open_connection", open_connection
-    )
-
-    result = await forward_with_trailer(
-        method="POST",
-        url="https://enclave.tinfoil.sh/v1/chat/completions?stream=true",
-        headers={"Authorization": "Bearer upstream"},
-        body=b"opaque",
-    )
-
-    assert result.status_code == 200
-    assert result.body == b"hello"
-    assert result.trailers == [
-        ("x-tinfoil-usage-metrics", "prompt=1,completion=2,total=3")
-    ]
-    assert b"Connection: close" in writer.written
-    writer.close.assert_called_once()
-    writer.wait_closed.assert_awaited_once()
-
-
-@pytest.mark.asyncio
-async def test_forward_with_trailer_strips_hop_by_hop_headers(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    response = b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok"
-    reader = FakeReader([response])
-    writer = FakeWriter()
-    monkeypatch.setattr(
-        "routstr.upstream.tinfoil_trailer.asyncio.open_connection",
-        AsyncMock(return_value=(reader, writer)),
-    )
-
-    await forward_with_trailer(
-        method="POST",
-        url="https://enclave.tinfoil.sh/v1/chat/completions",
-        headers={
-            "Authorization": "Bearer upstream",
-            "Connection": "keep-alive, X-Client-Hop",
-            "Keep-Alive": "timeout=5",
-            "Proxy-Authenticate": "Basic",
-            "Proxy-Authorization": "Basic secret",
-            "TE": "trailers",
-            "Trailer": "X-Usage",
-            "Transfer-Encoding": "chunked",
-            "Upgrade": "websocket",
-            "X-Client-Hop": "remove-me",
-            "X-End-To-End": "preserve-me",
-        },
-        body=b"opaque",
-    )
-
-    serialized_headers = writer.written.split(b"\r\n\r\n", 1)[0].lower()
-    for name in (
-        b"keep-alive",
-        b"proxy-authenticate",
-        b"proxy-authorization",
-        b"te:",
-        b"trailer:",
-        b"transfer-encoding",
-        b"upgrade:",
-        b"x-client-hop",
-    ):
-        assert name not in serialized_headers
-    assert b"connection: close" in serialized_headers
-    assert b"content-length: 6" in serialized_headers
-    assert b"x-end-to-end: preserve-me" in serialized_headers
-
-
-@pytest.mark.asyncio
-async def test_forward_with_trailer_enforces_response_size_limit(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    response = b"HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\nhello"
-    reader = FakeReader([response])
-    writer = FakeWriter()
-    monkeypatch.setattr(
-        "routstr.upstream.tinfoil_trailer.asyncio.open_connection",
-        AsyncMock(return_value=(reader, writer)),
-    )
-
-    with pytest.raises(ValueError, match="EHBP response exceeded"):
-        await forward_with_trailer(
-            method="POST",
-            url="https://enclave.tinfoil.sh/v1/chat/completions",
-            headers={},
-            body=b"opaque",
-            max_response_bytes=4,
-        )
-
-    writer.close.assert_called_once()

tests/unit/test_wallet.py

@@ -1,22 +1,11 @@
 import base64
 import json
-import socket
 from unittest.mock import AsyncMock, Mock, patch
 
-import httpx
 import pytest
 
 from routstr.core.db import ApiKey
-from routstr.wallet import (
-    MintConnectionError,
-    TokenConsumedError,
-    classify_redemption_error,
-    credit_balance,
-    get_balance,
-    is_mint_connection_error,
-    recieve_token,
-    send_token,
-)
+from routstr.wallet import credit_balance, get_balance, recieve_token, send_token
 
 
 @pytest.mark.asyncio
@@ -242,15 +231,9 @@ async def test_credit_balance_rejects_missing_key() -> None:
             "routstr.wallet.recieve_token",
             return_value=(1000, "sat", "http://mint:3338"),
         ):
-            # Post-redemption: token already spent, so a vanished key is a
-            # non-retryable TokenConsumedError, not a generic token error.
-            with pytest.raises(TokenConsumedError, match="disappeared") as exc_info:
+            with pytest.raises(ValueError, match="disappeared"):
                 await credit_balance(token_str, mock_key, mock_session)
 
-    classified = classify_redemption_error(exc_info.value)
-    assert classified is not None
-    _type, status, _msg, code = classified
-    assert (status, code) == (500, "cashu_token_consumed")
     # UPDATE matched nothing; committing would hide the failed credit.
     assert mock_session.exec.called
     assert not mock_session.commit.called
@@ -919,10 +902,9 @@ def _with_recovery_mocks(
 
 
 @pytest.mark.asyncio
-async def test_swap_mint_failure_after_melt_is_token_consumed() -> None:
-    """A non-recoverable mint failure after melt is a non-retryable
-    TokenConsumedError (the melt already spent the foreign proofs), with the
-    original error preserved in the cause chain."""
+async def test_swap_mint_failure_propagates_unwrapped() -> None:
+    """A non-recoverable mint failure after melt propagates as-is (a 500, not a
+    client error): the melt already spent the foreign proofs."""
     from routstr.wallet import swap_to_primary_mint
 
     mock_token, mock_token_wallet, mock_primary_wallet = _make_swap_mocks(
@@ -937,10 +919,10 @@ async def test_swap_mint_failure_after_melt_is_token_consumed() -> None:
     with patch.object(settings, "primary_mint", "http://primary:3338"):
         with patch.object(settings, "primary_mint_unit", "sat"):
             with patch("routstr.wallet.get_wallet", return_value=mock_primary_wallet):
-                with pytest.raises(TokenConsumedError) as exc_info:
+                with pytest.raises(Exception, match="Quote is expired") as exc_info:
                     await swap_to_primary_mint(mock_token, mock_token_wallet)
 
-    assert "Quote is expired" in str(exc_info.value.__cause__)
+    assert type(exc_info.value) is Exception  # original error, not wrapped
     assert mock_token_wallet.melt.call_count == 1
     mock_primary_wallet.restore_tokens_for_keyset.assert_not_called()
 
@@ -995,7 +977,7 @@ async def test_swap_recovery_shortfall_refuses_credit() -> None:
     with patch.object(settings, "primary_mint", "http://primary:3338"):
         with patch.object(settings, "primary_mint_unit", "sat"):
             with patch("routstr.wallet.get_wallet", return_value=mock_primary_wallet):
-                with pytest.raises(TokenConsumedError, match="Swap recovery failed"):
+                with pytest.raises(ValueError, match="Swap recovery failed"):
                     await swap_to_primary_mint(mock_token, mock_token_wallet)
 
 
@@ -1022,7 +1004,7 @@ async def test_swap_recovery_failure_wrapped() -> None:
     with patch.object(settings, "primary_mint", "http://primary:3338"):
         with patch.object(settings, "primary_mint_unit", "sat"):
             with patch("routstr.wallet.get_wallet", return_value=mock_primary_wallet):
-                with pytest.raises(TokenConsumedError, match="recovery unsuccessful"):
+                with pytest.raises(ValueError, match="recovery unsuccessful"):
                     await swap_to_primary_mint(mock_token, mock_token_wallet)
 
 
@@ -1110,214 +1092,3 @@ async def test_swap_does_not_retry_on_payment_failure() -> None:
 
     assert mock_token_wallet.melt.call_count == 1
     assert mock_primary_wallet.request_mint.call_count == 2
-
-
-# --- Mint-unreachable classification (is_mint_connection_error) ---------------
-
-
-def _chain(outer: BaseException, cause: BaseException) -> BaseException:
-    """Attach ``cause`` as the ``__cause__`` of ``outer`` (as ``raise X from Y``
-    would) and return ``outer``."""
-    outer.__cause__ = cause
-    return outer
-
-
-@pytest.mark.parametrize(
-    "error",
-    [
-        httpx.ConnectError("connection refused"),
-        httpx.ConnectTimeout("timed out"),
-        httpx.ReadTimeout("read timed out"),  # subclass of TimeoutException
-        httpx.PoolTimeout("pool timed out"),
-        httpx.WriteError("write failed"),  # subclass of NetworkError
-        ConnectionRefusedError("refused"),  # subclass of ConnectionError
-        ConnectionResetError("reset"),
-        socket.gaierror("Name or service not known"),
-        TimeoutError("timed out"),  # asyncio.TimeoutError alias on 3.11+
-        MintConnectionError("mint down"),
-        # Wrapped: the real transport error survives in the __cause__ chain.
-        _chain(ValueError("Failed to estimate fees: boom"), httpx.ConnectError("x")),
-        # Two levels deep.
-        _chain(
-            RuntimeError("outer"),
-            _chain(ValueError("mid"), httpx.ConnectTimeout("deep")),
-        ),
-    ],
-)
-def test_is_mint_connection_error_detects_transport_failures(
-    error: BaseException,
-) -> None:
-    assert is_mint_connection_error(error) is True
-
-
-@pytest.mark.parametrize(
-    "error",
-    [
-        ValueError("token already spent"),
-        ValueError("Mint unreachable: all connection attempts failed"),  # text only
-        ValueError("Invalid Cashu token"),
-        # Mint answered with an error status — reachable, so NOT a connection error.
-        httpx.HTTPStatusError(
-            "500", request=httpx.Request("POST", "http://m"), response=httpx.Response(500)
-        ),
-        RuntimeError("some internal fault"),
-    ],
-)
-def test_is_mint_connection_error_ignores_non_transport(error: BaseException) -> None:
-    assert is_mint_connection_error(error) is False
-
-
-def test_is_mint_connection_error_survives_reference_cycle() -> None:
-    """A pathological cause/context cycle must not hang the classifier."""
-    a = ValueError("a")
-    b = ValueError("b")
-    a.__cause__ = b
-    b.__context__ = a
-    assert is_mint_connection_error(a) is False
-
-
-def test_token_consumed_seals_transport_cause() -> None:
-    """A transport error wrapped in TokenConsumedError is NOT retryable — the
-    token is spent, so the seal wins over the httpx cause underneath."""
-    try:
-        raise httpx.ConnectError("mint down")
-    except httpx.ConnectError as exc:
-        consumed = TokenConsumedError("credit failed")
-        consumed.__cause__ = exc
-
-    assert is_mint_connection_error(consumed) is False
-    classified = classify_redemption_error(consumed)
-    assert classified is not None
-    type_, status, _msg, code = classified
-    assert (type_, status, code) == ("token_consumed", 500, "cashu_token_consumed")
-
-
-@pytest.mark.parametrize(
-    "error",
-    [
-        # The message credit_balance raises for a dust/zero redemption.
-        ValueError("Redeemed token amount must be positive, got 0 msats"),
-        ValueError("Redeemed token amount must be positive, got -5 msats"),
-        ValueError("Failed to redeem Cashu token: token yielded no value"),
-    ],
-)
-def test_classify_zero_value(error: ValueError) -> None:
-    """A zero/negative redemption gets its own documented code, not the generic
-    cashu_token_redemption_failed bucket."""
-    classified = classify_redemption_error(error)
-    assert classified is not None
-    type_, status, _msg, code = classified
-    assert (type_, status, code) == ("cashu_error", 400, "cashu_token_zero_value")
-
-
-def test_classify_generic_valueerror_is_not_zero_value() -> None:
-    """A generic wallet ValueError still falls to the generic bucket — the
-    zero-value match must not over-trigger."""
-    classified = classify_redemption_error(ValueError("some unexpected wallet condition"))
-    assert classified is not None
-    type_, status, _msg, code = classified
-    assert (type_, status, code) == (
-        "cashu_error",
-        400,
-        "cashu_token_redemption_failed",
-    )
-
-
-@pytest.mark.asyncio
-async def test_swap_mint_transport_error_after_melt_is_not_retryable() -> None:
-    """A transport error minting on the primary mint (after the foreign melt
-    already spent the proofs) classifies as a non-retryable token_consumed 500,
-    never a retryable mint_unreachable 503."""
-    from routstr.wallet import swap_to_primary_mint
-
-    mock_token, mock_token_wallet, mock_primary_wallet = _make_swap_mocks(
-        1000, fee_reserves=[10, 10]
-    )
-    # Melt succeeds (proofs spent); minting on primary hits a transport error.
-    mock_primary_wallet.mint = AsyncMock(
-        side_effect=httpx.ConnectError("primary mint down")
-    )
-
-    from routstr.core.settings import settings
-
-    with patch.object(settings, "primary_mint", "http://primary:3338"):
-        with patch.object(settings, "primary_mint_unit", "sat"):
-            with patch("routstr.wallet.get_wallet", return_value=mock_primary_wallet):
-                with pytest.raises(TokenConsumedError) as exc_info:
-                    await swap_to_primary_mint(mock_token, mock_token_wallet)
-
-    classified = classify_redemption_error(exc_info.value)
-    assert classified is not None
-    _type, status, _msg, code = classified
-    assert status == 500
-    assert code == "cashu_token_consumed"
-    assert is_mint_connection_error(exc_info.value) is False
-    assert mock_token_wallet.melt.call_count == 1
-
-
-@pytest.mark.asyncio
-async def test_credit_balance_db_transport_error_is_token_consumed() -> None:
-    """A transport-like DB failure after the token is redeemed must be
-    non-retryable (token_consumed), not a retryable mint_unreachable."""
-    mock_key = Mock()
-    mock_key.balance = 1000
-    mock_key.hashed_key = "test_hash"
-    mock_session = AsyncMock()
-    mock_session.exec = AsyncMock(side_effect=ConnectionError("db connection reset"))
-
-    with patch(
-        "routstr.wallet.recieve_token",
-        return_value=(100, "sat", "https://mint.example"),
-    ):
-        with pytest.raises(TokenConsumedError) as exc_info:
-            await credit_balance("cashuAtoken", mock_key, mock_session)
-
-    assert is_mint_connection_error(exc_info.value) is False
-
-
-@pytest.mark.asyncio
-async def test_swap_fee_estimation_transport_error_raises_mint_connection_error() -> None:
-    """A transport failure while estimating fees is surfaced as
-    MintConnectionError (→ 503), not a generic fee ValueError (→ 422)."""
-    from routstr.wallet import swap_to_primary_mint
-
-    mock_token, mock_token_wallet, mock_primary_wallet = _make_swap_mocks(
-        1000, fee_reserves=[10]
-    )
-    mock_primary_wallet.request_mint = AsyncMock(
-        side_effect=httpx.ConnectError("All connection attempts failed")
-    )
-
-    from routstr.core.settings import settings
-
-    with patch.object(settings, "primary_mint", "http://primary:3338"):
-        with patch.object(settings, "primary_mint_unit", "sat"):
-            with patch("routstr.wallet.get_wallet", return_value=mock_primary_wallet):
-                with pytest.raises(MintConnectionError):
-                    await swap_to_primary_mint(mock_token, mock_token_wallet)
-
-    mock_token_wallet.melt.assert_not_called()
-
-
-@pytest.mark.asyncio
-async def test_swap_melt_transport_error_raises_mint_connection_error() -> None:
-    """A transport failure during melt is surfaced as MintConnectionError and
-    is NOT retried — the mint is down, not demanding higher fees."""
-    from routstr.wallet import swap_to_primary_mint
-
-    mock_token, mock_token_wallet, mock_primary_wallet = _make_swap_mocks(
-        1000, fee_reserves=[10, 10]
-    )
-    mock_token_wallet.melt = AsyncMock(
-        side_effect=httpx.ConnectTimeout("timed out")
-    )
-
-    from routstr.core.settings import settings
-
-    with patch.object(settings, "primary_mint", "http://primary:3338"):
-        with patch.object(settings, "primary_mint_unit", "sat"):
-            with patch("routstr.wallet.get_wallet", return_value=mock_primary_wallet):
-                with pytest.raises(MintConnectionError):
-                    await swap_to_primary_mint(mock_token, mock_token_wallet)
-
-    assert mock_token_wallet.melt.call_count == 1

ui/Dockerfile

@@ -4,15 +4,15 @@ FROM base AS deps
 RUN apk add --no-cache libc6-compat
 WORKDIR /app
 
-RUN corepack enable pnpm && corepack prepare pnpm@10.15.0 --activate
+RUN corepack enable pnpm && corepack prepare pnpm@latest --activate
 
-COPY package.json pnpm-lock.yaml* pnpm-workspace.yaml* ./
+COPY package.json pnpm-lock.yaml* ./
 RUN pnpm install --frozen-lockfile
 
 FROM base AS builder
 WORKDIR /app
 
-RUN corepack enable pnpm && corepack prepare pnpm@10.15.0 --activate
+RUN corepack enable pnpm && corepack prepare pnpm@latest --activate
 
 COPY --from=deps /app/node_modules ./node_modules
 COPY . .

ui/Dockerfile.build

@@ -6,14 +6,14 @@ RUN apk add --no-cache libc6-compat
 WORKDIR /app
 
 # Copy package files
-COPY package.json pnpm-lock.yaml* pnpm-workspace.yaml* ./
-RUN corepack enable pnpm && corepack prepare pnpm@10.15.0 --activate
+COPY package.json pnpm-lock.yaml* ./
+RUN corepack enable pnpm && corepack prepare pnpm@latest --activate
 RUN pnpm install --frozen-lockfile
 
 # Build the UI
 FROM base AS builder
 WORKDIR /app
-RUN corepack enable pnpm && corepack prepare pnpm@10.15.0 --activate
+RUN corepack enable pnpm && corepack prepare pnpm@latest --activate
 COPY --from=deps /app/node_modules ./node_modules
 COPY . .
 

ui/components/add-model-form.tsx

@@ -86,7 +86,7 @@ export function AddModelForm({
 
   return (
     <Dialog open={isOpen} onOpenChange={handleClose}>
-      <DialogContent className='max-h-[90dvh] overflow-y-auto sm:max-w-[600px]'>
+      <DialogContent className='max-h-[90vh] overflow-y-auto sm:max-w-[600px]'>
         <DialogHeader>
           <DialogTitle className='flex items-center gap-2'>
             <Plus className='h-5 w-5' />

ui/components/add-provider-model-dialog.tsx

@@ -438,7 +438,7 @@ export function AddProviderModelDialog({
 
   return (
     <Dialog open={isOpen} onOpenChange={(open) => !open && onClose()}>
-      <DialogContent className='max-h-[90dvh] overflow-y-auto sm:max-w-[720px]'>
+      <DialogContent className='max-h-[90vh] overflow-y-auto sm:max-w-[720px]'>
         <DialogHeader>
           <DialogTitle className='flex items-center gap-2'>
             <Plus className='h-4 w-4' />

ui/components/collect-models-dialog.tsx

@@ -177,7 +177,7 @@ export function CollectModelsDialog({
 
   return (
     <Dialog open={isOpen} onOpenChange={handleClose}>
-      <DialogContent className='max-h-[80dvh] sm:max-w-[700px]'>
+      <DialogContent className='max-h-[80vh] sm:max-w-[700px]'>
         <DialogHeader>
           <DialogTitle className='flex items-center gap-2'>
             <Download className='h-5 w-5' />

ui/components/cost-calculator-dialog.tsx

@@ -25,7 +25,7 @@ export function CostCalculatorDialog({
 }: CostCalculatorDialogProps) {
   return (
     <Dialog open={isOpen} onOpenChange={onClose}>
-      <DialogContent className='max-h-[90dvh] overflow-y-auto sm:max-w-[700px]'>
+      <DialogContent className='max-h-[90vh] overflow-y-auto sm:max-w-[700px]'>
         <DialogHeader>
           <DialogTitle className='flex items-center gap-2'>
             <Calculator className='h-5 w-5' />

ui/components/edit-group-form.tsx

@@ -100,7 +100,7 @@ export function EditGroupForm({
 
   return (
     <Dialog open={isOpen} onOpenChange={handleClose}>
-      <DialogContent className='max-h-[90dvh] overflow-y-auto sm:max-w-[700px]'>
+      <DialogContent className='max-h-[90vh] overflow-y-auto sm:max-w-[700px]'>
         <DialogHeader>
           <DialogTitle className='flex items-center gap-2'>
             <Users className='h-5 w-5' />

ui/components/provider-card.tsx

@@ -213,7 +213,7 @@ export function ProviderCard({
       </CardHeader>
 
       <Dialog open={isKeyModalOpen} onOpenChange={setIsKeyModalOpen}>
-        <DialogContent className='max-h-[90dvh] overflow-y-auto sm:max-w-[500px]'>
+        <DialogContent className='max-h-[90vh] overflow-y-auto sm:max-w-[500px]'>
           <DialogHeader>
             <DialogTitle>
               {provider.api_key

ui/components/provider-form-dialog-content.tsx

@@ -53,7 +53,7 @@ export function ProviderFormDialogContent({
   availableMints,
 }: ProviderFormDialogContentProps) {
   return (
-    <DialogContent className='max-h-[90dvh] overflow-y-auto sm:max-w-[500px]'>
+    <DialogContent className='max-h-[90vh] overflow-y-auto sm:max-w-[500px]'>
       <DialogHeader>
         <DialogTitle>{title}</DialogTitle>
         <DialogDescription>{description}</DialogDescription>

ui/components/providers/ProviderBalance.tsx

@@ -112,7 +112,7 @@ export function ProviderBalance({
       </Button>
 
       <Dialog open={isTopupDialogOpen} onOpenChange={handleCloseDialog}>
-        <DialogContent className='max-h-[90dvh] overflow-y-auto sm:max-w-md'>
+        <DialogContent className='max-h-[90vh] overflow-y-auto sm:max-w-md'>
           <DialogHeader>
             <DialogTitle>Top Up Balance</DialogTitle>
             <DialogDescription>

ui/components/providers/RoutstrProviderCard.tsx

@@ -239,7 +239,7 @@ export function RoutstrProviderCard({
       </Card>
 
       <Dialog open={isKeyDialogOpen} onOpenChange={setIsKeyDialogOpen}>
-        <DialogContent className='max-h-[90dvh] overflow-y-auto sm:max-w-lg'>
+        <DialogContent className='max-h-[90vh] overflow-y-auto sm:max-w-lg'>
           <DialogHeader>
             <DialogTitle>
               {hasApiKey ? 'Create New Key on Upstream Node' : 'Create API Key'}

ui/components/top-models-usage-chart.tsx

@@ -626,7 +626,7 @@ export function TopModelsUsageChart({
             className={cn(
               'aspect-auto w-full',
               isFullscreen
-                ? 'h-[calc(100dvh-220px)] min-h-[340px] sm:h-[calc(100dvh-260px)] sm:min-h-[420px]'
+                ? 'h-[calc(100vh-220px)] min-h-[340px] sm:h-[calc(100vh-260px)] sm:min-h-[420px]'
                 : 'h-[260px] sm:h-[340px]'
             )}
             onMouseLeave={() => {

ui/components/ui/dialog.tsx

@@ -130,7 +130,7 @@ function DialogContent({
         <DrawerPrimitive.Content
           data-slot='dialog-content'
           className={cn(
-            'border-border bg-card data-closed:animate-out data-open:animate-in data-closed:slide-out-to-bottom data-open:slide-in-from-bottom fixed inset-x-0 bottom-0 z-50 grid max-h-[90dvh] w-full gap-4 rounded-t-xl border-t p-4 pb-[calc(1rem+env(safe-area-inset-bottom))] shadow-lg',
+            'border-border bg-card data-closed:animate-out data-open:animate-in data-closed:slide-out-to-bottom data-open:slide-in-from-bottom fixed inset-x-0 bottom-0 z-50 grid max-h-[90vh] w-full gap-4 rounded-t-xl border-t p-4 pb-[calc(1rem+env(safe-area-inset-bottom))] shadow-lg',
             className
           )}
           {...(props as React.ComponentProps<typeof DrawerPrimitive.Content>)}

ui/components/ui/drawer.tsx

@@ -56,7 +56,7 @@ function DrawerContent({
       <DrawerPrimitive.Content
         data-slot='drawer-content'
         className={cn(
-          'bg-background group/drawer-content fixed z-50 flex h-auto flex-col text-sm data-[vaul-drawer-direction=bottom]:inset-x-0 data-[vaul-drawer-direction=bottom]:bottom-0 data-[vaul-drawer-direction=bottom]:mt-24 data-[vaul-drawer-direction=bottom]:max-h-[80dvh] data-[vaul-drawer-direction=bottom]:rounded-t-xl data-[vaul-drawer-direction=bottom]:border-t data-[vaul-drawer-direction=bottom]:pb-[calc(0.5rem+env(safe-area-inset-bottom))] data-[vaul-drawer-direction=left]:inset-y-0 data-[vaul-drawer-direction=left]:left-0 data-[vaul-drawer-direction=left]:w-3/4 data-[vaul-drawer-direction=left]:rounded-r-xl data-[vaul-drawer-direction=left]:border-r data-[vaul-drawer-direction=right]:inset-y-0 data-[vaul-drawer-direction=right]:right-0 data-[vaul-drawer-direction=right]:w-3/4 data-[vaul-drawer-direction=right]:rounded-l-xl data-[vaul-drawer-direction=right]:border-l data-[vaul-drawer-direction=top]:inset-x-0 data-[vaul-drawer-direction=top]:top-0 data-[vaul-drawer-direction=top]:mb-24 data-[vaul-drawer-direction=top]:max-h-[80dvh] data-[vaul-drawer-direction=top]:rounded-b-xl data-[vaul-drawer-direction=top]:border-b data-[vaul-drawer-direction=left]:sm:max-w-sm data-[vaul-drawer-direction=right]:sm:max-w-sm',
+          'bg-background group/drawer-content fixed z-50 flex h-auto flex-col text-sm data-[vaul-drawer-direction=bottom]:inset-x-0 data-[vaul-drawer-direction=bottom]:bottom-0 data-[vaul-drawer-direction=bottom]:mt-24 data-[vaul-drawer-direction=bottom]:max-h-[80vh] data-[vaul-drawer-direction=bottom]:rounded-t-xl data-[vaul-drawer-direction=bottom]:border-t data-[vaul-drawer-direction=bottom]:pb-[calc(0.5rem+env(safe-area-inset-bottom))] data-[vaul-drawer-direction=left]:inset-y-0 data-[vaul-drawer-direction=left]:left-0 data-[vaul-drawer-direction=left]:w-3/4 data-[vaul-drawer-direction=left]:rounded-r-xl data-[vaul-drawer-direction=left]:border-r data-[vaul-drawer-direction=right]:inset-y-0 data-[vaul-drawer-direction=right]:right-0 data-[vaul-drawer-direction=right]:w-3/4 data-[vaul-drawer-direction=right]:rounded-l-xl data-[vaul-drawer-direction=right]:border-l data-[vaul-drawer-direction=top]:inset-x-0 data-[vaul-drawer-direction=top]:top-0 data-[vaul-drawer-direction=top]:mb-24 data-[vaul-drawer-direction=top]:max-h-[80vh] data-[vaul-drawer-direction=top]:rounded-b-xl data-[vaul-drawer-direction=top]:border-b data-[vaul-drawer-direction=left]:sm:max-w-sm data-[vaul-drawer-direction=right]:sm:max-w-sm',
           className
         )}
         {...props}

ui/components/usage-metrics-chart.tsx

@@ -291,7 +291,7 @@ export function UsageMetricsChart({
             className={cn(
               'aspect-auto w-full',
               isFullscreen
-                ? 'h-[calc(100dvh-220px)] min-h-[340px] sm:h-[calc(100dvh-260px)] sm:min-h-[420px]'
+                ? 'h-[calc(100vh-220px)] min-h-[340px] sm:h-[calc(100vh-260px)] sm:min-h-[420px]'
                 : 'h-[260px] sm:h-[340px]'
             )}
             config={chartConfig}

ui/package.json

@@ -45,7 +45,7 @@
     "@radix-ui/react-tooltip": "^1.2.8",
     "@tanstack/react-query": "^5.90.21",
     "@tanstack/react-table": "^8.21.3",
-    "axios": "^1.16.0",
+    "axios": "^1.13.5",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",
@@ -54,7 +54,7 @@
     "geist": "^1.7.0",
     "input-otp": "^1.4.2",
     "lucide-react": "^0.575.0",
-    "next": "16.2.6",
+    "next": "16.1.6",
     "next-themes": "^0.4.6",
     "qrcode": "^1.5.4",
     "qrcode.react": "^4.2.0",
@@ -81,7 +81,7 @@
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
     "eslint": "^9.7.0",
-    "eslint-config-next": "16.2.6",
+    "eslint-config-next": "16.1.6",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.5",
     "eslint-plugin-react": "^7.37.5",
@@ -89,5 +89,11 @@
     "prettier-plugin-tailwindcss": "^0.7.2",
     "tailwindcss": "^4.2.0",
     "typescript": "^5.9.3"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "sharp",
+      "unrs-resolver"
+    ]
   }
 }

ui/pnpm-lock.yaml

@@ -4,20 +4,6 @@ settings:
   autoInstallPeers: true
   excludeLinksFromLockfile: false
 
-overrides:
-  '@babel/core': 7.29.6
-  flatted: 3.4.2
-  follow-redirects: 1.16.0
-  form-data: 4.0.6
-  ajv@6: 6.14.0
-  brace-expansion@1: 1.1.13
-  brace-expansion@5: 5.0.6
-  js-yaml: 4.2.0
-  minimatch@3: 3.1.4
-  picomatch@2: 2.3.2
-  picomatch@4: 4.0.4
-  postcss: 8.5.10
-
 importers:
 
   .:
@@ -119,8 +105,8 @@ importers:
         specifier: ^8.21.3
         version: 8.21.3(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
       axios:
-        specifier: ^1.16.0
-        version: 1.18.1
+        specifier: ^1.13.5
+        version: 1.13.6
       class-variance-authority:
         specifier: ^0.7.1
         version: 0.7.1
@@ -138,7 +124,7 @@ importers:
         version: 8.6.0(react@19.2.4)
       geist:
         specifier: ^1.7.0
-        version: 1.7.0(next@16.2.6(@babel/core@7.29.6)(react-dom@19.2.4(react@19.2.4))(react@19.2.4))
+        version: 1.7.0(next@16.1.6(@babel/core@7.29.0)(react-dom@19.2.4(react@19.2.4))(react@19.2.4))
       input-otp:
         specifier: ^1.4.2
         version: 1.4.2(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
@@ -146,8 +132,8 @@ importers:
         specifier: ^0.575.0
         version: 0.575.0(react@19.2.4)
       next:
-        specifier: 16.2.6
-        version: 16.2.6(@babel/core@7.29.6)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+        specifier: 16.1.6
+        version: 16.1.6(@babel/core@7.29.0)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
       next-themes:
         specifier: ^0.4.6
         version: 0.4.6(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
@@ -222,8 +208,8 @@ importers:
         specifier: ^9.7.0
         version: 9.38.0(jiti@2.6.1)
       eslint-config-next:
-        specifier: 16.2.6
-        version: 16.2.6(@typescript-eslint/parser@8.57.0(eslint@9.38.0(jiti@2.6.1))(typescript@5.9.3))(eslint@9.38.0(jiti@2.6.1))(typescript@5.9.3)
+        specifier: 16.1.6
+        version: 16.1.6(@typescript-eslint/parser@8.57.0(eslint@9.38.0(jiti@2.6.1))(typescript@5.9.3))(eslint@9.38.0(jiti@2.6.1))(typescript@5.9.3)
       eslint-config-prettier:
         specifier: ^10.1.8
         version: 10.1.8(eslint@9.38.0(jiti@2.6.1))
@@ -256,20 +242,16 @@ packages:
     resolution: {integrity: sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/code-frame@7.29.7':
-    resolution: {integrity: sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==}
-    engines: {node: '>=6.9.0'}
-
   '@babel/compat-data@7.29.0':
     resolution: {integrity: sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/core@7.29.6':
-    resolution: {integrity: sha512-QdxmAo/ikZqqRGA8s43ww8lcql6naWRvEz0FFrl6MIlc7Gi6TroXnSdWa5U/kq6fzcpqpHesicQxFZIieZbyIA==}
+  '@babel/core@7.29.0':
+    resolution: {integrity: sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/generator@7.29.7':
-    resolution: {integrity: sha512-DkXD5OJQaAQIdZ1bt3UZdEnHAn9Imd3IVBdX03UFe+ony9Ojw5pzr9YVKGDY1jt+Gcn/FnGkNf8r+Vj5NOJWtQ==}
+  '@babel/generator@7.29.1':
+    resolution: {integrity: sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==}
     engines: {node: '>=6.9.0'}
 
   '@babel/helper-compilation-targets@7.28.6':
@@ -288,30 +270,22 @@ packages:
     resolution: {integrity: sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
-      '@babel/core': 7.29.6
+      '@babel/core': ^7.0.0
 
   '@babel/helper-string-parser@7.27.1':
     resolution: {integrity: sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-string-parser@7.29.7':
-    resolution: {integrity: sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==}
-    engines: {node: '>=6.9.0'}
-
   '@babel/helper-validator-identifier@7.28.5':
     resolution: {integrity: sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helper-validator-identifier@7.29.7':
-    resolution: {integrity: sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==}
-    engines: {node: '>=6.9.0'}
-
   '@babel/helper-validator-option@7.27.1':
     resolution: {integrity: sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/helpers@7.29.7':
-    resolution: {integrity: sha512-1k2lAGRMfHTcwuNYcCNUmaUffmQv8KWMfh2iJUUeRlwlwH4FdNG7mfPI10NPfLHJFThE4Tyr4mv7kTNZOiPuBg==}
+  '@babel/helpers@7.28.6':
+    resolution: {integrity: sha512-xOBvwq86HHdB7WUDTfKfT/Vuxh7gElQ+Sfti2Cy6yIWNW05P8iUslOVcZ4/sKbE+/jQaukQAdz/gf3724kYdqw==}
     engines: {node: '>=6.9.0'}
 
   '@babel/parser@7.29.0':
@@ -319,11 +293,6 @@ packages:
     engines: {node: '>=6.0.0'}
     hasBin: true
 
-  '@babel/parser@7.29.7':
-    resolution: {integrity: sha512-hnORnjP/1P/zFEndoeX+n+t1RwWRJiJpM/jO7FW32Kn9r5+sJB2JWOdYo4L6k78j15eCwY3Gm/7364B1EMwtNg==}
-    engines: {node: '>=6.0.0'}
-    hasBin: true
-
   '@babel/runtime@7.28.6':
     resolution: {integrity: sha512-05WQkdpL9COIMz4LjTxGpPNCdlpyimKppYNoJ5Di5EUObifl8t4tuLuUBBZEpoLYOmfvIWrsp9fCl0HoPRVTdA==}
     engines: {node: '>=6.9.0'}
@@ -332,10 +301,6 @@ packages:
     resolution: {integrity: sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/template@7.29.7':
-    resolution: {integrity: sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==}
-    engines: {node: '>=6.9.0'}
-
   '@babel/traverse@7.29.0':
     resolution: {integrity: sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==}
     engines: {node: '>=6.9.0'}
@@ -344,10 +309,6 @@ packages:
     resolution: {integrity: sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/types@7.29.7':
-    resolution: {integrity: sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA==}
-    engines: {node: '>=6.9.0'}
-
   '@base-ui/react@1.2.0':
     resolution: {integrity: sha512-O6aEQHcm+QyGTFY28xuwRD3SEJGZOBDpyjN2WvpfWYFVhg+3zfXPysAILqtM0C1kWC82MccOE/v1j+GHXE4qIw==}
     engines: {node: '>=14.0.0'}
@@ -639,56 +600,56 @@ packages:
   '@napi-rs/wasm-runtime@0.2.12':
     resolution: {integrity: sha512-ZVWUcfwY4E/yPitQJl481FjFo3K22D6qF0DuFH6Y/nbnE11GY5uguDxZMGXPQ8WQ0128MXQD7TnfHyK4oWoIJQ==}
 
-  '@next/env@16.2.6':
-    resolution: {integrity: sha512-gd8HoHN4ufj73WmR3JmVolrpJR47ILK6LouP5xElPglaVxir6e1a7VzvTvDWkOoPXT9rkkTzyCxBu4yeZfZwcw==}
+  '@next/env@16.1.6':
+    resolution: {integrity: sha512-N1ySLuZjnAtN3kFnwhAwPvZah8RJxKasD7x1f8shFqhncnWZn4JMfg37diLNuoHsLAlrDfM3g4mawVdtAG8XLQ==}
 
-  '@next/eslint-plugin-next@16.2.6':
-    resolution: {integrity: sha512-Z8l6o4JWKUl755x4R+wogD86KPeU+Ckw4K+SYG4kHeOJtRenDeK+OSbGcqZpDtbwn9DsJVdir2UxmwXuinUbUw==}
+  '@next/eslint-plugin-next@16.1.6':
+    resolution: {integrity: sha512-/Qq3PTagA6+nYVfryAtQ7/9FEr/6YVyvOtl6rZnGsbReGLf0jZU6gkpr1FuChAQpvV46a78p4cmHOVP8mbfSMQ==}
 
-  '@next/swc-darwin-arm64@16.2.6':
-    resolution: {integrity: sha512-ZJGkkcNfYgrrMkqOdZ7zoLa1TOy0qpcMfk/z4Mh/FKUz40gVO+HNQWqmLxf67Z5WB64DRp0dhEbyHfel+6sJUg==}
+  '@next/swc-darwin-arm64@16.1.6':
+    resolution: {integrity: sha512-wTzYulosJr/6nFnqGW7FrG3jfUUlEf8UjGA0/pyypJl42ExdVgC6xJgcXQ+V8QFn6niSG2Pb8+MIG1mZr2vczw==}
     engines: {node: '>= 10'}
     cpu: [arm64]
     os: [darwin]
 
-  '@next/swc-darwin-x64@16.2.6':
-    resolution: {integrity: sha512-v/YLBHIY132Ced3puBJ7YJKw1lqsCrgcNo2aRJlCEyQrrCeRJlvGlnmxhPxNQI3KE3N1DN5r9TPNPvka3nq5RQ==}
+  '@next/swc-darwin-x64@16.1.6':
+    resolution: {integrity: sha512-BLFPYPDO+MNJsiDWbeVzqvYd4NyuRrEYVB5k2N3JfWncuHAy2IVwMAOlVQDFjj+krkWzhY2apvmekMkfQR0CUQ==}
     engines: {node: '>= 10'}
     cpu: [x64]
     os: [darwin]
 
-  '@next/swc-linux-arm64-gnu@16.2.6':
-    resolution: {integrity: sha512-RPOvqlYBbcQjkz9VQQDZ2T2bARIjXZV1KFlt+V2Mr6SW/e4I9fcKsaA0hdyf2FHoTlsV2xnBd5Y912rP/1Ce6w==}
+  '@next/swc-linux-arm64-gnu@16.1.6':
+    resolution: {integrity: sha512-OJYkCd5pj/QloBvoEcJ2XiMnlJkRv9idWA/j0ugSuA34gMT6f5b7vOiCQHVRpvStoZUknhl6/UxOXL4OwtdaBw==}
     engines: {node: '>= 10'}
     cpu: [arm64]
     os: [linux]
 
-  '@next/swc-linux-arm64-musl@16.2.6':
-    resolution: {integrity: sha512-URUTu1+dMkxJsPFgm+OeEvq9wf5sujw0EvgYy80TDGHTSLTnIHeqb0Eu8A3sC95IRgjejQL+kC4mw+4yPxiAXA==}
+  '@next/swc-linux-arm64-musl@16.1.6':
+    resolution: {integrity: sha512-S4J2v+8tT3NIO9u2q+S0G5KdvNDjXfAv06OhfOzNDaBn5rw84DGXWndOEB7d5/x852A20sW1M56vhC/tRVbccQ==}
     engines: {node: '>= 10'}
     cpu: [arm64]
     os: [linux]
 
-  '@next/swc-linux-x64-gnu@16.2.6':
-    resolution: {integrity: sha512-DOj182mPV8G3UkrayLoREM5YEYI+Dk5wv7Ox9xl1fFibAELEsFD0lDPfHIeILlutMMfdyhlzYPELG3peuKaurw==}
+  '@next/swc-linux-x64-gnu@16.1.6':
+    resolution: {integrity: sha512-2eEBDkFlMMNQnkTyPBhQOAyn2qMxyG2eE7GPH2WIDGEpEILcBPI/jdSv4t6xupSP+ot/jkfrCShLAa7+ZUPcJQ==}
     engines: {node: '>= 10'}
     cpu: [x64]
     os: [linux]
 
-  '@next/swc-linux-x64-musl@16.2.6':
-    resolution: {integrity: sha512-HKQ5SP/V/ub73UvF7n/zeJlxk2kLmtL7Wzrg4WfmkjmNos5onJ2tKu7yZOPdL18A6Svfn3max29ym+ry7NkK4g==}
+  '@next/swc-linux-x64-musl@16.1.6':
+    resolution: {integrity: sha512-oicJwRlyOoZXVlxmIMaTq7f8pN9QNbdes0q2FXfRsPhfCi8n8JmOZJm5oo1pwDaFbnnD421rVU409M3evFbIqg==}
     engines: {node: '>= 10'}
     cpu: [x64]
     os: [linux]
 
-  '@next/swc-win32-arm64-msvc@16.2.6':
-    resolution: {integrity: sha512-LZXpTlPyS5v7HhSmnvsLGP3iIYgYOBnc8r8ArlT55sGHV89bR2HlDdBjWQ+PY6SJMmk8TuVGFuxalnP3k/0Dwg==}
+  '@next/swc-win32-arm64-msvc@16.1.6':
+    resolution: {integrity: sha512-gQmm8izDTPgs+DCWH22kcDmuUp7NyiJgEl18bcr8irXA5N2m2O+JQIr6f3ct42GOs9c0h8QF3L5SzIxcYAAXXw==}
     engines: {node: '>= 10'}
     cpu: [arm64]
     os: [win32]
 
-  '@next/swc-win32-x64-msvc@16.2.6':
-    resolution: {integrity: sha512-F0+4i0h9J6C4eE3EAPWsoCk7UW/dbzOjyzxY0qnDUOYFu6FFmdZ6l97/XdV3/Nz3VYyO7UWjyEJUXkGqcoXfMA==}
+  '@next/swc-win32-x64-msvc@16.1.6':
+    resolution: {integrity: sha512-NRfO39AIrzBnixKbjuo2YiYhB6o9d8v/ymU9m/Xk8cyVk+k7XylniXkHwjs4s70wedVffc6bQNbufk5v0xEm0A==}
     engines: {node: '>= 10'}
     cpu: [x64]
     os: [win32]
@@ -1849,12 +1810,8 @@ packages:
     engines: {node: '>=0.4.0'}
     hasBin: true
 
-  agent-base@6.0.2:
-    resolution: {integrity: sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==}
-    engines: {node: '>= 6.0.0'}
-
-  ajv@6.14.0:
-    resolution: {integrity: sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==}
+  ajv@6.12.6:
+    resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==}
 
   ansi-regex@5.0.1:
     resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==}
@@ -1925,8 +1882,8 @@ packages:
     resolution: {integrity: sha512-BASOg+YwO2C+346x3LZOeoovTIoTrRqEsqMa6fmfAV0P+U9mFr9NsyOEpiYvFjbc64NMrSswhV50WdXzdb/Z5A==}
     engines: {node: '>=4'}
 
-  axios@1.18.1:
-    resolution: {integrity: sha512-3nTvFlvpn9Zu/RkHUqtc7/+al4UpRW5az71ap5zccp6e8RAYEzhMTecX8Dz1wWDYrPpUoB1HAQEGEAEvUr7S9g==}
+  axios@1.13.6:
+    resolution: {integrity: sha512-ChTCHMouEe2kn713WHbQGcuYrr6fXTBiu460OTwWrWob16g1bXn4vtz07Ope7ewMozJAnEquLk5lWQWtBig9DQ==}
 
   axobject-query@4.1.0:
     resolution: {integrity: sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ==}
@@ -1944,11 +1901,11 @@ packages:
     engines: {node: '>=6.0.0'}
     hasBin: true
 
-  brace-expansion@1.1.13:
-    resolution: {integrity: sha512-9ZLprWS6EENmhEOpjCYW2c8VkmOvckIJZfkr7rBW6dObmfgJ/L1GpSYW5Hpo9lDz4D1+n0Ckz8rU7FwHDQiG/w==}
+  brace-expansion@1.1.12:
+    resolution: {integrity: sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==}
 
-  brace-expansion@5.0.6:
-    resolution: {integrity: sha512-kLpxurY4Z4r9sgMsyG0Z9uzsBlgiU/EFKhj/h91/8yHu0edo7XuixOIH3VcJ8kkxs6/jPzoI6U9Vj3WqbMQ94g==}
+  brace-expansion@5.0.4:
+    resolution: {integrity: sha512-h+DEnpVvxmfVefa4jFbCf5HdH5YMDXRsmKflpf1pILZWRFlTbJpxeU55nJl4Smt5HQaGzg1o6RHFPJaOqnmBDg==}
     engines: {node: 18 || 20 || >=22}
 
   braces@3.0.3:
@@ -2225,8 +2182,8 @@ packages:
     resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==}
     engines: {node: '>=10'}
 
-  eslint-config-next@16.2.6:
-    resolution: {integrity: sha512-z2ELYSkyrrJ6cuunTU8vhsT/RpouPkjaSah06nVW6Rg2Hpg0Vs8s497/e5s8G8qtdp4ccsiovz5P1rv+5VSW2Q==}
+  eslint-config-next@16.1.6:
+    resolution: {integrity: sha512-vKq40io2B0XtkkNDYyleATwblNt8xuh3FWp8SpSz3pt7P01OkBFlKsJZ2mWt5WsCySlDQLckb1zMY9yE9Qy0LA==}
     peerDependencies:
       eslint: '>=9.0.0'
       typescript: '>=3.3.1'
@@ -2391,7 +2348,7 @@ packages:
     resolution: {integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==}
     engines: {node: '>=12.0.0'}
     peerDependencies:
-      picomatch: 4.0.4
+      picomatch: ^3 || ^4
     peerDependenciesMeta:
       picomatch:
         optional: true
@@ -2416,11 +2373,11 @@ packages:
     resolution: {integrity: sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==}
     engines: {node: '>=16'}
 
-  flatted@3.4.2:
-    resolution: {integrity: sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==}
+  flatted@3.3.3:
+    resolution: {integrity: sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==}
 
-  follow-redirects@1.16.0:
-    resolution: {integrity: sha512-y5rN/uOsadFT/JfYwhxRS5R7Qce+g3zG97+JrtFZlC9klX/W5hD7iiLzScI4nZqUS7DNUdhPgw4xI8W2LuXlUw==}
+  follow-redirects@1.15.11:
+    resolution: {integrity: sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==}
     engines: {node: '>=4.0'}
     peerDependencies:
       debug: '*'
@@ -2432,8 +2389,8 @@ packages:
     resolution: {integrity: sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==}
     engines: {node: '>= 0.4'}
 
-  form-data@4.0.6:
-    resolution: {integrity: sha512-vKatAh4SlVfgbv+YtmhiRjhEMJsYpsG1Y2rMQtR+SVSbytsSD1YGzDIcrAJmdFec88u/+VoGmxnl+80gL1tRCQ==}
+  form-data@4.0.5:
+    resolution: {integrity: sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==}
     engines: {node: '>= 6'}
 
   function-bind@1.1.2:
@@ -2536,20 +2493,12 @@ packages:
     resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==}
     engines: {node: '>= 0.4'}
 
-  hasown@2.0.4:
-    resolution: {integrity: sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==}
-    engines: {node: '>= 0.4'}
-
   hermes-estree@0.25.1:
     resolution: {integrity: sha512-0wUoCcLp+5Ev5pDW2OriHC2MJCbwLwuRx+gAqMTOkGKJJiBCLjtrvy4PWUGn6MIVefecRpzoOZ/UV6iGdOr+Cw==}
 
   hermes-parser@0.25.1:
     resolution: {integrity: sha512-6pEjquH3rqaI6cYAXYPcz9MS4rY6R4ngRgrgfDshRptUZIc3lw0MCIJIGDj9++mfySOuPTHB4nrSW99BCvOPIA==}
 
-  https-proxy-agent@5.0.1:
-    resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==}
-    engines: {node: '>= 6'}
-
   ignore@5.3.2:
     resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==}
     engines: {node: '>= 4'}
@@ -2710,8 +2659,8 @@ packages:
   js-tokens@4.0.0:
     resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
 
-  js-yaml@4.2.0:
-    resolution: {integrity: sha512-ePWsvanv0DWuDRsW8dnt+R4jQ31SCRCQ7hhNcPXZPsoBZiemuZNYGf7adZdqX2D86j6rvKp3RpCxVTSb8WQlOw==}
+  js-yaml@4.1.1:
+    resolution: {integrity: sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==}
     hasBin: true
 
   jsesc@3.1.0:
@@ -2875,8 +2824,11 @@ packages:
     resolution: {integrity: sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==}
     engines: {node: 18 || 20 || >=22}
 
-  minimatch@3.1.4:
-    resolution: {integrity: sha512-twmL+S8+7yIsE9wsqgzU3E8/LumN3M3QELrBZ20OdmQ9jB2JvW5oZtBEmft84k/Gs5CG9mqtWc6Y9vW+JEzGxw==}
+  minimatch@3.1.2:
+    resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==}
+
+  minimatch@3.1.5:
+    resolution: {integrity: sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==}
 
   minimist@1.2.8:
     resolution: {integrity: sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==}
@@ -2903,8 +2855,8 @@ packages:
       react: ^16.8 || ^17 || ^18 || ^19 || ^19.0.0-rc
       react-dom: ^16.8 || ^17 || ^18 || ^19 || ^19.0.0-rc
 
-  next@16.2.6:
-    resolution: {integrity: sha512-qOVgKJg1+At15NpeUP+eJgCHvTCgXsogweq87Ri/Ix7PkqQHg4sdaXmSFqKlgaIXE4kW0g25LE68W87UANlHtw==}
+  next@16.1.6:
+    resolution: {integrity: sha512-hkyRkcu5x/41KoqnROkfTm2pZVbKxvbZRuNvKXLRXxs3VfyO0WhY50TQS40EuKO9SW3rBj/sF3WbVwDACeMZyw==}
     engines: {node: '>=20.9.0'}
     hasBin: true
     peerDependencies:
@@ -3005,12 +2957,12 @@ packages:
   picocolors@1.1.1:
     resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
 
-  picomatch@2.3.2:
-    resolution: {integrity: sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==}
+  picomatch@2.3.1:
+    resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==}
     engines: {node: '>=8.6'}
 
-  picomatch@4.0.4:
-    resolution: {integrity: sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==}
+  picomatch@4.0.3:
+    resolution: {integrity: sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==}
     engines: {node: '>=12'}
 
   pngjs@5.0.0:
@@ -3021,8 +2973,12 @@ packages:
     resolution: {integrity: sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==}
     engines: {node: '>= 0.4'}
 
-  postcss@8.5.10:
-    resolution: {integrity: sha512-pMMHxBOZKFU6HgAZ4eyGnwXF/EvPGGqUr0MnZ5+99485wwW41kW91A4LOGxSHhgugZmSChL5AlElNdwlNgcnLQ==}
+  postcss@8.4.31:
+    resolution: {integrity: sha512-PS08Iboia9mts/2ygV3eLpY5ghnUcfLV/EXTOW1E2qYxJKGGBUtNjN76FYHnMs36RmARn41bC0AZmn+rR0OVpQ==}
+    engines: {node: ^10 || ^12 || >=14}
+
+  postcss@8.5.6:
+    resolution: {integrity: sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==}
     engines: {node: ^10 || ^12 || >=14}
 
   prelude-ls@1.2.1:
@@ -3096,9 +3052,8 @@ packages:
   prop-types@15.8.1:
     resolution: {integrity: sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==}
 
-  proxy-from-env@2.1.0:
-    resolution: {integrity: sha512-cJ+oHTW1VAEa8cJslgmUZrc+sjRKgAKl3Zyse6+PV38hZe/V6Z14TbCuXcan9F9ghlz4QrFr2c92TNF82UkYHA==}
-    engines: {node: '>=10'}
+  proxy-from-env@1.1.0:
+    resolution: {integrity: sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==}
 
   punycode@2.3.1:
     resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==}
@@ -3625,22 +3580,16 @@ snapshots:
       js-tokens: 4.0.0
       picocolors: 1.1.1
 
-  '@babel/code-frame@7.29.7':
-    dependencies:
-      '@babel/helper-validator-identifier': 7.29.7
-      js-tokens: 4.0.0
-      picocolors: 1.1.1
-
   '@babel/compat-data@7.29.0': {}
 
-  '@babel/core@7.29.6':
+  '@babel/core@7.29.0':
     dependencies:
       '@babel/code-frame': 7.29.0
-      '@babel/generator': 7.29.7
+      '@babel/generator': 7.29.1
       '@babel/helper-compilation-targets': 7.28.6
-      '@babel/helper-module-transforms': 7.28.6(@babel/core@7.29.6)
-      '@babel/helpers': 7.29.7
-      '@babel/parser': 7.29.7
+      '@babel/helper-module-transforms': 7.28.6(@babel/core@7.29.0)
+      '@babel/helpers': 7.28.6
+      '@babel/parser': 7.29.0
       '@babel/template': 7.28.6
       '@babel/traverse': 7.29.0
       '@babel/types': 7.29.0
@@ -3653,10 +3602,10 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/generator@7.29.7':
+  '@babel/generator@7.29.1':
     dependencies:
-      '@babel/parser': 7.29.7
-      '@babel/types': 7.29.7
+      '@babel/parser': 7.29.0
+      '@babel/types': 7.29.0
       '@jridgewell/gen-mapping': 0.3.13
       '@jridgewell/trace-mapping': 0.3.31
       jsesc: 3.1.0
@@ -3678,9 +3627,9 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@babel/helper-module-transforms@7.28.6(@babel/core@7.29.6)':
+  '@babel/helper-module-transforms@7.28.6(@babel/core@7.29.0)':
     dependencies:
-      '@babel/core': 7.29.6
+      '@babel/core': 7.29.0
       '@babel/helper-module-imports': 7.28.6
       '@babel/helper-validator-identifier': 7.28.5
       '@babel/traverse': 7.29.0
@@ -3689,47 +3638,33 @@ snapshots:
 
   '@babel/helper-string-parser@7.27.1': {}
 
-  '@babel/helper-string-parser@7.29.7': {}
-
   '@babel/helper-validator-identifier@7.28.5': {}
 
-  '@babel/helper-validator-identifier@7.29.7': {}
-
   '@babel/helper-validator-option@7.27.1': {}
 
-  '@babel/helpers@7.29.7':
+  '@babel/helpers@7.28.6':
     dependencies:
-      '@babel/template': 7.29.7
-      '@babel/types': 7.29.7
+      '@babel/template': 7.28.6
+      '@babel/types': 7.29.0
 
   '@babel/parser@7.29.0':
     dependencies:
       '@babel/types': 7.29.0
 
-  '@babel/parser@7.29.7':
-    dependencies:
-      '@babel/types': 7.29.7
-
   '@babel/runtime@7.28.6': {}
 
   '@babel/template@7.28.6':
     dependencies:
       '@babel/code-frame': 7.29.0
-      '@babel/parser': 7.29.7
+      '@babel/parser': 7.29.0
       '@babel/types': 7.29.0
 
-  '@babel/template@7.29.7':
-    dependencies:
-      '@babel/code-frame': 7.29.7
-      '@babel/parser': 7.29.7
-      '@babel/types': 7.29.7
-
   '@babel/traverse@7.29.0':
     dependencies:
       '@babel/code-frame': 7.29.0
-      '@babel/generator': 7.29.7
+      '@babel/generator': 7.29.1
       '@babel/helper-globals': 7.28.0
-      '@babel/parser': 7.29.7
+      '@babel/parser': 7.29.0
       '@babel/template': 7.28.6
       '@babel/types': 7.29.0
       debug: 4.4.3
@@ -3741,11 +3676,6 @@ snapshots:
       '@babel/helper-string-parser': 7.27.1
       '@babel/helper-validator-identifier': 7.28.5
 
-  '@babel/types@7.29.7':
-    dependencies:
-      '@babel/helper-string-parser': 7.29.7
-      '@babel/helper-validator-identifier': 7.29.7
-
   '@base-ui/react@1.2.0(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
     dependencies:
       '@babel/runtime': 7.28.6
@@ -3831,7 +3761,7 @@ snapshots:
     dependencies:
       '@eslint/object-schema': 2.1.7
       debug: 4.4.3
-      minimatch: 3.1.4
+      minimatch: 3.1.5
     transitivePeerDependencies:
       - supports-color
 
@@ -3845,14 +3775,14 @@ snapshots:
 
   '@eslint/eslintrc@3.3.3':
     dependencies:
-      ajv: 6.14.0
+      ajv: 6.12.6
       debug: 4.4.3
       espree: 10.4.0
       globals: 14.0.0
       ignore: 5.3.2
       import-fresh: 3.3.1
-      js-yaml: 4.2.0
-      minimatch: 3.1.4
+      js-yaml: 4.1.1
+      minimatch: 3.1.2
       strip-json-comments: 3.1.1
     transitivePeerDependencies:
       - supports-color
@@ -4022,34 +3952,34 @@ snapshots:
       '@tybys/wasm-util': 0.10.1
     optional: true
 
-  '@next/env@16.2.6': {}
+  '@next/env@16.1.6': {}
 
-  '@next/eslint-plugin-next@16.2.6':
+  '@next/eslint-plugin-next@16.1.6':
     dependencies:
       fast-glob: 3.3.1
 
-  '@next/swc-darwin-arm64@16.2.6':
+  '@next/swc-darwin-arm64@16.1.6':
     optional: true
 
-  '@next/swc-darwin-x64@16.2.6':
+  '@next/swc-darwin-x64@16.1.6':
     optional: true
 
-  '@next/swc-linux-arm64-gnu@16.2.6':
+  '@next/swc-linux-arm64-gnu@16.1.6':
     optional: true
 
-  '@next/swc-linux-arm64-musl@16.2.6':
+  '@next/swc-linux-arm64-musl@16.1.6':
     optional: true
 
-  '@next/swc-linux-x64-gnu@16.2.6':
+  '@next/swc-linux-x64-gnu@16.1.6':
     optional: true
 
-  '@next/swc-linux-x64-musl@16.2.6':
+  '@next/swc-linux-x64-musl@16.1.6':
     optional: true
 
-  '@next/swc-win32-arm64-msvc@16.2.6':
+  '@next/swc-win32-arm64-msvc@16.1.6':
     optional: true
 
-  '@next/swc-win32-x64-msvc@16.2.6':
+  '@next/swc-win32-x64-msvc@16.1.6':
     optional: true
 
   '@nodelib/fs.scandir@2.1.5':
@@ -4968,7 +4898,7 @@ snapshots:
       '@alloc/quick-lru': 5.2.0
       '@tailwindcss/node': 4.2.1
       '@tailwindcss/oxide': 4.2.1
-      postcss: 8.5.10
+      postcss: 8.5.6
       tailwindcss: 4.2.1
 
   '@tanstack/query-core@5.90.20': {}
@@ -5203,13 +5133,7 @@ snapshots:
 
   acorn@8.15.0: {}
 
-  agent-base@6.0.2:
-    dependencies:
-      debug: 4.4.3
-    transitivePeerDependencies:
-      - supports-color
-
-  ajv@6.14.0:
+  ajv@6.12.6:
     dependencies:
       fast-deep-equal: 3.1.3
       fast-json-stable-stringify: 2.1.0
@@ -5309,15 +5233,13 @@ snapshots:
 
   axe-core@4.11.1: {}
 
-  axios@1.18.1:
+  axios@1.13.6:
     dependencies:
-      follow-redirects: 1.16.0
-      form-data: 4.0.6
-      https-proxy-agent: 5.0.1
-      proxy-from-env: 2.1.0
+      follow-redirects: 1.15.11
+      form-data: 4.0.5
+      proxy-from-env: 1.1.0
     transitivePeerDependencies:
       - debug
-      - supports-color
 
   axobject-query@4.1.0: {}
 
@@ -5327,12 +5249,12 @@ snapshots:
 
   baseline-browser-mapping@2.10.0: {}
 
-  brace-expansion@1.1.13:
+  brace-expansion@1.1.12:
     dependencies:
       balanced-match: 1.0.2
       concat-map: 0.0.1
 
-  brace-expansion@5.0.6:
+  brace-expansion@5.0.4:
     dependencies:
       balanced-match: 4.0.4
 
@@ -5717,9 +5639,9 @@ snapshots:
 
   escape-string-regexp@4.0.0: {}
 
-  eslint-config-next@16.2.6(@typescript-eslint/parser@8.57.0(eslint@9.38.0(jiti@2.6.1))(typescript@5.9.3))(eslint@9.38.0(jiti@2.6.1))(typescript@5.9.3):
+  eslint-config-next@16.1.6(@typescript-eslint/parser@8.57.0(eslint@9.38.0(jiti@2.6.1))(typescript@5.9.3))(eslint@9.38.0(jiti@2.6.1))(typescript@5.9.3):
     dependencies:
-      '@next/eslint-plugin-next': 16.2.6
+      '@next/eslint-plugin-next': 16.1.6
       eslint: 9.38.0(jiti@2.6.1)
       eslint-import-resolver-node: 0.3.9
       eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0)(eslint@9.38.0(jiti@2.6.1))
@@ -5790,7 +5712,7 @@ snapshots:
       hasown: 2.0.2
       is-core-module: 2.16.1
       is-glob: 4.0.3
-      minimatch: 3.1.4
+      minimatch: 3.1.5
       object.fromentries: 2.0.8
       object.groupby: 1.0.3
       object.values: 1.2.1
@@ -5818,7 +5740,7 @@ snapshots:
       hasown: 2.0.2
       jsx-ast-utils: 3.3.5
       language-tags: 1.0.9
-      minimatch: 3.1.4
+      minimatch: 3.1.5
       object.fromentries: 2.0.8
       safe-regex-test: 1.1.0
       string.prototype.includes: 2.0.1
@@ -5834,7 +5756,7 @@ snapshots:
 
   eslint-plugin-react-hooks@7.0.1(eslint@9.38.0(jiti@2.6.1)):
     dependencies:
-      '@babel/core': 7.29.6
+      '@babel/core': 7.29.0
       '@babel/parser': 7.29.0
       eslint: 9.38.0(jiti@2.6.1)
       hermes-parser: 0.25.1
@@ -5855,7 +5777,7 @@ snapshots:
       estraverse: 5.3.0
       hasown: 2.0.2
       jsx-ast-utils: 3.3.5
-      minimatch: 3.1.4
+      minimatch: 3.1.2
       object.entries: 1.1.9
       object.fromentries: 2.0.8
       object.values: 1.2.1
@@ -5890,7 +5812,7 @@ snapshots:
       '@humanwhocodes/module-importer': 1.0.1
       '@humanwhocodes/retry': 0.4.3
       '@types/estree': 1.0.8
-      ajv: 6.14.0
+      ajv: 6.12.6
       chalk: 4.1.2
       cross-spawn: 7.0.6
       debug: 4.4.3
@@ -5909,7 +5831,7 @@ snapshots:
       is-glob: 4.0.3
       json-stable-stringify-without-jsonify: 1.0.1
       lodash.merge: 4.6.2
-      minimatch: 3.1.4
+      minimatch: 3.1.5
       natural-compare: 1.4.0
       optionator: 0.9.4
     optionalDependencies:
@@ -5957,9 +5879,9 @@ snapshots:
     dependencies:
       reusify: 1.1.0
 
-  fdir@6.5.0(picomatch@4.0.4):
+  fdir@6.5.0(picomatch@4.0.3):
     optionalDependencies:
-      picomatch: 4.0.4
+      picomatch: 4.0.3
 
   file-entry-cache@8.0.0:
     dependencies:
@@ -5981,23 +5903,23 @@ snapshots:
 
   flat-cache@4.0.1:
     dependencies:
-      flatted: 3.4.2
+      flatted: 3.3.3
       keyv: 4.5.4
 
-  flatted@3.4.2: {}
+  flatted@3.3.3: {}
 
-  follow-redirects@1.16.0: {}
+  follow-redirects@1.15.11: {}
 
   for-each@0.3.5:
     dependencies:
       is-callable: 1.2.7
 
-  form-data@4.0.6:
+  form-data@4.0.5:
     dependencies:
       asynckit: 0.4.0
       combined-stream: 1.0.8
       es-set-tostringtag: 2.1.0
-      hasown: 2.0.4
+      hasown: 2.0.2
       mime-types: 2.1.35
 
   function-bind@1.1.2: {}
@@ -6013,9 +5935,9 @@ snapshots:
 
   functions-have-names@1.2.3: {}
 
-  geist@1.7.0(next@16.2.6(@babel/core@7.29.6)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)):
+  geist@1.7.0(next@16.1.6(@babel/core@7.29.0)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)):
     dependencies:
-      next: 16.2.6(@babel/core@7.29.6)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      next: 16.1.6(@babel/core@7.29.0)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
 
   generator-function@2.0.1: {}
 
@@ -6096,23 +6018,12 @@ snapshots:
     dependencies:
       function-bind: 1.1.2
 
-  hasown@2.0.4:
-    dependencies:
-      function-bind: 1.1.2
-
   hermes-estree@0.25.1: {}
 
   hermes-parser@0.25.1:
     dependencies:
       hermes-estree: 0.25.1
 
-  https-proxy-agent@5.0.1:
-    dependencies:
-      agent-base: 6.0.2
-      debug: 4.4.3
-    transitivePeerDependencies:
-      - supports-color
-
   ignore@5.3.2: {}
 
   ignore@7.0.5: {}
@@ -6272,7 +6183,7 @@ snapshots:
 
   js-tokens@4.0.0: {}
 
-  js-yaml@4.2.0:
+  js-yaml@4.1.1:
     dependencies:
       argparse: 2.0.1
 
@@ -6394,7 +6305,7 @@ snapshots:
   micromatch@4.0.8:
     dependencies:
       braces: 3.0.3
-      picomatch: 2.3.2
+      picomatch: 2.3.1
 
   mime-db@1.52.0: {}
 
@@ -6404,11 +6315,15 @@ snapshots:
 
   minimatch@10.2.4:
     dependencies:
-      brace-expansion: 5.0.6
+      brace-expansion: 5.0.4
 
-  minimatch@3.1.4:
+  minimatch@3.1.2:
     dependencies:
-      brace-expansion: 1.1.13
+      brace-expansion: 1.1.12
+
+  minimatch@3.1.5:
+    dependencies:
+      brace-expansion: 1.1.12
 
   minimist@1.2.8: {}
 
@@ -6425,25 +6340,25 @@ snapshots:
       react: 19.2.4
       react-dom: 19.2.4(react@19.2.4)
 
-  next@16.2.6(@babel/core@7.29.6)(react-dom@19.2.4(react@19.2.4))(react@19.2.4):
+  next@16.1.6(@babel/core@7.29.0)(react-dom@19.2.4(react@19.2.4))(react@19.2.4):
     dependencies:
-      '@next/env': 16.2.6
+      '@next/env': 16.1.6
       '@swc/helpers': 0.5.15
       baseline-browser-mapping: 2.10.0
       caniuse-lite: 1.0.30001776
-      postcss: 8.5.10
+      postcss: 8.4.31
       react: 19.2.4
       react-dom: 19.2.4(react@19.2.4)
-      styled-jsx: 5.1.6(@babel/core@7.29.6)(react@19.2.4)
+      styled-jsx: 5.1.6(@babel/core@7.29.0)(react@19.2.4)
     optionalDependencies:
-      '@next/swc-darwin-arm64': 16.2.6
-      '@next/swc-darwin-x64': 16.2.6
-      '@next/swc-linux-arm64-gnu': 16.2.6
-      '@next/swc-linux-arm64-musl': 16.2.6
-      '@next/swc-linux-x64-gnu': 16.2.6
-      '@next/swc-linux-x64-musl': 16.2.6
-      '@next/swc-win32-arm64-msvc': 16.2.6
-      '@next/swc-win32-x64-msvc': 16.2.6
+      '@next/swc-darwin-arm64': 16.1.6
+      '@next/swc-darwin-x64': 16.1.6
+      '@next/swc-linux-arm64-gnu': 16.1.6
+      '@next/swc-linux-arm64-musl': 16.1.6
+      '@next/swc-linux-x64-gnu': 16.1.6
+      '@next/swc-linux-x64-musl': 16.1.6
+      '@next/swc-win32-arm64-msvc': 16.1.6
+      '@next/swc-win32-x64-msvc': 16.1.6
       sharp: 0.34.5
     transitivePeerDependencies:
       - '@babel/core'
@@ -6538,15 +6453,21 @@ snapshots:
 
   picocolors@1.1.1: {}
 
-  picomatch@2.3.2: {}
+  picomatch@2.3.1: {}
 
-  picomatch@4.0.4: {}
+  picomatch@4.0.3: {}
 
   pngjs@5.0.0: {}
 
   possible-typed-array-names@1.1.0: {}
 
-  postcss@8.5.10:
+  postcss@8.4.31:
+    dependencies:
+      nanoid: 3.3.11
+      picocolors: 1.1.1
+      source-map-js: 1.2.1
+
+  postcss@8.5.6:
     dependencies:
       nanoid: 3.3.11
       picocolors: 1.1.1
@@ -6570,7 +6491,7 @@ snapshots:
       object-assign: 4.1.1
       react-is: 16.13.1
 
-  proxy-from-env@2.1.0: {}
+  proxy-from-env@1.1.0: {}
 
   punycode@2.3.1: {}
 
@@ -6980,12 +6901,12 @@ snapshots:
 
   strip-json-comments@3.1.1: {}
 
-  styled-jsx@5.1.6(@babel/core@7.29.6)(react@19.2.4):
+  styled-jsx@5.1.6(@babel/core@7.29.0)(react@19.2.4):
     dependencies:
       client-only: 0.0.1
       react: 19.2.4
     optionalDependencies:
-      '@babel/core': 7.29.6
+      '@babel/core': 7.29.0
 
   supports-color@7.2.0:
     dependencies:
@@ -7009,8 +6930,8 @@ snapshots:
 
   tinyglobby@0.2.15:
     dependencies:
-      fdir: 6.5.0(picomatch@4.0.4)
-      picomatch: 4.0.4
+      fdir: 6.5.0(picomatch@4.0.3)
+      picomatch: 4.0.3
 
   to-regex-range@5.0.1:
     dependencies:

ui/pnpm-workspace.yaml

@@ -1,17 +0,0 @@
-overrides:
-  '@babel/core': 7.29.6
-  flatted: 3.4.2
-  follow-redirects: 1.16.0
-  form-data: 4.0.6
-  ajv@6: 6.14.0
-  brace-expansion@1: 1.1.13
-  brace-expansion@5: 5.0.6
-  js-yaml: 4.2.0
-  minimatch@3: 3.1.4
-  picomatch@2: 2.3.2
-  picomatch@4: 4.0.4
-  postcss: 8.5.10
-
-onlyBuiltDependencies:
-  - sharp
-  - unrs-resolver

uv.lock

@@ -17,7 +17,7 @@ wheels = [
 
 [[package]]
 name = "aiohttp"
-version = "3.12.15"
+version = "3.14.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohappyeyeballs" },
@@ -26,61 +26,111 @@ dependencies = [
     { name = "frozenlist" },
     { name = "multidict" },
     { name = "propcache" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
     { name = "yarl" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/9b/e7/d92a237d8802ca88483906c388f7c201bbe96cd80a165ffd0ac2f6a8d59f/aiohttp-3.12.15.tar.gz", hash = "sha256:4fc61385e9c98d72fcdf47e6dd81833f47b2f77c114c29cd64a361be57a763a2", size = 7823716, upload-time = "2025-07-29T05:52:32.215Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/78/8ea7308cac6934de8c74a14f3d5f65d1c89287426688be79538d0e5c013d/aiohttp-3.14.1.tar.gz", hash = "sha256:307f2cff90a764d329e77040603fa032db89c5c24fdad50c4c15334cba744035", size = 7955794, upload-time = "2026-06-07T21:09:35.529Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/20/19/9e86722ec8e835959bd97ce8c1efa78cf361fa4531fca372551abcc9cdd6/aiohttp-3.12.15-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:d3ce17ce0220383a0f9ea07175eeaa6aa13ae5a41f30bc61d84df17f0e9b1117", size = 711246, upload-time = "2025-07-29T05:50:15.937Z" },
-    { url = "https://files.pythonhosted.org/packages/71/f9/0a31fcb1a7d4629ac9d8f01f1cb9242e2f9943f47f5d03215af91c3c1a26/aiohttp-3.12.15-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:010cc9bbd06db80fe234d9003f67e97a10fe003bfbedb40da7d71c1008eda0fe", size = 483515, upload-time = "2025-07-29T05:50:17.442Z" },
-    { url = "https://files.pythonhosted.org/packages/62/6c/94846f576f1d11df0c2e41d3001000527c0fdf63fce7e69b3927a731325d/aiohttp-3.12.15-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3f9d7c55b41ed687b9d7165b17672340187f87a773c98236c987f08c858145a9", size = 471776, upload-time = "2025-07-29T05:50:19.568Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/6c/f766d0aaafcee0447fad0328da780d344489c042e25cd58fde566bf40aed/aiohttp-3.12.15-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bc4fbc61bb3548d3b482f9ac7ddd0f18c67e4225aaa4e8552b9f1ac7e6bda9e5", size = 1741977, upload-time = "2025-07-29T05:50:21.665Z" },
-    { url = "https://files.pythonhosted.org/packages/17/e5/fb779a05ba6ff44d7bc1e9d24c644e876bfff5abe5454f7b854cace1b9cc/aiohttp-3.12.15-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7fbc8a7c410bb3ad5d595bb7118147dfbb6449d862cc1125cf8867cb337e8728", size = 1690645, upload-time = "2025-07-29T05:50:23.333Z" },
-    { url = "https://files.pythonhosted.org/packages/37/4e/a22e799c2035f5d6a4ad2cf8e7c1d1bd0923192871dd6e367dafb158b14c/aiohttp-3.12.15-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:74dad41b3458dbb0511e760fb355bb0b6689e0630de8a22b1b62a98777136e16", size = 1789437, upload-time = "2025-07-29T05:50:25.007Z" },
-    { url = "https://files.pythonhosted.org/packages/28/e5/55a33b991f6433569babb56018b2fb8fb9146424f8b3a0c8ecca80556762/aiohttp-3.12.15-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3b6f0af863cf17e6222b1735a756d664159e58855da99cfe965134a3ff63b0b0", size = 1828482, upload-time = "2025-07-29T05:50:26.693Z" },
-    { url = "https://files.pythonhosted.org/packages/c6/82/1ddf0ea4f2f3afe79dffed5e8a246737cff6cbe781887a6a170299e33204/aiohttp-3.12.15-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b5b7fe4972d48a4da367043b8e023fb70a04d1490aa7d68800e465d1b97e493b", size = 1730944, upload-time = "2025-07-29T05:50:28.382Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/96/784c785674117b4cb3877522a177ba1b5e4db9ce0fd519430b5de76eec90/aiohttp-3.12.15-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6443cca89553b7a5485331bc9bedb2342b08d073fa10b8c7d1c60579c4a7b9bd", size = 1668020, upload-time = "2025-07-29T05:50:30.032Z" },
-    { url = "https://files.pythonhosted.org/packages/12/8a/8b75f203ea7e5c21c0920d84dd24a5c0e971fe1e9b9ebbf29ae7e8e39790/aiohttp-3.12.15-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6c5f40ec615e5264f44b4282ee27628cea221fcad52f27405b80abb346d9f3f8", size = 1716292, upload-time = "2025-07-29T05:50:31.983Z" },
-    { url = "https://files.pythonhosted.org/packages/47/0b/a1451543475bb6b86a5cfc27861e52b14085ae232896a2654ff1231c0992/aiohttp-3.12.15-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:2abbb216a1d3a2fe86dbd2edce20cdc5e9ad0be6378455b05ec7f77361b3ab50", size = 1711451, upload-time = "2025-07-29T05:50:33.989Z" },
-    { url = "https://files.pythonhosted.org/packages/55/fd/793a23a197cc2f0d29188805cfc93aa613407f07e5f9da5cd1366afd9d7c/aiohttp-3.12.15-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:db71ce547012a5420a39c1b744d485cfb823564d01d5d20805977f5ea1345676", size = 1691634, upload-time = "2025-07-29T05:50:35.846Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/bf/23a335a6670b5f5dfc6d268328e55a22651b440fca341a64fccf1eada0c6/aiohttp-3.12.15-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:ced339d7c9b5030abad5854aa5413a77565e5b6e6248ff927d3e174baf3badf7", size = 1785238, upload-time = "2025-07-29T05:50:37.597Z" },
-    { url = "https://files.pythonhosted.org/packages/57/4f/ed60a591839a9d85d40694aba5cef86dde9ee51ce6cca0bb30d6eb1581e7/aiohttp-3.12.15-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:7c7dd29c7b5bda137464dc9bfc738d7ceea46ff70309859ffde8c022e9b08ba7", size = 1805701, upload-time = "2025-07-29T05:50:39.591Z" },
-    { url = "https://files.pythonhosted.org/packages/85/e0/444747a9455c5de188c0f4a0173ee701e2e325d4b2550e9af84abb20cdba/aiohttp-3.12.15-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:421da6fd326460517873274875c6c5a18ff225b40da2616083c5a34a7570b685", size = 1718758, upload-time = "2025-07-29T05:50:41.292Z" },
-    { url = "https://files.pythonhosted.org/packages/36/ab/1006278d1ffd13a698e5dd4bfa01e5878f6bddefc296c8b62649753ff249/aiohttp-3.12.15-cp311-cp311-win32.whl", hash = "sha256:4420cf9d179ec8dfe4be10e7d0fe47d6d606485512ea2265b0d8c5113372771b", size = 428868, upload-time = "2025-07-29T05:50:43.063Z" },
-    { url = "https://files.pythonhosted.org/packages/10/97/ad2b18700708452400278039272032170246a1bf8ec5d832772372c71f1a/aiohttp-3.12.15-cp311-cp311-win_amd64.whl", hash = "sha256:edd533a07da85baa4b423ee8839e3e91681c7bfa19b04260a469ee94b778bf6d", size = 453273, upload-time = "2025-07-29T05:50:44.613Z" },
-    { url = "https://files.pythonhosted.org/packages/63/97/77cb2450d9b35f517d6cf506256bf4f5bda3f93a66b4ad64ba7fc917899c/aiohttp-3.12.15-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:802d3868f5776e28f7bf69d349c26fc0efadb81676d0afa88ed00d98a26340b7", size = 702333, upload-time = "2025-07-29T05:50:46.507Z" },
-    { url = "https://files.pythonhosted.org/packages/83/6d/0544e6b08b748682c30b9f65640d006e51f90763b41d7c546693bc22900d/aiohttp-3.12.15-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f2800614cd560287be05e33a679638e586a2d7401f4ddf99e304d98878c29444", size = 476948, upload-time = "2025-07-29T05:50:48.067Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/1d/c8c40e611e5094330284b1aea8a4b02ca0858f8458614fa35754cab42b9c/aiohttp-3.12.15-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8466151554b593909d30a0a125d638b4e5f3836e5aecde85b66b80ded1cb5b0d", size = 469787, upload-time = "2025-07-29T05:50:49.669Z" },
-    { url = "https://files.pythonhosted.org/packages/38/7d/b76438e70319796bfff717f325d97ce2e9310f752a267bfdf5192ac6082b/aiohttp-3.12.15-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2e5a495cb1be69dae4b08f35a6c4579c539e9b5706f606632102c0f855bcba7c", size = 1716590, upload-time = "2025-07-29T05:50:51.368Z" },
-    { url = "https://files.pythonhosted.org/packages/79/b1/60370d70cdf8b269ee1444b390cbd72ce514f0d1cd1a715821c784d272c9/aiohttp-3.12.15-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6404dfc8cdde35c69aaa489bb3542fb86ef215fc70277c892be8af540e5e21c0", size = 1699241, upload-time = "2025-07-29T05:50:53.628Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/2b/4968a7b8792437ebc12186db31523f541943e99bda8f30335c482bea6879/aiohttp-3.12.15-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3ead1c00f8521a5c9070fcb88f02967b1d8a0544e6d85c253f6968b785e1a2ab", size = 1754335, upload-time = "2025-07-29T05:50:55.394Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/c1/49524ed553f9a0bec1a11fac09e790f49ff669bcd14164f9fab608831c4d/aiohttp-3.12.15-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6990ef617f14450bc6b34941dba4f12d5613cbf4e33805932f853fbd1cf18bfb", size = 1800491, upload-time = "2025-07-29T05:50:57.202Z" },
-    { url = "https://files.pythonhosted.org/packages/de/5e/3bf5acea47a96a28c121b167f5ef659cf71208b19e52a88cdfa5c37f1fcc/aiohttp-3.12.15-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd736ed420f4db2b8148b52b46b88ed038d0354255f9a73196b7bbce3ea97545", size = 1719929, upload-time = "2025-07-29T05:50:59.192Z" },
-    { url = "https://files.pythonhosted.org/packages/39/94/8ae30b806835bcd1cba799ba35347dee6961a11bd507db634516210e91d8/aiohttp-3.12.15-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c5092ce14361a73086b90c6efb3948ffa5be2f5b6fbcf52e8d8c8b8848bb97c", size = 1635733, upload-time = "2025-07-29T05:51:01.394Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/46/06cdef71dd03acd9da7f51ab3a9107318aee12ad38d273f654e4f981583a/aiohttp-3.12.15-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:aaa2234bb60c4dbf82893e934d8ee8dea30446f0647e024074237a56a08c01bd", size = 1696790, upload-time = "2025-07-29T05:51:03.657Z" },
-    { url = "https://files.pythonhosted.org/packages/02/90/6b4cfaaf92ed98d0ec4d173e78b99b4b1a7551250be8937d9d67ecb356b4/aiohttp-3.12.15-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:6d86a2fbdd14192e2f234a92d3b494dd4457e683ba07e5905a0b3ee25389ac9f", size = 1718245, upload-time = "2025-07-29T05:51:05.911Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/e6/2593751670fa06f080a846f37f112cbe6f873ba510d070136a6ed46117c6/aiohttp-3.12.15-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a041e7e2612041a6ddf1c6a33b883be6a421247c7afd47e885969ee4cc58bd8d", size = 1658899, upload-time = "2025-07-29T05:51:07.753Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/28/c15bacbdb8b8eb5bf39b10680d129ea7410b859e379b03190f02fa104ffd/aiohttp-3.12.15-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5015082477abeafad7203757ae44299a610e89ee82a1503e3d4184e6bafdd519", size = 1738459, upload-time = "2025-07-29T05:51:09.56Z" },
-    { url = "https://files.pythonhosted.org/packages/00/de/c269cbc4faa01fb10f143b1670633a8ddd5b2e1ffd0548f7aa49cb5c70e2/aiohttp-3.12.15-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:56822ff5ddfd1b745534e658faba944012346184fbfe732e0d6134b744516eea", size = 1766434, upload-time = "2025-07-29T05:51:11.423Z" },
-    { url = "https://files.pythonhosted.org/packages/52/b0/4ff3abd81aa7d929b27d2e1403722a65fc87b763e3a97b3a2a494bfc63bc/aiohttp-3.12.15-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b2acbbfff69019d9014508c4ba0401822e8bae5a5fdc3b6814285b71231b60f3", size = 1726045, upload-time = "2025-07-29T05:51:13.689Z" },
-    { url = "https://files.pythonhosted.org/packages/71/16/949225a6a2dd6efcbd855fbd90cf476052e648fb011aa538e3b15b89a57a/aiohttp-3.12.15-cp312-cp312-win32.whl", hash = "sha256:d849b0901b50f2185874b9a232f38e26b9b3d4810095a7572eacea939132d4e1", size = 423591, upload-time = "2025-07-29T05:51:15.452Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/d8/fa65d2a349fe938b76d309db1a56a75c4fb8cc7b17a398b698488a939903/aiohttp-3.12.15-cp312-cp312-win_amd64.whl", hash = "sha256:b390ef5f62bb508a9d67cb3bba9b8356e23b3996da7062f1a57ce1a79d2b3d34", size = 450266, upload-time = "2025-07-29T05:51:17.239Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/33/918091abcf102e39d15aba2476ad9e7bd35ddb190dcdd43a854000d3da0d/aiohttp-3.12.15-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:9f922ffd05034d439dde1c77a20461cf4a1b0831e6caa26151fe7aa8aaebc315", size = 696741, upload-time = "2025-07-29T05:51:19.021Z" },
-    { url = "https://files.pythonhosted.org/packages/b5/2a/7495a81e39a998e400f3ecdd44a62107254803d1681d9189be5c2e4530cd/aiohttp-3.12.15-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:2ee8a8ac39ce45f3e55663891d4b1d15598c157b4d494a4613e704c8b43112cd", size = 474407, upload-time = "2025-07-29T05:51:21.165Z" },
-    { url = "https://files.pythonhosted.org/packages/49/fc/a9576ab4be2dcbd0f73ee8675d16c707cfc12d5ee80ccf4015ba543480c9/aiohttp-3.12.15-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3eae49032c29d356b94eee45a3f39fdf4b0814b397638c2f718e96cfadf4c4e4", size = 466703, upload-time = "2025-07-29T05:51:22.948Z" },
-    { url = "https://files.pythonhosted.org/packages/09/2f/d4bcc8448cf536b2b54eed48f19682031ad182faa3a3fee54ebe5b156387/aiohttp-3.12.15-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b97752ff12cc12f46a9b20327104448042fce5c33a624f88c18f66f9368091c7", size = 1705532, upload-time = "2025-07-29T05:51:25.211Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/f3/59406396083f8b489261e3c011aa8aee9df360a96ac8fa5c2e7e1b8f0466/aiohttp-3.12.15-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:894261472691d6fe76ebb7fcf2e5870a2ac284c7406ddc95823c8598a1390f0d", size = 1686794, upload-time = "2025-07-29T05:51:27.145Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/71/164d194993a8d114ee5656c3b7ae9c12ceee7040d076bf7b32fb98a8c5c6/aiohttp-3.12.15-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5fa5d9eb82ce98959fc1031c28198b431b4d9396894f385cb63f1e2f3f20ca6b", size = 1738865, upload-time = "2025-07-29T05:51:29.366Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/00/d198461b699188a93ead39cb458554d9f0f69879b95078dce416d3209b54/aiohttp-3.12.15-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f0fa751efb11a541f57db59c1dd821bec09031e01452b2b6217319b3a1f34f3d", size = 1788238, upload-time = "2025-07-29T05:51:31.285Z" },
-    { url = "https://files.pythonhosted.org/packages/85/b8/9e7175e1fa0ac8e56baa83bf3c214823ce250d0028955dfb23f43d5e61fd/aiohttp-3.12.15-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5346b93e62ab51ee2a9d68e8f73c7cf96ffb73568a23e683f931e52450e4148d", size = 1710566, upload-time = "2025-07-29T05:51:33.219Z" },
-    { url = "https://files.pythonhosted.org/packages/59/e4/16a8eac9df39b48ae102ec030fa9f726d3570732e46ba0c592aeeb507b93/aiohttp-3.12.15-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:049ec0360f939cd164ecbfd2873eaa432613d5e77d6b04535e3d1fbae5a9e645", size = 1624270, upload-time = "2025-07-29T05:51:35.195Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/f8/cd84dee7b6ace0740908fd0af170f9fab50c2a41ccbc3806aabcb1050141/aiohttp-3.12.15-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b52dcf013b57464b6d1e51b627adfd69a8053e84b7103a7cd49c030f9ca44461", size = 1677294, upload-time = "2025-07-29T05:51:37.215Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/42/d0f1f85e50d401eccd12bf85c46ba84f947a84839c8a1c2c5f6e8ab1eb50/aiohttp-3.12.15-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:9b2af240143dd2765e0fb661fd0361a1b469cab235039ea57663cda087250ea9", size = 1708958, upload-time = "2025-07-29T05:51:39.328Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/6b/f6fa6c5790fb602538483aa5a1b86fcbad66244997e5230d88f9412ef24c/aiohttp-3.12.15-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ac77f709a2cde2cc71257ab2d8c74dd157c67a0558a0d2799d5d571b4c63d44d", size = 1651553, upload-time = "2025-07-29T05:51:41.356Z" },
-    { url = "https://files.pythonhosted.org/packages/04/36/a6d36ad545fa12e61d11d1932eef273928b0495e6a576eb2af04297fdd3c/aiohttp-3.12.15-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:47f6b962246f0a774fbd3b6b7be25d59b06fdb2f164cf2513097998fc6a29693", size = 1727688, upload-time = "2025-07-29T05:51:43.452Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/c8/f195e5e06608a97a4e52c5d41c7927301bf757a8e8bb5bbf8cef6c314961/aiohttp-3.12.15-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:760fb7db442f284996e39cf9915a94492e1896baac44f06ae551974907922b64", size = 1761157, upload-time = "2025-07-29T05:51:45.643Z" },
-    { url = "https://files.pythonhosted.org/packages/05/6a/ea199e61b67f25ba688d3ce93f63b49b0a4e3b3d380f03971b4646412fc6/aiohttp-3.12.15-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ad702e57dc385cae679c39d318def49aef754455f237499d5b99bea4ef582e51", size = 1710050, upload-time = "2025-07-29T05:51:48.203Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/2e/ffeb7f6256b33635c29dbed29a22a723ff2dd7401fff42ea60cf2060abfb/aiohttp-3.12.15-cp313-cp313-win32.whl", hash = "sha256:f813c3e9032331024de2eb2e32a88d86afb69291fbc37a3a3ae81cc9917fb3d0", size = 422647, upload-time = "2025-07-29T05:51:50.718Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/8e/78ee35774201f38d5e1ba079c9958f7629b1fd079459aea9467441dbfbf5/aiohttp-3.12.15-cp313-cp313-win_amd64.whl", hash = "sha256:1a649001580bdb37c6fdb1bebbd7e3bc688e8ec2b5c6f52edbb664662b17dc84", size = 449067, upload-time = "2025-07-29T05:51:52.549Z" },
+    { url = "https://files.pythonhosted.org/packages/26/dd/bf526e6f0a1120dd6f2df2e97bacfe4d358f13d17a0ff5847301a1375a51/aiohttp-3.14.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:aa00140699487bd435fde4342d85c94cb256b7cd3a5b9c3396c67f19922afda2", size = 765225, upload-time = "2026-06-07T21:06:07.957Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/e1/a2872aa55495a70f61310d411541c6ee23812d9a884e000c716e1bc3edbf/aiohttp-3.14.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1c1af67559445498b502030c35c59db59966f47041ca9de5b4e707f86bd10b5f", size = 518743, upload-time = "2026-06-07T21:06:09.749Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/e7/c60c7b209e509cc787de3cea0550a518538cfc08003e1c1e14c1c63fff71/aiohttp-3.14.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d44ec478e713ee7f29b439f7eb8dc2b9d4079e11ae114d2c2ac3d5daf30516c8", size = 514139, upload-time = "2026-06-07T21:06:11.26Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/8d/614ace2f579702c9840ab1e1447fd8509e35b0b904f7196418fa2f57b25d/aiohttp-3.14.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d3b1a184a9a8f548a6b73f1e26b96b052193e4b3175ed7342aaf1151a1f00a04", size = 1784088, upload-time = "2026-06-07T21:06:12.887Z" },
+    { url = "https://files.pythonhosted.org/packages/49/e0/726e90f99542bf292f81a96a12cc4847deb86f3ccf62c6f4014a201f4d33/aiohttp-3.14.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5f2504bc0322437c9a1ff6d3333ca56c7477b727c995f036b976ae17b98372c8", size = 1737835, upload-time = "2026-06-07T21:06:14.564Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/4b/d176d5c4db9d33dacf0543102ea59503bc1d528af4cfd0b719949ca49389/aiohttp-3.14.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:73f05ea02013e02512c3bf42714f1208c57168c779cc6fe23516e4543089d0a6", size = 1842801, upload-time = "2026-06-07T21:06:16.228Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/d6/5a99b563690ea0cbed912ae94a2ce33993a5709a651a3a4fe761e7dd973a/aiohttp-3.14.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:797457503c2d426bee06eef808d07b31ede30b65e054444e7de64cad0061b7af", size = 1929992, upload-time = "2026-06-07T21:06:17.947Z" },
+    { url = "https://files.pythonhosted.org/packages/76/7f/a987b14a3859094b3cea3f4825219c3e5536242564af6e3f9c2f6c994eb2/aiohttp-3.14.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b821a1f7dedf7e37450654e620038ac3b2e81e8fa6ea269337e97101978ec730", size = 1786989, upload-time = "2026-06-07T21:06:19.677Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/1a/420e5c85a3e73349372ed22ce0b6af86bfa6ce16a4b20a64a2e94608c781/aiohttp-3.14.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4cd96b5ba05d67ed0cf00b5b405c8cd99586d8e3481e8ee0a831057591af7621", size = 1640129, upload-time = "2026-06-07T21:06:22.558Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/80/18a592ed3be0a402cc03670bd72ee1f8563ddbe1d8d5542dbf868f274136/aiohttp-3.14.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d459b98a932296c6f0e94f87511a0b1b90a8a02c30a50e60a297619cd5a58ee", size = 1756576, upload-time = "2026-06-07T21:06:24.8Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/0b/8b3d5713373858ff71a617daf6e3b0e81ad63e79d09a3cf2f6b6b983939c/aiohttp-3.14.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:764457a7be60825fb770a644852ff717bcbb5042f189f2bd16df61a81b3f6573", size = 1754668, upload-time = "2026-06-07T21:06:26.528Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/49/fd564575cf225821d7ba5a117cb8bc27213d8a7e1811162afb43ae077039/aiohttp-3.14.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f7a16ef45b081454ef844502d87a848876c490c4cb5c650c230f6ec79ed2c1e7", size = 1817019, upload-time = "2026-06-07T21:06:28.297Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/1b/e850c9ae6fc91356552ae668bb6c51e93fa29c8aef13398a10b56678557f/aiohttp-3.14.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:2fbc3ed048b3475b9f0cbcb9978e9d2d3511acd91ead203af26ed9f0056004cf", size = 1631638, upload-time = "2026-06-07T21:06:30.242Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/94/3c337ba72451a89806ace6f75bddc92bafc5b8d53d90115a512858024b63/aiohttp-3.14.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:bedb0cd073cc2dc035e30aeb99444389d3cd2113afe4ef9fcd23d439f5bade85", size = 1835660, upload-time = "2026-06-07T21:06:31.943Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/9c/9c18cf367a0498212d9ba7daf990b504a5e8ae064cda4b504e2647c89c03/aiohttp-3.14.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b6feea921016eb3d4e04d65fc4e9ca402d1a3801f562aef94989f54694917af3", size = 1775698, upload-time = "2026-06-07T21:06:33.72Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/63/a251a9d2a6cb45065b2ddc0bde2b3dd10108740a9a42f632c66405a761a2/aiohttp-3.14.1-cp311-cp311-win32.whl", hash = "sha256:313701e488100074ce99850404ee36e741abf6330179fec908a1944ecf570126", size = 458386, upload-time = "2026-06-07T21:06:35.279Z" },
+    { url = "https://files.pythonhosted.org/packages/17/ca/69274c51dcd6e8947d77b2806cf47a4a15f2c846e2cbeb1882547d3da283/aiohttp-3.14.1-cp311-cp311-win_amd64.whl", hash = "sha256:03ab4530fdcb3a543a122ba4b65ac9919da9fe9f78a03d328a6e38ff962f7aa5", size = 483406, upload-time = "2026-06-07T21:06:36.824Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/8a/c25904f77690c3688ec140f87591ef11a0cfe36bf3d5c0f1f38056fb62b3/aiohttp-3.14.1-cp311-cp311-win_arm64.whl", hash = "sha256:486f7d16ed54c39c2cbd7ca71fd8ba2b8bb7860df65bd7b6ed640bab96a38a8b", size = 452987, upload-time = "2026-06-07T21:06:38.371Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/21/151624b51cd92553d95424daf4bf19f19ce9be9002d19253e7e7ce67197b/aiohttp-3.14.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d35143e27778b4bb0fb189562d7f275bff79c62ab8e98459717c0ea617ff2480", size = 757402, upload-time = "2026-06-07T21:06:40.311Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/82/280619e0bd7bf2454987e19282616e84762255dd9c8468f62382e8c191f1/aiohttp-3.14.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bcfb80a2cc36fba2534e5e5b5264dc7ae6fcd9bf15256da3e53d2f499e6fa29d", size = 512310, upload-time = "2026-06-07T21:06:42.207Z" },
+    { url = "https://files.pythonhosted.org/packages/55/b2/2aac325583aaa1353045f96dffa586d8a34e8322e14a7ba49cffeb103ab4/aiohttp-3.14.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:27fd7c91e51729b4f7e1577865fa6d34c9adccbc39aabe9000285b48af9f0ec2", size = 512448, upload-time = "2026-06-07T21:06:43.813Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/72/a60607cb849faa8af8a356c9329ea2eb6f395d49e82cc82ccba1fd8deb8f/aiohttp-3.14.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:64c567bf9eaf664280116a8688f63016e6b32db2505908e2bdaca1b6438142f2", size = 1766854, upload-time = "2026-06-07T21:06:45.391Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/d3/d9fe1c9ec7557ab4d0d82bebaa728c6418f0b93295ec2f4ab015f7710cc7/aiohttp-3.14.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:f5e6ff2bdbb8f4cd3fbe41f99e25bbcd58e3bf9f13d3dd31a11e7917251cc77a", size = 1740884, upload-time = "2026-06-07T21:06:47.413Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/dc/f2cecfaf9337ba3e63f181500814ff502aa3d00d9c7ec93a9d23d10a27b2/aiohttp-3.14.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2f73e01dc37122325caf079982621262f96d74823c179038a82fddfc50359264", size = 1810034, upload-time = "2026-06-07T21:06:50.165Z" },
+    { url = "https://files.pythonhosted.org/packages/66/d7/2ff65c5e65c0d7476daf7e15c032e0805e36811185b9623e3238ad6c763e/aiohttp-3.14.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:bb2c0c80d431c0d03f2c7dbf125150fedd4f0de17366a7ca33f7ccb822391842", size = 1904054, upload-time = "2026-06-07T21:06:52.035Z" },
+    { url = "https://files.pythonhosted.org/packages/20/9c/d445818389df371f56d141d881153ba23183c4735a03f7356ffb43f7757d/aiohttp-3.14.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3e6fc1a85fa7194a1a7d19f44e8609180f4a8eb5fa4c7ed8b4355f080fad235c", size = 1790278, upload-time = "2026-06-07T21:06:54.049Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/aa/bf04cb4d865fc6101c2229a294ad744973b72e513fdc5a6b791e6983d72a/aiohttp-3.14.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:686b6c0d3911ec387b444ddf5dc62fb7f7c0a7d5186a7861626496a5ab4aff95", size = 1591795, upload-time = "2026-06-07T21:06:55.911Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/b4/4dac0038960427ba832f6609dfb4ea5437d7fd80c72001b9e48f834f428b/aiohttp-3.14.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c6fa4dc7ad6f8109c70bb1499e589f76b0b792baf39f9b017eb92c8a81d0a199", size = 1728397, upload-time = "2026-06-07T21:06:57.777Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/f9/7cd4e8ad7aa3b75f17d56bb5498dd604a93d4e6eece822ba0568c413fff0/aiohttp-3.14.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:87a5eea1b2a5e21e1ebdbb33ad4165359189327e63fc4e4894693e7f821ac817", size = 1766504, upload-time = "2026-06-07T21:07:00.009Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/df/fc01d9fcad0f73fed3f3d361f1f94f975947b50dff82919f6dc2bf4316cc/aiohttp-3.14.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1c1421eb01d4fd608d88cc8290211d177a58532b55ad94076fb349c5bf467f0a", size = 1777806, upload-time = "2026-06-07T21:07:02.064Z" },
+    { url = "https://files.pythonhosted.org/packages/41/09/47e2d090bddcc8fb4ccb4c314aadc32d7c5d9bb55f50f6ad1c92fc15d501/aiohttp-3.14.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:34b257ec41345c1e8f2df68fa908a7952f5de932723871eb633ecbbff396c9a4", size = 1580707, upload-time = "2026-06-07T21:07:03.942Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/36/f1a4ce904ae0b6930cfe9afc96d0896f7ec1a620c400405d63783bb95a9c/aiohttp-3.14.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:de538791a80e5d862addbc183f70f0158ac9b9bb872bb147f1fd2a683691e087", size = 1798121, upload-time = "2026-06-07T21:07:05.987Z" },
+    { url = "https://files.pythonhosted.org/packages/70/0a/e0075ce9ca0279ee1d4f0c0b85f54fea02ebc83c3007651a72bece658fec/aiohttp-3.14.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6f71173be42d3241d428f760122febb748de0623f44308a6f120d0dd9ec572e3", size = 1767580, upload-time = "2026-06-07T21:07:07.873Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/61/a0c0a8f327a9c52095cdd8e312391b00d3ed64ab6c72bb5c33d8ec251cf7/aiohttp-3.14.1-cp312-cp312-win32.whl", hash = "sha256:ec8dc383ee57ea3e883477dcca3f11b65d58199f1080acaf4cd6ad9a99698be4", size = 452771, upload-time = "2026-06-07T21:07:09.669Z" },
+    { url = "https://files.pythonhosted.org/packages/df/d9/ea367c75f16ac9c6cdc8febb25e8318fa21a2b1bc8d6514d4b2d890bface/aiohttp-3.14.1-cp312-cp312-win_amd64.whl", hash = "sha256:2aa92c87868cd13674989f9ee83e5f9f7ea4237589b728048e1f0c8f6caa3271", size = 479873, upload-time = "2026-06-07T21:07:11.538Z" },
+    { url = "https://files.pythonhosted.org/packages/03/64/8d96784a7851156db8a4c6c3f6f91042fdf39fb15a4cc38c8b3c14833c45/aiohttp-3.14.1-cp312-cp312-win_arm64.whl", hash = "sha256:2c840c90759922cb5e6dda94596e079a30fb5a5ba548e7e0dc00574703940847", size = 448073, upload-time = "2026-06-07T21:07:13.637Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/97/bd137012dd97e1649162b099135a80e1fd59aaa807b2430fc448d1029aff/aiohttp-3.14.1-cp313-cp313-android_21_arm64_v8a.whl", hash = "sha256:b3a03285a7f9c7b016324574a6d92a1c895da6b978cb8f1deee3ac72bc6da178", size = 506882, upload-time = "2026-06-07T21:07:15.501Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/79/e5cc690e9d922a66887ceeaca53a8ffd5a7b0be3816142b7abc433742d89/aiohttp-3.14.1-cp313-cp313-android_21_x86_64.whl", hash = "sha256:2a73f487ab8ef5abbb24b7aa9b73e98eaba9e9e031804ff2416f02eca315ccaf", size = 515270, upload-time = "2026-06-07T21:07:17.53Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/22/a73ccbf9dbd6e26dda0b24d5fd5db7da92ee3383a79f47677ffb834c5c5b/aiohttp-3.14.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:915fbb7b41b115192259f8c9ae58f3ddc444d2b5579917270211858e606a4afd", size = 485841, upload-time = "2026-06-07T21:07:19.555Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/b9/57ed8eaf596321c2ad747bd480fb1700dbd7177c60dfc9e4c187f629662e/aiohttp-3.14.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:7fb4bdf95b0561a79f259f9d28fbc109728c5ee7f27aff6391f0ca703a329abe", size = 492088, upload-time = "2026-06-07T21:07:21.581Z" },
+    { url = "https://files.pythonhosted.org/packages/78/c0/5ebe5270a7c140d7c6f79dcb018640225f14d406c149e4eec04a7d82fe71/aiohttp-3.14.1-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:1b9748363260121d2927704f5d4fc498150669ca3ae93625986ee89c8f80dcd4", size = 501564, upload-time = "2026-06-07T21:07:23.388Z" },
+    { url = "https://files.pythonhosted.org/packages/75/7f/8cdaa24fc7983865e0915153b96a9ac5bcdd3548d64c5a27d17cecccad2d/aiohttp-3.14.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:86a6dab78b0e43e2897a3bbe15745aa60dc5423ca437b7b0b164c069bf91b876", size = 751998, upload-time = "2026-06-07T21:07:25.046Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/f4/c4227aacfacc5cb0cc2d119b65301d177912a6842cd64e120c47af76064f/aiohttp-3.14.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4dfd6e47d3c44c2279907607f73a4240b88c69eb8b90da7e2441a8045dfd21da", size = 510918, upload-time = "2026-06-07T21:07:27.28Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/01/a2d5f96cd4e74424864d30bc0a7e44d0a12dacdcfa91b5b2d1bd3dca6bf3/aiohttp-3.14.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:317acd9f8602858dc7d59679812c376c7f0b97bcbbf16e0d6237f54141d8a8a6", size = 508657, upload-time = "2026-06-07T21:07:29.252Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/ed/3c0fb5c500fdd8e7ebc10d1889c04384fffa1a9163eac1356088ca9da1b1/aiohttp-3.14.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bd869c427324e5cb15195793de951295710db28be7d818247f3097b4ab5d4b96", size = 1757907, upload-time = "2026-06-07T21:07:31.03Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/ab/d4c924d9bd5be3050c226612413ce68cb54c70d2c31b661bfc8d9a5b6a70/aiohttp-3.14.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:93b032b5ec3255473c143627d21a69ac74ae12f7f33974cb587c564d11b1066f", size = 1737565, upload-time = "2026-06-07T21:07:33.031Z" },
+    { url = "https://files.pythonhosted.org/packages/19/2a/37326821ff779084020cdc33224d20b19f42f4183a500ff92022a739eda7/aiohttp-3.14.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f234b4deb12f3ad59127e037bc57c40c21e45b45282df7d3a55a0f409f595296", size = 1799018, upload-time = "2026-06-07T21:07:35.003Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/4f/6e947ba73e4ce09070761c05ed3a8ceb7c21f5e46798671d8b2aac0e4626/aiohttp-3.14.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9af6779bfb46abf124068327abcdf9ce95c9ef8287a3e8da76ccf2d0f16c28fa", size = 1894416, upload-time = "2026-06-07T21:07:36.956Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/6e/dbf1d0625dc711fb2851f4f3c3055c39ed58bae92082d8c627dbe6013736/aiohttp-3.14.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:faccab372e66bc76d5731525e7f1143c922271725b9d38c9f97edcc66266b451", size = 1783881, upload-time = "2026-06-07T21:07:39.063Z" },
+    { url = "https://files.pythonhosted.org/packages/44/c2/5e25098a67268ed369483ae7d1a58bd0a13d03aab860d2a0e4a6eb25b046/aiohttp-3.14.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f380468b09d2a81633ee863b0ec5648d364bd17bb8ecfb8c2f387f7ac1faf42c", size = 1587572, upload-time = "2026-06-07T21:07:41.058Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/bd/cf9cee17e140f942a3de73e658a543aa8fbf35a5fc67a9d2538d52d77f0b/aiohttp-3.14.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:97e704dcd26271f5bda3fa07c3ce0fb76d6d3f8659f4baa1a24442cc9ba177ca", size = 1722137, upload-time = "2026-06-07T21:07:43.014Z" },
+    { url = "https://files.pythonhosted.org/packages/89/6d/5684f8c59045c96f81a18cefbc1fbbd79d25b88f1c622f2a5c5c08fcb632/aiohttp-3.14.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:269b76ac5394092b95bc4a098f4fc6c191c083c3bd12775d1e30e663132f6a09", size = 1755953, upload-time = "2026-06-07T21:07:45.933Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/40/35caf3170f8359760740a7d9aa0fff2e344bef98e1d1186f5a0f6dec17e6/aiohttp-3.14.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c0b3e614340c889d575451696374c9d17affd54cd607ca0babed8f8c37b9397", size = 1766479, upload-time = "2026-06-07T21:07:48.047Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/a1/b0c61e7a137f0d81de49a82023a6df73c3c16d6fefb0f8e4a93d21639002/aiohttp-3.14.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:5663ee9257cfa1add7253a7da3035a02f31b6600ec48261585e1800a81533080", size = 1580077, upload-time = "2026-06-07T21:07:50.069Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/41/194ea4623693009fcefebef7aef63c141754f153e9cd0d39d3b9e36c175c/aiohttp-3.14.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:603a2c834142172ffddc054067f5ec0ca65d57a0aa98a71bc81952573208e345", size = 1791688, upload-time = "2026-06-07T21:07:52.106Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/45/4de841f005cfe1fd63e2a2fe011262c515e2a62aa6994b15947e7d717ac9/aiohttp-3.14.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:cb21957bb8aca671c1765e32f58164cf0c50e6bf41c0bbbd16da20732ecaf588", size = 1761094, upload-time = "2026-06-07T21:07:54.113Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/ae/dbce10533d3896d544d5053939ed75b7dc31a1b0973d959b1b5ae21028d6/aiohttp-3.14.1-cp313-cp313-win32.whl", hash = "sha256:e509a55f681e6158c20f70f102f9cf61fb20fbc382272bc6d94b7343f2582780", size = 452662, upload-time = "2026-06-07T21:07:56.06Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/d9/0bf1a19362c32f06229da5e7ddfcec91f93474d6307f7a2d3135e9c674dc/aiohttp-3.14.1-cp313-cp313-win_amd64.whl", hash = "sha256:1ac8531b638959718e18c2207fbfe297819875da46a740b29dfa29beba64355a", size = 479748, upload-time = "2026-06-07T21:07:58.319Z" },
+    { url = "https://files.pythonhosted.org/packages/22/0a/62e7232dc9484fbec112ceb32efb6a624cc7994ec6e2b019286f17c4e8f2/aiohttp-3.14.1-cp313-cp313-win_arm64.whl", hash = "sha256:250d14af67f6b6a1a4a811049b1afa69d61d617fca6bf33149b3ab1a6dbcf7b8", size = 447723, upload-time = "2026-06-07T21:08:00.154Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/a1/5fafa04e1ca91ddb47608699d60649c1c6db3cf41c99e78fc4056f9513db/aiohttp-3.14.1-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:7c106c26852ca1c2047c6b80384f17100b4e439af276f21ef3d4e2f450ae7e15", size = 508531, upload-time = "2026-06-07T21:08:02.093Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/2e/bfa02f699d87ffc86d5959270b28f1cb410add3ccaced8ed2e0b8a5238fc/aiohttp-3.14.1-cp314-cp314-android_24_x86_64.whl", hash = "sha256:20205f7f5ade7aaec9f4b500549bbc071b046453aed72f9c06dcab87896a83e8", size = 514718, upload-time = "2026-06-07T21:08:04.476Z" },
+    { url = "https://files.pythonhosted.org/packages/85/a5/9594ad6289eebbc97d167c44213d557807f90e59115caad24de21ad2c3b1/aiohttp-3.14.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:62a759436b29e677181a9e76bab8b8f689a29cb9c535f45f7c48c9c830d3f8c3", size = 487918, upload-time = "2026-06-07T21:08:06.377Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/61/16a32c36c3c49edec122a3dc811f2057df2f94d3b14aa107c8017d981618/aiohttp-3.14.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:2964cbf553df4d7a57348da44d961d871895fc1ee4e8c322b2a95612c7b17fba", size = 494014, upload-time = "2026-06-07T21:08:08.263Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/89/3ebcf96ed99c05bec9c434aaac6963fd3cbab4a786ae739908a144d9ce44/aiohttp-3.14.1-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:237651caadc3a59badd39319c54642b5299e9cc98a3a194310e55d5bb9f5e397", size = 502398, upload-time = "2026-06-07T21:08:10.244Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/3d/b74870a0c2d40c355928cd5b96c7a11fa821b8a40fc41365e64479b151fb/aiohttp-3.14.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:896e12dfdbbab9d8f7e16d2b28c6769a60126fa92095d1ebf9473d02593a2448", size = 758018, upload-time = "2026-06-07T21:08:12.447Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/66/f42f5c984d99e49c6cff5f26f590750f2e2f7ef1fcfb99966ab5be1b632e/aiohttp-3.14.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d03f281ed22579314ba00821ce20115a7c0ac430660b4cc05704a3f818b3e004", size = 512462, upload-time = "2026-06-07T21:08:14.624Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/a7/248e1aebe0c7810b0271e021a0f2a5eb6e78a051885b3c9df49f42a5802d/aiohttp-3.14.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:07eabb979d236335fed927e137a928c9adfb7df3b9ec7aa31726f133a62be983", size = 512824, upload-time = "2026-06-07T21:08:16.572Z" },
+    { url = "https://files.pythonhosted.org/packages/26/97/2aa0e5ba0727dc3bd5aaebb7ccbc510f7dfb7fb961ec87497cd496635ab1/aiohttp-3.14.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4fe1f1087cbadb280b5e1bb054a4f00d1423c74d6626c5e48400d871d34ecefe", size = 1749898, upload-time = "2026-06-07T21:08:18.635Z" },
+    { url = "https://files.pythonhosted.org/packages/00/8d/e97f6c96c891d457c8479d92a514ba194d0412f981d72c70341ee18488ed/aiohttp-3.14.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:367a9314fdc79dab0fac96e216cb41dd73c85bdca85306ce8999118ba7e0f333", size = 1710114, upload-time = "2026-06-07T21:08:20.892Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/e6/aa8d7e863048c8fceb5cd6ce74017311cec3ead07847387e12265fb4444e/aiohttp-3.14.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a24f677ebe83749039e7bdf862ff0bbb16818ae4193d4ef96505e269375bcce0", size = 1802541, upload-time = "2026-06-07T21:08:23.044Z" },
+    { url = "https://files.pythonhosted.org/packages/83/a8/72193137de57fda4ebfae4563182d082c8856e3b6e9871d0b46f028fb369/aiohttp-3.14.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c83afe0ba876be7e943d2e0ba645809ad441575d2840c895c21ee5de93b9377a", size = 1875776, upload-time = "2026-06-07T21:08:25.288Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/18/938441025db6769a3464596b2410af3afde0b21eb2f204c6f766f68af4bd/aiohttp-3.14.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:634e385930fb6d2d479cf3aa66515955863b77a5e3c2b5894ca259a25b308602", size = 1760329, upload-time = "2026-06-07T21:08:27.363Z" },
+    { url = "https://files.pythonhosted.org/packages/60/29/bf2496b4065e76e09fe48015aaffe5ce161d8f089b06ac6982070f653076/aiohttp-3.14.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:eeea07c4397bbc57719c4eed8f9c284874d4f175f9b6d57f7a1546b976d455ca", size = 1587293, upload-time = "2026-06-07T21:08:29.805Z" },
+    { url = "https://files.pythonhosted.org/packages/49/a2/2136674d52123b1354bd05dd5753c318db47dc0c927cc70b27bab3755456/aiohttp-3.14.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:335c0cc3e3545ce98dcb9cfcb836f40c3411f43fa03dab757597d80c89af8a35", size = 1714756, upload-time = "2026-06-07T21:08:32.094Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/b9/e5fd2e6f915503081c0f9b1e8540947037929c70c191da2e4d54b31a21a1/aiohttp-3.14.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:ae6be797afdef264e8a84864a85b196ca06045586481b3df8a967322fd2fa844", size = 1721052, upload-time = "2026-06-07T21:08:34.167Z" },
+    { url = "https://files.pythonhosted.org/packages/63/5a/2833e324a2263e104e31e2e91bc5bbee81bc499afd32203faee048a883f0/aiohttp-3.14.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:8560b4d712474335d08907db7973f71912d3a9a8f1dee992ec06b5d2fe359496", size = 1766888, upload-time = "2026-06-07T21:08:36.95Z" },
+    { url = "https://files.pythonhosted.org/packages/57/fa/dea6511870913162f3b2e8c42a7614eb203a4540b8c2da43e0bfb0548f3c/aiohttp-3.14.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7edd08e0a5deb1e8564a2fcd8f4561014a3f05252334671bbf55ddd47db0e5", size = 1581679, upload-time = "2026-06-07T21:08:39.292Z" },
+    { url = "https://files.pythonhosted.org/packages/14/bd/3cf0d55e71784b33534e9710a67d382d900598b4787fbce6cc7317f8c42a/aiohttp-3.14.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:b6ff7fcee63287ae57b5df3e4f5957ce032122802509246dec1a5bcc55904c95", size = 1782021, upload-time = "2026-06-07T21:08:41.407Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/af/14bb5843eccbe234f4dfb78ab73e549d99727247e62ae5d62cbd22eaf5b0/aiohttp-3.14.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6ffbb2f4ec1ceaff7e07d43922954da26b223d188bf30658e561b98e23089444", size = 1742574, upload-time = "2026-06-07T21:08:43.795Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/1e/fbeb7af9210a67ac0f9c9bec0f8f4568497924e33137a3d5b48e1cf85f3f/aiohttp-3.14.1-cp314-cp314-win32.whl", hash = "sha256:a9875b46d910cff3ea2f5962f9d266b465459fe634e22556ab9bd6fc1192eea0", size = 457773, upload-time = "2026-06-07T21:08:46.168Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/2b/13e8d741a9ec5db7d900c060554cf8352ab85e44e2a4469ebb9d377bda17/aiohttp-3.14.1-cp314-cp314-win_amd64.whl", hash = "sha256:af8b4b81a960eeaf1234971ac3cd0ba5901f3cd42eae42a46b4d089a8b492719", size = 485001, upload-time = "2026-06-07T21:08:48.401Z" },
+    { url = "https://files.pythonhosted.org/packages/df/30/491acfa2c4d6c3ff59c49a14fc1b50be3241e25bbb0c84c09e2da4d11395/aiohttp-3.14.1-cp314-cp314-win_arm64.whl", hash = "sha256:cf4491381b1b57425c315a56a439251b1bdac07b2275f19a8c44bc57744532ec", size = 453809, upload-time = "2026-06-07T21:08:50.7Z" },
+    { url = "https://files.pythonhosted.org/packages/34/e3/19dbe1a1f4cc6230eb9e314de7fe68053b0992f9302b27d12141a0b5db53/aiohttp-3.14.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:819c054312f1af92947e6a55883d1b66feefab11531a7fc45e0fb9b63880b5c2", size = 793320, upload-time = "2026-06-07T21:08:52.775Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/20/1b7182219ba1b108430d6e4dc53d25ae02dcfcf5a045b33af4e8c5167527/aiohttp-3.14.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:10ee9c1753a8f706345b22496c79fbddb5be0599e0823f3738b1534058e25340", size = 529077, upload-time = "2026-06-07T21:08:55Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/c8/14ce60ec31a2e5f5274bb17d383a6f7a3aabca31ac04eee05585bbadab16/aiohttp-3.14.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1601cc37baf5750ccacae618ec2daf020769581695550e3b654a911f859c563d", size = 532476, upload-time = "2026-06-07T21:08:57.176Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/02/9ac85e081e53da2e061b02fa7758fe0a12d17b8ce2d1f5e6c7cb76730328/aiohttp-3.14.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4d6e0ac9da31c9c04c84e1c0182ad8d6df35965a85cae29cd71d089621b3ae94", size = 1922347, upload-time = "2026-06-07T21:08:59.563Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/3e/d3ba07a0ab38b5389e10bec4362d21e10a4f667cba2d79ba30837b3a5059/aiohttp-3.14.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:9e8f2d660c350b3d0e259c7a7e3d9b7fc8b41210cbcc3d4a7076ff0a5e5c2fdc", size = 1786465, upload-time = "2026-06-07T21:09:01.909Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/cb/e2ee978a00cfb2df829704a69528b18154eba5939f45bc1efa8f33aee4c5/aiohttp-3.14.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4691802dda97be727f79d86818acaad7eb8e9252626a1d6b519fedbb92d5e251", size = 1909423, upload-time = "2026-06-07T21:09:04.357Z" },
+    { url = "https://files.pythonhosted.org/packages/73/5d/1430334858b1022b58ae50399a918f0bd6fe8fa7fa183598d657ff61e040/aiohttp-3.14.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c389c482a7e9b9dc3ee2701ac46c4125297a3818875b9c305ddb603c04828fd1", size = 2001906, upload-time = "2026-06-07T21:09:06.722Z" },
+    { url = "https://files.pythonhosted.org/packages/66/4e/560c7472d3d198a23aa5c8b19a5115bf6a9b77b7d3e4bb363da320430ad2/aiohttp-3.14.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fc0cacab7ba4e56f0f81c82a98c09bed2f39c940107b03a34b168bdf7597edd3", size = 1877095, upload-time = "2026-06-07T21:09:09.011Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/f1/4745806578d447db4a784a8591e2dae3afdfc2bcb96f8f81271b13df6543/aiohttp-3.14.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:979ed4717f59b8bb12e3963378fa285d93d367e15bcd66c721311826d3c44a6c", size = 1676222, upload-time = "2026-06-07T21:09:11.461Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/c9/48255813cca749a229ef0ab476004ec623728ad79a9c0840616f6c076325/aiohttp-3.14.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:38e1e7daaea81df51c952e18483f323d878499a1e2bfe564790e0f9701d6f203", size = 1842922, upload-time = "2026-06-07T21:09:14.118Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/c0/bbd054e2bee909f529523a5af3891052606af5143c09f5f183ec3b234676/aiohttp-3.14.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:4132e72c608fe9fecb8f409113567605915b83e9bdd3ea56538d2f9cd35002f1", size = 1825035, upload-time = "2026-06-07T21:09:16.447Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/ae/90395d4376deceb74e09ec26b6adf7d2015a6f8802d6d84446af860fef04/aiohttp-3.14.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:eefd9cc9b6d4a2db5f00a26bc3e4f9acf71926a6ec557cd56c9c6f27c290b665", size = 1849512, upload-time = "2026-06-07T21:09:18.742Z" },
+    { url = "https://files.pythonhosted.org/packages/93/bd/fb25f3049957553d4ce0ba6ae480aa2f592a6985497fca590837d16c1be0/aiohttp-3.14.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:b165790117eea512d7f3fb22f1f6dad3d55a7189571993eb015591c1401276d1", size = 1668571, upload-time = "2026-06-07T21:09:21.458Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/22/7f73303d64dd567ff3addca90b556690ed1233a47b8f55d242fb90af3681/aiohttp-3.14.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:ed09c7eb1c391271c2ed0314a51903e72a3acb653d5ccfc264cdf3ef11f8269d", size = 1881159, upload-time = "2026-06-07T21:09:23.813Z" },
+    { url = "https://files.pythonhosted.org/packages/44/be/0474c5a8b5640e1e4aa1923430a91f4151be82e511373fe764189b89aef5/aiohttp-3.14.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:99abd37084b82f5830c635fddd0b4993b9742a66eb746dacf433c8590e8f9e3c", size = 1841409, upload-time = "2026-06-07T21:09:26.207Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/3c/bb4a7cba26956cb3da4553cc2056cf67be5b5ff6e6d8fa4fbdff73bfb7ae/aiohttp-3.14.1-cp314-cp314t-win32.whl", hash = "sha256:47ddf841cdecc810749921d25606dee45857d12d2ad5ddb7b5bd7eab12e4b365", size = 494166, upload-time = "2026-06-07T21:09:28.505Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/84/ec80c2c1f66a952555a9f86df6b33af65108a6febfa0471b69013a12f807/aiohttp-3.14.1-cp314-cp314t-win_amd64.whl", hash = "sha256:5e78b522b7a6e27e0b25d19b247b75039ac4c94f99823e3c9e53ae1603a9f7e9", size = 530255, upload-time = "2026-06-07T21:09:30.843Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/71/6e22be134a4061ada85a92951b842f2657f17d926b727f3f94c56ae963d6/aiohttp-3.14.1-cp314-cp314t-win_arm64.whl", hash = "sha256:90d53f1609c29ccc2193945ef732428382a28f78d0456ae4d3daf0d48b74f0f6", size = 469640, upload-time = "2026-06-07T21:09:33.028Z" },
 ]
 
 [[package]]
@@ -261,56 +311,50 @@ wheels = [
 
 [[package]]
 name = "brotli"
-version = "1.1.0"
+version = "1.2.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/2f/c2/f9e977608bdf958650638c3f1e28f85a1b075f075ebbe77db8555463787b/Brotli-1.1.0.tar.gz", hash = "sha256:81de08ac11bcb85841e440c13611c00b67d3bf82698314928d0b676362546724", size = 7372270, upload-time = "2023-09-07T14:05:41.643Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f7/16/c92ca344d646e71a43b8bb353f0a6490d7f6e06210f8554c8f874e454285/brotli-1.2.0.tar.gz", hash = "sha256:e310f77e41941c13340a95976fe66a8a95b01e783d430eeaf7a2f87e0a57dd0a", size = 7388632, upload-time = "2025-11-05T18:39:42.86Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/96/12/ad41e7fadd5db55459c4c401842b47f7fee51068f86dd2894dd0dcfc2d2a/Brotli-1.1.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a3daabb76a78f829cafc365531c972016e4aa8d5b4bf60660ad8ecee19df7ccc", size = 873068, upload-time = "2023-09-07T14:03:37.779Z" },
-    { url = "https://files.pythonhosted.org/packages/95/4e/5afab7b2b4b61a84e9c75b17814198ce515343a44e2ed4488fac314cd0a9/Brotli-1.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c8146669223164fc87a7e3de9f81e9423c67a79d6b3447994dfb9c95da16e2d6", size = 446244, upload-time = "2023-09-07T14:03:39.223Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/e6/f305eb61fb9a8580c525478a4a34c5ae1a9bcb12c3aee619114940bc513d/Brotli-1.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:30924eb4c57903d5a7526b08ef4a584acc22ab1ffa085faceb521521d2de32dd", size = 2906500, upload-time = "2023-09-07T14:03:40.858Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/4f/af6846cfbc1550a3024e5d3775ede1e00474c40882c7bf5b37a43ca35e91/Brotli-1.1.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ceb64bbc6eac5a140ca649003756940f8d6a7c444a68af170b3187623b43bebf", size = 2943950, upload-time = "2023-09-07T14:03:42.896Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/e7/ca2993c7682d8629b62630ebf0d1f3bb3d579e667ce8e7ca03a0a0576a2d/Brotli-1.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a469274ad18dc0e4d316eefa616d1d0c2ff9da369af19fa6f3daa4f09671fd61", size = 2918527, upload-time = "2023-09-07T14:03:44.552Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/96/da98e7bedc4c51104d29cc61e5f449a502dd3dbc211944546a4cc65500d3/Brotli-1.1.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:524f35912131cc2cabb00edfd8d573b07f2d9f21fa824bd3fb19725a9cf06327", size = 2845489, upload-time = "2023-09-07T14:03:46.594Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/ef/ccbc16947d6ce943a7f57e1a40596c75859eeb6d279c6994eddd69615265/Brotli-1.1.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:5b3cc074004d968722f51e550b41a27be656ec48f8afaeeb45ebf65b561481dd", size = 2914080, upload-time = "2023-09-07T14:03:48.204Z" },
-    { url = "https://files.pythonhosted.org/packages/80/d6/0bd38d758d1afa62a5524172f0b18626bb2392d717ff94806f741fcd5ee9/Brotli-1.1.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:19c116e796420b0cee3da1ccec3b764ed2952ccfcc298b55a10e5610ad7885f9", size = 2813051, upload-time = "2023-09-07T14:03:50.348Z" },
-    { url = "https://files.pythonhosted.org/packages/14/56/48859dd5d129d7519e001f06dcfbb6e2cf6db92b2702c0c2ce7d97e086c1/Brotli-1.1.0-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:510b5b1bfbe20e1a7b3baf5fed9e9451873559a976c1a78eebaa3b86c57b4265", size = 2938172, upload-time = "2023-09-07T14:03:52.395Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/77/a236d5f8cd9e9f4348da5acc75ab032ab1ab2c03cc8f430d24eea2672888/Brotli-1.1.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:a1fd8a29719ccce974d523580987b7f8229aeace506952fa9ce1d53a033873c8", size = 2933023, upload-time = "2023-09-07T14:03:53.96Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/87/3b283efc0f5cb35f7f84c0c240b1e1a1003a5e47141a4881bf87c86d0ce2/Brotli-1.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c247dd99d39e0338a604f8c2b3bc7061d5c2e9e2ac7ba9cc1be5a69cb6cd832f", size = 2935871, upload-time = "2024-10-18T12:32:16.688Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/eb/2be4cc3e2141dc1a43ad4ca1875a72088229de38c68e842746b342667b2a/Brotli-1.1.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1b2c248cd517c222d89e74669a4adfa5577e06ab68771a529060cf5a156e9757", size = 2847784, upload-time = "2024-10-18T12:32:18.459Z" },
-    { url = "https://files.pythonhosted.org/packages/66/13/b58ddebfd35edde572ccefe6890cf7c493f0c319aad2a5badee134b4d8ec/Brotli-1.1.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:2a24c50840d89ded6c9a8fdc7b6ed3692ed4e86f1c4a4a938e1e92def92933e0", size = 3034905, upload-time = "2024-10-18T12:32:20.192Z" },
-    { url = "https://files.pythonhosted.org/packages/84/9c/bc96b6c7db824998a49ed3b38e441a2cae9234da6fa11f6ed17e8cf4f147/Brotli-1.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f31859074d57b4639318523d6ffdca586ace54271a73ad23ad021acd807eb14b", size = 2929467, upload-time = "2024-10-18T12:32:21.774Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/71/8f161dee223c7ff7fea9d44893fba953ce97cf2c3c33f78ba260a91bcff5/Brotli-1.1.0-cp311-cp311-win32.whl", hash = "sha256:39da8adedf6942d76dc3e46653e52df937a3c4d6d18fdc94a7c29d263b1f5b50", size = 333169, upload-time = "2023-09-07T14:03:55.404Z" },
-    { url = "https://files.pythonhosted.org/packages/02/8a/fece0ee1057643cb2a5bbf59682de13f1725f8482b2c057d4e799d7ade75/Brotli-1.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:aac0411d20e345dc0920bdec5548e438e999ff68d77564d5e9463a7ca9d3e7b1", size = 357253, upload-time = "2023-09-07T14:03:56.643Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/d0/5373ae13b93fe00095a58efcbce837fd470ca39f703a235d2a999baadfbc/Brotli-1.1.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:32d95b80260d79926f5fab3c41701dbb818fde1c9da590e77e571eefd14abe28", size = 815693, upload-time = "2024-10-18T12:32:23.824Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/48/f6e1cdf86751300c288c1459724bfa6917a80e30dbfc326f92cea5d3683a/Brotli-1.1.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b760c65308ff1e462f65d69c12e4ae085cff3b332d894637f6273a12a482d09f", size = 422489, upload-time = "2024-10-18T12:32:25.641Z" },
-    { url = "https://files.pythonhosted.org/packages/06/88/564958cedce636d0f1bed313381dfc4b4e3d3f6015a63dae6146e1b8c65c/Brotli-1.1.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:316cc9b17edf613ac76b1f1f305d2a748f1b976b033b049a6ecdfd5612c70409", size = 873081, upload-time = "2023-09-07T14:03:57.967Z" },
-    { url = "https://files.pythonhosted.org/packages/58/79/b7026a8bb65da9a6bb7d14329fd2bd48d2b7f86d7329d5cc8ddc6a90526f/Brotli-1.1.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:caf9ee9a5775f3111642d33b86237b05808dafcd6268faa492250e9b78046eb2", size = 446244, upload-time = "2023-09-07T14:03:59.319Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/18/c18c32ecea41b6c0004e15606e274006366fe19436b6adccc1ae7b2e50c2/Brotli-1.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:70051525001750221daa10907c77830bc889cb6d865cc0b813d9db7fefc21451", size = 2906505, upload-time = "2023-09-07T14:04:01.327Z" },
-    { url = "https://files.pythonhosted.org/packages/08/c8/69ec0496b1ada7569b62d85893d928e865df29b90736558d6c98c2031208/Brotli-1.1.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7f4bf76817c14aa98cc6697ac02f3972cb8c3da93e9ef16b9c66573a68014f91", size = 2944152, upload-time = "2023-09-07T14:04:03.033Z" },
-    { url = "https://files.pythonhosted.org/packages/ab/fb/0517cea182219d6768113a38167ef6d4eb157a033178cc938033a552ed6d/Brotli-1.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d0c5516f0aed654134a2fc936325cc2e642f8a0e096d075209672eb321cff408", size = 2919252, upload-time = "2023-09-07T14:04:04.675Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/53/73a3431662e33ae61a5c80b1b9d2d18f58dfa910ae8dd696e57d39f1a2f5/Brotli-1.1.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6c3020404e0b5eefd7c9485ccf8393cfb75ec38ce75586e046573c9dc29967a0", size = 2845955, upload-time = "2023-09-07T14:04:06.585Z" },
-    { url = "https://files.pythonhosted.org/packages/55/ac/bd280708d9c5ebdbf9de01459e625a3e3803cce0784f47d633562cf40e83/Brotli-1.1.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:4ed11165dd45ce798d99a136808a794a748d5dc38511303239d4e2363c0695dc", size = 2914304, upload-time = "2023-09-07T14:04:08.668Z" },
-    { url = "https://files.pythonhosted.org/packages/76/58/5c391b41ecfc4527d2cc3350719b02e87cb424ef8ba2023fb662f9bf743c/Brotli-1.1.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:4093c631e96fdd49e0377a9c167bfd75b6d0bad2ace734c6eb20b348bc3ea180", size = 2814452, upload-time = "2023-09-07T14:04:10.736Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/4e/91b8256dfe99c407f174924b65a01f5305e303f486cc7a2e8a5d43c8bec3/Brotli-1.1.0-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:7e4c4629ddad63006efa0ef968c8e4751c5868ff0b1c5c40f76524e894c50248", size = 2938751, upload-time = "2023-09-07T14:04:12.875Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/a6/e2a39a5d3b412938362bbbeba5af904092bf3f95b867b4a3eb856104074e/Brotli-1.1.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:861bf317735688269936f755fa136a99d1ed526883859f86e41a5d43c61d8966", size = 2933757, upload-time = "2023-09-07T14:04:14.551Z" },
-    { url = "https://files.pythonhosted.org/packages/13/f0/358354786280a509482e0e77c1a5459e439766597d280f28cb097642fc26/Brotli-1.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:87a3044c3a35055527ac75e419dfa9f4f3667a1e887ee80360589eb8c90aabb9", size = 2936146, upload-time = "2024-10-18T12:32:27.257Z" },
-    { url = "https://files.pythonhosted.org/packages/80/f7/daf538c1060d3a88266b80ecc1d1c98b79553b3f117a485653f17070ea2a/Brotli-1.1.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c5529b34c1c9d937168297f2c1fde7ebe9ebdd5e121297ff9c043bdb2ae3d6fb", size = 2848055, upload-time = "2024-10-18T12:32:29.376Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/cf/0eaa0585c4077d3c2d1edf322d8e97aabf317941d3a72d7b3ad8bce004b0/Brotli-1.1.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:ca63e1890ede90b2e4454f9a65135a4d387a4585ff8282bb72964fab893f2111", size = 3035102, upload-time = "2024-10-18T12:32:31.371Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/63/1c1585b2aa554fe6dbce30f0c18bdbc877fa9a1bf5ff17677d9cca0ac122/Brotli-1.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e79e6520141d792237c70bcd7a3b122d00f2613769ae0cb61c52e89fd3443839", size = 2930029, upload-time = "2024-10-18T12:32:33.293Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/3b/4e3fd1893eb3bbfef8e5a80d4508bec17a57bb92d586c85c12d28666bb13/Brotli-1.1.0-cp312-cp312-win32.whl", hash = "sha256:5f4d5ea15c9382135076d2fb28dde923352fe02951e66935a9efaac8f10e81b0", size = 333276, upload-time = "2023-09-07T14:04:16.49Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/d5/942051b45a9e883b5b6e98c041698b1eb2012d25e5948c58d6bf85b1bb43/Brotli-1.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:906bc3a79de8c4ae5b86d3d75a8b77e44404b0f4261714306e3ad248d8ab0951", size = 357255, upload-time = "2023-09-07T14:04:17.83Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/9f/fb37bb8ffc52a8da37b1c03c459a8cd55df7a57bdccd8831d500e994a0ca/Brotli-1.1.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8bf32b98b75c13ec7cf774164172683d6e7891088f6316e54425fde1efc276d5", size = 815681, upload-time = "2024-10-18T12:32:34.942Z" },
-    { url = "https://files.pythonhosted.org/packages/06/b3/dbd332a988586fefb0aa49c779f59f47cae76855c2d00f450364bb574cac/Brotli-1.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7bc37c4d6b87fb1017ea28c9508b36bbcb0c3d18b4260fcdf08b200c74a6aee8", size = 422475, upload-time = "2024-10-18T12:32:36.485Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/80/6aaddc2f63dbcf2d93c2d204e49c11a9ec93a8c7c63261e2b4bd35198283/Brotli-1.1.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3c0ef38c7a7014ffac184db9e04debe495d317cc9c6fb10071f7fefd93100a4f", size = 2906173, upload-time = "2024-10-18T12:32:37.978Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/1d/e6ca79c96ff5b641df6097d299347507d39a9604bde8915e76bf026d6c77/Brotli-1.1.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:91d7cc2a76b5567591d12c01f019dd7afce6ba8cba6571187e21e2fc418ae648", size = 2943803, upload-time = "2024-10-18T12:32:39.606Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/a3/d98d2472e0130b7dd3acdbb7f390d478123dbf62b7d32bda5c830a96116d/Brotli-1.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a93dde851926f4f2678e704fadeb39e16c35d8baebd5252c9fd94ce8ce68c4a0", size = 2918946, upload-time = "2024-10-18T12:32:41.679Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/a5/c69e6d272aee3e1423ed005d8915a7eaa0384c7de503da987f2d224d0721/Brotli-1.1.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f0db75f47be8b8abc8d9e31bc7aad0547ca26f24a54e6fd10231d623f183d089", size = 2845707, upload-time = "2024-10-18T12:32:43.478Z" },
-    { url = "https://files.pythonhosted.org/packages/58/9f/4149d38b52725afa39067350696c09526de0125ebfbaab5acc5af28b42ea/Brotli-1.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6967ced6730aed543b8673008b5a391c3b1076d834ca438bbd70635c73775368", size = 2936231, upload-time = "2024-10-18T12:32:45.224Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/5a/145de884285611838a16bebfdb060c231c52b8f84dfbe52b852a15780386/Brotli-1.1.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:7eedaa5d036d9336c95915035fb57422054014ebdeb6f3b42eac809928e40d0c", size = 2848157, upload-time = "2024-10-18T12:32:46.894Z" },
-    { url = "https://files.pythonhosted.org/packages/50/ae/408b6bfb8525dadebd3b3dd5b19d631da4f7d46420321db44cd99dcf2f2c/Brotli-1.1.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:d487f5432bf35b60ed625d7e1b448e2dc855422e87469e3f450aa5552b0eb284", size = 3035122, upload-time = "2024-10-18T12:32:48.844Z" },
-    { url = "https://files.pythonhosted.org/packages/af/85/a94e5cfaa0ca449d8f91c3d6f78313ebf919a0dbd55a100c711c6e9655bc/Brotli-1.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:832436e59afb93e1836081a20f324cb185836c617659b07b129141a8426973c7", size = 2930206, upload-time = "2024-10-18T12:32:51.198Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/f0/a61d9262cd01351df22e57ad7c34f66794709acab13f34be2675f45bf89d/Brotli-1.1.0-cp313-cp313-win32.whl", hash = "sha256:43395e90523f9c23a3d5bdf004733246fba087f2948f87ab28015f12359ca6a0", size = 333804, upload-time = "2024-10-18T12:32:52.661Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/c1/ec214e9c94000d1c1974ec67ced1c970c148aa6b8d8373066123fc3dbf06/Brotli-1.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:9011560a466d2eb3f5a6e4929cf4a09be405c64154e12df0dd72713f6500e32b", size = 358517, upload-time = "2024-10-18T12:32:54.066Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/ef/f285668811a9e1ddb47a18cb0b437d5fc2760d537a2fe8a57875ad6f8448/brotli-1.2.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:15b33fe93cedc4caaff8a0bd1eb7e3dab1c61bb22a0bf5bdfdfd97cd7da79744", size = 863110, upload-time = "2025-11-05T18:38:12.978Z" },
+    { url = "https://files.pythonhosted.org/packages/50/62/a3b77593587010c789a9d6eaa527c79e0848b7b860402cc64bc0bc28a86c/brotli-1.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:898be2be399c221d2671d29eed26b6b2713a02c2119168ed914e7d00ceadb56f", size = 445438, upload-time = "2025-11-05T18:38:14.208Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/e1/7fadd47f40ce5549dc44493877db40292277db373da5053aff181656e16e/brotli-1.2.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:350c8348f0e76fff0a0fd6c26755d2653863279d086d3aa2c290a6a7251135dd", size = 1534420, upload-time = "2025-11-05T18:38:15.111Z" },
+    { url = "https://files.pythonhosted.org/packages/12/8b/1ed2f64054a5a008a4ccd2f271dbba7a5fb1a3067a99f5ceadedd4c1d5a7/brotli-1.2.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2e1ad3fda65ae0d93fec742a128d72e145c9c7a99ee2fcd667785d99eb25a7fe", size = 1632619, upload-time = "2025-11-05T18:38:16.094Z" },
+    { url = "https://files.pythonhosted.org/packages/89/5a/7071a621eb2d052d64efd5da2ef55ecdac7c3b0c6e4f9d519e9c66d987ef/brotli-1.2.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:40d918bce2b427a0c4ba189df7a006ac0c7277c180aee4617d99e9ccaaf59e6a", size = 1426014, upload-time = "2025-11-05T18:38:17.177Z" },
+    { url = "https://files.pythonhosted.org/packages/26/6d/0971a8ea435af5156acaaccec1a505f981c9c80227633851f2810abd252a/brotli-1.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2a7f1d03727130fc875448b65b127a9ec5d06d19d0148e7554384229706f9d1b", size = 1489661, upload-time = "2025-11-05T18:38:18.41Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/75/c1baca8b4ec6c96a03ef8230fab2a785e35297632f402ebb1e78a1e39116/brotli-1.2.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:9c79f57faa25d97900bfb119480806d783fba83cd09ee0b33c17623935b05fa3", size = 1599150, upload-time = "2025-11-05T18:38:19.792Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/1a/23fcfee1c324fd48a63d7ebf4bac3a4115bdb1b00e600f80f727d850b1ae/brotli-1.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:844a8ceb8483fefafc412f85c14f2aae2fb69567bf2a0de53cdb88b73e7c43ae", size = 1493505, upload-time = "2025-11-05T18:38:20.913Z" },
+    { url = "https://files.pythonhosted.org/packages/36/e5/12904bbd36afeef53d45a84881a4810ae8810ad7e328a971ebbfd760a0b3/brotli-1.2.0-cp311-cp311-win32.whl", hash = "sha256:aa47441fa3026543513139cb8926a92a8e305ee9c71a6209ef7a97d91640ea03", size = 334451, upload-time = "2025-11-05T18:38:21.94Z" },
+    { url = "https://files.pythonhosted.org/packages/02/8b/ecb5761b989629a4758c394b9301607a5880de61ee2ee5fe104b87149ebc/brotli-1.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:022426c9e99fd65d9475dce5c195526f04bb8be8907607e27e747893f6ee3e24", size = 369035, upload-time = "2025-11-05T18:38:22.941Z" },
+    { url = "https://files.pythonhosted.org/packages/11/ee/b0a11ab2315c69bb9b45a2aaed022499c9c24a205c3a49c3513b541a7967/brotli-1.2.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:35d382625778834a7f3061b15423919aa03e4f5da34ac8e02c074e4b75ab4f84", size = 861543, upload-time = "2025-11-05T18:38:24.183Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/2f/29c1459513cd35828e25531ebfcbf3e92a5e49f560b1777a9af7203eb46e/brotli-1.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7a61c06b334bd99bc5ae84f1eeb36bfe01400264b3c352f968c6e30a10f9d08b", size = 444288, upload-time = "2025-11-05T18:38:25.139Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/6f/feba03130d5fceadfa3a1bb102cb14650798c848b1df2a808356f939bb16/brotli-1.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:acec55bb7c90f1dfc476126f9711a8e81c9af7fb617409a9ee2953115343f08d", size = 1528071, upload-time = "2025-11-05T18:38:26.081Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/38/f3abb554eee089bd15471057ba85f47e53a44a462cfce265d9bf7088eb09/brotli-1.2.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:260d3692396e1895c5034f204f0db022c056f9e2ac841593a4cf9426e2a3faca", size = 1626913, upload-time = "2025-11-05T18:38:27.284Z" },
+    { url = "https://files.pythonhosted.org/packages/03/a7/03aa61fbc3c5cbf99b44d158665f9b0dd3d8059be16c460208d9e385c837/brotli-1.2.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:072e7624b1fc4d601036ab3f4f27942ef772887e876beff0301d261210bca97f", size = 1419762, upload-time = "2025-11-05T18:38:28.295Z" },
+    { url = "https://files.pythonhosted.org/packages/21/1b/0374a89ee27d152a5069c356c96b93afd1b94eae83f1e004b57eb6ce2f10/brotli-1.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:adedc4a67e15327dfdd04884873c6d5a01d3e3b6f61406f99b1ed4865a2f6d28", size = 1484494, upload-time = "2025-11-05T18:38:29.29Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/57/69d4fe84a67aef4f524dcd075c6eee868d7850e85bf01d778a857d8dbe0a/brotli-1.2.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:7a47ce5c2288702e09dc22a44d0ee6152f2c7eda97b3c8482d826a1f3cfc7da7", size = 1593302, upload-time = "2025-11-05T18:38:30.639Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/3b/39e13ce78a8e9a621c5df3aeb5fd181fcc8caba8c48a194cd629771f6828/brotli-1.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:af43b8711a8264bb4e7d6d9a6d004c3a2019c04c01127a868709ec29962b6036", size = 1487913, upload-time = "2025-11-05T18:38:31.618Z" },
+    { url = "https://files.pythonhosted.org/packages/62/28/4d00cb9bd76a6357a66fcd54b4b6d70288385584063f4b07884c1e7286ac/brotli-1.2.0-cp312-cp312-win32.whl", hash = "sha256:e99befa0b48f3cd293dafeacdd0d191804d105d279e0b387a32054c1180f3161", size = 334362, upload-time = "2025-11-05T18:38:32.939Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/4e/bc1dcac9498859d5e353c9b153627a3752868a9d5f05ce8dedd81a2354ab/brotli-1.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:b35c13ce241abdd44cb8ca70683f20c0c079728a36a996297adb5334adfc1c44", size = 369115, upload-time = "2025-11-05T18:38:33.765Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/d4/4ad5432ac98c73096159d9ce7ffeb82d151c2ac84adcc6168e476bb54674/brotli-1.2.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:9e5825ba2c9998375530504578fd4d5d1059d09621a02065d1b6bfc41a8e05ab", size = 861523, upload-time = "2025-11-05T18:38:34.67Z" },
+    { url = "https://files.pythonhosted.org/packages/91/9f/9cc5bd03ee68a85dc4bc89114f7067c056a3c14b3d95f171918c088bf88d/brotli-1.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0cf8c3b8ba93d496b2fae778039e2f5ecc7cff99df84df337ca31d8f2252896c", size = 444289, upload-time = "2025-11-05T18:38:35.6Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/b6/fe84227c56a865d16a6614e2c4722864b380cb14b13f3e6bef441e73a85a/brotli-1.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c8565e3cdc1808b1a34714b553b262c5de5fbda202285782173ec137fd13709f", size = 1528076, upload-time = "2025-11-05T18:38:36.639Z" },
+    { url = "https://files.pythonhosted.org/packages/55/de/de4ae0aaca06c790371cf6e7ee93a024f6b4bb0568727da8c3de112e726c/brotli-1.2.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:26e8d3ecb0ee458a9804f47f21b74845cc823fd1bb19f02272be70774f56e2a6", size = 1626880, upload-time = "2025-11-05T18:38:37.623Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/16/a1b22cbea436642e071adcaf8d4b350a2ad02f5e0ad0da879a1be16188a0/brotli-1.2.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:67a91c5187e1eec76a61625c77a6c8c785650f5b576ca732bd33ef58b0dff49c", size = 1419737, upload-time = "2025-11-05T18:38:38.729Z" },
+    { url = "https://files.pythonhosted.org/packages/46/63/c968a97cbb3bdbf7f974ef5a6ab467a2879b82afbc5ffb65b8acbb744f95/brotli-1.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4ecdb3b6dc36e6d6e14d3a1bdc6c1057c8cbf80db04031d566eb6080ce283a48", size = 1484440, upload-time = "2025-11-05T18:38:39.916Z" },
+    { url = "https://files.pythonhosted.org/packages/06/9d/102c67ea5c9fc171f423e8399e585dabea29b5bc79b05572891e70013cdd/brotli-1.2.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3e1b35d56856f3ed326b140d3c6d9db91740f22e14b06e840fe4bb1923439a18", size = 1593313, upload-time = "2025-11-05T18:38:41.24Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/4a/9526d14fa6b87bc827ba1755a8440e214ff90de03095cacd78a64abe2b7d/brotli-1.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:54a50a9dad16b32136b2241ddea9e4df159b41247b2ce6aac0b3276a66a8f1e5", size = 1487945, upload-time = "2025-11-05T18:38:42.277Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/e8/3fe1ffed70cbef83c5236166acaed7bb9c766509b157854c80e2f766b38c/brotli-1.2.0-cp313-cp313-win32.whl", hash = "sha256:1b1d6a4efedd53671c793be6dd760fcf2107da3a52331ad9ea429edf0902f27a", size = 334368, upload-time = "2025-11-05T18:38:43.345Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/91/e739587be970a113b37b821eae8097aac5a48e5f0eca438c22e4c7dd8648/brotli-1.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:b63daa43d82f0cdabf98dee215b375b4058cce72871fd07934f179885aad16e8", size = 369116, upload-time = "2025-11-05T18:38:44.609Z" },
+    { url = "https://files.pythonhosted.org/packages/17/e1/298c2ddf786bb7347a1cd71d63a347a79e5712a7c0cba9e3c3458ebd976f/brotli-1.2.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:6c12dad5cd04530323e723787ff762bac749a7b256a5bece32b2243dd5c27b21", size = 863080, upload-time = "2025-11-05T18:38:45.503Z" },
+    { url = "https://files.pythonhosted.org/packages/84/0c/aac98e286ba66868b2b3b50338ffbd85a35c7122e9531a73a37a29763d38/brotli-1.2.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:3219bd9e69868e57183316ee19c84e03e8f8b5a1d1f2667e1aa8c2f91cb061ac", size = 445453, upload-time = "2025-11-05T18:38:46.433Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/f1/0ca1f3f99ae300372635ab3fe2f7a79fa335fee3d874fa7f9e68575e0e62/brotli-1.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:963a08f3bebd8b75ac57661045402da15991468a621f014be54e50f53a58d19e", size = 1528168, upload-time = "2025-11-05T18:38:47.371Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/a6/2ebfc8f766d46df8d3e65b880a2e220732395e6d7dc312c1e1244b0f074a/brotli-1.2.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9322b9f8656782414b37e6af884146869d46ab85158201d82bab9abbcb971dc7", size = 1627098, upload-time = "2025-11-05T18:38:48.385Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/2f/0976d5b097ff8a22163b10617f76b2557f15f0f39d6a0fe1f02b1a53e92b/brotli-1.2.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cf9cba6f5b78a2071ec6fb1e7bd39acf35071d90a81231d67e92d637776a6a63", size = 1419861, upload-time = "2025-11-05T18:38:49.372Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/97/d76df7176a2ce7616ff94c1fb72d307c9a30d2189fe877f3dd99af00ea5a/brotli-1.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7547369c4392b47d30a3467fe8c3330b4f2e0f7730e45e3103d7d636678a808b", size = 1484594, upload-time = "2025-11-05T18:38:50.655Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/93/14cf0b1216f43df5609f5b272050b0abd219e0b54ea80b47cef9867b45e7/brotli-1.2.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:fc1530af5c3c275b8524f2e24841cbe2599d74462455e9bae5109e9ff42e9361", size = 1593455, upload-time = "2025-11-05T18:38:51.624Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/73/3183c9e41ca755713bdf2cc1d0810df742c09484e2e1ddd693bee53877c1/brotli-1.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d2d085ded05278d1c7f65560aae97b3160aeb2ea2c0b3e26204856beccb60888", size = 1488164, upload-time = "2025-11-05T18:38:53.079Z" },
+    { url = "https://files.pythonhosted.org/packages/64/6a/0c78d8f3a582859236482fd9fa86a65a60328a00983006bcf6d83b7b2253/brotli-1.2.0-cp314-cp314-win32.whl", hash = "sha256:832c115a020e463c2f67664560449a7bea26b0c1fdd690352addad6d0a08714d", size = 339280, upload-time = "2025-11-05T18:38:54.02Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/10/56978295c14794b2c12007b07f3e41ba26acda9257457d7085b0bb3bb90c/brotli-1.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:e7c0af964e0b4e3412a0ebf341ea26ec767fa0b4cf81abb5e897c9338b5ad6a3", size = 375639, upload-time = "2025-11-05T18:38:55.67Z" },
 ]
 
 [[package]]
@@ -364,32 +408,39 @@ wheels = [
 
 [[package]]
 name = "cbor2"
-version = "5.6.5"
+version = "5.9.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e4/aa/ba55b47d51d27911981a18743b4d3cebfabccbb0598c09801b734cec4184/cbor2-5.6.5.tar.gz", hash = "sha256:b682820677ee1dbba45f7da11898d2720f92e06be36acec290867d5ebf3d7e09", size = 100886, upload-time = "2024-10-09T12:26:24.106Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/bd/cb/09939728be094d155b5d4ac262e39877875f5f7e36eea66beb359f647bd0/cbor2-5.9.0.tar.gz", hash = "sha256:85c7a46279ac8f226e1059275221e6b3d0e370d2bb6bd0500f9780781615bcea", size = 111231, upload-time = "2026-03-22T15:56:50.638Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/bd/b7/ef045245180510305648fd604244d3bb1ecf1b20de68f42ab5bc20198024/cbor2-5.6.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:863e0983989d56d5071270790e7ed8ddbda88c9e5288efdb759aba2efee670bc", size = 66452, upload-time = "2024-10-09T12:25:36.676Z" },
-    { url = "https://files.pythonhosted.org/packages/41/20/5a9d93f86b1e8fd9d9db33aff39c0e3a8459e0803ec24bd837d8b56d4a1d/cbor2-5.6.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5cff06464b8f4ca6eb9abcba67bda8f8334a058abc01005c8e616728c387ad32", size = 67421, upload-time = "2024-10-09T12:25:38.114Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/1e/2010f6d02dd117df88df64baf3eeca6aa6614cc81bdd6bfabf615889cf1f/cbor2-5.6.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f4c7dbcdc59ea7f5a745d3e30ee5e6b6ff5ce7ac244aa3de6786391b10027bb3", size = 260756, upload-time = "2024-10-09T12:25:39.657Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/84/e177d9bef4749d14f31c513b25e341ac84e403e2ffa2bde562eac9e6184b/cbor2-5.6.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:34cf5ab0dc310c3d0196caa6ae062dc09f6c242e2544bea01691fe60c0230596", size = 249210, upload-time = "2024-10-09T12:25:41.316Z" },
-    { url = "https://files.pythonhosted.org/packages/38/75/ebfdbb281104b46419fe7cb65979de9927b75acebcb6afa0af291f728cd2/cbor2-5.6.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6797b824b26a30794f2b169c0575301ca9b74ae99064e71d16e6ba0c9057de51", size = 249138, upload-time = "2024-10-09T12:25:42.432Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/1e/12d887fb1a8227a16181eeec5d43057e251204626d73e1c20a77046ac1b1/cbor2-5.6.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:73b9647eed1493097db6aad61e03d8f1252080ee041a1755de18000dd2c05f37", size = 247156, upload-time = "2024-10-09T12:25:43.588Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/76/478c12193de9517ce691bb8a3f7c00eafdd6a1bc3f7f23282ecdd99d02ec/cbor2-5.6.5-cp311-cp311-win_amd64.whl", hash = "sha256:6e14a1bf6269d25e02ef1d4008e0ce8880aa271d7c6b4c329dba48645764f60e", size = 66319, upload-time = "2024-10-09T12:25:44.621Z" },
-    { url = "https://files.pythonhosted.org/packages/57/af/84ced14c541451696825b7b8ccbb7668f688372ad8ee74aaca4311e79672/cbor2-5.6.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e25c2aebc9db99af7190e2261168cdde8ed3d639ca06868e4f477cf3a228a8e9", size = 67553, upload-time = "2024-10-09T12:25:45.767Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/d6/f63a840c68fed4de67d5441947af2dc695152cc488bb0e57312832fb923a/cbor2-5.6.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fde21ac1cf29336a31615a2c469a9cb03cf0add3ae480672d4d38cda467d07fc", size = 67569, upload-time = "2024-10-09T12:25:46.665Z" },
-    { url = "https://files.pythonhosted.org/packages/77/ac/5fb79db6e882ec29680f4a974d35c098020a1b4709cad077667a8c3f4676/cbor2-5.6.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a8947c102cac79d049eadbd5e2ffb8189952890df7cbc3ee262bbc2f95b011a9", size = 276610, upload-time = "2024-10-09T12:25:48.14Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/cb/70751377d94112001d46c311b5c40b45f34863dfa78a6bc71b71f40c8c7f/cbor2-5.6.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:38886c41bebcd7dca57739439455bce759f1e4c551b511f618b8e9c1295b431b", size = 270004, upload-time = "2024-10-09T12:25:49.769Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/90/08800367e920aef31b93bd7b0cd6fadcb3a3f2243f4ed77a0d1c76f22b99/cbor2-5.6.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ae2b49226224e92851c333b91d83292ec62eba53a19c68a79890ce35f1230d70", size = 264913, upload-time = "2024-10-09T12:25:50.92Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/9c/76b11a5ea7548bccb0dfef3e8fb3ede48bfeb39348f0c217519e0c40d33a/cbor2-5.6.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f2764804ffb6553283fc4afb10a280715905a4cea4d6dc7c90d3e89c4a93bc8d", size = 266751, upload-time = "2024-10-09T12:25:52.777Z" },
-    { url = "https://files.pythonhosted.org/packages/10/18/3866693a87c90cb12f7942e791d0f03a40ba44887dde7b7fc85319647efe/cbor2-5.6.5-cp312-cp312-win_amd64.whl", hash = "sha256:a3ac50485cf67dfaab170a3e7b527630e93cb0a6af8cdaa403054215dff93adf", size = 66739, upload-time = "2024-10-09T12:25:54.606Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/69/77e93caae71d1baee927c9762e702c464715d88073133052c74ecc9d37d4/cbor2-5.6.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f0d0a9c5aabd48ecb17acf56004a7542a0b8d8212be52f3102b8218284bd881e", size = 67647, upload-time = "2024-10-09T12:25:55.637Z" },
-    { url = "https://files.pythonhosted.org/packages/84/83/cb941d4fd10e4696b2c0f6fb2e3056d9a296e5765b2000a69e29a507f819/cbor2-5.6.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:61ceb77e6aa25c11c814d4fe8ec9e3bac0094a1f5bd8a2a8c95694596ea01e08", size = 67657, upload-time = "2024-10-09T12:25:56.528Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/3f/e16a1e29994483c751b714cdf61d2956290b0b30e94690fa714a9f155c5c/cbor2-5.6.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:97a7e409b864fecf68b2ace8978eb5df1738799a333ec3ea2b9597bfcdd6d7d2", size = 275863, upload-time = "2024-10-09T12:25:57.462Z" },
-    { url = "https://files.pythonhosted.org/packages/64/04/f64bda3eea649fe6644c59f13d0e1f4666d975ce305cadf13835233b2a26/cbor2-5.6.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f6d69f38f7d788b04c09ef2b06747536624b452b3c8b371ab78ad43b0296fab", size = 269131, upload-time = "2024-10-09T12:25:59.635Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/8d/0d5ad3467f70578b032b3f52eb0f01f0327d5ae6b1f9e7d4d4e01a73aa95/cbor2-5.6.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f91e6d74fa6917df31f8757fdd0e154203b0dd0609ec53eb957016a2b474896a", size = 264728, upload-time = "2024-10-09T12:26:01.407Z" },
-    { url = "https://files.pythonhosted.org/packages/77/cb/9b4f7890325eaa374c21fcccfee61a099ccb9ea0bc0f606acf7495f9568c/cbor2-5.6.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5ce13a27ef8fddf643fc17a753fe34aa72b251d03c23da6a560c005dc171085b", size = 266314, upload-time = "2024-10-09T12:26:02.451Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/cd/793dc041395609f5dd1edfdf0aecde504dc0fd35ed67eb3b2db79fb8ef4d/cbor2-5.6.5-cp313-cp313-win_amd64.whl", hash = "sha256:54c72a3207bb2d4480c2c39dad12d7971ce0853a99e3f9b8d559ce6eac84f66f", size = 66792, upload-time = "2024-10-09T12:26:03.615Z" },
-    { url = "https://files.pythonhosted.org/packages/9b/ef/1c4698cac96d792005ef0611832f38eaee477c275ab4b02cbfc4daba7ad3/cbor2-5.6.5-py3-none-any.whl", hash = "sha256:3038523b8fc7de312bb9cdcbbbd599987e64307c4db357cd2030c472a6c7d468", size = 23752, upload-time = "2024-10-09T12:26:23.167Z" },
+    { url = "https://files.pythonhosted.org/packages/43/aa/317c7118b8dda4c9563125c1a12c70c5b41e36677964a49c72b1aac061ec/cbor2-5.9.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0485d3372fc832c5e16d4eb45fa1a20fc53e806e6c29a1d2b0d3e176cedd52b9", size = 70578, upload-time = "2026-03-22T15:56:03.835Z" },
+    { url = "https://files.pythonhosted.org/packages/31/43/fe29b1f897770011a5e7497f4523c2712282ee4a6cbf775ea6383fb7afb9/cbor2-5.9.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a9d6e4e0f988b0e766509a8071975a8ee99f930e14a524620bf38083106158d2", size = 268738, upload-time = "2026-03-22T15:56:05.222Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/1a/e494568f3d8aafbcdfe361df44c3bcf5cdab5183e25ea08e3d3f9fcf4075/cbor2-5.9.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5326336f633cc89dfe543c78829c16c3a6449c2c03277d1ddba99086c3323363", size = 262571, upload-time = "2026-03-22T15:56:06.411Z" },
+    { url = "https://files.pythonhosted.org/packages/42/2e/92acd6f87382fd44a34d9d7e85cc45372e6ba664040b72d1d9df648b25d0/cbor2-5.9.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:5e702b02d42a5ace45425b595ffe70fe35aebaf9a3cdfdc2c758b6189c744422", size = 262356, upload-time = "2026-03-22T15:56:08.236Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/68/52c039a28688baeeb78b0be7483855e6c66ea05884a937444deede0c87b8/cbor2-5.9.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:2372d357d403e7912f104ff085950ffc82a5854d6d717f1ca1ce16a40a0ef5a7", size = 257604, upload-time = "2026-03-22T15:56:09.835Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/e4/10d96a7f73ed9227090ce6e3df5d73329eb6a267dab7d5b989e6fbf6c504/cbor2-5.9.0-cp311-cp311-win_amd64.whl", hash = "sha256:1d02b65f070fd726bdc310d927228975bb655d155bf059b6eb7cacefb3dca86f", size = 69388, upload-time = "2026-03-22T15:56:11.28Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/c6/eea5829aa5a649db540f47ea35f4bf2313383d28246f0cbc50432cfad6b3/cbor2-5.9.0-cp311-cp311-win_arm64.whl", hash = "sha256:837754ece9052b3f607047e1741e5f852a538aa2b0ee3db11c82a8fa11804aa4", size = 65315, upload-time = "2026-03-22T15:56:12.326Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/39/72d8a5a4b06565561ec28f4fcb41aff7bb77f51705c01f00b8254a2aca4f/cbor2-5.9.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1f223dffb1bcdd2764665f04c1152943d9daa4bc124a576cd8dee1cad4264313", size = 71223, upload-time = "2026-03-22T15:56:13.68Z" },
+    { url = "https://files.pythonhosted.org/packages/09/fd/7ddf3d3153b54c69c3be77172b8d9aa3a9d74f62a7fbde614d53eaeed9a4/cbor2-5.9.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ae6c706ac1d85a0b3cb3395308fd0c4d55e3202b4760773675957e93cdff45fc", size = 287865, upload-time = "2026-03-22T15:56:14.813Z" },
+    { url = "https://files.pythonhosted.org/packages/db/9d/7ede2cc42f9bb4260492e7d29d2aab781eacbbcfb09d983de1e695077199/cbor2-5.9.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4cd43d8fc374b31643b2830910f28177a606a7bc84975a62675dd3f2e320fc7b", size = 288246, upload-time = "2026-03-22T15:56:16.113Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/9d/588ebc7c5bc5843f609b05fe07be8575c7dec987735b0bbc908ac9c1264a/cbor2-5.9.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4aa07b392cc3d76fb31c08a46a226b58c320d1c172ff3073e864409ced7bc50f", size = 280214, upload-time = "2026-03-22T15:56:17.519Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/a1/6fc8f4b15c6a27e7fbb7966c30c2b4b18c274a3221fa2f5e6235502d34bc/cbor2-5.9.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:971d425b3a23b75953d8853d5f9911bdeefa09d759ee3b5e6b07b5ff3cbd9073", size = 282162, upload-time = "2026-03-22T15:56:18.975Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/20/9a22cfe08be16ddfeef2542cf4eeed1b29f3f57ddbba0b42f7e0bb8331fd/cbor2-5.9.0-cp312-cp312-win_amd64.whl", hash = "sha256:34a6cb15e6ab6a8eae94ad2041731cd3ef786af43a8df99f847969af5b902ee7", size = 70049, upload-time = "2026-03-22T15:56:20.502Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/9e/695f92d09006614034e25a9f5b10620f3b219f79c1bec3c37b7c6f27a7a9/cbor2-5.9.0-cp312-cp312-win_arm64.whl", hash = "sha256:7d1ddc4541e7367ac58c2470cc0df847f7137167fe4f5729e2d3cc0b993d7da4", size = 65382, upload-time = "2026-03-22T15:56:21.526Z" },
+    { url = "https://files.pythonhosted.org/packages/81/c5/4901e21a8afe9448fd947b11e8f383903207cd6dd0800e5f5a386838de5b/cbor2-5.9.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fbb06f34aa645b4deca66643bba3d400d20c15312d1fe88d429be60c1ab50f27", size = 71284, upload-time = "2026-03-22T15:56:22.836Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/10/df643a381aebc3f05486de4813662bc58accb640fc3275cb276a75e89694/cbor2-5.9.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ac684fe195c39821fca70d18afbf748f728aefbfbf88456018d299e559b8cae0", size = 287682, upload-time = "2026-03-22T15:56:24.024Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/0c/8aa6b766059ae4a0ca1ec3ff96fe3823a69a7be880dba2e249f7fbe2700b/cbor2-5.9.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2a54fbb32cb828c214f7f333a707e4aec61182e7efdc06ea5d9596d3ecee624a", size = 288009, upload-time = "2026-03-22T15:56:25.305Z" },
+    { url = "https://files.pythonhosted.org/packages/74/07/6236bc25c183a9cf7e8062e5dddf9eae9b0b14ebf14a58a69fe5a1e872c6/cbor2-5.9.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4753a6d1bc71054d9179557bc65740860f185095ccb401d46637fff028a5b3ec", size = 280437, upload-time = "2026-03-22T15:56:26.479Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/0a/84328d23c3c68874ac6497edb9b1900579a1028efa54734df3f1762bbc15/cbor2-5.9.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:380e534482b843e43442b87d8777a7bf9bed20cb7526f89b780c3400f617304b", size = 282247, upload-time = "2026-03-22T15:56:28.644Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/f6/89b4627e09d028c8e5fcaf7cb55f225c33ce6e037ec1844e65d02bcfa945/cbor2-5.9.0-cp313-cp313-win_amd64.whl", hash = "sha256:dcf0f695873e5c94bd072d6af8698e72b8fb7f7a18f37e0bced1041b7111a6cf", size = 70089, upload-time = "2026-03-22T15:56:29.801Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/7c/efadcd5f0102db692490e4e206988a2f98d39a09912090db497a2b800885/cbor2-5.9.0-cp313-cp313-win_arm64.whl", hash = "sha256:f7c9751a9611601ab326d8f5837f01379195bbf06175fb4effeb552140e7c9e8", size = 65466, upload-time = "2026-03-22T15:56:30.823Z" },
+    { url = "https://files.pythonhosted.org/packages/08/7d/9ccc36d10ef96e6038e48046ebe1ce35a1e7814da0e1e204d09e6ef09b8d/cbor2-5.9.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23606d31ba1368bd1b6602e3020ee88fe9523ca80e8630faf6b2fc904fd84560", size = 71500, upload-time = "2026-03-22T15:56:31.876Z" },
+    { url = "https://files.pythonhosted.org/packages/70/e1/a6cca2cc72e13f00030c6a649f57ae703eb2c620806ab70c40db8eab33fa/cbor2-5.9.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0322296b9d52f55880e300ba8ba09ecf644303b99b51138bbb1c0fb644fa7c3e", size = 286953, upload-time = "2026-03-22T15:56:33.292Z" },
+    { url = "https://files.pythonhosted.org/packages/08/3c/24cd5ef488a957d90e016f200a3aad820e4c2f85edd61c9fe4523007a1ee/cbor2-5.9.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:422817286c1d0ce947fb2f7eca9212b39bddd7231e8b452e2d2cc52f15332dba", size = 285454, upload-time = "2026-03-22T15:56:34.703Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/35/dca96818494c0ba47cdd73e8d809b27fa91f8fa0ce32a068a09237687454/cbor2-5.9.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9a4907e0c3035bb8836116854ed8e56d8aef23909d601fa59706320897ec2551", size = 279441, upload-time = "2026-03-22T15:56:35.888Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/44/d3362378b16e53cf7e535a3f5aed8476e2109068154e24e31981ef5bde9e/cbor2-5.9.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:fb7afe77f8d269e42d7c4b515c6fd14f1ccc0625379fb6829b269f493d16eddd", size = 279673, upload-time = "2026-03-22T15:56:37.08Z" },
+    { url = "https://files.pythonhosted.org/packages/43/d1/3533a697e5842fff7c2f64912eb251f8dcab3a8b5d88e228d6eebc3b5021/cbor2-5.9.0-cp314-cp314-win_amd64.whl", hash = "sha256:86baf870d4c0bfc6f79de3801f3860a84ab76d9c8b0abb7f081f2c14c38d79d3", size = 71940, upload-time = "2026-03-22T15:56:38.366Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/e2/c6ba75f3fb25dfa15ab6999cc8709c821987e9ed8e375d7f58539261bcb9/cbor2-5.9.0-cp314-cp314-win_arm64.whl", hash = "sha256:7221483fad0c63afa4244624d552abf89d7dfdbc5f5edfc56fc1ff2b4b818975", size = 67639, upload-time = "2026-03-22T15:56:39.39Z" },
+    { url = "https://files.pythonhosted.org/packages/42/ff/b83492b096fbef26e9cb62c1a4bf2d3cef579ea7b33138c6c37c4ae66f67/cbor2-5.9.0-py3-none-any.whl", hash = "sha256:27695cbd70c90b8de5c4a284642c2836449b14e2c2e07e3ffe0744cb7669a01b", size = 24627, upload-time = "2026-03-22T15:56:48.847Z" },
 ]
 
 [[package]]
@@ -1475,14 +1526,14 @@ wheels = [
 
 [[package]]
 name = "marshmallow"
-version = "3.26.1"
+version = "3.26.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "packaging" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ab/5e/5e53d26b42ab75491cda89b871dab9e97c840bf12c63ec58a1919710cd06/marshmallow-3.26.1.tar.gz", hash = "sha256:e6d8affb6cb61d39d26402096dc0aee12d5a26d490a121f118d2e81dc0719dc6", size = 221825, upload-time = "2025-02-03T15:32:25.093Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/55/79/de6c16cc902f4fc372236926b0ce2ab7845268dcc30fb2fbb7f71b418631/marshmallow-3.26.2.tar.gz", hash = "sha256:bbe2adb5a03e6e3571b573f42527c6fe926e17467833660bebd11593ab8dfd57", size = 222095, upload-time = "2025-12-22T06:53:53.309Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/34/75/51952c7b2d3873b44a0028b1bd26a25078c18f92f256608e8d1dc61b39fd/marshmallow-3.26.1-py3-none-any.whl", hash = "sha256:3350409f20a70a7e4e11a27661187b77cdcaeb20abca41c1454fe33636bea09c", size = 50878, upload-time = "2025-02-03T15:32:22.295Z" },
+    { url = "https://files.pythonhosted.org/packages/be/2f/5108cb3ee4ba6501748c4908b908e55f42a5b66245b4cfe0c99326e1ef6e/marshmallow-3.26.2-py3-none-any.whl", hash = "sha256:013fa8a3c4c276c24d26d84ce934dc964e2aa794345a0f8c7e5a7191482c8a73", size = 50964, upload-time = "2025-12-22T06:53:51.801Z" },
 ]
 
 [[package]]
@@ -2062,16 +2113,16 @@ wheels = [
 
 [[package]]
 name = "pydantic-settings"
-version = "2.14.0"
+version = "2.14.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pydantic" },
     { name = "python-dotenv" },
     { name = "typing-inspection" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/42/98/c8345dccdc31de4228c039a98f6467a941e39558da41c1744fbe29fa5666/pydantic_settings-2.14.0.tar.gz", hash = "sha256:24285fd4b0e0c06507dd9fdfd331ee23794305352aaec8fc4eb92d4047aeb67d", size = 235709, upload-time = "2026-04-20T13:37:40.293Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/5c/b5/8f48e906c3e0205276e8bd8cb7512217a87b2685304d64be27cad5b3019f/pydantic_settings-2.14.2.tar.gz", hash = "sha256:c19dd64b19097f1de80184f0cc7b0272a13ae6e170cbf240a3e27e381ed14a5f", size = 237700, upload-time = "2026-06-19T13:44:56.324Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/01/dd/bebff3040138f00ae8a102d426b27349b9a49acc310fcae7f92112d867e3/pydantic_settings-2.14.0-py3-none-any.whl", hash = "sha256:fc8d5d692eb7092e43c8647c1c35a3ecd00e040fcf02ed86f4cb5458ca62182e", size = 60940, upload-time = "2026-04-20T13:37:38.586Z" },
+    { url = "https://files.pythonhosted.org/packages/77/c1/6e422f34e569cf8e18df68d1939c81c099d2b61e4f7d9621c8a77560799c/pydantic_settings-2.14.2-py3-none-any.whl", hash = "sha256:a20c97b37910b6550d5ea50fbcc2d4187defe58cd57070b73863d069419c9440", size = 61715, upload-time = "2026-06-19T13:44:55.02Z" },
 ]
 
 [[package]]
@@ -2085,11 +2136,11 @@ wheels = [
 
 [[package]]
 name = "pyjwt"
-version = "2.10.1"
+version = "2.13.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e7/46/bd74733ff231675599650d3e47f361794b22ef3e3770998dda30d3b63726/pyjwt-2.10.1.tar.gz", hash = "sha256:3cc5772eb20009233caf06e9d8a0577824723b44e6648ee0a2aedb6cf9381953", size = 87785, upload-time = "2024-11-28T03:43:29.933Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/3b/81/58d0ac84e1ef3a3843791d6954d94c0b33d526c75eeb1efbce9d0a4c4077/pyjwt-2.13.0.tar.gz", hash = "sha256:41571c89ca91598c79e8ef18a2d07367d4810fbbd6f637794879baf1b7703423", size = 107515, upload-time = "2026-05-21T19:54:36.618Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/61/ad/689f02752eeec26aed679477e80e632ef1b682313be70793d798c1d5fc8f/PyJWT-2.10.1-py3-none-any.whl", hash = "sha256:dcdd193e30abefd5debf142f9adfcdd2b58004e644f25406ffaebd50bd98dacb", size = 22997, upload-time = "2024-11-28T03:43:27.893Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/5e/ecf12fdb62546d64385c158514e9b2b671f7832108ef2ecd2020ce0af2d1/pyjwt-2.13.0-py3-none-any.whl", hash = "sha256:66adcc2aff09b3f1bbd95fc1e1577df8ac8723c978552fd43304c8a290ac5728", size = 31274, upload-time = "2026-05-21T19:54:35.362Z" },
 ]
 
 [[package]]
@@ -2149,11 +2200,11 @@ wheels = [
 
 [[package]]
 name = "python-dotenv"
-version = "1.1.1"
+version = "1.2.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f6/b0/4bc07ccd3572a2f9df7e6782f52b0c6c90dcbb803ac4a167702d7d0dfe1e/python_dotenv-1.1.1.tar.gz", hash = "sha256:a8a6399716257f45be6a007360200409fce5cda2661e3dec71d23dc15f6189ab", size = 41978, upload-time = "2025-06-24T04:21:07.341Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135, upload-time = "2026-03-01T16:00:26.196Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/ed/539768cf28c661b5b068d66d96a2f155c4971a5d55684a514c1a0e0dec2f/python_dotenv-1.1.1-py3-none-any.whl", hash = "sha256:31f23644fe2602f88ff55e1f5c79ba497e01224ee7737937930c448e4d0e24dc", size = 20556, upload-time = "2025-06-24T04:21:06.073Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" },
 ]
 
 [[package]]
@@ -2167,11 +2218,11 @@ wheels = [
 
 [[package]]
 name = "python-multipart"
-version = "0.0.20"
+version = "0.0.32"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f3/87/f44d7c9f274c7ee665a29b885ec97089ec5dc034c7f3fafa03da9e39a09e/python_multipart-0.0.20.tar.gz", hash = "sha256:8dd0cab45b8e23064ae09147625994d090fa46f5b0d1e13af944c331a7fa9d13", size = 37158, upload-time = "2024-12-16T19:45:46.972Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/5b/42/55c32bb9b12693c092ad250a0e82edb5b31ddeda6eb772de5f308b3804ad/python_multipart-0.0.32.tar.gz", hash = "sha256:be54b7f3fa167bb83e4fcd936b887b708f4e57fe75911c02aebf53efaf8d938e", size = 46881, upload-time = "2026-06-04T16:18:58.647Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/45/58/38b5afbc1a800eeea951b9285d3912613f2603bdf897a4ab0f4bd7f405fc/python_multipart-0.0.20-py3-none-any.whl", hash = "sha256:8a62d3a8335e06589fe01f2a3e178cdcc632f3fbe0d492ad9ee0ec35aab1f104", size = 24546, upload-time = "2024-12-16T19:45:44.423Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/04/e8135ebd1ad02c56ec633277529b2602ff99ff634be76cdba5744cf554fd/python_multipart-0.0.32-py3-none-any.whl", hash = "sha256:ff6d3f776f16878c894e52e107296ffc890e913c611b1a4ec6c44e2821fe2e23", size = 30042, upload-time = "2026-06-04T16:18:57.319Z" },
 ]
 
 [[package]]
@@ -2384,7 +2435,7 @@ wheels = [
 
 [[package]]
 name = "routstr"
-version = "0.4.4"
+version = "0.4.3"
 source = { editable = "." }
 dependencies = [
     { name = "aiosqlite" },
@@ -2392,7 +2443,6 @@ dependencies = [
     { name = "cashu" },
     { name = "fastapi", extra = ["standard"] },
     { name = "greenlet" },
-    { name = "h11" },
     { name = "httpx", extra = ["socks"] },
     { name = "litellm" },
     { name = "marshmallow" },
@@ -2427,7 +2477,6 @@ requires-dist = [
     { name = "cashu", specifier = ">=0.20" },
     { name = "fastapi", extras = ["standard"], specifier = ">=0.115" },
     { name = "greenlet", specifier = ">=3.2.1" },
-    { name = "h11", specifier = ">=0.14" },
     { name = "httpx", extras = ["socks"], specifier = ">=0.25.2" },
     { name = "litellm", specifier = ">=1.55.0" },
     { name = "marshmallow", specifier = ">=3.13,<4.0" },
@@ -2910,11 +2959,11 @@ wheels = [
 
 [[package]]
 name = "urllib3"
-version = "2.6.3"
+version = "2.7.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" }
 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" },
+    { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" },
 ]
 
 [[package]]