feat: add option to disable testnut mock upstream

.github/workflows/test.yml

@@ -59,30 +59,25 @@ jobs:
       - name: Checkout code
         uses: actions/checkout@v4
 
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 10
-
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
           node-version: "18"
-          cache: "pnpm"
-          cache-dependency-path: ui/pnpm-lock.yaml
+          cache: "npm"
+          cache-dependency-path: ui/package-lock.json
 
       - name: Install UI dependencies
         working-directory: ./ui
-        run: pnpm install --frozen-lockfile
+        run: npm ci
 
       - name: Run UI format check
         working-directory: ./ui
-        run: pnpm run format-check
+        run: npm run format-check
 
       - name: Run UI linting
         working-directory: ./ui
-        run: pnpm run lint
+        run: npm run lint
 
       - name: Run UI build
         working-directory: ./ui
-        run: pnpm run build
+        run: npm run build

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "routstr"
-version = "0.2.2"
+version = "0.2.1"
 description = "Payment proxy for your LLM endpoint using cashu and nostr."
 readme = "README.md"
 requires-python = ">=3.11"

routstr/auth.py

@@ -441,29 +441,6 @@ async def adjust_payment_for_tokens(
         },
     )
 
-    async def release_reservation_only() -> None:
-        """Fallback to release reservation without charging when main update fails."""
-        try:
-            release_stmt = (
-                update(ApiKey)
-                .where(col(ApiKey.hashed_key) == key.hashed_key)
-                .values(reserved_balance=col(ApiKey.reserved_balance) - deducted_max_cost)
-            )
-            await session.exec(release_stmt)  # type: ignore[call-overload]
-            await session.commit()
-            logger.warning(
-                "Released reservation without charging (fallback)",
-                extra={
-                    "key_hash": key.hashed_key[:8] + "...",
-                    "deducted_max_cost": deducted_max_cost,
-                },
-            )
-        except Exception as e:
-            logger.error(
-                "Failed to release reservation in fallback",
-                extra={"error": str(e), "key_hash": key.hashed_key[:8] + "..."},
-            )
-
     match await calculate_cost(response_data, deducted_max_cost, session):
         case MaxCostData() as cost:
             logger.debug(
@@ -488,7 +465,7 @@ async def adjust_payment_for_tokens(
             await session.commit()
             if result.rowcount == 0:
                 logger.error(
-                    "Failed to finalize max-cost payment - retrying reservation release",
+                    "Failed to finalize max-cost payment - insufficient reserved balance",
                     extra={
                         "key_hash": key.hashed_key[:8] + "...",
                         "deducted_max_cost": deducted_max_cost,
@@ -497,7 +474,6 @@ async def adjust_payment_for_tokens(
                         "model": model,
                     },
                 )
-                await release_reservation_only()
             else:
                 await session.refresh(key)
                 logger.info(
@@ -592,14 +568,13 @@ async def adjust_payment_for_tokens(
                     )
                 else:
                     logger.warning(
-                        "Failed to finalize additional charge - releasing reservation",
+                        "Failed to finalize additional charge (concurrent operation)",
                         extra={
                             "key_hash": key.hashed_key[:8] + "...",
                             "attempted_charge": total_cost_msats,
                             "model": model,
                         },
                     )
-                    await release_reservation_only()
             else:
                 # Refund some of the base cost
                 refund = abs(cost_difference)
@@ -628,7 +603,7 @@ async def adjust_payment_for_tokens(
 
                 if result.rowcount == 0:
                     logger.error(
-                        "Failed to finalize payment - releasing reservation",
+                        "Failed to finalize payment - insufficient reserved balance",
                         extra={
                             "key_hash": key.hashed_key[:8] + "...",
                             "deducted_max_cost": deducted_max_cost,
@@ -637,27 +612,28 @@ async def adjust_payment_for_tokens(
                             "model": model,
                         },
                     )
-                    await release_reservation_only()
-                else:
-                    cost.total_msats = total_cost_msats
-                    await session.refresh(key)
+                    # Still return the cost data even if we couldn't properly finalize
+                    # The reservation was already made, so the user has paid
 
-                    logger.info(
-                        "Refund processed successfully",
-                        extra={
-                            "key_hash": key.hashed_key[:8] + "...",
-                            "refunded_amount": refund,
-                            "new_balance": key.balance,
-                            "final_cost": cost.total_msats,
-                            "model": model,
-                        },
-                    )
+                cost.total_msats = total_cost_msats
+                await session.refresh(key)
+
+                logger.info(
+                    "Refund processed successfully",
+                    extra={
+                        "key_hash": key.hashed_key[:8] + "...",
+                        "refunded_amount": refund,
+                        "new_balance": key.balance,
+                        "final_cost": cost.total_msats,
+                        "model": model,
+                    },
+                )
 
             return cost.dict()
 
         case CostDataError() as error:
             logger.error(
-                "Cost calculation error during payment adjustment - releasing reservation",
+                "Cost calculation error during payment adjustment",
                 extra={
                     "key_hash": key.hashed_key[:8] + "...",
                     "model": model,
@@ -665,7 +641,6 @@ async def adjust_payment_for_tokens(
                     "error_code": error.code,
                 },
             )
-            await release_reservation_only()
 
             raise HTTPException(
                 status_code=400,
@@ -677,12 +652,7 @@ async def adjust_payment_for_tokens(
                     }
                 },
             )
-    # Fallback: should not reach here, but release reservation just in case
-    logger.error(
-        "Unexpected fallback in adjust_payment_for_tokens - releasing reservation",
-        extra={"key_hash": key.hashed_key[:8] + "...", "model": model},
-    )
-    await release_reservation_only()
+    # Fallback return to satisfy type checker; execution should not reach here
     return {
         "base_msats": deducted_max_cost,
         "input_msats": 0,

routstr/balance.py

@@ -154,8 +154,7 @@ async def refund_wallet_endpoint(
         return cached
 
     key: ApiKey = await validate_bearer_key(bearer_value, session)
-
-    remaining_balance_msats: int = key.total_balance
+    remaining_balance_msats: int = key.balance
 
     if key.refund_currency == "sat":
         remaining_balance = remaining_balance_msats // 1000

routstr/core/db.py

@@ -6,7 +6,7 @@ from typing import AsyncGenerator
 from alembic import command
 from alembic.config import Config
 from sqlalchemy.ext.asyncio.engine import create_async_engine
-from sqlmodel import Field, Relationship, SQLModel, func, select, update
+from sqlmodel import Field, Relationship, SQLModel, func, select
 from sqlmodel.ext.asyncio.session import AsyncSession
 
 from .logging import get_logger
@@ -53,14 +53,6 @@ class ApiKey(SQLModel, table=True):  # type: ignore
         return self.balance - self.reserved_balance
 
 
-async def reset_all_reserved_balances(session: AsyncSession) -> None:
-    logger.info("Resetting all reserved balances to 0")
-    stmt = update(ApiKey).values(reserved_balance=0)
-    await session.exec(stmt)  # type: ignore[call-overload]
-    await session.commit()
-    logger.info("Reserved balances reset successfully")
-
-
 class ModelRow(SQLModel, table=True):  # type: ignore
     __tablename__ = "models"
     id: str = Field(primary_key=True)

routstr/core/main.py

@@ -33,9 +33,9 @@ setup_logging()
 logger = get_logger(__name__)
 
 if os.getenv("VERSION_SUFFIX") is not None:
-    __version__ = f"0.2.2-{os.getenv('VERSION_SUFFIX')}"
+    __version__ = f"0.2.1-{os.getenv('VERSION_SUFFIX')}"
 else:
-    __version__ = "0.2.2"
+    __version__ = "0.2.1"
 
 
 @asynccontextmanager
@@ -61,10 +61,6 @@ async def lifespan(_: FastAPI) -> AsyncGenerator[None, None]:
         # Initialize application settings (env -> computed -> DB precedence)
         async with create_session() as session:
             s = await SettingsService.initialize(session)
-            if s.reset_reserved_balance_on_startup:
-                from .db import reset_all_reserved_balances
-
-                await reset_all_reserved_balances(session)
 
         # Apply app metadata from settings
         try:

routstr/core/settings.py

@@ -47,6 +47,9 @@ class Settings(BaseSettings):
     receive_ln_address: str = Field(default="", env="RECEIVE_LN_ADDRESS")
     primary_mint: str = Field(default="", env="PRIMARY_MINT_URL")
     primary_mint_unit: str = Field(default="sat", env="PRIMARY_MINT_UNIT")
+    disable_testnut_mock_upstream: bool = Field(
+        default=False, env="DISABLE_TESTNUT_MOCK_UPSTREAM"
+    )
 
     # Pricing
     # Default behavior: derive pricing from MODELS
@@ -61,9 +64,6 @@ class Settings(BaseSettings):
     tolerance_percentage: float = Field(default=1.0, env="TOLERANCE_PERCENTAGE")
     # Minimum per-request charge in millisatoshis when model pricing is free/zero
     min_request_msat: int = Field(default=1, env="MIN_REQUEST_MSAT")
-    reset_reserved_balance_on_startup: bool = Field(
-        default=True, env="RESET_RESERVED_BALANCE_ON_STARTUP"
-    )  # deactivate in horizontal scaling setups
 
     # Network
     cors_origins: list[str] = Field(default_factory=lambda: ["*"], env="CORS_ORIGINS")

routstr/payment/lnurl.py

@@ -283,7 +283,7 @@ async def raw_send_to_lnurl(
             f"({min_sendable_sat} - {max_sendable_sat} {unit})"
         )
 
-    estimated_fees_sat = int(max(math.ceil((amount_msat / 1000) * 0.01), 2)) + 1
+    estimated_fees_sat = int(max(math.ceil((amount_msat / 1000) * 0.01), 2))
     estimated_fees_msat = estimated_fees_sat * 1000
     final_amount = amount_msat - estimated_fees_msat
 

routstr/proxy.py

@@ -148,7 +148,10 @@ async def proxy(
     else:
         model_id = request_body_dict.get("model", "unknown")
 
-    if "https://testnut.cashu.space" in settings.cashu_mints:
+    if (
+        "https://testnut.cashu.space" in settings.cashu_mints
+        and not settings.disable_testnut_mock_upstream
+    ):
         try:
             token_str = None
             if x_cashu_header := headers.get("x-cashu"):

routstr/upstream/base.py

@@ -447,11 +447,6 @@ class BaseUpstreamProvider:
                 async with create_session() as new_session:
                     fresh_key = await new_session.get(key.__class__, key.hashed_key)
                     if not fresh_key:
-                        logger.warning(
-                            "Key not found when finalizing streaming payment",
-                            extra={"key_hash": key.hashed_key[:8] + "..."},
-                        )
-                        usage_finalized = True
                         return None
                     try:
                         fallback: dict = {
@@ -480,7 +475,6 @@ class BaseUpstreamProvider:
                                 "key_hash": key.hashed_key[:8] + "...",
                             },
                         )
-                        usage_finalized = True
                         return None
 
             try:
@@ -590,10 +584,8 @@ class BaseUpstreamProvider:
                         "key_hash": key.hashed_key[:8] + "...",
                     },
                 )
+                await finalize_without_usage()
                 raise
-            finally:
-                if not usage_finalized:
-                    await finalize_without_usage()
 
         # Remove inaccurate encoding headers from upstream response
         response_headers = dict(response.headers)
@@ -746,11 +738,6 @@ class BaseUpstreamProvider:
                 async with create_session() as new_session:
                     fresh_key = await new_session.get(key.__class__, key.hashed_key)
                     if not fresh_key:
-                        logger.warning(
-                            "Key not found when finalizing Responses API streaming payment",
-                            extra={"key_hash": key.hashed_key[:8] + "..."},
-                        )
-                        usage_finalized = True
                         return None
                     try:
                         fallback: dict = {
@@ -779,7 +766,6 @@ class BaseUpstreamProvider:
                                 "key_hash": key.hashed_key[:8] + "...",
                             },
                         )
-                        usage_finalized = True
                         return None
 
             try:
@@ -904,10 +890,8 @@ class BaseUpstreamProvider:
                         "key_hash": key.hashed_key[:8] + "...",
                     },
                 )
+                await finalize_without_usage()
                 raise
-            finally:
-                if not usage_finalized:
-                    await finalize_without_usage()
 
         # Remove inaccurate encoding headers from upstream response
         response_headers = dict(response.headers)
@@ -1026,208 +1010,6 @@ class BaseUpstreamProvider:
             )
             raise
 
-    async def _finalize_generic_streaming_payment(
-        self, key_hash: str, max_cost: int, path: str
-    ) -> None:
-        """Background task to finalize payment for generic streaming requests."""
-        async with create_session() as session:
-            key = await session.get(ApiKey, key_hash)
-            if not key:
-                logger.warning(
-                    "Key not found during background payment finalization",
-                    extra={"key_hash": key_hash[:8] + "..."},
-                )
-                return
-
-            try:
-                # Finalize with "unknown" model and no usage to release reservation/charge max cost
-                await adjust_payment_for_tokens(
-                    key,
-                    {"model": "unknown", "usage": None},
-                    session,
-                    max_cost,
-                )
-                logger.info(
-                    "Finalized generic streaming payment in background",
-                    extra={
-                        "path": path,
-                        "key_hash": key_hash[:8] + "...",
-                    },
-                )
-            except Exception as e:
-                logger.error(
-                    "Error finalizing generic streaming payment in background",
-                    extra={
-                        "error": str(e),
-                        "key_hash": key_hash[:8] + "...",
-                        "path": path,
-                    },
-                )
-
-    async def handle_streaming_messages_completion(
-        self, response: httpx.Response, key: ApiKey, max_cost_for_model: int
-    ) -> StreamingResponse:
-        async def stream_with_cost(
-            max_cost_for_model: int,
-        ) -> AsyncGenerator[bytes, None]:
-            stored_chunks: list[bytes] = []
-            usage_finalized: bool = False
-            last_model_seen: str | None = None
-            input_tokens: int = 0
-            output_tokens: int = 0
-
-            async def finalize_without_usage() -> bytes | None:
-                nonlocal usage_finalized
-                if usage_finalized:
-                    return None
-                async with create_session() as new_session:
-                    fresh_key = await new_session.get(key.__class__, key.hashed_key)
-                    if not fresh_key:
-                        usage_finalized = True
-                        return None
-                    try:
-                        fallback: dict = {
-                            "model": last_model_seen or "unknown",
-                            "usage": None,
-                        }
-                        cost_data = await adjust_payment_for_tokens(
-                            fresh_key, fallback, new_session, max_cost_for_model
-                        )
-                        usage_finalized = True
-                        return f"event: cost\ndata: {json.dumps({'cost': cost_data})}\n\n".encode()
-                    except Exception:
-                        usage_finalized = True
-                        return None
-
-            try:
-                async for chunk in response.aiter_bytes():
-                    stored_chunks.append(chunk)
-                    try:
-                        decoded_chunk = chunk.decode("utf-8", errors="ignore")
-                        for line in decoded_chunk.split("\n"):
-                            if line.startswith("data: "):
-                                try:
-                                    data = json.loads(line[6:])
-                                    if isinstance(data, dict):
-                                        msg = data.get("message", {})
-                                        if msg and msg.get("model"):
-                                            last_model_seen = str(msg.get("model"))
-
-                                        if usage := msg.get("usage"):
-                                            input_tokens += usage.get("input_tokens", 0)
-                                            output_tokens += usage.get(
-                                                "output_tokens", 0
-                                            )
-
-                                        if usage := data.get("usage"):
-                                            input_tokens += usage.get("input_tokens", 0)
-                                            output_tokens += usage.get(
-                                                "output_tokens", 0
-                                            )
-                                except json.JSONDecodeError:
-                                    pass
-                    except Exception:
-                        pass
-
-                    yield chunk
-
-                usage_data = {
-                    "input_tokens": input_tokens,
-                    "output_tokens": output_tokens,
-                }
-
-                if input_tokens > 0 or output_tokens > 0:
-                    async with create_session() as new_session:
-                        fresh_key = await new_session.get(key.__class__, key.hashed_key)
-                        if fresh_key:
-                            try:
-                                combined_data = {
-                                    "model": last_model_seen or "unknown",
-                                    "usage": usage_data,
-                                }
-                                cost_data = await adjust_payment_for_tokens(
-                                    fresh_key,
-                                    combined_data,
-                                    new_session,
-                                    max_cost_for_model,
-                                )
-                                usage_finalized = True
-                                yield f"event: cost\ndata: {json.dumps({'cost': cost_data})}\n\n".encode()
-                            except Exception:
-                                pass
-
-                if not usage_finalized:
-                    maybe_cost_event = await finalize_without_usage()
-                    if maybe_cost_event is not None:
-                        yield maybe_cost_event
-
-            except Exception:
-                if not usage_finalized:
-                    await finalize_without_usage()
-                raise
-            finally:
-                if not usage_finalized:
-                    await finalize_without_usage()
-
-        response_headers = dict(response.headers)
-        response_headers.pop("content-encoding", None)
-        response_headers.pop("content-length", None)
-
-        return StreamingResponse(
-            stream_with_cost(max_cost_for_model),
-            status_code=response.status_code,
-            headers=response_headers,
-        )
-
-    async def handle_non_streaming_messages_completion(
-        self,
-        response: httpx.Response,
-        key: ApiKey,
-        session: AsyncSession,
-        deducted_max_cost: int,
-        path: str,
-    ) -> Response:
-        try:
-            content = await response.aread()
-            response_json = json.loads(content)
-
-            if path.endswith("count_tokens") and "usage" not in response_json:
-                input_tokens = response_json.get("input_tokens", 0)
-                response_json["usage"] = {"input_tokens": input_tokens}
-
-            cost_data = await adjust_payment_for_tokens(
-                key, response_json, session, deducted_max_cost
-            )
-            response_json["cost"] = cost_data
-
-            allowed_headers = {
-                "content-type",
-                "cache-control",
-                "date",
-                "vary",
-                "access-control-allow-origin",
-                "access-control-allow-methods",
-                "access-control-allow-headers",
-                "access-control-allow-credentials",
-                "access-control-expose-headers",
-                "access-control-max-age",
-            }
-
-            response_headers = {
-                k: v
-                for k, v in response.headers.items()
-                if k.lower() in allowed_headers
-            }
-
-            return Response(
-                content=json.dumps(response_json).encode(),
-                status_code=response.status_code,
-                headers=response_headers,
-                media_type="application/json",
-            )
-        except Exception:
-            raise
-
     async def forward_request(
         self,
         request: Request,
@@ -1321,54 +1103,7 @@ class BaseUpstreamProvider:
                     await client.aclose()
                 return mapped_error
 
-            if (
-                path.endswith("chat/completions")
-                or path.endswith("embeddings")
-                or path.endswith("messages")
-                or path.endswith("messages/count_tokens")
-            ):
-                if path.endswith("messages"):
-                    client_wants_streaming = False
-                    if request_body:
-                        try:
-                            request_data = json.loads(request_body)
-                            client_wants_streaming = request_data.get("stream", False)
-                        except json.JSONDecodeError:
-                            pass
-
-                    content_type = response.headers.get("content-type", "")
-                    upstream_is_streaming = "text/event-stream" in content_type
-                    is_streaming = client_wants_streaming and upstream_is_streaming
-
-                    if is_streaming and response.status_code == 200:
-                        result = await self.handle_streaming_messages_completion(
-                            response, key, max_cost_for_model
-                        )
-                        background_tasks = BackgroundTasks()
-                        background_tasks.add_task(response.aclose)
-                        background_tasks.add_task(client.aclose)
-                        result.background = background_tasks
-                        return result
-
-                    if response.status_code == 200:
-                        try:
-                            return await self.handle_non_streaming_messages_completion(
-                                response, key, session, max_cost_for_model, path
-                            )
-                        finally:
-                            await response.aclose()
-                            await client.aclose()
-
-                if path.endswith("messages/count_tokens"):
-                    if response.status_code == 200:
-                        try:
-                            return await self.handle_non_streaming_messages_completion(
-                                response, key, session, max_cost_for_model, path
-                            )
-                        finally:
-                            await response.aclose()
-                            await client.aclose()
-
+            if path.endswith("chat/completions") or path.endswith("embeddings"):
                 if path.endswith("chat/completions"):
                     client_wants_streaming = False
                     if request_body:
@@ -1426,12 +1161,6 @@ class BaseUpstreamProvider:
             background_tasks = BackgroundTasks()
             background_tasks.add_task(response.aclose)
             background_tasks.add_task(client.aclose)
-            background_tasks.add_task(
-                self._finalize_generic_streaming_payment,
-                key.hashed_key,
-                max_cost_for_model,
-                path,
-            )
 
             logger.debug(
                 "Streaming non-chat response",
@@ -1635,15 +1364,9 @@ class BaseUpstreamProvider:
             background_tasks = BackgroundTasks()
             background_tasks.add_task(response.aclose)
             background_tasks.add_task(client.aclose)
-            background_tasks.add_task(
-                self._finalize_generic_streaming_payment,
-                key.hashed_key,
-                max_cost_for_model,
-                path,
-            )
 
             logger.debug(
-                "Streaming non-Responses API response",
+                "Streaming non-chat response",
                 extra={
                     "path": path,
                     "status_code": response.status_code,

routstr/upstream/gemini.py

@@ -187,44 +187,11 @@ class GeminiUpstreamProvider(BaseUpstreamProvider):
                 )
 
                 async def stream_with_cost() -> AsyncGenerator[bytes, None]:
-                    payment_finalized = False
-
-                    async def finalize_payment() -> None:
-                        nonlocal payment_finalized
-                        if payment_finalized:
-                            return
-                        from ..auth import adjust_payment_for_tokens
-                        from ..core.db import create_session
-
-                        async with create_session() as new_session:
-                            fresh_key = await new_session.get(
-                                key.__class__, key.hashed_key
-                            )
-                            if fresh_key:
-                                try:
-                                    await adjust_payment_for_tokens(
-                                        fresh_key,
-                                        {
-                                            "model": model_obj.id,
-                                            "usage": final_usage_data,
-                                        },
-                                        new_session,
-                                        max_cost_for_model,
-                                    )
-                                    payment_finalized = True
-                                except Exception as cost_error:
-                                    logger.error(
-                                        "Error finalizing Gemini streaming payment in fallback",
-                                        extra={
-                                            "error": str(cost_error),
-                                            "key_hash": key.hashed_key[:8] + "...",
-                                        },
-                                    )
-
                     try:
                         async for chunk in response_generator:
                             sse_data = f"data: {json.dumps(chunk)}\n\n"
                             yield sse_data.encode()
+
                     except Exception as e:
                         logger.error(
                             "Error in Gemini streaming response",
@@ -235,9 +202,6 @@ class GeminiUpstreamProvider(BaseUpstreamProvider):
                             },
                         )
                         raise
-                    finally:
-                        if not payment_finalized:
-                            await finalize_payment()
 
                 return StreamingResponse(
                     stream_with_cost(),

routstr/upstream/helpers.py

@@ -218,7 +218,10 @@ async def init_upstreams() -> list[BaseUpstreamProvider]:
         results = await asyncio.gather(*tasks)
         upstreams = [p for p in results if p is not None]
 
-        if "https://testnut.cashu.space" in settings.cashu_mints:
+        if (
+            "https://testnut.cashu.space" in settings.cashu_mints
+            and not settings.disable_testnut_mock_upstream
+        ):
             from .fake import MockUpstreamProvider
 
             mock_provider = MockUpstreamProvider("mock", "mock")

routstr/wallet.py

@@ -81,7 +81,7 @@ async def swap_to_primary_mint(
         amount_msat = token_amount
     else:
         raise ValueError("Invalid unit")
-    estimated_fee_sat = math.ceil(max(amount_msat // 1000 * 0.01, 2)) + 1
+    estimated_fee_sat = math.ceil(max(amount_msat // 1000 * 0.01, 2))
     amount_msat_after_fee = amount_msat - estimated_fee_sat * 1000
     primary_wallet = await get_wallet(settings.primary_mint, settings.primary_mint_unit)
 
@@ -313,7 +313,10 @@ async def periodic_payout() -> None:
         try:
             async with db.create_session() as session:
                 for mint_url in settings.cashu_mints:
-                    if mint_url == "https://testnut.cashu.space":
+                    if (
+                        mint_url == "https://testnut.cashu.space"
+                        and not settings.disable_testnut_mock_upstream
+                    ):
                         continue
                     for unit in ["sat", "msat"]:
                         wallet = await get_wallet(mint_url, unit)

scripts/reproduce_bug_staging.py

@@ -1,101 +0,0 @@
-import asyncio
-
-import httpx
-
-BASE_URL = input("Enter routstr URL: ")
-API_KEY = input("Enter key or token: ")
-
-
-async def get_balance(client: httpx.AsyncClient) -> int:
-    response = await client.get("/v1/balance/info")
-    response.raise_for_status()
-    data = response.json()
-    print(f"Current Balance Info: {data}")
-    return data.get("reserved", 0)
-
-
-async def reproduce() -> None:
-    headers = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}
-
-    async with httpx.AsyncClient(
-        base_url=BASE_URL, headers=headers, timeout=30.0
-    ) as client:
-        print("Checking initial balance...")
-        try:
-            initial_reserved = await get_balance(client)
-        except Exception as e:
-            print(f"Failed to get balance: {e}")
-            return
-
-        print("\nStarting streaming request...")
-        try:
-            # Create a separate client for the stream so we can close it independently if needed,
-            # but usually just breaking the loop and exiting the context manager is enough.
-            # However, to be sure we simulate a harsh disconnect, we can just cancel the task or close the client.
-
-            async with client.stream(
-                "POST",
-                "/v1/chat/completions",
-                json={
-                    "model": "gpt-5-nano",
-                    "messages": [
-                        {
-                            "role": "user",
-                            "content": "Write a long poem about the ocean.",
-                        }
-                    ],
-                    "stream": True,
-                },
-            ) as response:
-                print(f"Stream status: {response.status_code}")
-                if response.status_code != 200:
-                    err_bytes = await response.aread()
-                    try:
-                        err_str = err_bytes.decode()
-                    except Exception:
-                        err_str = repr(err_bytes)
-                    print(f"Error: {err_str}")
-                    return
-
-                print("Stream started. Reading a few chunks...")
-                count = 0
-                async for chunk in response.aiter_bytes():
-                    print(f"Received chunk: {len(chunk)} bytes")
-                    count += 1
-                    if count >= 3:
-                        print("Simulating client disconnect (breaking stream)...")
-                        break
-
-        except Exception as e:
-            print(f"Stream interrupted (expected): {e}")
-
-        # Wait a bit for the server to realize we disconnected (though with asyncio it might be immediate or depend on keepalive)
-        print("\nWaiting for server to process disconnect...")
-        await asyncio.sleep(21)
-
-        print("\nChecking final balance...")
-        try:
-            final_reserved = await get_balance(client)
-        except Exception:
-            # Retry once if connection was closed
-            async with httpx.AsyncClient(
-                base_url=BASE_URL, headers=headers, timeout=30.0
-            ) as new_client:
-                final_reserved = await get_balance(new_client)
-
-        if final_reserved > initial_reserved:
-            print(
-                f"\n[FAIL] Bug reproduced! Reserved balance increased: {initial_reserved} -> {final_reserved}"
-            )
-            print(f"Accumulated reserved balance: {final_reserved - initial_reserved}")
-        else:
-            print(
-                f"\n[PASS] Reserved balance released correctly: {initial_reserved} -> {final_reserved}"
-            )
-
-
-if __name__ == "__main__":
-    try:
-        asyncio.run(reproduce())
-    except KeyboardInterrupt:
-        pass

ui/Dockerfile

@@ -4,22 +4,17 @@ FROM base AS deps
 RUN apk add --no-cache libc6-compat
 WORKDIR /app
 
-RUN corepack enable pnpm && corepack prepare pnpm@latest --activate
-
-COPY package.json pnpm-lock.yaml* ./
-RUN pnpm install --frozen-lockfile
+COPY package.json yarn.lock* package-lock.json* pnpm-lock.yaml* .npmrc* ./
+RUN npm i
 
 FROM base AS builder
 WORKDIR /app
-
-RUN corepack enable pnpm && corepack prepare pnpm@latest --activate
-
 COPY --from=deps /app/node_modules ./node_modules
 COPY . .
 
 ENV NEXT_TELEMETRY_DISABLED=1
 
-RUN pnpm run build
+RUN npm run build
 FROM base AS runner
 WORKDIR /app
 

ui/Dockerfile.build

@@ -6,14 +6,12 @@ RUN apk add --no-cache libc6-compat
 WORKDIR /app
 
 # Copy package files
-COPY package.json pnpm-lock.yaml* ./
-RUN corepack enable pnpm && corepack prepare pnpm@latest --activate
-RUN pnpm install --frozen-lockfile
+COPY package.json package-lock.json* pnpm-lock.yaml* ./
+RUN npm ci
 
 # Build the UI
 FROM base AS builder
 WORKDIR /app
-RUN corepack enable pnpm && corepack prepare pnpm@latest --activate
 COPY --from=deps /app/node_modules ./node_modules
 COPY . .
 
@@ -29,7 +27,7 @@ ENV NODE_ENV=production
 ENV NEXT_TELEMETRY_DISABLED=1
 
 # Build the application
-RUN pnpm run build && \
+RUN npm run build && \
     echo "UI build completed at $(date)"
 
 # Use the builder stage as the final stage

ui/app/providers/page.tsx

@@ -208,12 +208,7 @@ function ProviderBalance({
     return <Skeleton className='h-9 w-24' />;
   }
 
-  if (
-    error ||
-    !balanceData?.ok ||
-    balanceData.balance_data === undefined ||
-    balanceData.balance_data === null
-  ) {
+  if (error || !balanceData?.ok || !balanceData.balance_data) {
     return null;
   }
 

ui/package.json

@@ -15,7 +15,6 @@
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/modifiers": "^9.0.0",
     "@dnd-kit/sortable": "^10.0.0",
-    "@dnd-kit/utilities": "^3.2.2",
     "@hookform/resolvers": "^5.0.1",
     "@radix-ui/react-alert-dialog": "^1.1.10",
     "@radix-ui/react-avatar": "^1.1.6",
@@ -41,17 +40,17 @@
     "@radix-ui/react-toggle": "^1.1.6",
     "@radix-ui/react-toggle-group": "^1.1.6",
     "@radix-ui/react-tooltip": "^1.2.3",
-    "@tanstack/react-query": "^5.90.16",
+    "@tanstack/react-query": "^5.74.4",
     "@tanstack/react-table": "^8.21.3",
     "axios": "^1.13.2",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",
-    "date-fns": "^4.1.0",
+    "date-fns": "^3.6.0",
     "embla-carousel-react": "^8.6.0",
     "input-otp": "^1.4.2",
-    "lucide-react": "^0.562.0",
-    "next": "15.5.9",
+    "lucide-react": "^0.501.0",
+    "next": "15.3.1",
     "next-themes": "^0.4.6",
     "qrcode": "^1.5.4",
     "qrcode.react": "^4.2.0",
@@ -68,21 +67,21 @@
     "zustand": "^5.0.3"
   },
   "devDependencies": {
-    "@eslint/eslintrc": "^3.3.3",
-    "@tailwindcss/postcss": "^4.1.18",
-    "@tanstack/react-query-devtools": "^5.91.2",
+    "@eslint/eslintrc": "^3",
+    "@tailwindcss/postcss": "^4",
+    "@tanstack/react-query-devtools": "^5.74.4",
     "@types/node": "^20",
     "@types/qrcode": "^1.5.6",
     "@types/react": "^19",
     "@types/react-dom": "^19",
     "eslint": "^9.25.0",
-    "eslint-config-next": "15.5.9",
+    "eslint-config-next": "15.3.1",
     "eslint-config-prettier": "^10.1.2",
     "eslint-plugin-prettier": "^5.2.6",
     "eslint-plugin-react": "^7.37.5",
     "prettier": "^3.5.3",
     "prettier-plugin-tailwindcss": "^0.6.11",
-    "tailwindcss": "^4.1.18",
+    "tailwindcss": "^4",
     "typescript": "^5"
   }
 }

ui/tsconfig.json

@@ -22,12 +22,6 @@
       "@/*": ["./*"]
     }
   },
-  "include": [
-    "next-env.d.ts",
-    "**/*.ts",
-    "**/*.tsx",
-    ".next/types/**/*.ts",
-    ".next/dev/types/**/*.ts"
-  ],
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
   "exclude": ["node_modules"]
 }

uv.lock

@@ -1878,7 +1878,7 @@ wheels = [
 
 [[package]]
 name = "routstr"
-version = "0.2.2"
+version = "0.2.1"
 source = { editable = "." }
 dependencies = [
     { name = "aiosqlite" },