enforce model price calculation

.github/workflows/container.yml

@@ -14,14 +14,6 @@ jobs:
     steps:
       - name: Checkout code
         uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Resolve git metadata
-        id: gitmeta
-        run: |
-          echo "sha=$(git rev-parse --short=7 HEAD)" >> "$GITHUB_OUTPUT"
-          echo "tag=$(git describe --tags --exact-match HEAD 2>/dev/null || true)" >> "$GITHUB_OUTPUT"
 
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v2
@@ -38,9 +30,6 @@ jobs:
         with:
           context: .
           push: true
-          build-args: |
-            GIT_COMMIT=${{ steps.gitmeta.outputs.sha }}
-            GIT_TAG=${{ steps.gitmeta.outputs.tag }}
           tags: |
             ghcr.io/routstr/proxy:latest
             ghcr.io/routstr/core:latest

Dockerfile

@@ -21,10 +21,6 @@ WORKDIR /app
 
 COPY . .
 
-ARG GIT_COMMIT=""
-ARG GIT_TAG=""
-ENV GIT_COMMIT=${GIT_COMMIT}
-ENV GIT_TAG=${GIT_TAG}
 ENV PORT=8000
 ENV PYTHONUNBUFFERED=1
 

Dockerfile.full

@@ -41,10 +41,6 @@ RUN uv sync --no-dev
 # Copy the built UI from the ui-builder stage
 COPY --from=ui-builder /app/ui/out ./ui_out
 
-ARG GIT_COMMIT=""
-ARG GIT_TAG=""
-ENV GIT_COMMIT=${GIT_COMMIT}
-ENV GIT_TAG=${GIT_TAG}
 ENV PORT=8000
 ENV PYTHONUNBUFFERED=1
 

README.md

@@ -51,26 +51,14 @@ curl https://api.routstr.com/v1/chat/completions \
 
 ## Quick Start (Docker)
 
-If you are a node runner, start a Routstr Core instance using Docker Compose:
+If you are a node runner, start a Routstr Core instance and configure upstream access in the dashboard.
 
-1. **Prepare your `.env`**:
-   ```bash
-   ADMIN_PASSWORD=mysecretpassword
-   NAME="My AI Node"
-   DESCRIPTION="Fast access to models"
-   NSEC=yournsec
-   RECEIVE_LN_ADDRESS=yourname@wallet.com
-   ```
-
-2. **Start the services**:
-   ```bash
-   docker compose up -d
-   ```
-
-3. **Configure**:
-   Open [http://localhost:8000/admin/](http://localhost:8000/admin/) to connect your AI providers and set pricing.
-
-For full instructions, see the **[Provider Quick Start Guide](https://docs.routstr.com/provider/quickstart/)**.
+```bash
+docker run -d \
+  --name routstr-proxy \
+  -p 8000:8000 \
+  ghcr.io/routstr/proxy:latest
+```
 
 ## Development
 

docs/provider/deployment.md

@@ -6,7 +6,16 @@ Production deployment guide for Routstr Provider nodes.
 
 For production, use Docker Compose with persistent storage and optional Tor support.
 
-Use the included `compose.yml` for a flexible setup that handles both the UI and the node execution. This is useful for development or when you want to manage Tor as a separate service.
+### Unified Setup (All-in-one)
+To build and run the node with the UI integrated in a single container using the multi-stage build:
+
+```bash
+docker build -f Dockerfile.full -t routstr-full .
+docker run -d -p 8000:8000 --env-file .env routstr-full
+```
+
+### Advanced Setup (Separated UI & Node)
+Use the included `compose.yml` for a more flexible setup that separates the UI build process from the node execution. This is useful for development or when you want to manage Tor as a separate service.
 
 ```bash
 docker compose up -d
@@ -175,16 +184,20 @@ docker compose up -d
 
 ## Building from Source
 
-### Using Docker Compose
-The easiest way to build everything from source:
+### Unified Image (UI + Node)
+The easiest way to build everything from source into a single production-ready image:
 
 ```bash
-docker compose build
+docker build -f Dockerfile.full -t routstr-full .
 ```
 
 ### Individual Components
-If you prefer building the node only (requires manual UI build first):
+If you prefer building them separately or using Docker Compose:
 
 ```bash
+# Build using compose
+docker compose build
+
+# Or build the node only (requires manual UI build first)
 docker build -t routstr-node .
 ```

docs/provider/quickstart.md

@@ -35,7 +35,6 @@ ADMIN_PASSWORD=mysecretpassword
 # Node Identity
 NAME="My AI Node"
 DESCRIPTION="Fast access to models"
-NSEC=yournsec
 
 # Lightning Payouts
 RECEIVE_LN_ADDRESS=yourname@wallet.com
@@ -44,10 +43,32 @@ RECEIVE_LN_ADDRESS=yourname@wallet.com
 
 ## 2. Start the Node
 
-The recommended way to run Routstr is using Docker Compose, which handles the node, the UI, and optional services like Tor.
+You can run the pre-built image directly:
 
 ```bash
-docker compose up -d
+docker run -d \
+  --name routstr \
+  -p 8000:8000 \
+  --env-file .env \
+  -v routstr-data:/app/data \
+  ghcr.io/routstr/proxy:latest
+```
+
+*Note: The pre-built image does not contain the UI. For the all-in-one experience with the Admin Dashboard, use the Build from Source instructions below.*
+
+### Build from Source (Recommended)
+
+If you want to build the node and UI yourself from source, use the unified Dockerfile:
+
+```bash
+git clone https://github.com/routstr/routstr-core.git
+cd routstr-core
+# Edit your .env with ADMIN_PASSWORD and API keys
+cp .env.example .env
+nano .env
+
+docker build -f Dockerfile.full -t routstr-local .
+docker run -d -p 8000:8000 --env-file .env --name routstr routstr-local
 ```
 
 Verify it's running:
@@ -56,15 +77,6 @@ Verify it's running:
 curl http://localhost:8000/v1/info
 ```
 
-### Build from Source (Optional)
-
-If you've cloned the repository and want to build the images yourself:
-
-```bash
-docker compose build
-docker compose up -d
-```
-
 ---
 
 ## 3. Configure via Dashboard

migrations/versions/02650cd6f028_add_routstr_fees_table.py

@@ -1,32 +0,0 @@
-"""add routstr_fees table
-
-Revision ID: 02650cd6f028
-Revises: c3d4e5f6a7b8
-Create Date: 2026-04-24 00:00:00.000000
-"""
-
-import sqlalchemy as sa
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision = "02650cd6f028"
-down_revision = "c3d4e5f6a7b8"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    op.create_table(
-        "routstr_fees",
-        sa.Column("id", sa.Integer(), nullable=False),
-        sa.Column("accumulated_msats", sa.Integer(), nullable=False, server_default="0"),
-        sa.Column("total_paid_msats", sa.Integer(), nullable=False, server_default="0"),
-        sa.Column("last_paid_at", sa.Integer(), nullable=True),
-        sa.PrimaryKeyConstraint("id"),
-    )
-    # Seed with a single row
-    op.execute("INSERT INTO routstr_fees (id, accumulated_msats, total_paid_msats) VALUES (1, 0, 0)")
-
-
-def downgrade() -> None:
-    op.drop_table("routstr_fees")

migrations/versions/c3d4e5f6a7b8_add_source_to_cashu_transactions.py

@@ -1,36 +0,0 @@
-"""add source to cashu_transactions
-
-Revision ID: c3d4e5f6a7b8
-Revises: b1c2d3e4f5a6
-Create Date: 2026-04-10 00:00:00.000000
-"""
-
-import sqlalchemy as sa
-import sqlmodel
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision = "c3d4e5f6a7b8"
-down_revision = "b1c2d3e4f5a6"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    conn = op.get_bind()
-    inspector = sa.inspect(conn)
-    columns = [col["name"] for col in inspector.get_columns("cashu_transactions")]
-    if "source" not in columns:
-        op.add_column(
-            "cashu_transactions",
-            sa.Column(
-                "source",
-                sqlmodel.sql.sqltypes.AutoString(),
-                nullable=False,
-                server_default="x-cashu",
-            ),
-        )
-
-
-def downgrade() -> None:
-    op.drop_column("cashu_transactions", "source")

migrations/versions/cli_tokens_table.py

@@ -1,34 +0,0 @@
-"""add cli_tokens table
-
-Revision ID: cli_tokens_001
-Revises: e8f9a0b1c2d3
-Create Date: 2026-04-25 00:00:00.000000
-"""
-
-from __future__ import annotations
-
-import sqlalchemy as sa
-from alembic import op
-
-revision = "cli_tokens_001"
-down_revision = "e8f9a0b1c2d3"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    op.create_table(
-        "cli_tokens",
-        sa.Column("id", sa.String(), primary_key=True, nullable=False),
-        sa.Column("token", sa.String(), nullable=False, unique=True),
-        sa.Column("name", sa.String(), nullable=False),
-        sa.Column("created_at", sa.Integer(), nullable=False),
-        sa.Column("last_used_at", sa.Integer(), nullable=True),
-        sa.Column("expires_at", sa.Integer(), nullable=True),
-    )
-    op.create_index("ix_cli_tokens_token", "cli_tokens", ["token"], unique=True)
-
-
-def downgrade() -> None:
-    op.drop_index("ix_cli_tokens_token", table_name="cli_tokens")
-    op.drop_table("cli_tokens")

migrations/versions/d4e5f6a7b8c9_add_api_key_to_cashu_transactions.py

@@ -1,46 +0,0 @@
-"""add api key link to cashu_transactions
-
-Revision ID: d4e5f6a7b8c9
-Revises: c3d4e5f6a7b8
-Create Date: 2026-04-20 00:00:00.000000
-"""
-
-import sqlalchemy as sa
-import sqlmodel
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision = "d4e5f6a7b8c9"
-down_revision = "c3d4e5f6a7b8"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    conn = op.get_bind()
-    inspector = sa.inspect(conn)
-    columns = [col["name"] for col in inspector.get_columns("cashu_transactions")]
-    indexes = {index["name"] for index in inspector.get_indexes("cashu_transactions")}
-
-    if "api_key_hashed_key" not in columns:
-        op.add_column(
-            "cashu_transactions",
-            sa.Column(
-                "api_key_hashed_key",
-                sqlmodel.sql.sqltypes.AutoString(),
-                nullable=True,
-            ),
-        )
-
-    if "ix_cashu_transactions_api_key_hashed_key" not in indexes:
-        op.create_index(
-            "ix_cashu_transactions_api_key_hashed_key",
-            "cashu_transactions",
-            ["api_key_hashed_key"],
-            unique=False,
-        )
-
-
-def downgrade() -> None:
-    op.drop_index("ix_cashu_transactions_api_key_hashed_key", table_name="cashu_transactions")
-    op.drop_column("cashu_transactions", "api_key_hashed_key")

migrations/versions/e8f9a0b1c2d3_merge_heads.py

@@ -1,20 +0,0 @@
-"""merge heads: routstr_fees + api_key_to_cashu_transactions
-
-Revision ID: e8f9a0b1c2d3
-Revises: 02650cd6f028, d4e5f6a7b8c9
-Create Date: 2026-04-24 00:00:00.000000
-"""
-
-# revision identifiers, used by Alembic.
-revision = "e8f9a0b1c2d3"
-down_revision = ("02650cd6f028", "d4e5f6a7b8c9")
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    pass
-
-
-def downgrade() -> None:
-    pass

pyproject.toml

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

routstr/auth.py

@@ -12,7 +12,7 @@ from sqlalchemy.exc import IntegrityError
 from sqlmodel import col, select, update
 
 from .core import get_logger
-from .core.db import ApiKey, AsyncSession, accumulate_routstr_fee
+from .core.db import ApiKey, AsyncSession
 from .core.settings import settings
 from .payment.cost_calculation import (
     CostData,
@@ -25,12 +25,6 @@ from .wallet import credit_balance, deserialize_token_from_string
 logger = get_logger(__name__)
 payments_logger = get_logger("routstr.payments")
 
-# Routstr platform fee constants
-ROUTSTR_FEE_PERCENT: float = 2.1
-ROUTSTR_LN_ADDRESS: str = "npub130mznv74rxs032peqym6g3wqavh472623mt3z5w73xq9r6qqdufs7ql29s@npub.cash"
-ROUTSTR_FEE_PAYOUT_INTERVAL_SECONDS: int = 900
-ROUTSTR_FEE_DEFAULT_PAYOUT: int = 200
-
 # TODO: implement prepaid api key (not like it was before)
 # PREPAID_API_KEY = os.environ.get("PREPAID_API_KEY", None)
 # PREPAID_BALANCE = int(os.environ.get("PREPAID_BALANCE", "0")) * 1000  # Convert to msats
@@ -747,17 +741,6 @@ async def adjust_payment_for_tokens(
                 },
             )
 
-    async def _accumulate_fee(total_cost_msats: int) -> None:
-        if total_cost_msats > 0 and ROUTSTR_FEE_PERCENT > 0:
-            fee_msats = math.ceil(total_cost_msats * ROUTSTR_FEE_PERCENT / 100)
-            try:
-                await accumulate_routstr_fee(session, fee_msats)
-            except Exception as e:
-                logger.warning(
-                    "Failed to accumulate Routstr fee",
-                    extra={"error": str(e), "fee_msats": fee_msats},
-                )
-
     match await calculate_cost(response_data, deducted_max_cost, session):
         case MaxCostData() as cost:
             logger.debug(
@@ -849,7 +832,6 @@ async def adjust_payment_for_tokens(
                         "model": model,
                     },
                 )
-                await _accumulate_fee(cost.total_msats)
                 payments_logger.info(
                     "FINALIZE",
                     extra={
@@ -953,7 +935,6 @@ async def adjust_payment_for_tokens(
                 await session.refresh(billing_key)
                 if billing_key.hashed_key != key.hashed_key:
                     await session.refresh(key)
-                await _accumulate_fee(total_cost_msats)
                 payments_logger.info(
                     "FINALIZE",
                     extra={
@@ -1024,7 +1005,6 @@ async def adjust_payment_for_tokens(
                             "model": model,
                         },
                     )
-                    await _accumulate_fee(total_cost_msats)
                     payments_logger.info(
                         "FINALIZE",
                         extra={
@@ -1150,7 +1130,6 @@ async def adjust_payment_for_tokens(
                             "model": model,
                         },
                     )
-                    await _accumulate_fee(total_cost_msats)
                     payments_logger.info(
                         "FINALIZE",
                         extra={

routstr/balance.py

@@ -7,16 +7,10 @@ from typing import Annotated, NoReturn
 from fastapi import APIRouter, Depends, Header, HTTPException
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel
-from sqlmodel import col, select, update
+from sqlmodel import select
 
 from .auth import get_billing_key, validate_bearer_key
-from .core.db import (
-    ApiKey,
-    AsyncSession,
-    CashuTransaction,
-    get_session,
-    store_cashu_transaction,
-)
+from .core.db import ApiKey, AsyncSession, CashuTransaction, get_session
 from .core.logging import get_logger
 from .core.settings import settings
 from .lightning import lightning_router
@@ -211,26 +205,6 @@ async def _refund_cache_set(authorization: str, value: dict[str, str]) -> None:
         _refund_cache[key] = (expiry, value)
 
 
-async def _restore_balance(
-    session: AsyncSession, hashed_key: str, balance: int, reserved_balance: int
-) -> None:
-    """Restore balance after a failed refund mint attempt."""
-    restore_stmt = (
-        update(ApiKey)
-        .where(col(ApiKey.hashed_key) == hashed_key)
-        .values(
-            balance=col(ApiKey.balance) + balance,
-            reserved_balance=col(ApiKey.reserved_balance) + reserved_balance,
-        )
-    )
-    await session.exec(restore_stmt)  # type: ignore[call-overload]
-    await session.commit()
-    logger.info(
-        "refund_wallet_endpoint: balance restored after mint failure",
-        extra={"hashed_key": hashed_key, "restored_balance": balance},
-    )
-
-
 @router.post("/refund", response_model=None)
 async def refund_wallet_endpoint(
     authorization: Annotated[str | None, Header()] = None,
@@ -312,31 +286,7 @@ async def refund_wallet_endpoint(
     elif remaining_balance <= 0:
         raise HTTPException(status_code=400, detail="No balance to refund")
 
-    # Capture values before debit — the session may refresh key after commit
-    pre_debit_balance = key.balance
-    pre_debit_reserved = key.reserved_balance
-
-    # --- DEBIT FIRST: atomically zero the balance before minting tokens ---
-    # This prevents the race where a concurrent topup/spend happens between
-    # reading the balance and minting the refund token (double-spend).
-    debit_stmt = (
-        update(ApiKey)
-        .where(col(ApiKey.hashed_key) == key.hashed_key)
-        .where(col(ApiKey.balance) == pre_debit_balance)
-        .where(col(ApiKey.reserved_balance) == pre_debit_reserved)
-        .values(balance=0, reserved_balance=0)
-    )
-    debit_result = await session.exec(debit_stmt)  # type: ignore[call-overload]
-    await session.commit()
-
-    if debit_result.rowcount == 0:
-        # Balance changed between read and debit — another request is active
-        raise HTTPException(
-            status_code=409,
-            detail="Balance changed concurrently. Please retry the refund.",
-        )
-
-    # --- MINT: balance is locked at zero, safe to create the refund token ---
+    # Perform refund operation first, before modifying balance
     try:
         if key.refund_address:
             from .core.settings import settings as global_settings
@@ -360,24 +310,11 @@ async def refund_wallet_endpoint(
         else:
             result["msats"] = str(remaining_balance_msats)
 
-        if "token" in result:
-            logger.info(
-                "refund_wallet_endpoint: cashu token issued",
-                extra={
-                    "path": "/v1/wallet/refund",
-                    "token": result["token"],
-                    "amount": remaining_balance,
-                    "currency": key.refund_currency or "sat",
-                },
-            )
-
     except HTTPException:
-        # Minting failed — restore the debited balance
-        await _restore_balance(session, key.hashed_key, pre_debit_balance, pre_debit_reserved)
+        # Re-raise HTTP exceptions (like 400 for balance too small)
         raise
     except Exception as e:
-        # Minting failed — restore the debited balance
-        await _restore_balance(session, key.hashed_key, pre_debit_balance, pre_debit_reserved)
+        # If refund fails, don't modify the database
         error_msg = str(e)
         if (
             "mint" in error_msg.lower()
@@ -391,67 +328,23 @@ async def refund_wallet_endpoint(
 
     await _refund_cache_set(bearer_value, result)
 
-    if "token" in result:
-        try:
-            await store_cashu_transaction(
-                token=result["token"],
-                amount=remaining_balance,
-                unit=key.refund_currency or "sat",
-                mint_url=key.refund_mint_url,
-                typ="out",
-                collected=False,
-                source="apikey",
-                api_key_hashed_key=key.hashed_key,
-            )
-        except Exception:
-            pass  # store_cashu_transaction already logs
+    previous_reserved_balance = key.reserved_balance
+    key.balance = 0
+    key.reserved_balance = 0
+    session.add(key)
+    await session.commit()
 
     logger.info(
         "refund_wallet_endpoint: refund successful",
         extra={
             "refunded_msats": remaining_balance_msats,
-            "previous_reserved_balance": key.reserved_balance,
+            "previous_reserved_balance": previous_reserved_balance,
         },
     )
 
     return result
 
 
-@router.get("/history")
-async def wallet_history(
-    key: ApiKey = Depends(get_key_from_header),
-    session: AsyncSession = Depends(get_session),
-) -> dict[str, list[dict[str, str | int | bool | None]]]:
-    if key.parent_key_hash:
-        raise HTTPException(
-            status_code=400,
-            detail="Cannot view child key history. Please use the parent key instead.",
-        )
-
-    result = await session.exec(
-        select(CashuTransaction)
-        .where(CashuTransaction.api_key_hashed_key == key.hashed_key)
-        .order_by(col(CashuTransaction.created_at).desc())
-    )
-    transactions = result.all()
-    return {
-        "transactions": [
-            {
-                "id": tx.id,
-                "type": tx.type,
-                "source": tx.source,
-                "amount": tx.amount,
-                "unit": tx.unit,
-                "mint_url": tx.mint_url,
-                "created_at": tx.created_at,
-                "collected": tx.collected,
-                "swept": tx.swept,
-            }
-            for tx in transactions
-        ]
-    }
-
-
 @router.post("/donate")
 async def donate(token: str, ref: str | None = None) -> str:
     try:

routstr/core/admin.py

@@ -20,7 +20,6 @@ from ..wallet import (
 from .db import (
     ApiKey,
     CashuTransaction,
-    CliToken,
     ModelRow,
     UpstreamProviderRow,
     create_session,
@@ -39,27 +38,12 @@ ADMIN_SESSION_DURATION = 3600
 MAX_USAGE_ANALYTICS_HOURS = 365 * 24
 
 
-async def require_admin_api(request: Request) -> None:
+def require_admin_api(request: Request) -> None:
     auth_header = request.headers.get("Authorization")
-    if not auth_header or not auth_header.startswith("Bearer "):
-        raise HTTPException(status_code=403, detail="Unauthorized")
-
-    token = auth_header.split(" ", 1)[1]
-    now_ts = int(datetime.now(timezone.utc).timestamp())
-
-    # 1) Short-lived session token (in-memory)
-    expiry = admin_sessions.get(token)
-    if expiry and expiry > now_ts:
-        return
-
-    # 2) Long-lived CLI token (DB-backed)
-    async with create_session() as session:
-        result = await session.exec(select(CliToken).where(CliToken.token == token))
-        cli_token = result.first()
-        if cli_token and (cli_token.expires_at is None or cli_token.expires_at > now_ts):
-            cli_token.last_used_at = now_ts
-            session.add(cli_token)
-            await session.commit()
+    if auth_header and auth_header.startswith("Bearer "):
+        token = auth_header.split(" ", 1)[1]
+        expiry = admin_sessions.get(token)
+        if expiry and expiry > int(datetime.now(timezone.utc).timestamp()):
             return
 
     raise HTTPException(status_code=403, detail="Unauthorized")
@@ -258,73 +242,6 @@ async def admin_logout(request: Request) -> dict[str, object]:
     return {"ok": True}
 
 
-# ─── CLI Tokens (long-lived bearer tokens for CLI/agent use) ───
-
-
-class CliTokenCreate(BaseModel):
-    name: str
-    expires_in_days: int | None = None
-
-
-@admin_router.get("/api/cli-tokens", dependencies=[Depends(require_admin_api)])
-async def list_cli_tokens() -> list[dict[str, object]]:
-    async with create_session() as session:
-        result = await session.exec(select(CliToken))
-        tokens = result.all()
-    return [
-        {
-            "id": t.id,
-            "name": t.name,
-            "token_preview": f"{t.token[:8]}...{t.token[-4:]}",
-            "created_at": t.created_at,
-            "last_used_at": t.last_used_at,
-            "expires_at": t.expires_at,
-        }
-        for t in tokens
-    ]
-
-
-@admin_router.post("/api/cli-tokens", dependencies=[Depends(require_admin_api)])
-async def create_cli_token(payload: CliTokenCreate) -> dict[str, object]:
-    name = (payload.name or "").strip()
-    if not name:
-        raise HTTPException(status_code=400, detail="Name is required")
-
-    raw_token = secrets.token_urlsafe(32)
-    expires_at: int | None = None
-    if payload.expires_in_days is not None and payload.expires_in_days > 0:
-        expires_at = int(datetime.now(timezone.utc).timestamp()) + (
-            payload.expires_in_days * 86400
-        )
-
-    async with create_session() as session:
-        cli_token = CliToken(token=raw_token, name=name, expires_at=expires_at)
-        session.add(cli_token)
-        await session.commit()
-        await session.refresh(cli_token)
-
-    return {
-        "id": cli_token.id,
-        "name": cli_token.name,
-        "token": raw_token,  # full token returned only on creation
-        "created_at": cli_token.created_at,
-        "expires_at": cli_token.expires_at,
-    }
-
-
-@admin_router.delete(
-    "/api/cli-tokens/{token_id}", dependencies=[Depends(require_admin_api)]
-)
-async def revoke_cli_token(token_id: str) -> dict[str, object]:
-    async with create_session() as session:
-        cli_token = await session.get(CliToken, token_id)
-        if not cli_token:
-            raise HTTPException(status_code=404, detail="Token not found")
-        await session.delete(cli_token)
-        await session.commit()
-    return {"ok": True, "deleted_id": token_id}
-
-
 class WithdrawRequest(BaseModel):
     amount: int
     mint_url: str | None = None
@@ -1418,56 +1335,41 @@ async def get_transactions_api(
     type: str | None = None,
     status: str | None = None,
     search: str | None = None,
-    source: str | None = None,
-    limit: int = 50,
-    offset: int = 0,
+    limit: int = 100,
 ) -> dict:
     async with create_session() as session:
-        from sqlmodel import col, func
+        from sqlmodel import col
 
-        base = select(CashuTransaction)
+        stmt = select(CashuTransaction)
         if type:
-            base = base.where(CashuTransaction.type == type)
-        if source:
-            if source == "x-cashu":
-                base = base.where(
-                    (CashuTransaction.source == "x-cashu")
-                    | (CashuTransaction.source == None)  # noqa: E711
-                )
-            else:
-                base = base.where(CashuTransaction.source == source)
+            stmt = stmt.where(CashuTransaction.type == type)
         if status:
             if status == "collected":
-                base = base.where(CashuTransaction.collected == True)  # noqa: E712
+                stmt = stmt.where(CashuTransaction.collected == True)  # noqa: E712
             elif status == "swept":
-                base = base.where(CashuTransaction.swept == True)  # noqa: E712
+                stmt = stmt.where(CashuTransaction.swept == True)  # noqa: E712
             elif status == "pending":
-                base = base.where(
+                stmt = stmt.where(
                     CashuTransaction.collected == False,  # noqa: E712
                     CashuTransaction.swept == False,  # noqa: E712
                 )
 
         if search:
             search_pattern = f"%{search}%"
-            base = base.where(
+            stmt = stmt.where(
                 (col(CashuTransaction.id).like(search_pattern))
                 | (col(CashuTransaction.token).like(search_pattern))
                 | (col(CashuTransaction.request_id).like(search_pattern))
-                | (col(CashuTransaction.api_key_hashed_key).like(search_pattern))
             )
 
-        count_result = await session.exec(
-            select(func.count()).select_from(base.subquery())
-        )
-        total = count_result.one()
+        stmt = stmt.order_by(col(CashuTransaction.created_at).desc()).limit(limit)
 
-        stmt = base.order_by(col(CashuTransaction.created_at).desc()).offset(offset).limit(limit)
         results = await session.exec(stmt)
         transactions = results.all()
 
         return {
             "transactions": [tx.dict() for tx in transactions],
-            "total": total,
+            "total": len(transactions),
         }
 
 

routstr/core/db.py

@@ -10,9 +10,8 @@ from alembic import command
 from alembic.config import Config
 from alembic.util.exc import CommandError
 from sqlalchemy import UniqueConstraint
-from sqlalchemy.exc import OperationalError
 from sqlalchemy.ext.asyncio.engine import create_async_engine
-from sqlmodel import Field, Relationship, SQLModel, col, func, select, update
+from sqlmodel import Field, Relationship, SQLModel, func, select, update
 from sqlmodel.ext.asyncio.session import AsyncSession
 
 from .logging import get_logger
@@ -155,16 +154,6 @@ class CashuTransaction(SQLModel, table=True):  # type: ignore
     )
     collected: bool = Field(default=False)
     swept: bool = Field(default=False)
-    source: str = Field(
-        default="x-cashu",
-        description="Payment source: x-cashu or apikey",
-    )
-    api_key_hashed_key: str | None = Field(
-        default=None,
-        foreign_key="api_keys.hashed_key",
-        index=True,
-        description="Associated API key hash for wallet history",
-    )
 
 
 async def store_cashu_transaction(
@@ -176,8 +165,6 @@ async def store_cashu_transaction(
     request_id: str | None = None,
     collected: bool = False,
     created_at: int | None = None,
-    source: str = "x-cashu",
-    api_key_hashed_key: str | None = None,
 ) -> None:
     try:
         async with create_session() as session:
@@ -190,8 +177,6 @@ async def store_cashu_transaction(
                 request_id=request_id,
                 collected=collected,
                 created_at=created_at or int(time.time()),
-                source=source,
-                api_key_hashed_key=api_key_hashed_key,
             )
             session.add(tx)
             await session.commit()
@@ -231,66 +216,6 @@ class UpstreamProviderRow(SQLModel, table=True):  # type: ignore
     )
 
 
-class RoutstrFee(SQLModel, table=True):  # type: ignore
-    __tablename__ = "routstr_fees"
-    id: int = Field(default=1, primary_key=True)
-    accumulated_msats: int = Field(default=0)
-    total_paid_msats: int = Field(default=0)
-    last_paid_at: int | None = Field(default=None)
-
-
-class CliToken(SQLModel, table=True):  # type: ignore
-    """Long-lived authorization token for CLI/agent use against admin endpoints."""
-
-    __tablename__ = "cli_tokens"
-    id: str = Field(
-        primary_key=True, default_factory=lambda: uuid.uuid4().hex
-    )
-    token: str = Field(unique=True, index=True, description="Bearer token value")
-    name: str = Field(description="Human-readable label for this token")
-    created_at: int = Field(default_factory=lambda: int(time.time()))
-    last_used_at: int | None = Field(default=None)
-    expires_at: int | None = Field(
-        default=None, description="Optional expiry unix timestamp; null = never expires"
-    )
-
-
-async def accumulate_routstr_fee(session: AsyncSession, amount_msats: int) -> None:
-    stmt = (
-        update(RoutstrFee)
-        .where(col(RoutstrFee.id) == 1)
-        .values(accumulated_msats=RoutstrFee.accumulated_msats + amount_msats)
-    )
-    result = await session.exec(stmt)  # type: ignore[call-overload]
-    if result.rowcount == 0:
-        session.add(RoutstrFee(id=1, accumulated_msats=amount_msats))
-    await session.commit()
-
-
-async def get_routstr_fee(session: AsyncSession) -> RoutstrFee:
-    fee = await session.get(RoutstrFee, 1)
-    if fee is None:
-        fee = RoutstrFee(id=1, accumulated_msats=0, total_paid_msats=0)
-        session.add(fee)
-        await session.commit()
-        await session.refresh(fee)
-    return fee
-
-
-async def reset_routstr_fee(session: AsyncSession, paid_msats: int) -> None:
-    stmt = (
-        update(RoutstrFee)
-        .where(col(RoutstrFee.id) == 1)
-        .values(
-            accumulated_msats=RoutstrFee.accumulated_msats - paid_msats,
-            total_paid_msats=RoutstrFee.total_paid_msats + paid_msats,
-            last_paid_at=int(time.time()),
-        )
-    )
-    await session.exec(stmt)  # type: ignore[call-overload]
-    await session.commit()
-
-
 async def balances_for_mint_and_unit(
     db_session: AsyncSession, mint_url: str, unit: str
 ) -> int:
@@ -406,17 +331,6 @@ def run_migrations() -> None:
                 command.stamp(alembic_cfg, "head")
             else:
                 raise
-        except OperationalError as e:
-            if "duplicate column name" in str(e).lower():
-                logger.warning(
-                    "Migration hit a column that already exists (likely added via "
-                    "create_all on another branch). Stamping to current head.",
-                    extra={"error": str(e)},
-                )
-                _clear_alembic_version()
-                command.stamp(alembic_cfg, "head")
-            else:
-                raise
 
         logger.info("Database migrations completed successfully")
 

routstr/core/main.py

@@ -1,4 +1,5 @@
 import asyncio
+import os
 from contextlib import asynccontextmanager
 from pathlib import Path
 from typing import AsyncGenerator
@@ -8,8 +9,6 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse, RedirectResponse
 from fastapi.staticfiles import StaticFiles
 from starlette.exceptions import HTTPException
-from starlette.responses import Response as StarletteResponse
-from starlette.types import Scope
 
 from ..auth import periodic_key_reset
 from ..balance import balance_router, deprecated_wallet_router
@@ -23,7 +22,7 @@ from ..payment.models import models_router, update_sats_pricing
 from ..payment.price import update_prices_periodically
 from ..proxy import initialize_upstreams, proxy_router, refresh_model_maps_periodically
 from ..upstream.auto_topup import periodic_auto_topup
-from ..wallet import periodic_payout, periodic_refund_sweep, periodic_routstr_fee_payout
+from ..wallet import periodic_payout, periodic_refund_sweep
 from .admin import admin_router
 from .db import create_session, init_db, run_migrations
 from .exceptions import general_exception_handler, http_exception_handler
@@ -31,12 +30,16 @@ from .logging import get_logger, setup_logging
 from .middleware import LoggingMiddleware
 from .settings import SettingsService
 from .settings import settings as global_settings
-from .version import __version__
 
 # Initialize logging first
 setup_logging()
 logger = get_logger(__name__)
 
+if os.getenv("VERSION_SUFFIX") is not None:
+    __version__ = f"0.4.1-{os.getenv('VERSION_SUFFIX')}"
+else:
+    __version__ = "0.4.1"
+
 
 @asynccontextmanager
 async def lifespan(_: FastAPI) -> AsyncGenerator[None, None]:
@@ -53,7 +56,6 @@ async def lifespan(_: FastAPI) -> AsyncGenerator[None, None]:
     key_reset_task = None
     auto_topup_task = None
     refund_sweep_task = None
-    routstr_fee_task = None
 
     try:
         # Run database migrations on startup
@@ -100,11 +102,8 @@ async def lifespan(_: FastAPI) -> AsyncGenerator[None, None]:
         btc_price_task = asyncio.create_task(update_prices_periodically())
         pricing_task = asyncio.create_task(update_sats_pricing())
         if global_settings.models_refresh_interval_seconds > 0:
-            # Pass the accessor (not its current value) so the loop sees providers
-            # added/changed via reinitialize_upstreams() instead of staying pinned
-            # to the startup snapshot.
             models_refresh_task = asyncio.create_task(
-                refresh_upstreams_models_periodically(get_upstreams)
+                refresh_upstreams_models_periodically(get_upstreams())
             )
         model_maps_refresh_task = asyncio.create_task(refresh_model_maps_periodically())
         payout_task = asyncio.create_task(periodic_payout())
@@ -116,7 +115,6 @@ async def lifespan(_: FastAPI) -> AsyncGenerator[None, None]:
         key_reset_task = asyncio.create_task(periodic_key_reset())
         auto_topup_task = asyncio.create_task(periodic_auto_topup())
         refund_sweep_task = asyncio.create_task(periodic_refund_sweep())
-        routstr_fee_task = asyncio.create_task(periodic_routstr_fee_payout())
 
         yield
 
@@ -154,8 +152,6 @@ async def lifespan(_: FastAPI) -> AsyncGenerator[None, None]:
             auto_topup_task.cancel()
         if refund_sweep_task is not None:
             refund_sweep_task.cancel()
-        if routstr_fee_task is not None:
-            routstr_fee_task.cancel()
 
         try:
             tasks_to_wait = []
@@ -181,8 +177,6 @@ async def lifespan(_: FastAPI) -> AsyncGenerator[None, None]:
                 tasks_to_wait.append(auto_topup_task)
             if refund_sweep_task is not None:
                 tasks_to_wait.append(refund_sweep_task)
-            if routstr_fee_task is not None:
-                tasks_to_wait.append(routstr_fee_task)
 
             if tasks_to_wait:
                 await asyncio.gather(*tasks_to_wait, return_exceptions=True)
@@ -194,23 +188,6 @@ async def lifespan(_: FastAPI) -> AsyncGenerator[None, None]:
             )
 
 
-class _ImmutableStaticFiles(StaticFiles):
-    """Static files with long Cache-Control for content-hashed Next.js assets.
-
-    Files under `/_next/static/` are emitted with content hashes in their
-    filenames and never mutate, so we serve them with a one-year immutable
-    cache header so browsers and CDNs stop revalidating on every reload.
-    """
-
-    async def get_response(self, path: str, scope: Scope) -> StarletteResponse:
-        response = await super().get_response(path, scope)
-        if response.status_code == 200:
-            response.headers["Cache-Control"] = (
-                "public, max-age=31536000, immutable"
-            )
-        return response
-
-
 app = FastAPI(version=__version__, lifespan=lifespan)
 
 
@@ -257,7 +234,7 @@ if UI_DIST_PATH.exists() and UI_DIST_PATH.is_dir():
 
     app.mount(
         "/_next",
-        _ImmutableStaticFiles(directory=UI_DIST_PATH / "_next", check_dir=True),
+        StaticFiles(directory=UI_DIST_PATH / "_next", check_dir=True),
         name="next-static",
     )
 
@@ -265,12 +242,10 @@ if UI_DIST_PATH.exists() and UI_DIST_PATH.is_dir():
     async def serve_root_ui() -> FileResponse:
         return FileResponse(UI_DIST_PATH / "index.html")
 
-    # Serve the App Router RSC payload for the home page.
+    # Add explicit route for /index.txt to redirect to /
     @app.get("/index.txt", include_in_schema=False)
-    async def serve_root_rsc() -> FileResponse:
-        return FileResponse(
-            UI_DIST_PATH / "index.txt", media_type="text/x-component"
-        )
+    async def redirect_index_txt() -> RedirectResponse:
+        return RedirectResponse("/")
 
     @app.get("/admin")
     async def admin_redirect() -> FileResponse:
@@ -284,96 +259,82 @@ if UI_DIST_PATH.exists() and UI_DIST_PATH.is_dir():
     async def serve_login_ui() -> FileResponse:
         return FileResponse(UI_DIST_PATH / "login" / "index.html")
 
+    # Add explicit route for /login/index.txt to redirect to /login
     @app.get("/login/index.txt", include_in_schema=False)
-    async def serve_login_rsc() -> FileResponse:
-        return FileResponse(
-            UI_DIST_PATH / "login" / "index.txt", media_type="text/x-component"
-        )
+    async def redirect_login_index_txt() -> RedirectResponse:
+        return RedirectResponse("/login")
 
     @app.get("/model", include_in_schema=False)
     async def serve_models_ui() -> FileResponse:
         return FileResponse(UI_DIST_PATH / "model" / "index.html")
 
+    # Add explicit route for /model/index.txt to redirect to /model
     @app.get("/model/index.txt", include_in_schema=False)
-    async def serve_model_rsc() -> FileResponse:
-        return FileResponse(
-            UI_DIST_PATH / "model" / "index.txt", media_type="text/x-component"
-        )
+    async def redirect_model_index_txt() -> RedirectResponse:
+        return RedirectResponse("/model")
 
     @app.get("/providers", include_in_schema=False)
     async def serve_providers_ui() -> FileResponse:
         return FileResponse(UI_DIST_PATH / "providers" / "index.html")
 
+    # Add explicit route for /providers/index.txt to redirect to /providers
     @app.get("/providers/index.txt", include_in_schema=False)
-    async def serve_providers_rsc() -> FileResponse:
-        return FileResponse(
-            UI_DIST_PATH / "providers" / "index.txt",
-            media_type="text/x-component",
-        )
+    async def redirect_providers_index_txt() -> RedirectResponse:
+        return RedirectResponse("/providers")
 
     @app.get("/settings", include_in_schema=False)
     async def serve_settings_ui() -> FileResponse:
         return FileResponse(UI_DIST_PATH / "settings" / "index.html")
 
+    # Add explicit route for /settings/index.txt to redirect to /settings
     @app.get("/settings/index.txt", include_in_schema=False)
-    async def serve_settings_rsc() -> FileResponse:
-        return FileResponse(
-            UI_DIST_PATH / "settings" / "index.txt",
-            media_type="text/x-component",
-        )
+    async def redirect_settings_index_txt() -> RedirectResponse:
+        return RedirectResponse("/settings")
 
     @app.get("/transactions", include_in_schema=False)
     async def serve_transactions_ui() -> FileResponse:
         return FileResponse(UI_DIST_PATH / "transactions" / "index.html")
 
+    # Add explicit route for /transactions/index.txt to redirect to /transactions
     @app.get("/transactions/index.txt", include_in_schema=False)
-    async def serve_transactions_rsc() -> FileResponse:
-        return FileResponse(
-            UI_DIST_PATH / "transactions" / "index.txt",
-            media_type="text/x-component",
-        )
+    async def redirect_transactions_index_txt() -> RedirectResponse:
+        return RedirectResponse("/transactions")
 
     @app.get("/balances", include_in_schema=False)
     async def serve_balances_ui() -> FileResponse:
         return FileResponse(UI_DIST_PATH / "balances" / "index.html")
 
+    # Add explicit route for /balances/index.txt to redirect to /balances
     @app.get("/balances/index.txt", include_in_schema=False)
-    async def serve_balances_rsc() -> FileResponse:
-        return FileResponse(
-            UI_DIST_PATH / "balances" / "index.txt",
-            media_type="text/x-component",
-        )
+    async def redirect_balances_index_txt() -> RedirectResponse:
+        return RedirectResponse("/balances")
 
     @app.get("/logs", include_in_schema=False)
     async def serve_logs_ui() -> FileResponse:
         return FileResponse(UI_DIST_PATH / "logs" / "index.html")
 
+    # Add explicit route for /logs/index.txt to redirect to /logs
     @app.get("/logs/index.txt", include_in_schema=False)
-    async def serve_logs_rsc() -> FileResponse:
-        return FileResponse(
-            UI_DIST_PATH / "logs" / "index.txt", media_type="text/x-component"
-        )
+    async def redirect_logs_index_txt() -> RedirectResponse:
+        return RedirectResponse("/logs")
 
     @app.get("/usage", include_in_schema=False)
     async def serve_usage_ui() -> FileResponse:
         return FileResponse(UI_DIST_PATH / "usage" / "index.html")
 
+    # Add explicit route for /usage/index.txt to redirect to /usage
     @app.get("/usage/index.txt", include_in_schema=False)
-    async def serve_usage_rsc() -> FileResponse:
-        return FileResponse(
-            UI_DIST_PATH / "usage" / "index.txt", media_type="text/x-component"
-        )
+    async def redirect_usage_index_txt() -> RedirectResponse:
+        return RedirectResponse("/usage")
 
     @app.get("/unauthorized", include_in_schema=False)
     async def serve_unauthorized_ui() -> FileResponse:
         return FileResponse(UI_DIST_PATH / "unauthorized" / "index.html")
 
+    # Add explicit route for /unauthorized/index.txt to redirect to /unauthorized
     @app.get("/unauthorized/index.txt", include_in_schema=False)
-    async def serve_unauthorized_rsc() -> FileResponse:
-        return FileResponse(
-            UI_DIST_PATH / "unauthorized" / "index.txt",
-            media_type="text/x-component",
-        )
+    async def redirect_unauthorized_index_txt() -> RedirectResponse:
+        return RedirectResponse("/unauthorized")
 
     @app.get("/favicon.ico", include_in_schema=False)
     async def serve_favicon() -> FileResponse:
@@ -386,6 +347,9 @@ if UI_DIST_PATH.exists() and UI_DIST_PATH.is_dir():
     async def serve_icon() -> FileResponse:
         return FileResponse(UI_DIST_PATH / "icon.ico")
 
+    app.mount(
+        "/static", StaticFiles(directory=UI_DIST_PATH, check_dir=True), name="ui-static"
+    )
 else:
     logger.warning(
         f"UI dist directory not found at {UI_DIST_PATH}, skipping static file serving"

routstr/core/middleware.py

@@ -14,54 +14,8 @@ logger = get_logger(__name__)
 request_id_context: ContextVar[str | None] = ContextVar("request_id")
 
 
-# Methods that are never logged: HEAD requests are health probes from
-# monitoring/load balancers, OPTIONS are CORS preflights — both are framework
-# chatter, not user-meaningful events.
-_SKIP_LOG_METHODS: frozenset[str] = frozenset({"HEAD", "OPTIONS"})
-
-# Path prefixes to skip. Includes Next.js static chunks and the admin
-# dashboard's internal polling API (/admin/api/*) which the UI hits on a timer
-# to refresh balances, logs, providers, etc. — high volume, low diagnostic
-# value. Mutating admin actions are recorded separately in the audit log.
-_SKIP_LOG_PREFIXES: tuple[str, ...] = (
-    "/_next/",
-    "/admin/api/",
-)
-
-# Exact paths to skip. RSC payload prefetches (`*/index.txt`) fire automatically
-# as the user hovers near `<Link>`s, and `/v1/wallet/info` is polled by the UI.
-_SKIP_LOG_EXACT: frozenset[str] = frozenset(
-    {
-        "/favicon.ico",
-        "/icon.ico",
-        "/v1/wallet/info",
-        "/index.txt",
-        "/login/index.txt",
-        "/model/index.txt",
-        "/providers/index.txt",
-        "/settings/index.txt",
-        "/transactions/index.txt",
-        "/balances/index.txt",
-        "/logs/index.txt",
-        "/usage/index.txt",
-        "/unauthorized/index.txt",
-    }
-)
-
-
-def _should_log(method: str, path: str) -> bool:
-    if method in _SKIP_LOG_METHODS:
-        return False
-    if path in _SKIP_LOG_EXACT:
-        return False
-    return not any(path.startswith(prefix) for prefix in _SKIP_LOG_PREFIXES)
-
-
 class LoggingMiddleware(BaseHTTPMiddleware):
-    """Middleware to log proxy interactions and page navigation.
-
-    Skips logging for static assets and Next.js chunks to avoid noise.
-    """
+    """Middleware to log detailed request and response information."""
 
     async def dispatch(self, request: Request, call_next: Callable) -> Response:
         # Generate request ID
@@ -71,20 +25,56 @@ class LoggingMiddleware(BaseHTTPMiddleware):
         # Set request ID in context for logging
         token = request_id_context.set(request_id)
 
-        path = request.url.path
-        should_log = _should_log(request.method, path)
-
         # Start timing
         start_time = time.time()
 
-        if should_log:
-            logger.info(
-                "Incoming request",
+        # Log request details
+        request_body = None
+        if request.method in ["POST", "PUT", "PATCH"]:
+            try:
+                # Only read body for non-streaming requests
+                if hasattr(request, "_body"):
+                    request_body = await request.body()
+            except Exception:
+                pass
+
+        # Log incoming request
+        logger.info(
+            "Incoming request",
+            extra={
+                "request_id": request_id,
+                "method": request.method,
+                "path": request.url.path,
+                "query_params": dict(request.query_params),
+                "headers": {
+                    k: v
+                    for k, v in request.headers.items()
+                    if k.lower()
+                    not in [
+                        "authorization",
+                        "x-cashu",
+                        "cookie",
+                        "cf-connecting-ip",
+                        "cf-ipcountry",
+                        "x-forwarded-for",
+                        "x-real-ip",
+                    ]
+                },
+                "body_size": len(request_body) if request_body else 0,
+            },
+        )
+
+        # Log at TRACE level for full body (security filter will redact sensitive data)
+        if request_body and hasattr(logger, "exception"):
+            logger.exception(
+                "Request body",
                 extra={
                     "request_id": request_id,
                     "method": request.method,
-                    "path": path,
-                    "query_params": dict(request.query_params),
+                    "path": request.url.path,
+                    "body": request_body.decode("utf-8", errors="ignore")[
+                        :1000
+                    ],  # Limit size
                 },
             )
 
@@ -92,32 +82,36 @@ class LoggingMiddleware(BaseHTTPMiddleware):
         try:
             response = await call_next(request)
 
-            if should_log:
-                duration = time.time() - start_time
-                logger.info(
-                    "Request completed",
-                    extra={
-                        "request_id": request_id,
-                        "method": request.method,
-                        "path": path,
-                        "status_code": response.status_code,
-                        "duration_ms": round(duration * 1000, 2),
-                    },
-                )
+            # Calculate duration
+            duration = time.time() - start_time
+
+            # Log response
+            logger.info(
+                "Request completed",
+                extra={
+                    "request_id": request_id,
+                    "method": request.method,
+                    "path": request.url.path,
+                    "status_code": response.status_code,
+                    "duration_ms": round(duration * 1000, 2),
+                },
+            )
             if hasattr(response, "headers"):
                 response.headers["x-routstr-request-id"] = request_id
 
             return response
 
         except Exception as e:
-            # Always log failures, even for skipped paths, so we don't lose errors.
+            # Calculate duration
             duration = time.time() - start_time
+
+            # Log error
             logger.error(
                 "Request failed",
                 extra={
                     "request_id": request_id,
                     "method": request.method,
-                    "path": path,
+                    "path": request.url.path,
                     "duration_ms": round(duration * 1000, 2),
                     "error": str(e),
                     "error_type": type(e).__name__,

routstr/core/version.py

@@ -1,81 +0,0 @@
-"""Application version resolution.
-
-Priority order:
-
-1. ``VERSION_SUFFIX`` env var (manual override; preserves prior behaviour).
-2. Bare base version when HEAD is on the matching release tag (detected via
-   ``GIT_TAG`` env or ``git describe --tags --exact-match HEAD``).
-3. ``GIT_COMMIT`` env var (build-time injection) -> ``<base>+g<sha>``.
-4. Local ``.git`` lookup (source checkouts) -> ``<base>+g<sha>``.
-5. Fallback: bare base version.
-
-The ``+g<sha>`` form is PEP 440 local-version syntax so the result remains a
-valid package version.
-"""
-
-from __future__ import annotations
-
-import os
-import subprocess
-from functools import lru_cache
-from pathlib import Path
-
-BASE_VERSION = "0.4.3"
-
-_REPO_ROOT = Path(__file__).resolve().parents[2]
-_GIT_TIMEOUT_SECONDS = 2.0
-
-
-def _run_git(*args: str) -> str | None:
-    try:
-        result = subprocess.run(  # noqa: S603 - fixed argv, no shell
-            ["git", *args],
-            cwd=_REPO_ROOT,
-            check=False,
-            capture_output=True,
-            text=True,
-            timeout=_GIT_TIMEOUT_SECONDS,
-        )
-    except (FileNotFoundError, subprocess.SubprocessError, OSError):
-        return None
-    if result.returncode != 0:
-        return None
-    return result.stdout.strip() or None
-
-
-def _git_short_sha() -> str | None:
-    sha = os.getenv("GIT_COMMIT", "").strip()
-    if sha:
-        return sha[:7]
-    return _run_git("rev-parse", "--short=7", "HEAD")
-
-
-def _on_tagged_release() -> bool:
-    tag = os.getenv("GIT_TAG", "").strip()
-    if tag:
-        return tag.lstrip("v") == BASE_VERSION
-    described = _run_git("describe", "--tags", "--exact-match", "HEAD")
-    if not described:
-        return False
-    return described.lstrip("v") == BASE_VERSION
-
-
-@lru_cache(maxsize=1)
-def get_version() -> str:
-    suffix = os.getenv("VERSION_SUFFIX")
-    if suffix is not None:
-        return f"{BASE_VERSION}-{suffix}"
-
-    if _on_tagged_release():
-        return BASE_VERSION
-
-    sha = _git_short_sha()
-    if not sha:
-        return BASE_VERSION
-
-    return f"{BASE_VERSION}+g{sha}"
-
-
-__version__ = get_version()
-
-__all__ = ["BASE_VERSION", "__version__", "get_version"]

routstr/nostr/listing.py

@@ -26,7 +26,7 @@ logger = get_logger(__name__)
 
 def get_app_version() -> str | None:
     try:
-        from ..core.version import __version__ as imported_version
+        from ..core.main import __version__ as imported_version
 
         return imported_version
     except Exception:

routstr/payment/models.py

@@ -7,7 +7,7 @@ from fastapi import APIRouter, Depends
 from pydantic.v1 import BaseModel
 from sqlmodel.ext.asyncio.session import AsyncSession
 
-from ..core.db import ModelRow, UpstreamProviderRow, get_session
+from ..core.db import ModelRow, get_session
 from ..core.logging import get_logger
 from ..core.settings import settings
 from .price import sats_usd_price
@@ -182,11 +182,16 @@ def _row_to_model(
     )
 
     if apply_provider_fee:
-        (
-            parsed_pricing.max_prompt_cost,
-            parsed_pricing.max_completion_cost,
-            parsed_pricing.max_cost,
-        ) = _calculate_usd_max_costs(model)
+        max_prompt, max_completion, max_cost = _calculate_usd_max_costs(model)
+        parsed_pricing = Pricing(
+            **{
+                **parsed_pricing.dict(),
+                "max_prompt_cost": max_prompt,
+                "max_completion_cost": max_completion,
+                "max_cost": max_cost,
+            }
+        )
+        model = Model(**{**model.dict(), "pricing": parsed_pricing, "sats_pricing": None})
 
     try:
         sats_to_usd = sats_usd_price()
@@ -405,76 +410,6 @@ async def update_sats_pricing() -> None:
             logger.error(f"Error updating sats pricing: {e}")
 
 
-class ModelTestRequest(BaseModel):
-    model_id: str
-    endpoint_type: str
-    request_data: dict
-
-
-@models_router.post("/api/models/test")
-async def test_model(
-    payload: ModelTestRequest,
-    session: AsyncSession = Depends(get_session),
-) -> dict:
-    """Test a model by sending a request through its configured upstream provider."""
-    from sqlmodel import select
-
-    result = await session.execute(
-        select(ModelRow).where(ModelRow.id == payload.model_id)
-    )
-    model_row = result.scalars().first()
-
-    if not model_row:
-        return {
-            "success": False,
-            "error": f"Model '{payload.model_id}' not found in database",
-            "status_code": 404,
-        }
-
-    provider = await session.get(UpstreamProviderRow, model_row.upstream_provider_id)
-    if not provider:
-        return {
-            "success": False,
-            "error": "Upstream provider not found",
-            "status_code": 404,
-        }
-
-    base_url = provider.base_url.rstrip("/")
-    if payload.endpoint_type == "chat-completions":
-        url = f"{base_url}/chat/completions"
-    else:
-        url = f"{base_url}/{payload.endpoint_type}"
-
-    actual_model_id = model_row.forwarded_model_id or model_row.id
-    request_data = dict(payload.request_data)
-    request_data["model"] = actual_model_id
-
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {provider.api_key}",
-    }
-
-    try:
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            response = await client.post(url, json=request_data, headers=headers)
-            try:
-                response_data = response.json()
-            except Exception:
-                response_data = {"raw": response.text}
-
-            return {
-                "success": response.status_code < 400,
-                "data": response_data,
-                "status_code": response.status_code,
-            }
-    except Exception as e:
-        return {
-            "success": False,
-            "error": str(e),
-            "status_code": 500,
-        }
-
-
 @models_router.get("/v1/models")
 @models_router.get("/v1/models/", include_in_schema=False)
 @models_router.get("/models")

routstr/proxy.py

@@ -69,25 +69,7 @@ def get_upstreams() -> list[BaseUpstreamProvider]:
 
 def get_model_instance(model_id: str) -> Model | None:
     """Get Model instance by ID from global cache."""
-    if not model_id:
-        return None
-
-    model_id_lower = model_id.lower()
-    # Try exact match first
-    if model := _model_instances.get(model_id_lower):
-        return model
-
-    # Try stripping common version suffixes (e.g., -20251222)
-    # This handles cases where upstream returns a specific version
-    # but we only track the base model name.
-    import re
-
-    base_model_id = re.sub(r"-\d{8}$", "", model_id_lower)
-    if base_model_id != model_id_lower:
-        if model := _model_instances.get(base_model_id):
-            return model
-
-    return None
+    return _model_instances.get(model_id.lower())
 
 
 def get_provider_for_model(model_id: str) -> list[BaseUpstreamProvider] | None:

routstr/upstream/base.py

@@ -5,7 +5,6 @@ import hashlib
 import json
 import re
 import traceback
-import uuid
 from collections.abc import AsyncGenerator
 from typing import Mapping
 
@@ -119,51 +118,6 @@ class BaseUpstreamProvider:
             "can_show_balance": False,
         }
 
-    def inject_cost_metadata(
-        self,
-        response_json: dict,
-        cost_data: CostData | MaxCostData | dict,
-        key: ApiKey,
-    ) -> None:
-        """Unifies the injection of cost and usage metadata across all completion types."""
-        if isinstance(cost_data, dict):
-            total_msats = cost_data.get("total_msats", 0)
-            total_usd = cost_data.get("total_usd", 0.0)
-            cost_dict = cost_data
-        else:
-            total_msats = cost_data.total_msats
-            total_usd = cost_data.total_usd
-            cost_dict = cost_data.dict()
-
-        sats_cost = total_msats // 1000
-
-        # Inject into top-level usage block (OpenAI/Anthropic style)
-        if "usage" in response_json:
-            response_json["usage"]["cost"] = total_usd
-            response_json["usage"]["cost_sats"] = sats_cost
-            response_json["usage"]["remaining_balance_msats"] = key.balance
-
-        # Inject into Anthropic nested usage block if present
-        if (
-            "message" in response_json
-            and isinstance(response_json["message"], dict)
-            and "usage" in response_json["message"]
-        ):
-            response_json["message"]["usage"]["sats_cost"] = sats_cost
-
-        # Unified Routstr metadata
-        response_json["metadata"] = response_json.get("metadata", {})
-        response_json["metadata"]["routstr"] = {
-            "cost": cost_dict,
-            "sats_cost": sats_cost,
-            "remaining_balance_msats": key.balance,
-        }
-
-        # Legacy/Compatibility fields
-        response_json["cost"] = cost_dict.copy()
-        response_json["cost"]["sats_cost"] = sats_cost
-        response_json["cost"]["remaining_balance_msats"] = key.balance
-
     def prepare_headers(self, request_headers: dict) -> dict:
         """Prepare headers for upstream request by removing proxy-specific headers and adding authentication.
 
@@ -421,83 +375,75 @@ class BaseUpstreamProvider:
         """
         pass
 
-    async def forward_upstream_error_response(
+    async def map_upstream_error_response(
         self, request: Request, path: str, upstream_response: httpx.Response
     ) -> Response:
-        """Log upstream errors and forward the upstream response unchanged."""
+        """Map upstream error responses to appropriate proxy error responses.
+
+        Args:
+            request: Original FastAPI request
+            path: Request path
+            upstream_response: Response from upstream service
+
+        Returns:
+            Mapped error response with appropriate status code and error type
+        """
         status_code = upstream_response.status_code
         headers = dict(upstream_response.headers)
-        content_type = headers.get("content-type") or headers.get("Content-Type", "")
-        upstream_request_id = (
-            headers.get("request-id")
-            or headers.get("Request-Id")
-            or headers.get("x-request-id")
-            or headers.get("X-Request-Id")
-            or headers.get("anthropic-request-id")
-            or headers.get("openai-request-id")
-        )
-
-        body_read_error = None
+        content_type = headers.get("content-type", "")
         try:
             body_bytes = await upstream_response.aread()
-        except Exception as exc:
+        except Exception:
             body_bytes = b""
-            body_read_error = f"{type(exc).__name__}: {exc}"
 
         message, upstream_code = self._extract_upstream_error_message(body_bytes)
-        body_preview = body_bytes.decode("utf-8", errors="ignore").strip()[:500]
+        lowered_message = message.lower()
+        lowered_code = (upstream_code or "").lower()
 
-        logger.warning(
-            "Forwarding upstream error response as-is",
+        error_type = "upstream_error"
+        mapped_status = 502
+
+        if status_code in (400, 422):
+            error_type = "invalid_request_error"
+            mapped_status = 400
+        elif status_code in (401, 403):
+            error_type = "upstream_auth_error"
+            mapped_status = 502
+        elif status_code == 404:
+            if path.endswith("chat/completions"):
+                error_type = "invalid_model"
+                mapped_status = 400
+                if not message or message == "Upstream request failed":
+                    message = "Requested model is not available upstream"
+            elif "model" in lowered_message or "model" in lowered_code:
+                error_type = "invalid_model"
+                mapped_status = 400
+                if not message or message == "Upstream request failed":
+                    message = "Requested model is not available upstream"
+            else:
+                error_type = "upstream_error"
+                mapped_status = 502
+        elif status_code == 429:
+            error_type = "rate_limit_exceeded"
+            mapped_status = 429
+        elif status_code >= 500:
+            error_type = "upstream_error"
+            mapped_status = 502
+
+        logger.debug(
+            "Mapped upstream error",
             extra={
                 "path": path,
-                "provider": self.provider_type,
                 "upstream_status": status_code,
-                "upstream_code": upstream_code,
+                "mapped_status": mapped_status,
+                "error_type": error_type,
                 "upstream_content_type": content_type,
-                "upstream_request_id": upstream_request_id,
                 "message_preview": message[:200],
-                "body_preview": body_preview,
-                "body_read_error": body_read_error,
-                "method": request.method,
             },
         )
 
-        for header_name in (
-            "content-length",
-            "Content-Length",
-            "transfer-encoding",
-            "Transfer-Encoding",
-            "content-encoding",
-            "Content-Encoding",
-            "connection",
-            "Connection",
-            "keep-alive",
-            "Keep-Alive",
-            "proxy-authenticate",
-            "Proxy-Authenticate",
-            "proxy-authorization",
-            "Proxy-Authorization",
-            "te",
-            "TE",
-            "trailer",
-            "Trailer",
-            "upgrade",
-            "Upgrade",
-        ):
-            headers.pop(header_name, None)
-
-        if not content_type:
-            headers.pop("content-type", None)
-            headers.pop("Content-Type", None)
-
-        media_type = content_type or None
-
-        return Response(
-            content=body_bytes,
-            status_code=status_code,
-            headers=headers,
-            media_type=media_type,
+        return create_error_response(
+            error_type, message, mapped_status, request=request
         )
 
     async def handle_streaming_chat_completion(
@@ -571,32 +517,20 @@ class BaseUpstreamProvider:
                             continue
 
                         try:
-                            # Only parse if it looks like a JSON object to avoid SSE control messages or partials
-                            if part.strip().startswith(b"{") and part.strip().endswith(
-                                b"}"
-                            ):
-                                obj = json.loads(part)
-                                if isinstance(obj, dict):
-                                    if obj.get("model"):
-                                        last_model_seen = str(obj.get("model"))
-                                    if requested_model:
-                                        obj["model"] = requested_model
-                                    if (
-                                        "id" not in obj
-                                        or not isinstance(obj["id"], str)
-                                        or obj["id"] == "existing-id"
-                                    ):
-                                        if not hasattr(self, "_current_stream_id"):
-                                            self._current_stream_id = (
-                                                f"chatcmpl-{uuid.uuid4()}"
-                                            )
-                                        obj["id"] = self._current_stream_id
-                                    if isinstance(obj.get("usage"), dict):
-                                        usage_chunk_data = obj
-                                        continue
-                                    yield b"data: " + json.dumps(obj).encode() + b"\n\n"
+                            obj = json.loads(part)
+                            if isinstance(obj, dict):
+                                if obj.get("model"):
+                                    last_model_seen = str(obj.get("model"))
+                                if requested_model:
+                                    obj["model"] = requested_model
+
+                                if isinstance(obj.get("usage"), dict):
+                                    # Hold this chunk back to merge cost later
+                                    usage_chunk_data = obj
                                     continue
-                        except Exception:
+                                yield b"data: " + json.dumps(obj).encode() + b"\n\n"
+                                continue
+                        except json.JSONDecodeError:
                             pass
 
                         prefix = (
@@ -604,83 +538,57 @@ class BaseUpstreamProvider:
                         )
                         yield prefix + part
 
-                async with create_session() as session:
-                    fresh_key = await session.get(key.__class__, key.hashed_key)
-                    if fresh_key:
-                        cost_data: dict
-                        try:
-                            adjustment_input = (
-                                usage_chunk_data
-                                if usage_chunk_data is not None
-                                else {
-                                    "model": last_model_seen or "unknown",
-                                    "usage": None,
-                                }
-                            )
-                            cost_data = await adjust_payment_for_tokens(
-                                fresh_key,
-                                adjustment_input,
-                                session,
-                                max_cost_for_model,
-                            )
-                            usage_finalized = True
-                        except Exception as e:
-                            logger.exception(
-                                "Error during usage finalization",
-                                extra={
-                                    "key_hash": key.hashed_key[:8] + "...",
-                                    "error": str(e),
-                                },
-                            )
-
-                            # Fall back so we still emit a non-zero sats cost downstream.
-                            cost_data = {
-                                "base_msats": 0,
-                                "input_msats": 0,
-                                "output_msats": 0,
-                                "total_msats": 0,
-                                "total_usd": 0.0,
-                                "input_tokens": 0,
-                                "output_tokens": 0,
-                            }
-
-                        if usage_chunk_data is None:
-                            if not hasattr(self, "_current_stream_id"):
-                                self._current_stream_id = (
-                                    f"chatcmpl-{uuid.uuid4()}"
+                # Stream finished, process usage if found
+                if usage_chunk_data:
+                    async with create_session() as session:
+                        fresh_key = await session.get(key.__class__, key.hashed_key)
+                        if fresh_key:
+                            try:
+                                cost_data = await adjust_payment_for_tokens(
+                                    fresh_key,
+                                    usage_chunk_data,
+                                    session,
+                                    max_cost_for_model,
                                 )
-                            usage_chunk_data = {
-                                "id": self._current_stream_id,
-                                "object": "chat.completion.chunk",
-                                "model": last_model_seen or "unknown",
-                                "choices": [],
-                                "usage": {
-                                    "prompt_tokens": cost_data.get(
-                                        "input_tokens", 0
-                                    ),
-                                    "completion_tokens": cost_data.get(
-                                        "output_tokens", 0
-                                    ),
-                                    "total_tokens": cost_data.get(
-                                        "input_tokens", 0
-                                    )
-                                    + cost_data.get("output_tokens", 0),
-                                },
-                            }
+                                remaining_balance_msats = fresh_key.balance
+                                # Merge cost into usage
+                                usage_chunk_data["usage"]["cost"] = cost_data.get(
+                                    "total_usd", 0.0
+                                )
+                                usage_chunk_data["usage"]["cost_sats"] = (
+                                    cost_data.get("total_msats", 0) // 1000
+                                )
+                                usage_chunk_data["usage"]["remaining_balance_msats"] = (
+                                    remaining_balance_msats
+                                )
+                                # Keep detailed cost in metadata
+                                usage_chunk_data["metadata"] = usage_chunk_data.get(
+                                    "metadata", {}
+                                )
+                                usage_chunk_data["metadata"]["routstr"] = {
+                                    "cost": cost_data
+                                }
+                                usage_chunk_data["metadata"]["routstr"]["cost"][
+                                    "sats_cost"
+                                ] = cost_data.get("total_msats", 0) // 1000
+                                usage_chunk_data["metadata"]["routstr"]["cost"][
+                                    "remaining_balance_msats"
+                                ] = remaining_balance_msats
+                                yield f"data: {json.dumps(usage_chunk_data)}\n\n".encode()
+                                usage_finalized = True
+                            except Exception as e:
+                                logger.exception(
+                                    "Error during usage finalization",
+                                    extra={
+                                        "key_hash": key.hashed_key[:8] + "...",
+                                        "error": str(e),
+                                    },
+                                )
+                                # Fallback: yield original usage chunk if adjustment fails
+                                yield f"data: {json.dumps(usage_chunk_data)}\n\n".encode()
 
-                        try:
-                            self.inject_cost_metadata(
-                                usage_chunk_data, cost_data, fresh_key
-                            )
-                        except Exception:
-                            logger.exception(
-                                "Failed to inject cost metadata into streaming chunk",
-                                extra={
-                                    "key_hash": key.hashed_key[:8] + "...",
-                                },
-                            )
-
-                        yield f"data: {json.dumps(usage_chunk_data)}\n\n".encode()
+                if not usage_finalized:
+                    await finalize_db_only()
 
                 if done_seen:
                     yield b"data: [DONE]\n\n"
@@ -755,8 +663,6 @@ class BaseUpstreamProvider:
 
             if requested_model:
                 response_json["model"] = requested_model
-            if "id" not in response_json or not isinstance(response_json["id"], str):
-                response_json["id"] = f"chatcmpl-{uuid.uuid4()}"
 
             cost_data = await adjust_payment_for_tokens(
                 key, response_json, session, deducted_max_cost
@@ -771,9 +677,7 @@ class BaseUpstreamProvider:
                 response_json["usage"]["cost_sats"] = (
                     cost_data.get("total_msats", 0) // 1000
                 )
-                response_json["usage"]["remaining_balance_msats"] = (
-                    remaining_balance_msats
-                )
+                response_json["usage"]["remaining_balance_msats"] = remaining_balance_msats
 
             # Keep detailed cost
             response_json["metadata"] = response_json.get("metadata", {})
@@ -849,11 +753,7 @@ class BaseUpstreamProvider:
             raise
 
     async def handle_streaming_responses_completion(
-        self,
-        response: httpx.Response,
-        key: ApiKey,
-        max_cost_for_model: int,
-        requested_model: str | None = None,
+        self, response: httpx.Response, key: ApiKey, max_cost_for_model: int, requested_model: str | None = None
     ) -> StreamingResponse:
         """Handle streaming Responses API responses with token usage tracking and cost adjustment.
 
@@ -952,108 +852,65 @@ class BaseUpstreamProvider:
                         )
                         yield prefix + part
 
-                # Always emit a cost-bearing data chunk
-                async with create_session() as session:
-                    fresh_key = await session.get(key.__class__, key.hashed_key)
-                    if fresh_key:
-                        cost_data: dict
-                        try:
-                            adjustment_input = (
-                                usage_chunk_data
-                                if usage_chunk_data is not None
-                                else {
-                                    "model": last_model_seen or "unknown",
-                                    "usage": None,
-                                }
-                            )
-                            cost_data = await adjust_payment_for_tokens(
-                                fresh_key,
-                                adjustment_input,
-                                session,
-                                max_cost_for_model,
-                            )
-                            usage_finalized = True
-                        except Exception as e:
-                            logger.exception(
-                                "Error during Responses API usage finalization",
-                                extra={
-                                    "key_hash": key.hashed_key[:8] + "...",
-                                    "error": str(e),
-                                },
-                            )
-                            cost_data = {
-                                "base_msats": 0,
-                                "input_msats": 0,
-                                "output_msats": 0,
-                                "total_msats": 0,
-                                "total_usd": 0.0,
-                                "input_tokens": 0,
-                                "output_tokens": 0,
-                            }
-
-                        if usage_chunk_data is None:
-                            usage_chunk_data = {
-                                "type": "response.completed",
-                                "response": {
-                                    "model": last_model_seen or "unknown",
-                                    "usage": {
-                                        "input_tokens": cost_data.get(
-                                            "input_tokens", 0
-                                        ),
-                                        "output_tokens": cost_data.get(
-                                            "output_tokens", 0
-                                        ),
-                                        "total_tokens": cost_data.get(
-                                            "input_tokens", 0
-                                        )
-                                        + cost_data.get("output_tokens", 0),
-                                    },
-                                },
-                                "usage": {
-                                    "input_tokens": cost_data.get(
-                                        "input_tokens", 0
-                                    ),
-                                    "output_tokens": cost_data.get(
-                                        "output_tokens", 0
-                                    ),
-                                    "total_tokens": cost_data.get(
-                                        "input_tokens", 0
+                # Stream finished, process usage if found
+                if usage_chunk_data:
+                    async with create_session() as session:
+                        fresh_key = await session.get(key.__class__, key.hashed_key)
+                        if fresh_key:
+                            try:
+                                cost_data = await adjust_payment_for_tokens(
+                                    fresh_key,
+                                    usage_chunk_data,
+                                    session,
+                                    max_cost_for_model,
+                                )
+                                remaining_balance_msats = fresh_key.balance
+                                # Merge cost into usage chunk
+                                if (
+                                    "response" in usage_chunk_data
+                                    and "usage" in usage_chunk_data["response"]
+                                ):
+                                    usage_chunk_data["response"]["usage"]["cost"] = (
+                                        cost_data.get("total_usd", 0.0)
                                     )
-                                    + cost_data.get("output_tokens", 0),
-                                },
-                            }
+                                    usage_chunk_data["response"]["usage"][
+                                        "cost_sats"
+                                    ] = cost_data.get("total_msats", 0) // 1000
+                                    usage_chunk_data["response"]["usage"][
+                                        "remaining_balance_msats"
+                                    ] = remaining_balance_msats
+                                elif "usage" in usage_chunk_data:
+                                    usage_chunk_data["usage"]["cost"] = cost_data.get(
+                                        "total_usd", 0.0
+                                    )
+                                    usage_chunk_data["usage"]["cost_sats"] = (
+                                        cost_data.get("total_msats", 0) // 1000
+                                    )
+                                    usage_chunk_data["usage"][
+                                        "remaining_balance_msats"
+                                    ] = remaining_balance_msats
 
-                        remaining_balance_msats = fresh_key.balance
-                        sats_cost = cost_data.get("total_msats", 0) // 1000
+                                # Keep detailed cost in metadata
+                                usage_chunk_data["metadata"] = usage_chunk_data.get(
+                                    "metadata", {}
+                                )
+                                usage_chunk_data["metadata"]["routstr"] = {
+                                    "cost": cost_data
+                                }
+                                usage_chunk_data["metadata"]["routstr"]["cost"][
+                                    "sats_cost"
+                                ] = cost_data.get("total_msats", 0) // 1000
+                                usage_chunk_data["metadata"]["routstr"]["cost"][
+                                    "remaining_balance_msats"
+                                ] = remaining_balance_msats
+                                yield f"data: {json.dumps(usage_chunk_data)}\n\n".encode()
+                                usage_finalized = True
+                            except Exception:
+                                # Fallback: yield original usage chunk if adjustment fails
+                                yield f"data: {json.dumps(usage_chunk_data)}\n\n".encode()
 
-                        if (
-                            "response" in usage_chunk_data
-                            and isinstance(usage_chunk_data["response"], dict)
-                            and "usage" in usage_chunk_data["response"]
-                        ):
-                            usage_chunk_data["response"]["usage"]["cost"] = (
-                                cost_data.get("total_usd", 0.0)
-                            )
-                            usage_chunk_data["response"]["usage"][
-                                "cost_sats"
-                            ] = sats_cost
-                            usage_chunk_data["response"]["usage"][
-                                "remaining_balance_msats"
-                            ] = remaining_balance_msats
-
-                        try:
-                            self.inject_cost_metadata(
-                                usage_chunk_data, cost_data, fresh_key
-                            )
-                        except Exception:
-                            logger.exception(
-                                "Failed to inject cost metadata into Responses streaming chunk",
-                                extra={
-                                    "key_hash": key.hashed_key[:8] + "...",
-                                },
-                            )
-
-                        yield f"data: {json.dumps(usage_chunk_data)}\n\n".encode()
+                if not usage_finalized:
+                    await finalize_db_only()
 
                 if done_seen:
                     yield b"data: [DONE]\n\n"
@@ -1129,8 +986,6 @@ class BaseUpstreamProvider:
 
             if requested_model:
                 response_json["model"] = requested_model
-            if "id" not in response_json or not isinstance(response_json["id"], str):
-                response_json["id"] = f"chatcmpl-{uuid.uuid4()}"
 
             cost_data = await adjust_payment_for_tokens(
                 key, response_json, session, deducted_max_cost
@@ -1145,9 +1000,7 @@ class BaseUpstreamProvider:
                 response_json["usage"]["cost_sats"] = (
                     cost_data.get("total_msats", 0) // 1000
                 )
-                response_json["usage"]["remaining_balance_msats"] = (
-                    remaining_balance_msats
-                )
+                response_json["usage"]["remaining_balance_msats"] = remaining_balance_msats
 
             # Keep detailed cost
             response_json["metadata"] = response_json.get("metadata", {})
@@ -1261,11 +1114,7 @@ class BaseUpstreamProvider:
                 )
 
     async def handle_streaming_messages_completion(
-        self,
-        response: httpx.Response,
-        key: ApiKey,
-        max_cost_for_model: int,
-        requested_model: str | None = None,
+        self, response: httpx.Response, key: ApiKey, max_cost_for_model: int
     ) -> StreamingResponse:
         async def stream_with_cost(
             max_cost_for_model: int,
@@ -1304,8 +1153,6 @@ class BaseUpstreamProvider:
                     stored_chunks.append(chunk)
                     try:
                         decoded_chunk = chunk.decode("utf-8", errors="ignore")
-                        modified_lines = []
-                        changed = False
                         for line in decoded_chunk.split("\n"):
                             if line.startswith("data: "):
                                 try:
@@ -1315,20 +1162,6 @@ class BaseUpstreamProvider:
                                         if msg and msg.get("model"):
                                             last_model_seen = str(msg.get("model"))
 
-                                        if requested_model:
-                                            # Apply requested_model override
-                                            model_updated = False
-                                            if msg:
-                                                msg["model"] = requested_model
-                                                model_updated = True
-                                            if data.get("model"):
-                                                data["model"] = requested_model
-                                                model_updated = True
-
-                                            if model_updated:
-                                                line = "data: " + json.dumps(data)
-                                                changed = True
-
                                         if usage := msg.get("usage"):
                                             input_tokens += usage.get("input_tokens", 0)
                                             output_tokens += usage.get(
@@ -1342,14 +1175,10 @@ class BaseUpstreamProvider:
                                             )
                                 except json.JSONDecodeError:
                                     pass
-                            modified_lines.append(line)
-
-                        if changed:
-                            yield "\n".join(modified_lines).encode("utf-8")
-                        else:
-                            yield chunk
                     except Exception:
-                        yield chunk
+                        pass
+
+                    yield chunk
 
                 usage_data = {
                     "input_tokens": input_tokens,
@@ -1371,14 +1200,8 @@ class BaseUpstreamProvider:
                                     new_session,
                                     max_cost_for_model,
                                 )
-
-                                self.inject_cost_metadata(
-                                    combined_data, cost_data, fresh_key
-                                )
-
                                 usage_finalized = True
-                                # Emit the full combined_data as the cost
-                                yield f"event: cost\ndata: {json.dumps(combined_data)}\n\n".encode()
+                                yield f"event: cost\ndata: {json.dumps({'cost': cost_data})}\n\n".encode()
                             except Exception:
                                 pass
 
@@ -1416,22 +1239,11 @@ class BaseUpstreamProvider:
         session: AsyncSession,
         deducted_max_cost: int,
         path: str,
-        requested_model: str | None = None,
     ) -> Response:
         try:
             content = await response.aread()
             response_json = json.loads(content)
 
-            if requested_model:
-                if "model" in response_json:
-                    response_json["model"] = requested_model
-                if (
-                    "message" in response_json
-                    and isinstance(response_json["message"], dict)
-                    and "model" in response_json["message"]
-                ):
-                    response_json["message"]["model"] = requested_model
-
             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}
@@ -1439,8 +1251,7 @@ class BaseUpstreamProvider:
             cost_data = await adjust_payment_for_tokens(
                 key, response_json, session, deducted_max_cost
             )
-
-            self.inject_cost_metadata(response_json, cost_data, key)
+            response_json["cost"] = cost_data
 
             allowed_headers = {
                 "content-type",
@@ -1498,9 +1309,7 @@ class BaseUpstreamProvider:
         path = self.normalize_request_path(path, model_obj)
         url = self.build_request_url(path, model_obj)
 
-        original_model_id = (
-            (model_obj.forwarded_model_id or model_obj.id) if model_obj else None
-        )
+        original_model_id = (model_obj.forwarded_model_id or model_obj.id) if model_obj else None
 
         transformed_body = self.prepare_request_body(request_body, model_obj)
 
@@ -1545,28 +1354,15 @@ class BaseUpstreamProvider:
                     stream=True,
                 )
 
-            if response.status_code != 200:
-                logger.error(
-                    "Received upstream response",
-                    extra={
-                        "reason_phrase": response.reason_phrase,
-                        "status_code": response.status_code,
-                        "path": path,
-                        "key_hash": key.hashed_key[:8] + "...",
-                        "content_type": response.headers.get("content-type", "unknown"),
-                    },
-                )
-            else:
-                logger.info(
-                    "Received upstream response",
-                    extra={
-                        "reason_phrase": response.reason_phrase,
-                        "status_code": response.status_code,
-                        "path": path,
-                        "key_hash": key.hashed_key[:8] + "...",
-                        "content_type": response.headers.get("content-type", "unknown"),
-                    },
-                )
+            logger.info(
+                "Received upstream response",
+                extra={
+                    "status_code": response.status_code,
+                    "path": path,
+                    "key_hash": key.hashed_key[:8] + "...",
+                    "content_type": response.headers.get("content-type", "unknown"),
+                },
+            )
 
             if response.status_code != 200:
                 if response.status_code >= 500:
@@ -1578,7 +1374,7 @@ class BaseUpstreamProvider:
                     )
 
                 try:
-                    mapped_error = await self.forward_upstream_error_response(
+                    mapped_error = await self.map_upstream_error_response(
                         request, path, response
                     )
                 finally:
@@ -1607,10 +1403,7 @@ class BaseUpstreamProvider:
 
                     if is_streaming and response.status_code == 200:
                         result = await self.handle_streaming_messages_completion(
-                            response,
-                            key,
-                            max_cost_for_model,
-                            requested_model=original_model_id,
+                            response, key, max_cost_for_model
                         )
                         background_tasks = BackgroundTasks()
                         background_tasks.add_task(response.aclose)
@@ -1621,12 +1414,7 @@ class BaseUpstreamProvider:
                     if response.status_code == 200:
                         try:
                             return await self.handle_non_streaming_messages_completion(
-                                response,
-                                key,
-                                session,
-                                max_cost_for_model,
-                                path,
-                                requested_model=original_model_id,
+                                response, key, session, max_cost_for_model, path
                             )
                         finally:
                             await response.aclose()
@@ -1636,12 +1424,7 @@ class BaseUpstreamProvider:
                     if response.status_code == 200:
                         try:
                             return await self.handle_non_streaming_messages_completion(
-                                response,
-                                key,
-                                session,
-                                max_cost_for_model,
-                                path,
-                                requested_model=original_model_id,
+                                response, key, session, max_cost_for_model, path
                             )
                         finally:
                             await response.aclose()
@@ -1686,10 +1469,7 @@ class BaseUpstreamProvider:
                         background_tasks.add_task(response.aclose)
                         background_tasks.add_task(client.aclose)
                         result = await self.handle_streaming_chat_completion(
-                            response,
-                            key,
-                            max_cost_for_model,
-                            background_tasks,
+                            response, key, max_cost_for_model, background_tasks,
                             requested_model=original_model_id,
                         )
                         result.background = background_tasks
@@ -1699,10 +1479,7 @@ class BaseUpstreamProvider:
                 if response.status_code == 200:
                     try:
                         return await self.handle_non_streaming_chat_completion(
-                            response,
-                            key,
-                            session,
-                            max_cost_for_model,
+                            response, key, session, max_cost_for_model,
                             requested_model=original_model_id,
                         )
                     finally:
@@ -1818,9 +1595,7 @@ class BaseUpstreamProvider:
         path = self.normalize_request_path(path, model_obj)
         url = self.build_request_url(path, model_obj)
 
-        original_model_id = (
-            (model_obj.forwarded_model_id or model_obj.id) if model_obj else None
-        )
+        original_model_id = (model_obj.forwarded_model_id or model_obj.id) if model_obj else None
 
         transformed_body = self.prepare_responses_request_body(request_body, model_obj)
 
@@ -1885,7 +1660,7 @@ class BaseUpstreamProvider:
                     )
 
                 try:
-                    mapped_error = await self.forward_upstream_error_response(
+                    mapped_error = await self.map_upstream_error_response(
                         request, path, response
                     )
                 finally:
@@ -1908,9 +1683,7 @@ class BaseUpstreamProvider:
 
                 if is_streaming and response.status_code == 200:
                     result = await self.handle_streaming_responses_completion(
-                        response,
-                        key,
-                        max_cost_for_model,
+                        response, key, max_cost_for_model,
                         requested_model=original_model_id,
                     )
                     background_tasks = BackgroundTasks()
@@ -1922,10 +1695,7 @@ class BaseUpstreamProvider:
                 if response.status_code == 200:
                     try:
                         return await self.handle_non_streaming_responses_completion(
-                            response,
-                            key,
-                            session,
-                            max_cost_for_model,
+                            response, key, session, max_cost_for_model,
                             requested_model=original_model_id,
                         )
                     finally:
@@ -2057,7 +1827,7 @@ class BaseUpstreamProvider:
                 )
                 if response.status_code != 200:
                     try:
-                        mapped = await self.forward_upstream_error_response(
+                        mapped = await self.map_upstream_error_response(
                             request, path, response
                         )
                     finally:
@@ -2352,10 +2122,7 @@ class BaseUpstreamProvider:
                         )
 
                         refund_token = await self.send_refund(
-                            refund_amount,
-                            unit,
-                            mint,
-                            payment_token_hash,
+                            refund_amount, unit, mint, payment_token_hash,
                             request_id=request_id,
                         )
                         response_headers["X-Cashu"] = refund_token
@@ -2397,9 +2164,7 @@ class BaseUpstreamProvider:
                     try:
                         data_json = json.loads(line[6:])
                         if "usage" in data_json and data_json["usage"]:
-                            data_json["usage"]["cost_sats"] = (
-                                cost_data.total_msats // 1000
-                            )
+                            data_json["usage"]["cost_sats"] = cost_data.total_msats // 1000
                             lines[i] = "data: " + json.dumps(data_json)
                     except json.JSONDecodeError:
                         pass
@@ -2500,10 +2265,7 @@ class BaseUpstreamProvider:
 
             if refund_amount > 0:
                 refund_token = await self.send_refund(
-                    refund_amount,
-                    unit,
-                    mint,
-                    payment_token_hash,
+                    refund_amount, unit, mint, payment_token_hash,
                     request_id=request_id,
                 )
                 response_headers["X-Cashu"] = refund_token
@@ -2558,6 +2320,7 @@ class BaseUpstreamProvider:
                 extra={
                     "original_amount": amount,
                     "refund_amount": emergency_refund,
+                    "deduction": 60,
                 },
             )
 
@@ -2711,25 +2474,14 @@ class BaseUpstreamProvider:
                     stream=True,
                 )
 
-                if response.status_code != 200:
-                    logger.error(
-                        "Received upstream response",
-                        extra={
-                            "reason_phrase": response.reason_phrase,
-                            "status_code": response.status_code,
-                            "path": path,
-                            "response_headers": dict(response.headers),
-                        },
-                    )
-                else:
-                    logger.debug(
-                        "Received upstream response",
-                        extra={
-                            "status_code": response.status_code,
-                            "path": path,
-                            "response_headers": dict(response.headers),
-                        },
-                    )
+                logger.debug(
+                    "Received upstream response",
+                    extra={
+                        "status_code": response.status_code,
+                        "path": path,
+                        "response_headers": dict(response.headers),
+                    },
+                )
 
                 if response.status_code != 200:
                     logger.warning(
@@ -2743,10 +2495,7 @@ class BaseUpstreamProvider:
                     )
 
                     refund_token = await self.send_refund(
-                        amount,
-                        unit,
-                        mint,
-                        payment_token_hash,
+                        amount - 60, unit, mint, payment_token_hash,
                         request_id=getattr(request.state, "request_id", None),
                     )
 
@@ -3038,10 +2787,7 @@ class BaseUpstreamProvider:
                     )
 
                     refund_token = await self.send_refund(
-                        amount,
-                        unit,
-                        mint,
-                        payment_token_hash,
+                        amount - 60, unit, mint, payment_token_hash,
                         request_id=getattr(request.state, "request_id", None),
                     )
 
@@ -3305,10 +3051,7 @@ class BaseUpstreamProvider:
                         )
 
                         refund_token = await self.send_refund(
-                            refund_amount,
-                            unit,
-                            mint,
-                            payment_token_hash,
+                            refund_amount, unit, mint, payment_token_hash,
                             request_id=request_id,
                         )
                         response_headers["X-Cashu"] = refund_token
@@ -3350,9 +3093,7 @@ class BaseUpstreamProvider:
                     try:
                         data_json = json.loads(line[6:])
                         if "usage" in data_json and data_json["usage"]:
-                            data_json["usage"]["cost_sats"] = (
-                                cost_data.total_msats // 1000
-                            )
+                            data_json["usage"]["cost_sats"] = cost_data.total_msats // 1000
                             lines[i] = "data: " + json.dumps(data_json)
                     except json.JSONDecodeError:
                         pass
@@ -3441,10 +3182,7 @@ class BaseUpstreamProvider:
 
             if refund_amount > 0:
                 refund_token = await self.send_refund(
-                    refund_amount,
-                    unit,
-                    mint,
-                    payment_token_hash,
+                    refund_amount, unit, mint, payment_token_hash,
                     request_id=request_id,
                 )
                 response_headers["X-Cashu"] = refund_token
@@ -3499,6 +3237,7 @@ class BaseUpstreamProvider:
                 extra={
                     "original_amount": amount,
                     "refund_amount": emergency_refund,
+                    "deduction": 60,
                 },
             )
 

routstr/upstream/helpers.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import asyncio
 import os
 import re
-from typing import TYPE_CHECKING, Callable
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from ..core.settings import Settings
@@ -122,16 +122,12 @@ async def get_all_models_with_overrides(
 
 
 async def refresh_upstreams_models_periodically(
-    upstreams_provider: (
-        Callable[[], list[BaseUpstreamProvider]] | list[BaseUpstreamProvider]
-    ),
+    upstreams: list[BaseUpstreamProvider],
 ) -> None:
     """Background task to periodically refresh models cache for all providers.
 
     Args:
-        upstreams_provider: Either a callable returning the live upstream list
-            (preferred — picks up providers added/changed via reinitialize_upstreams),
-            or a static list (legacy, will go stale after reinitialize_upstreams).
+        upstreams: List of upstream provider instances
     """
     import asyncio
     import random
@@ -143,14 +139,9 @@ async def refresh_upstreams_models_periodically(
         logger.info("Provider models refresh disabled (interval <= 0)")
         return
 
-    def _resolve_upstreams() -> list[BaseUpstreamProvider]:
-        if callable(upstreams_provider):
-            return upstreams_provider()
-        return upstreams_provider
-
     while True:
         try:
-            for upstream in _resolve_upstreams():
+            for upstream in upstreams:
                 try:
                     await upstream.refresh_models_cache()
                 except Exception as e:

routstr/upstream/ppqai.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 import httpx
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 
 from ..core.logging import get_logger
 from ..payment.models import Architecture, Model, Pricing, async_fetch_openrouter_models
@@ -16,20 +16,18 @@ logger = get_logger(__name__)
 
 
 class PPQAIModelPricing(BaseModel):
-    ui: Optional[dict[str, float]] = None
-    api: Optional[dict[str, float]] = None
-    input_per_1M_tokens: Optional[float] = Field(None, alias="input_per_1M_tokens")
-    output_per_1M_tokens: Optional[float] = Field(None, alias="output_per_1M_tokens")
+    ui: dict[str, float]
+    api: dict[str, float]
 
 
 class PPQAIModel(BaseModel):
     id: str
-    provider: Optional[str] = None
+    provider: str
     name: str
     created_at: int
     context_length: int
     pricing: PPQAIModelPricing
-    popular: bool = False
+    popular: bool
 
 
 class PPQAIUpstreamProvider(BaseUpstreamProvider):
@@ -136,54 +134,31 @@ class PPQAIUpstreamProvider(BaseUpstreamProvider):
                         )
 
                         if or_model:
-                            input_price = None
-                            if ppqai_model.pricing.api:
-                                input_price = ppqai_model.pricing.api.get(
-                                    "input_per_1M"
-                                )
-                            elif ppqai_model.pricing.input_per_1M_tokens:
-                                input_price = ppqai_model.pricing.input_per_1M_tokens
-
-                            if input_price is not None:
+                            if input_price := ppqai_model.pricing.api.get(
+                                "input_per_1M"
+                            ):
                                 or_model.pricing.prompt = input_price / 1_000_000
-
-                            output_price = None
-                            if ppqai_model.pricing.api:
-                                output_price = ppqai_model.pricing.api.get(
-                                    "output_per_1M"
-                                )
-                            elif ppqai_model.pricing.output_per_1M_tokens:
-                                output_price = ppqai_model.pricing.output_per_1M_tokens
-
-                            if output_price is not None:
+                            if output_price := ppqai_model.pricing.api.get(
+                                "output_per_1M"
+                            ):
                                 or_model.pricing.completion = output_price / 1_000_000
-
                             if cl := ppqai_model.context_length:
                                 or_model.context_length = cl
                             models.append(or_model)
                         else:
-                            input_price = 0.0
-                            if ppqai_model.pricing.api:
-                                input_price = ppqai_model.pricing.api.get(
-                                    "input_per_1M", 0.0
-                                )
-                            elif ppqai_model.pricing.input_per_1M_tokens:
-                                input_price = ppqai_model.pricing.input_per_1M_tokens
-
-                            output_price = 0.0
-                            if ppqai_model.pricing.api:
-                                output_price = ppqai_model.pricing.api.get(
-                                    "output_per_1M", 0.0
-                                )
-                            elif ppqai_model.pricing.output_per_1M_tokens:
-                                output_price = ppqai_model.pricing.output_per_1M_tokens
+                            input_price = ppqai_model.pricing.api.get(
+                                "input_per_1M", 0.0
+                            )
+                            output_price = ppqai_model.pricing.api.get(
+                                "output_per_1M", 0.0
+                            )
 
                             models.append(
                                 Model(
                                     id=ppqai_model.id,
                                     name=ppqai_model.name,
                                     created=ppqai_model.created_at // 1000,
-                                    description=f"{ppqai_model.provider or 'PPQ.AI'} model",
+                                    description=f"{ppqai_model.provider} model",
                                     context_length=ppqai_model.context_length,
                                     architecture=Architecture(
                                         modality="text->text",

routstr/wallet.py

@@ -8,7 +8,6 @@ from cashu.wallet.wallet import Wallet
 from sqlmodel import col, select, update
 
 from .core import db, get_logger
-from .core.db import store_cashu_transaction
 from .core.settings import settings
 from .payment.lnurl import raw_send_to_lnurl
 
@@ -156,20 +155,6 @@ async def swap_to_primary_mint(
         raise ValueError("Invalid unit")
     primary_wallet = await get_wallet(settings.primary_mint, settings.primary_mint_unit)
 
-    # If the token is already from the primary mint, we don't need to swap
-    # and we definitely don't want to calculate or pay fees.
-    if token_obj.mint == settings.primary_mint:
-        logger.info(
-            "swap_to_primary_mint: token already on primary mint, skipping swap",
-            extra={
-                "mint": token_obj.mint,
-                "amount": token_amount,
-                "unit": token_obj.unit,
-            },
-        )
-        await token_wallet.split(proofs=token_obj.proofs, amount=0, include_fees=True)
-        return token_amount, token_obj.unit, token_obj.mint
-
     minted_amount = await _calculate_swap_amount(
         amount_msat,
         token_obj.unit,
@@ -280,8 +265,6 @@ async def credit_balance(
 
     try:
         amount, unit, mint_url = await recieve_token(cashu_token)
-        original_amount = amount
-        original_unit = unit
         logger.info(
             "credit_balance: Token redeemed successfully",
             extra={"amount": amount, "unit": unit, "mint_url": mint_url},
@@ -313,19 +296,6 @@ async def credit_balance(
             extra={"new_balance": key.balance},
         )
 
-        try:
-            await store_cashu_transaction(
-                token=cashu_token,
-                amount=original_amount,
-                unit=original_unit,
-                mint_url=mint_url,
-                typ="in",
-                source="apikey",
-                api_key_hashed_key=key.hashed_key,
-            )
-        except Exception:
-            pass
-
         logger.info(
             "Cashu token successfully redeemed and stored",
             extra={"amount": amount, "unit": unit, "mint_url": mint_url},
@@ -565,7 +535,7 @@ async def periodic_refund_sweep() -> None:
                     except Exception as e:
                         error_msg = str(e).lower()
                         if "already spent" in error_msg:
-                            refund.collected = True
+                            refund.swept = True
                             session.add(refund)
                             logger.info(
                                 "Refund already spent (client collected), marking swept",
@@ -589,46 +559,6 @@ async def periodic_refund_sweep() -> None:
             )
 
 
-async def periodic_routstr_fee_payout() -> None:
-    from .auth import (
-        ROUTSTR_FEE_DEFAULT_PAYOUT,
-        ROUTSTR_FEE_PAYOUT_INTERVAL_SECONDS,
-        ROUTSTR_LN_ADDRESS,
-    )
-
-    if not ROUTSTR_LN_ADDRESS:
-        logger.info("ROUTSTR_LN_ADDRESS not set, skipping fee payout")
-        return
-    while True:
-        await asyncio.sleep(ROUTSTR_FEE_PAYOUT_INTERVAL_SECONDS)
-        try:
-            async with db.create_session() as session:
-                fee = await db.get_routstr_fee(session)
-                accumulated_sats = fee.accumulated_msats // 1000
-                if accumulated_sats >= ROUTSTR_FEE_DEFAULT_PAYOUT:
-                    wallet = await get_wallet(settings.primary_mint, "sat")
-                    proofs = get_proofs_per_mint_and_unit(
-                        wallet, settings.primary_mint, "sat", not_reserved=True
-                    )
-                    amount_received = await raw_send_to_lnurl(
-                        wallet, proofs, ROUTSTR_LN_ADDRESS, "sat", amount=accumulated_sats
-                    )
-                    paid_msats = accumulated_sats * 1000
-                    await db.reset_routstr_fee(session, paid_msats)
-                    logger.info(
-                        "Routstr fee payout sent",
-                        extra={
-                            "accumulated_sats": accumulated_sats,
-                            "amount_received": amount_received,
-                        },
-                    )
-        except Exception as e:
-            logger.error(
-                f"Error in Routstr fee payout: {type(e).__name__}",
-                extra={"error": str(e)},
-            )
-
-
 async def send_to_lnurl(amount: int, unit: str, mint: str, address: str) -> int:
     wallet = await get_wallet(mint, unit)
     proofs = wallet._get_proofs_per_keyset(wallet.proofs)[wallet.keyset_id]

tests/integration/test_cli_tokens.py

@@ -1,302 +0,0 @@
-"""Integration tests for CLI token management (/admin/api/cli-tokens).
-
-Covers:
-- GET    /admin/api/cli-tokens           — list (preview only, no full token)
-- POST   /admin/api/cli-tokens           — create (returns full token once)
-- DELETE /admin/api/cli-tokens/{id}      — revoke
-- Using a CLI token as Bearer auth against admin endpoints
-- Expiry enforcement (expired tokens are rejected by require_admin_api)
-- last_used_at bump on successful use
-- Auth failures: missing token, wrong token, revoked token
-"""
-
-from __future__ import annotations
-
-import secrets
-import time
-from typing import AsyncGenerator
-
-import pytest
-import pytest_asyncio
-from httpx import AsyncClient
-from sqlmodel import select
-
-from routstr.core.admin import admin_sessions
-from routstr.core.db import AsyncSession, CliToken
-
-# ──────────────────────────────────────────────────────────────────────────────
-# Fixtures
-# ──────────────────────────────────────────────────────────────────────────────
-
-@pytest_asyncio.fixture
-async def admin_session_token() -> AsyncGenerator[str, None]:
-    """Inject a short-lived admin session token into admin_sessions."""
-    token = secrets.token_urlsafe(24)
-    admin_sessions[token] = int(time.time()) + 3600
-    yield token
-    admin_sessions.pop(token, None)
-
-
-@pytest_asyncio.fixture
-async def admin_client(
-    integration_client: AsyncClient, admin_session_token: str
-) -> AsyncClient:
-    """An integration_client pre-authenticated with an admin session token."""
-    integration_client.headers["Authorization"] = f"Bearer {admin_session_token}"
-    return integration_client
-
-
-# ──────────────────────────────────────────────────────────────────────────────
-# Creation
-# ──────────────────────────────────────────────────────────────────────────────
-
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_create_cli_token_returns_full_token_once(
-    admin_client: AsyncClient,
-) -> None:
-    """POST /admin/api/cli-tokens returns the raw token only on creation."""
-    resp = await admin_client.post(
-        "/admin/api/cli-tokens",
-        json={"name": "my-laptop"},
-    )
-    assert resp.status_code == 200
-    body = resp.json()
-
-    assert body["name"] == "my-laptop"
-    assert isinstance(body["id"], str) and body["id"]
-    assert isinstance(body["token"], str) and len(body["token"]) >= 32
-    assert body["expires_at"] is None
-    assert isinstance(body["created_at"], int)
-
-
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_create_cli_token_with_expiry(admin_client: AsyncClient) -> None:
-    """expires_in_days sets expires_at ~= now + days * 86400."""
-    before = int(time.time())
-    resp = await admin_client.post(
-        "/admin/api/cli-tokens",
-        json={"name": "ci-runner", "expires_in_days": 7},
-    )
-    assert resp.status_code == 200
-    body = resp.json()
-
-    assert body["expires_at"] is not None
-    delta = body["expires_at"] - before
-    # Allow 10s jitter around 7 * 86400
-    assert 7 * 86400 - 10 <= delta <= 7 * 86400 + 10
-
-
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_create_cli_token_rejects_empty_name(
-    admin_client: AsyncClient,
-) -> None:
-    resp = await admin_client.post(
-        "/admin/api/cli-tokens", json={"name": "   "}
-    )
-    assert resp.status_code == 400
-
-
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_create_cli_token_requires_admin(
-    integration_client: AsyncClient,
-) -> None:
-    """No admin token / no bearer → 403."""
-    resp = await integration_client.post(
-        "/admin/api/cli-tokens", json={"name": "no-auth"}
-    )
-    assert resp.status_code == 403
-
-
-# ──────────────────────────────────────────────────────────────────────────────
-# Listing
-# ──────────────────────────────────────────────────────────────────────────────
-
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_list_cli_tokens_returns_preview_not_full_token(
-    admin_client: AsyncClient,
-) -> None:
-    """Listing never leaks the raw token."""
-    create = await admin_client.post(
-        "/admin/api/cli-tokens", json={"name": "secret-keeper"}
-    )
-    assert create.status_code == 200
-    full_token = create.json()["token"]
-
-    resp = await admin_client.get("/admin/api/cli-tokens")
-    assert resp.status_code == 200
-    items = resp.json()
-    assert any(t["name"] == "secret-keeper" for t in items)
-
-    for t in items:
-        # No 'token' field, only 'token_preview'
-        assert "token" not in t
-        assert "token_preview" in t
-        assert full_token not in t["token_preview"]
-        assert "..." in t["token_preview"]
-
-
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_list_cli_tokens_requires_admin(
-    integration_client: AsyncClient,
-) -> None:
-    resp = await integration_client.get("/admin/api/cli-tokens")
-    assert resp.status_code == 403
-
-
-# ──────────────────────────────────────────────────────────────────────────────
-# Using a CLI token as admin auth
-# ──────────────────────────────────────────────────────────────────────────────
-
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_cli_token_authorizes_admin_endpoints(
-    admin_client: AsyncClient,
-    integration_client: AsyncClient,
-    integration_session: AsyncSession,
-) -> None:
-    """A freshly-created CLI token can be used as Bearer on admin endpoints."""
-    create = await admin_client.post(
-        "/admin/api/cli-tokens", json={"name": "cli-auth"}
-    )
-    assert create.status_code == 200
-    cli_token = create.json()["token"]
-    token_id = create.json()["id"]
-
-    # Use a NEW client to isolate the header from admin_session_token
-    integration_client.headers["Authorization"] = f"Bearer {cli_token}"
-    resp = await integration_client.get("/admin/api/cli-tokens")
-    assert resp.status_code == 200
-
-    # last_used_at should be populated after use
-    row = await integration_session.get(CliToken, token_id)
-    assert row is not None
-    assert row.last_used_at is not None
-    assert row.last_used_at >= row.created_at
-
-
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_expired_cli_token_is_rejected(
-    admin_client: AsyncClient,
-    integration_client: AsyncClient,
-    integration_session: AsyncSession,
-) -> None:
-    """A CLI token with expires_at in the past → 403."""
-    create = await admin_client.post(
-        "/admin/api/cli-tokens",
-        json={"name": "will-expire", "expires_in_days": 1},
-    )
-    assert create.status_code == 200
-    cli_token = create.json()["token"]
-    token_id = create.json()["id"]
-
-    # Force-expire it in the DB
-    row = await integration_session.get(CliToken, token_id)
-    assert row is not None
-    row.expires_at = int(time.time()) - 1
-    integration_session.add(row)
-    await integration_session.commit()
-
-    integration_client.headers["Authorization"] = f"Bearer {cli_token}"
-    resp = await integration_client.get("/admin/api/cli-tokens")
-    assert resp.status_code == 403
-
-
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_invalid_bearer_token_is_rejected(
-    integration_client: AsyncClient,
-) -> None:
-    integration_client.headers["Authorization"] = "Bearer not-a-real-token"
-    resp = await integration_client.get("/admin/api/cli-tokens")
-    assert resp.status_code == 403
-
-
-# ──────────────────────────────────────────────────────────────────────────────
-# Revocation
-# ──────────────────────────────────────────────────────────────────────────────
-
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_revoke_cli_token_removes_auth(
-    admin_client: AsyncClient,
-    integration_client: AsyncClient,
-    integration_session: AsyncSession,
-) -> None:
-    """After DELETE, the token no longer authorizes."""
-    create = await admin_client.post(
-        "/admin/api/cli-tokens", json={"name": "to-revoke"}
-    )
-    token_id = create.json()["id"]
-    cli_token = create.json()["token"]
-
-    revoke = await admin_client.delete(f"/admin/api/cli-tokens/{token_id}")
-    assert revoke.status_code == 200
-    assert revoke.json() == {"ok": True, "deleted_id": token_id}
-
-    # Row is gone
-    row = await integration_session.get(CliToken, token_id)
-    assert row is None
-
-    # Can no longer be used for auth
-    integration_client.headers["Authorization"] = f"Bearer {cli_token}"
-    resp = await integration_client.get("/admin/api/cli-tokens")
-    assert resp.status_code == 403
-
-
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_revoke_unknown_cli_token_returns_404(
-    admin_client: AsyncClient,
-) -> None:
-    resp = await admin_client.delete("/admin/api/cli-tokens/does-not-exist")
-    assert resp.status_code == 404
-
-
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_revoke_cli_token_requires_admin(
-    integration_client: AsyncClient,
-) -> None:
-    resp = await integration_client.delete("/admin/api/cli-tokens/anything")
-    assert resp.status_code == 403
-
-
-# ──────────────────────────────────────────────────────────────────────────────
-# Lifecycle / uniqueness
-# ──────────────────────────────────────────────────────────────────────────────
-
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_multiple_tokens_are_independent(
-    admin_client: AsyncClient,
-    integration_session: AsyncSession,
-) -> None:
-    """Creating N tokens yields N unique tokens that all live in DB."""
-    names = ["dev-a", "dev-b", "dev-c"]
-    raw_tokens: list[str] = []
-    ids: list[str] = []
-    for name in names:
-        r = await admin_client.post(
-            "/admin/api/cli-tokens", json={"name": name}
-        )
-        assert r.status_code == 200
-        raw_tokens.append(r.json()["token"])
-        ids.append(r.json()["id"])
-
-    # All unique
-    assert len(set(raw_tokens)) == len(raw_tokens)
-    assert len(set(ids)) == len(ids)
-
-    # All in DB
-    result = await integration_session.exec(
-        select(CliToken).where(CliToken.name.in_(names))  # type: ignore[attr-defined]
-    )
-    rows = result.all()
-    assert {r.name for r in rows} == set(names)

tests/integration/test_wallet_refund.py

@@ -13,7 +13,7 @@ import pytest
 from httpx import AsyncClient
 from sqlmodel import select
 
-from routstr.core.db import ApiKey, CashuTransaction
+from routstr.core.db import ApiKey
 
 
 @pytest.mark.integration
@@ -356,70 +356,6 @@ async def test_concurrent_refund_requests(
     assert len(successful) + len(failed) == 5
 
 
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_refund_rejects_concurrent_topup_on_same_key(
-    authenticated_client: AsyncClient,
-    testmint_wallet: Any,
-) -> None:
-    """Test refund returns 409 when a concurrent topup changes the balance first."""
-    from routstr import balance as balance_module
-
-    wallet_response = await authenticated_client.get("/v1/wallet/")
-    assert wallet_response.status_code == 200
-    initial_balance = wallet_response.json()["balance"]
-
-    topup_amount_sat = 500
-    topup_token = await testmint_wallet.mint_tokens(topup_amount_sat)
-
-    validate_called = asyncio.Event()
-    allow_refund_to_continue = asyncio.Event()
-    original_validate_bearer_key = balance_module.validate_bearer_key
-    delayed_once = False
-
-    async def delayed_validate_bearer_key(*args: Any, **kwargs: Any) -> ApiKey:
-        nonlocal delayed_once
-        key = await original_validate_bearer_key(*args, **kwargs)
-        if not delayed_once:
-            delayed_once = True
-            validate_called.set()
-            await allow_refund_to_continue.wait()
-        return key
-
-    async def issue_refund() -> Any:
-        return await authenticated_client.post("/v1/wallet/refund")
-
-    async def issue_topup() -> Any:
-        await validate_called.wait()
-        try:
-            return await authenticated_client.post(
-                "/v1/wallet/topup", params={"cashu_token": topup_token}
-            )
-        finally:
-            allow_refund_to_continue.set()
-
-    with patch(
-        "routstr.balance.validate_bearer_key", new=delayed_validate_bearer_key
-    ):
-        refund_response, topup_response = await asyncio.gather(
-            issue_refund(), issue_topup()
-        )
-
-    assert topup_response.status_code == 200
-    assert topup_response.json()["msats"] == topup_amount_sat * 1000
-    assert refund_response.status_code == 409
-    assert (
-        refund_response.json()["detail"]
-        == "Balance changed concurrently. Please retry the refund."
-    )
-
-    final_balance_response = await authenticated_client.get("/v1/wallet/")
-    assert final_balance_response.status_code == 200
-    assert final_balance_response.json()["balance"] == (
-        initial_balance + topup_amount_sat * 1000
-    )
-
-
 @pytest.mark.integration
 @pytest.mark.asyncio
 async def test_refund_during_active_usage(
@@ -458,42 +394,6 @@ async def test_refund_during_active_usage(
     assert response.json()["balance"] == 0
 
 
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_wallet_history_returns_apikey_transactions(
-    authenticated_client: AsyncClient,
-    testmint_wallet: Any,
-    integration_session: Any,
-) -> None:
-    wallet_response = await authenticated_client.get("/v1/wallet/")
-    api_key = wallet_response.json()["api_key"]
-    hashed_key = api_key[3:] if api_key.startswith("sk-") else api_key
-
-    topup_token = await testmint_wallet.mint_tokens(250)
-    topup_response = await authenticated_client.post(
-        "/v1/wallet/topup", params={"cashu_token": topup_token}
-    )
-    assert topup_response.status_code == 200
-
-    refund_response = await authenticated_client.post("/v1/wallet/refund")
-    assert refund_response.status_code == 200
-
-    history_response = await authenticated_client.get("/v1/wallet/history")
-    assert history_response.status_code == 200
-    transactions = history_response.json()["transactions"]
-    assert len(transactions) >= 2
-    assert all("api_key_hashed_key" not in tx for tx in transactions)
-    assert {tx["type"] for tx in transactions} >= {"in", "out"}
-
-    db_result = await integration_session.execute(
-        select(CashuTransaction).where(
-            CashuTransaction.api_key_hashed_key == hashed_key
-        )
-    )
-    db_transactions = db_result.scalars().all()
-    assert len(db_transactions) >= 2
-
-
 @pytest.mark.integration
 @pytest.mark.asyncio
 async def test_mint_unavailability_handling(

tests/integration/test_wallet_topup.py

@@ -11,7 +11,7 @@ import pytest
 from httpx import AsyncClient
 from sqlmodel import select
 
-from routstr.core.db import ApiKey, CashuTransaction
+from routstr.core.db import ApiKey
 
 from .utils import (
     CashuTokenGenerator,
@@ -71,16 +71,6 @@ async def test_topup_with_valid_token(  # type: ignore[no-untyped-def]
     assert db_key.balance == new_balance
     assert db_key.balance == initial_balance + (topup_amount * 1000)
 
-    tx_result = await integration_session.execute(
-        select(CashuTransaction).where(
-            CashuTransaction.token == token,
-            CashuTransaction.type == "in",
-        )
-    )
-    tx = tx_result.scalar_one()
-    assert tx.api_key_hashed_key == hashed_key
-    assert tx.source == "apikey"
-
 
 @pytest.mark.integration
 @pytest.mark.asyncio

tests/unit/test_balance.py

@@ -1,12 +1,11 @@
 import json
-from unittest.mock import AsyncMock, MagicMock, patch
+from unittest.mock import AsyncMock, MagicMock
 
 import pytest
 from fastapi.responses import JSONResponse
 
 from routstr.balance import refund_wallet_endpoint
-from routstr.core.db import ApiKey, CashuTransaction
-from routstr.wallet import credit_balance
+from routstr.core.db import CashuTransaction
 
 
 def _make_cashu_tx(
@@ -30,12 +29,6 @@ def _exec_result(tx: CashuTransaction | None) -> MagicMock:
     return result
 
 
-def _update_result(rowcount: int) -> MagicMock:
-    result = MagicMock()
-    result.rowcount = rowcount
-    return result
-
-
 @pytest.mark.asyncio
 async def test_refund_x_cashu_returns_token() -> None:
     x_cashu_token = "cashuAtest_token_value"
@@ -121,237 +114,3 @@ async def test_refund_x_cashu_swept_raises_410() -> None:
         )
 
     assert exc_info.value.status_code == 410
-
-
-# ---------------------------------------------------------------------------
-# source field defaults
-# ---------------------------------------------------------------------------
-
-
-def test_cashu_transaction_source_defaults_to_x_cashu() -> None:
-    tx = CashuTransaction(token="cashuAtest", amount=100, unit="msat")
-    assert tx.source == "x-cashu"
-
-
-def test_cashu_transaction_source_can_be_apikey() -> None:
-    tx = CashuTransaction(token="cashuAtest", amount=100, unit="msat", source="apikey")
-    assert tx.source == "apikey"
-
-
-# ---------------------------------------------------------------------------
-# apikey-based refund: token logging and CashuTransaction storage
-# ---------------------------------------------------------------------------
-
-
-def _make_api_key(
-    balance: int = 5000,
-    refund_currency: str | None = "sat",
-    refund_mint_url: str | None = "https://mint.example.com",
-    refund_address: str | None = None,
-    parent_key_hash: str | None = None,
-) -> ApiKey:
-    key = ApiKey(hashed_key="testhash")
-    key.balance = balance
-    key.reserved_balance = 0
-    key.refund_currency = refund_currency
-    key.refund_mint_url = refund_mint_url
-    key.refund_address = refund_address
-    key.parent_key_hash = parent_key_hash
-    key.total_spent = 0
-    key.total_requests = 0
-    return key
-
-
-@pytest.mark.asyncio
-async def test_apikey_refund_stores_cashu_transaction_with_apikey_source() -> None:
-    key = _make_api_key(balance=5000, refund_currency="sat")
-    refund_token = "cashuArefund_apikey_token"
-
-    session = MagicMock()
-    session.exec = AsyncMock(return_value=_update_result(1))
-    session.add = MagicMock()
-    session.commit = AsyncMock()
-
-    with (
-        patch("routstr.balance.validate_bearer_key", AsyncMock(return_value=key)),
-        patch("routstr.balance.get_billing_key", AsyncMock(return_value=key)),
-        patch("routstr.balance.send_token", AsyncMock(return_value=refund_token)),
-        patch("routstr.balance.store_cashu_transaction", AsyncMock()) as mock_store,
-        patch("routstr.balance._refund_cache_get", AsyncMock(return_value=None)),
-        patch("routstr.balance._refund_cache_set", AsyncMock()),
-    ):
-        result = await refund_wallet_endpoint(
-            authorization="Bearer sk-testhash",
-            x_cashu=None,
-            session=session,
-        )
-
-    assert isinstance(result, dict)
-    assert result["token"] == refund_token
-
-    mock_store.assert_awaited_once()
-    call_kwargs = mock_store.call_args.kwargs
-    assert call_kwargs["source"] == "apikey"
-    assert call_kwargs["token"] == refund_token
-    assert call_kwargs["typ"] == "out"
-    assert call_kwargs["api_key_hashed_key"] == key.hashed_key
-
-
-@pytest.mark.asyncio
-async def test_apikey_refund_logs_token() -> None:
-    key = _make_api_key(balance=5000, refund_currency="sat")
-    refund_token = "cashuAlogged_token"
-
-    session = MagicMock()
-    session.exec = AsyncMock(return_value=_update_result(1))
-    session.add = MagicMock()
-    session.commit = AsyncMock()
-
-    with (
-        patch("routstr.balance.validate_bearer_key", AsyncMock(return_value=key)),
-        patch("routstr.balance.get_billing_key", AsyncMock(return_value=key)),
-        patch("routstr.balance.send_token", AsyncMock(return_value=refund_token)),
-        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") as mock_logger,
-    ):
-        await refund_wallet_endpoint(
-            authorization="Bearer sk-testhash",
-            x_cashu=None,
-            session=session,
-        )
-
-    calls = [str(c) for c in mock_logger.info.call_args_list]
-    assert any("cashu token issued" in c for c in calls)
-
-
-@pytest.mark.asyncio
-async def test_apikey_refund_log_includes_path() -> None:
-    key = _make_api_key(balance=5000, refund_currency="sat")
-    refund_token = "cashuApath_token"
-
-    session = MagicMock()
-    session.exec = AsyncMock(return_value=_update_result(1))
-    session.add = MagicMock()
-    session.commit = AsyncMock()
-
-    with (
-        patch("routstr.balance.validate_bearer_key", AsyncMock(return_value=key)),
-        patch("routstr.balance.get_billing_key", AsyncMock(return_value=key)),
-        patch("routstr.balance.send_token", AsyncMock(return_value=refund_token)),
-        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") as mock_logger,
-    ):
-        await refund_wallet_endpoint(
-            authorization="Bearer sk-testhash",
-            x_cashu=None,
-            session=session,
-        )
-
-    # Find the "cashu token issued" call and verify extra contains the path
-    token_issued_calls = [
-        c for c in mock_logger.info.call_args_list
-        if c.args and "cashu token issued" in c.args[0]
-    ]
-    assert len(token_issued_calls) == 1
-    extra = token_issued_calls[0].kwargs.get("extra", {})
-    assert extra.get("path") == "/v1/wallet/refund"
-
-
-@pytest.mark.asyncio
-async def test_apikey_refund_rejects_on_concurrent_balance_change() -> None:
-    """When the debit CAS fails (rowcount=0), no token is minted and 409 is returned."""
-    from fastapi import HTTPException
-
-    key = _make_api_key(balance=5000, refund_currency="sat")
-
-    session = MagicMock()
-    # Debit returns rowcount=0 → balance changed concurrently
-    session.exec = AsyncMock(return_value=_update_result(0))
-    session.commit = AsyncMock()
-
-    mock_send_token = AsyncMock(return_value="cashuAshould_not_be_minted")
-
-    with (
-        patch("routstr.balance.validate_bearer_key", AsyncMock(return_value=key)),
-        patch("routstr.balance.get_billing_key", AsyncMock(return_value=key)),
-        patch("routstr.balance.send_token", mock_send_token),
-        patch("routstr.balance.store_cashu_transaction", AsyncMock()),
-        patch("routstr.balance._refund_cache_get", AsyncMock(return_value=None)),
-        patch("routstr.balance._refund_cache_set", AsyncMock()),
-    ):
-        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 == 409
-    # Crucially: send_token must NOT have been called
-    mock_send_token.assert_not_awaited()
-
-
-@pytest.mark.asyncio
-async def test_credit_balance_stores_apikey_transaction_history() -> None:
-    key = _make_api_key(balance=1000)
-    session = MagicMock()
-    session.exec = AsyncMock(return_value=_update_result(1))
-    session.commit = AsyncMock()
-    session.refresh = AsyncMock()
-
-    with (
-        patch(
-            "routstr.wallet.recieve_token",
-            AsyncMock(return_value=(100, "sat", "https://mint.example")),
-        ),
-        patch("routstr.wallet.store_cashu_transaction", AsyncMock()) as mock_store,
-    ):
-        amount = await credit_balance("cashuAtopup_token", key, session)
-
-    assert amount == 100_000
-    mock_store.assert_awaited_once()
-    call_kwargs = mock_store.call_args.kwargs
-    assert call_kwargs["typ"] == "in"
-    assert call_kwargs["source"] == "apikey"
-    assert call_kwargs["api_key_hashed_key"] == key.hashed_key
-    assert call_kwargs["amount"] == 100
-    assert call_kwargs["unit"] == "sat"
-    assert call_kwargs["token"] == "cashuAtopup_token"
-    assert call_kwargs["mint_url"] == "https://mint.example"
-
-
-@pytest.mark.asyncio
-async def test_apikey_refund_restores_balance_on_mint_failure() -> None:
-    """When debit succeeds but minting fails, balance must be restored."""
-    from fastapi import HTTPException
-
-    key = _make_api_key(balance=5000, refund_currency="sat")
-
-    # First exec call = debit (succeeds), second = restore
-    session = MagicMock()
-    session.exec = AsyncMock(side_effect=[_update_result(1), _update_result(1)])
-    session.commit = AsyncMock()
-
-    with (
-        patch("routstr.balance.validate_bearer_key", AsyncMock(return_value=key)),
-        patch("routstr.balance.get_billing_key", AsyncMock(return_value=key)),
-        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()),
-        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 == 503
-    # Verify two exec calls: debit + restore
-    assert session.exec.await_count == 2

tests/unit/test_models_refresh_loop.py

@@ -1,117 +0,0 @@
-"""Regression tests for the periodic upstream models refresh loop."""
-
-from __future__ import annotations
-
-import asyncio
-import os
-from typing import cast
-from unittest.mock import AsyncMock
-
-import pytest
-
-os.environ.setdefault("UPSTREAM_BASE_URL", "http://test")
-os.environ.setdefault("UPSTREAM_API_KEY", "test")
-
-from routstr.upstream.base import BaseUpstreamProvider  # noqa: E402
-
-
-class _FakeUpstream:
-    """Minimal stand-in for BaseUpstreamProvider used by the refresh loop.
-
-    Only ``base_url`` (for error logging) and ``refresh_models_cache`` (the call
-    under test) are exercised; everything else stays unused.
-    """
-
-    def __init__(self, name: str) -> None:
-        self.base_url = f"http://{name}"
-        self.refresh_models_cache = AsyncMock()
-
-
-def _make_fake_upstream(name: str) -> BaseUpstreamProvider:
-    # The loop only uses duck-typed attributes — cast keeps the test type-clean
-    # without dragging in BaseUpstreamProvider's full constructor.
-    return cast(BaseUpstreamProvider, _FakeUpstream(name))
-
-
-@pytest.mark.asyncio
-async def test_refresh_loop_picks_up_providers_added_after_startup(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """If a provider is added after the loop starts (e.g. via reinitialize_upstreams),
-    the next loop iteration must refresh it. Previously the loop captured the upstream
-    list at startup and missed any later additions."""
-    from routstr.core.settings import settings as global_settings
-    from routstr.upstream.helpers import refresh_upstreams_models_periodically
-
-    # Tight interval so the test finishes quickly.
-    monkeypatch.setattr(
-        global_settings, "models_refresh_interval_seconds", 1, raising=False
-    )
-
-    initial_upstream = _make_fake_upstream("initial")
-    live_list: list[BaseUpstreamProvider] = [initial_upstream]
-
-    # Stub out the post-iteration sats-pricing refresh so the loop body has no DB deps.
-    async def _noop_pricing_refresh() -> None:  # pragma: no cover - trivial stub
-        return None
-
-    monkeypatch.setattr(
-        "routstr.payment.models._update_sats_pricing_once",
-        _noop_pricing_refresh,
-    )
-
-    task = asyncio.create_task(
-        refresh_upstreams_models_periodically(lambda: live_list)
-    )
-
-    try:
-        # Wait for the first iteration to refresh the initial upstream.
-        for _ in range(40):
-            if initial_upstream.refresh_models_cache.await_count >= 1:  # type: ignore[attr-defined]
-                break
-            await asyncio.sleep(0.05)
-        assert initial_upstream.refresh_models_cache.await_count >= 1, (  # type: ignore[attr-defined]
-            "loop did not refresh the initial upstream within the timeout"
-        )
-
-        # Simulate reinitialize_upstreams: replace the live list contents with new
-        # provider instances. The loop must observe the swap on its next tick.
-        new_upstream = _make_fake_upstream("added-after-startup")
-        live_list[:] = [new_upstream]
-
-        for _ in range(60):
-            if new_upstream.refresh_models_cache.await_count >= 1:  # type: ignore[attr-defined]
-                break
-            await asyncio.sleep(0.05)
-
-        assert new_upstream.refresh_models_cache.await_count >= 1, (  # type: ignore[attr-defined]
-            "loop did not refresh the upstream added after startup — "
-            "regression: list snapshot captured at startup"
-        )
-    finally:
-        task.cancel()
-        try:
-            await task
-        except asyncio.CancelledError:
-            pass
-
-
-@pytest.mark.asyncio
-async def test_refresh_loop_disabled_when_interval_non_positive(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    from routstr.core.settings import settings as global_settings
-    from routstr.upstream.helpers import refresh_upstreams_models_periodically
-
-    monkeypatch.setattr(
-        global_settings, "models_refresh_interval_seconds", 0, raising=False
-    )
-
-    upstream = _make_fake_upstream("never-refreshed")
-
-    # Loop must return immediately without ever touching the upstream.
-    await asyncio.wait_for(
-        refresh_upstreams_models_periodically(lambda: [upstream]),
-        timeout=1.0,
-    )
-    upstream.refresh_models_cache.assert_not_awaited()  # type: ignore[attr-defined]

tests/unit/test_stream_id_injection.py

@@ -1,117 +0,0 @@
-import json
-from collections.abc import AsyncGenerator
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-
-from routstr.core.db import ApiKey
-from routstr.upstream.base import BaseUpstreamProvider
-
-
-@pytest.mark.asyncio
-async def test_stream_with_id_injection() -> None:
-    """Test that stream_with_cost correctly injects IDs into complete JSON chunks but skips partials."""
-    provider = BaseUpstreamProvider(
-        base_url="https://api.example.com", api_key="test_key"
-    )
-
-    # Mock response with mixed chunks:
-    # 1. Complete JSON without ID
-    # 2. Partial JSON (should be passed through)
-    # 3. Complete JSON with ID (should be preserved or updated if requested_model is set)
-    # 4. [DONE] message
-    chunks = [
-        b'data: {"choices": [{"delta": {"content": "Hello"}}]}\n\n',
-        b'data: {"choices": [{"delta": {"content": "',  # Partial
-        b'world"}}]}\n\n',
-        b'data: {"id": "existing-id", "choices": [{"delta": {"content": "!"}}]}\n\n',
-        b"data: [DONE]\n\n",
-    ]
-
-    async def aiter_bytes() -> AsyncGenerator[bytes, None]:
-        for chunk in chunks:
-            yield chunk
-
-    mock_response = MagicMock()
-    mock_response.status_code = 200
-    mock_response.headers = {"content-type": "text/event-stream"}
-    mock_response.aiter_bytes = aiter_bytes
-
-    key = MagicMock(spec=ApiKey)
-    key.hashed_key = "test_hash"
-    key.balance = 1000
-
-    background_tasks = MagicMock()
-
-    # We need to mock adjust_payment_for_tokens since it's called at the end
-    with MagicMock():
-        from routstr.upstream import base
-
-        # Mocking the module-level function used in the generator
-        base.adjust_payment_for_tokens = AsyncMock(
-            return_value={"total_usd": 0.1, "total_msats": 100}
-        )
-        # create_session() is used as an async context manager whose entered
-        # value exposes an awaitable .get(). Build a mock that behaves that
-        # way so the post-stream cost-chunk emission can run.
-        mock_session = MagicMock()
-        mock_session.get = AsyncMock(return_value=key)
-        mock_ctx = MagicMock()
-        mock_ctx.__aenter__ = AsyncMock(return_value=mock_session)
-        mock_ctx.__aexit__ = AsyncMock(return_value=None)
-        base.create_session = MagicMock(return_value=mock_ctx)
-
-        streaming_response = await provider.handle_streaming_chat_completion(
-            response=mock_response,
-            key=key,
-            max_cost_for_model=100,
-            background_tasks=background_tasks,
-            requested_model="test-model",
-        )
-
-        results = []
-        async for chunk in streaming_response.body_iterator:
-            results.append(chunk)
-
-        # Parse results
-        parsed_results = []
-        for r in results:
-            if isinstance(r, bytes) and r.startswith(b"data: "):
-                data = r[6:].decode().strip()
-                if data == "[DONE]":
-                    parsed_results.append(data)
-                else:
-                    try:
-                        parsed_results.append(json.loads(data))
-                    except (json.JSONDecodeError, UnicodeDecodeError):
-                        parsed_results.append(
-                            data
-                        )  # Keep as string if it failed to parse
-
-        # Verifications
-        # 1. First chunk should have an injected ID and the requested model
-        assert isinstance(parsed_results[0], dict)
-        assert "id" in parsed_results[0]
-        assert parsed_results[0]["id"].startswith("chatcmpl-")
-        assert parsed_results[0]["model"] == "test-model"
-
-        # 2. Second chunk was partial, should be passed as-is
-        # In current implementation, re.split(b"data: ", b'data: {...') gives ['', '{...']
-        # The first empty part is skipped. The second part is processed.
-
-        # Check that we have results
-        assert len(parsed_results) >= 4
-
-        # Find the chunk that was "existing-id"
-        id_chunk = next(
-            r
-            for r in parsed_results
-            if isinstance(r, dict)
-            and "choices" in r
-            and r["choices"][0]["delta"].get("content") == "!"
-        )
-        assert id_chunk["id"] == parsed_results[0]["id"]
-        assert id_chunk["model"] == "test-model"
-
-        # 4. [DONE] should be there
-        assert "[DONE]" in parsed_results

tests/unit/test_wallet.py

@@ -220,33 +220,6 @@ async def test_recieve_token_untrusted_mint() -> None:
 
 
 @pytest.mark.asyncio
-@pytest.mark.asyncio
-async def test_swap_to_primary_mint_already_on_primary() -> None:
-    from routstr.core.settings import settings
-    from routstr.wallet import swap_to_primary_mint
-
-    mock_token = Mock()
-    mock_token.mint = settings.primary_mint
-    mock_token.amount = 1000
-    mock_token.unit = "sat"
-    mock_token.proofs = []
-
-    mock_token_wallet = Mock()
-    mock_token_wallet.split = AsyncMock(return_value=None)
-    mock_token_wallet.request_mint = AsyncMock()
-    mock_token_wallet.melt_quote = AsyncMock()
-
-    with patch("routstr.wallet.get_wallet", AsyncMock(return_value=mock_token_wallet)):
-        amount, unit, mint = await swap_to_primary_mint(mock_token, mock_token_wallet)
-
-    assert amount == 1000
-    assert unit == "sat"
-    assert mint == settings.primary_mint
-    mock_token_wallet.split.assert_called_once()
-    mock_token_wallet.request_mint.assert_not_called()
-    mock_token_wallet.melt_quote.assert_not_called()
-
-
 async def test_swap_to_primary_mint_success() -> None:
     """Test successful swap with dynamic fee calculation."""
     from routstr.wallet import swap_to_primary_mint

ui/app/settings/page.tsx

@@ -4,7 +4,6 @@ import * as React from 'react';
 import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/components/ui/tabs';
 import { ServerConfigSettings } from '@/components/settings/server-config-settings';
 import { AdminSettings } from '@/components/settings/admin-settings';
-import { CliTokensSettings } from '@/components/settings/cli-tokens-settings';
 import { AppPageShell } from '@/components/app-page-shell';
 import { PageHeader } from '@/components/page-header';
 
@@ -20,7 +19,6 @@ export default function SettingsPage() {
           <TabsList variant='line' className='mb-4 w-full'>
             <TabsTrigger value='admin'>Admin Settings</TabsTrigger>
             <TabsTrigger value='server'>Server Config</TabsTrigger>
-            <TabsTrigger value='cli-tokens'>CLI Tokens</TabsTrigger>
           </TabsList>
           <TabsContent value='server'>
             <ServerConfigSettings />
@@ -28,9 +26,6 @@ export default function SettingsPage() {
           <TabsContent value='admin'>
             <AdminSettings />
           </TabsContent>
-          <TabsContent value='cli-tokens'>
-            <CliTokensSettings />
-          </TabsContent>
         </Tabs>
       </div>
     </AppPageShell>

ui/app/transactions/page.tsx

@@ -1,7 +1,7 @@
 'use client';
 
 import { useState, useEffect } from 'react';
-import { useQuery, keepPreviousData } from '@tanstack/react-query';
+import { useQuery } from '@tanstack/react-query';
 import { AppPageShell } from '@/components/app-page-shell';
 import { PageHeader } from '@/components/page-header';
 import {
@@ -22,7 +22,6 @@ import {
   SelectValue,
 } from '@/components/ui/select';
 import { Badge } from '@/components/ui/badge';
-import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/components/ui/tabs';
 import {
   Table,
   TableBody,
@@ -31,7 +30,7 @@ import {
   TableHeader,
   TableRow,
 } from '@/components/ui/table';
-import { ScrollArea, ScrollBar } from '@/components/ui/scroll-area';
+import { ScrollArea } from '@/components/ui/scroll-area';
 import { Skeleton } from '@/components/ui/skeleton';
 import {
   Empty,
@@ -48,10 +47,6 @@ import {
   Copy,
   Check,
   Receipt,
-  Key,
-  Zap,
-  ChevronLeft,
-  ChevronRight,
 } from 'lucide-react';
 import { AdminService, type Transaction } from '@/lib/api/services/admin';
 import { format } from 'date-fns';
@@ -59,147 +54,6 @@ import { toast } from 'sonner';
 
 const STORAGE_KEY = 'routstr-transaction-filters';
 
-function TransactionTable({
-  transactions,
-  copiedId,
-  onCopy,
-  getStatusBadge,
-}: {
-  transactions: Transaction[];
-  copiedId: string | null;
-  onCopy: (text: string, id: string) => void;
-  getStatusBadge: (tx: Transaction) => React.ReactNode;
-}) {
-  if (transactions.length === 0) {
-    return (
-      <Empty className='py-8'>
-        <EmptyHeader>
-          <EmptyMedia variant='icon'>
-            <Receipt className='h-4 w-4' />
-          </EmptyMedia>
-          <EmptyTitle>No transactions found</EmptyTitle>
-          <EmptyDescription>
-            Try adjusting your filters or check back later.
-          </EmptyDescription>
-        </EmptyHeader>
-      </Empty>
-    );
-  }
-
-  return (
-    <ScrollArea className='h-[55svh] min-h-[420px] w-full sm:h-[600px]'>
-      <div className='min-w-[800px]'>
-        <Table>
-          <TableHeader>
-            <TableRow>
-              <TableHead>Type</TableHead>
-              <TableHead>Amount</TableHead>
-              <TableHead>Status</TableHead>
-              <TableHead>API Key</TableHead>
-              <TableHead>Request ID</TableHead>
-              <TableHead>Mint</TableHead>
-              <TableHead>Date</TableHead>
-              <TableHead className='text-right'>Actions</TableHead>
-            </TableRow>
-          </TableHeader>
-          <TableBody>
-            {transactions.map((tx) => (
-              <TableRow key={tx.id}>
-                <TableCell>
-                  <div className='flex items-center gap-2'>
-                    {tx.type === 'in' ? (
-                      <ArrowDownLeft className='h-4 w-4 text-green-500' />
-                    ) : (
-                      <ArrowUpRight className='h-4 w-4 text-blue-500' />
-                    )}
-                    <span className='capitalize'>{tx.type}</span>
-                  </div>
-                </TableCell>
-                <TableCell className='font-mono'>
-                  {tx.amount} {tx.unit}
-                </TableCell>
-                <TableCell>{getStatusBadge(tx)}</TableCell>
-                <TableCell>
-                  {tx.api_key_hashed_key ? (
-                    <div className='flex items-center gap-1 text-xs'>
-                      <span className='max-w-[120px] truncate font-mono'>
-                        {tx.api_key_hashed_key.slice(0, 12)}...
-                      </span>
-                      <Button
-                        variant='ghost'
-                        size='icon'
-                        className='h-4 w-4'
-                        onClick={() =>
-                          onCopy(tx.api_key_hashed_key!, tx.id + '-apikey')
-                        }
-                      >
-                        {copiedId === tx.id + '-apikey' ? (
-                          <Check className='h-3 w-3' />
-                        ) : (
-                          <Copy className='h-3 w-3' />
-                        )}
-                      </Button>
-                    </div>
-                  ) : (
-                    <span className='text-muted-foreground text-xs'>—</span>
-                  )}
-                </TableCell>
-                <TableCell>
-                  {tx.request_id ? (
-                    <div className='flex items-center gap-1 text-xs'>
-                      <span className='max-w-[150px] truncate font-mono'>
-                        {tx.request_id}
-                      </span>
-                      <Button
-                        variant='ghost'
-                        size='icon'
-                        className='h-4 w-4'
-                        onClick={() => onCopy(tx.request_id!, tx.id + '-req')}
-                      >
-                        {copiedId === tx.id + '-req' ? (
-                          <Check className='h-3 w-3' />
-                        ) : (
-                          <Copy className='h-3 w-3' />
-                        )}
-                      </Button>
-                    </div>
-                  ) : (
-                    <span className='text-muted-foreground text-xs'>—</span>
-                  )}
-                </TableCell>
-                <TableCell>
-                  <div className='flex max-w-[150px] items-center gap-1 truncate text-xs'>
-                    <span className='truncate'>{tx.mint_url}</span>
-                  </div>
-                </TableCell>
-                <TableCell className='text-xs whitespace-nowrap'>
-                  {format(tx.created_at * 1000, 'yyyy-MM-dd HH:mm:ss')}
-                </TableCell>
-                <TableCell className='text-right'>
-                  <Button
-                    variant='ghost'
-                    size='icon'
-                    className='h-8 w-8'
-                    onClick={() => onCopy(tx.token, tx.id + '-token')}
-                    title='Copy Token'
-                  >
-                    {copiedId === tx.id + '-token' ? (
-                      <Check className='h-4 w-4' />
-                    ) : (
-                      <Copy className='h-4 w-4' />
-                    )}
-                  </Button>
-                </TableCell>
-              </TableRow>
-            ))}
-          </TableBody>
-        </Table>
-      </div>
-      <ScrollBar orientation='horizontal' />
-    </ScrollArea>
-  );
-}
-
 export default function TransactionsPage() {
   const [search, setSearch] = useState('');
   const [type, setType] = useState<string>('all');
@@ -227,63 +81,21 @@ export default function TransactionsPage() {
     localStorage.setItem(STORAGE_KEY, JSON.stringify(filters));
   }, [search, type, status]);
 
-  const PAGE_SIZE = 50;
-  const [activeTab, setActiveTab] = useState<string>('x-cashu');
-  const [xcashuPage, setXcashuPage] = useState(0);
-  const [apikeyPage, setApikeyPage] = useState(0);
-
-  const typeParam = type === 'all' ? undefined : type;
-  const statusParam = status === 'all' ? undefined : status;
-  const searchParam = search || undefined;
-
-  const xcashuQuery = useQuery({
-    queryKey: [
-      'transactions',
-      'x-cashu',
-      typeParam,
-      statusParam,
-      searchParam,
-      xcashuPage,
-    ],
+  const { data, isLoading, refetch, isRefetching } = useQuery({
+    queryKey: ['transactions', type, status, search],
     queryFn: () =>
       AdminService.getTransactions(
-        typeParam,
-        statusParam,
-        searchParam,
-        'x-cashu',
-        PAGE_SIZE,
-        xcashuPage * PAGE_SIZE
+        type === 'all' ? undefined : type,
+        status === 'all' ? undefined : status,
+        search || undefined,
+        100
       ),
-    placeholderData: keepPreviousData,
-  });
-
-  const apikeyQuery = useQuery({
-    queryKey: [
-      'transactions',
-      'apikey',
-      typeParam,
-      statusParam,
-      searchParam,
-      apikeyPage,
-    ],
-    queryFn: () =>
-      AdminService.getTransactions(
-        typeParam,
-        statusParam,
-        searchParam,
-        'apikey',
-        PAGE_SIZE,
-        apikeyPage * PAGE_SIZE
-      ),
-    placeholderData: keepPreviousData,
   });
 
   const handleClearFilters = () => {
     setSearch('');
     setType('all');
     setStatus('all');
-    setXcashuPage(0);
-    setApikeyPage(0);
   };
 
   const copyToClipboard = (text: string, id: string) => {
@@ -333,91 +145,15 @@ export default function TransactionsPage() {
     .filter(Boolean)
     .join(' • ');
 
-  // Reset pages when filters change
-  useEffect(() => {
-    setXcashuPage(0);
-    setApikeyPage(0);
-  }, [type, status, search]);
-
-  const isRefetching = xcashuQuery.isRefetching || apikeyQuery.isRefetching;
-
-  const renderCardContent = (
-    query: typeof xcashuQuery,
-    page: number,
-    setPage: (p: number) => void
-  ) => {
-    if (query.isLoading) {
-      return (
-        <div className='space-y-2'>
-          {Array.from({ length: 8 }).map((_, index) => (
-            <Skeleton
-              key={`tx-loading-${index}`}
-              className='h-16 w-full rounded-lg'
-            />
-          ))}
-        </div>
-      );
-    }
-
-    const transactions = query.data?.transactions ?? [];
-    const total = query.data?.total ?? 0;
-    const totalPages = Math.ceil(total / PAGE_SIZE);
-
-    return (
-      <>
-        {totalPages > 1 && (
-          <div className='flex flex-col gap-2 border-b pb-3 sm:flex-row sm:items-center sm:justify-between'>
-            <span className='text-muted-foreground text-xs sm:text-sm'>
-              {page * PAGE_SIZE + 1}–{Math.min((page + 1) * PAGE_SIZE, total)}{' '}
-              of {total}
-            </span>
-            <div className='flex items-center gap-2'>
-              <Button
-                variant='outline'
-                size='sm'
-                disabled={page === 0}
-                onClick={() => setPage(page - 1)}
-              >
-                <ChevronLeft className='h-4 w-4' />
-                <span className='hidden sm:inline'>Previous</span>
-              </Button>
-              <span className='text-xs sm:text-sm'>
-                {page + 1} / {totalPages}
-              </span>
-              <Button
-                variant='outline'
-                size='sm'
-                disabled={page >= totalPages - 1}
-                onClick={() => setPage(page + 1)}
-              >
-                <span className='hidden sm:inline'>Next</span>
-                <ChevronRight className='h-4 w-4' />
-              </Button>
-            </div>
-          </div>
-        )}
-        <TransactionTable
-          transactions={transactions}
-          copiedId={copiedId}
-          onCopy={copyToClipboard}
-          getStatusBadge={getStatusBadge}
-        />
-      </>
-    );
-  };
-
   return (
     <AppPageShell contentClassName='mx-auto w-full max-w-5xl overflow-x-hidden'>
       <div className='space-y-6'>
         <PageHeader
-          title='Cashu Transactions'
-          description='View all incoming and outgoing Cashu token transactions.'
+          title='X-Cashu Transactions'
+          description='View all incoming and outgoing X-Cashu token transactions.'
           actions={
             <Button
-              onClick={() => {
-                xcashuQuery.refetch();
-                apikeyQuery.refetch();
-              }}
+              onClick={() => refetch()}
               variant='outline'
               size='sm'
               disabled={isRefetching}
@@ -445,7 +181,7 @@ export default function TransactionsPage() {
                   <Search className='text-muted-foreground absolute top-2.5 left-2.5 h-4 w-4' />
                   <Input
                     id='search'
-                    placeholder='Search by ID, token, request ID or key hash...'
+                    placeholder='Search by ID, token or request ID...'
                     className='pl-8'
                     value={search}
                     onChange={(e) => setSearch(e.target.value)}
@@ -492,68 +228,138 @@ export default function TransactionsPage() {
           </CardContent>
         </Card>
 
-        <Tabs
-          defaultValue='x-cashu'
-          value={activeTab}
-          onValueChange={setActiveTab}
-        >
-          <TabsList className='mb-4'>
-            <TabsTrigger value='x-cashu' className='flex items-center gap-2'>
-              <Zap className='h-4 w-4' />
-              X-Cashu
-              {xcashuQuery.data && (
-                <Badge variant='secondary' className='ml-1'>
-                  {xcashuQuery.data.total}
+        <Card>
+          <CardHeader>
+            <div className='flex flex-col items-start gap-2 sm:flex-row sm:items-center sm:justify-between'>
+              <CardTitle>Transaction History</CardTitle>
+              {data && (
+                <Badge variant='secondary'>
+                  {data.transactions.length} entries
                 </Badge>
               )}
-            </TabsTrigger>
-            <TabsTrigger value='apikey' className='flex items-center gap-2'>
-              <Key className='h-4 w-4' />
-              API Key
-              {apikeyQuery.data && (
-                <Badge variant='secondary' className='ml-1'>
-                  {apikeyQuery.data.total}
-                </Badge>
-              )}
-            </TabsTrigger>
-          </TabsList>
-
-          <TabsContent value='x-cashu'>
-            <Card>
-              <CardHeader>
-                <div className='flex flex-col items-start gap-2 sm:flex-row sm:items-center sm:justify-between'>
-                  <CardTitle>X-Cashu Transaction History</CardTitle>
-                  {hasActiveFilters && (
-                    <CardDescription>
-                      Filtered by {activeFilterDescription}
-                    </CardDescription>
-                  )}
-                </div>
-              </CardHeader>
-              <CardContent className='overflow-hidden'>
-                {renderCardContent(xcashuQuery, xcashuPage, setXcashuPage)}
-              </CardContent>
-            </Card>
-          </TabsContent>
-
-          <TabsContent value='apikey'>
-            <Card>
-              <CardHeader>
-                <div className='flex flex-col items-start gap-2 sm:flex-row sm:items-center sm:justify-between'>
-                  <CardTitle>API Key Transaction History</CardTitle>
-                  {hasActiveFilters && (
-                    <CardDescription>
-                      Filtered by {activeFilterDescription}
-                    </CardDescription>
-                  )}
-                </div>
-              </CardHeader>
-              <CardContent className='overflow-hidden'>
-                {renderCardContent(apikeyQuery, apikeyPage, setApikeyPage)}
-              </CardContent>
-            </Card>
-          </TabsContent>
-        </Tabs>
+            </div>
+            {hasActiveFilters && (
+              <CardDescription>
+                Showing transactions filtered by {activeFilterDescription}
+              </CardDescription>
+            )}
+          </CardHeader>
+          <CardContent className='overflow-hidden'>
+            {isLoading ? (
+              <div className='space-y-2'>
+                {Array.from({ length: 8 }).map((_, index) => (
+                  <Skeleton
+                    key={`tx-loading-${index}`}
+                    className='h-16 w-full rounded-lg'
+                  />
+                ))}
+              </div>
+            ) : data?.transactions && data.transactions.length > 0 ? (
+              <ScrollArea className='h-[55svh] min-h-[420px] w-full sm:h-[600px]'>
+                <Table>
+                  <TableHeader>
+                    <TableRow>
+                      <TableHead>Type</TableHead>
+                      <TableHead>Amount</TableHead>
+                      <TableHead>Status</TableHead>
+                      <TableHead>Request ID</TableHead>
+                      <TableHead>Mint</TableHead>
+                      <TableHead>Date</TableHead>
+                      <TableHead className='text-right'>Actions</TableHead>
+                    </TableRow>
+                  </TableHeader>
+                  <TableBody>
+                    {data.transactions.map((tx) => (
+                      <TableRow key={tx.id}>
+                        <TableCell>
+                          <div className='flex items-center gap-2'>
+                            {tx.type === 'in' ? (
+                              <ArrowDownLeft className='h-4 w-4 text-green-500' />
+                            ) : (
+                              <ArrowUpRight className='h-4 w-4 text-blue-500' />
+                            )}
+                            <span className='capitalize'>{tx.type}</span>
+                          </div>
+                        </TableCell>
+                        <TableCell className='font-mono'>
+                          {tx.amount} {tx.unit}
+                        </TableCell>
+                        <TableCell>{getStatusBadge(tx)}</TableCell>
+                        <TableCell>
+                          {tx.request_id ? (
+                            <div className='flex items-center gap-1 text-xs'>
+                              <span className='max-w-[150px] truncate font-mono'>
+                                {tx.request_id}
+                              </span>
+                              <Button
+                                variant='ghost'
+                                size='icon'
+                                className='h-4 w-4'
+                                onClick={() =>
+                                  copyToClipboard(
+                                    tx.request_id!,
+                                    tx.id + '-req'
+                                  )
+                                }
+                              >
+                                {copiedId === tx.id + '-req' ? (
+                                  <Check className='h-3 w-3' />
+                                ) : (
+                                  <Copy className='h-3 w-3' />
+                                )}
+                              </Button>
+                            </div>
+                          ) : (
+                            <span className='text-muted-foreground text-xs'>
+                              —
+                            </span>
+                          )}
+                        </TableCell>
+                        <TableCell>
+                          <div className='flex max-w-[150px] items-center gap-1 truncate text-xs'>
+                            <span className='truncate'>{tx.mint_url}</span>
+                          </div>
+                        </TableCell>
+                        <TableCell className='text-xs whitespace-nowrap'>
+                          {format(tx.created_at * 1000, 'yyyy-MM-dd HH:mm:ss')}
+                        </TableCell>
+                        <TableCell className='text-right'>
+                          <Button
+                            variant='ghost'
+                            size='icon'
+                            className='h-8 w-8'
+                            onClick={() =>
+                              copyToClipboard(tx.token, tx.id + '-token')
+                            }
+                            title='Copy Token'
+                          >
+                            {copiedId === tx.id + '-token' ? (
+                              <Check className='h-4 w-4' />
+                            ) : (
+                              <Copy className='h-4 w-4' />
+                            )}
+                          </Button>
+                        </TableCell>
+                      </TableRow>
+                    ))}
+                  </TableBody>
+                </Table>
+              </ScrollArea>
+            ) : (
+              <Empty className='py-8'>
+                <EmptyHeader>
+                  <EmptyMedia variant='icon'>
+                    <Receipt className='h-4 w-4' />
+                  </EmptyMedia>
+                  <EmptyTitle>No transactions found</EmptyTitle>
+                  <EmptyDescription>
+                    Try adjusting your filters or check back later.
+                  </EmptyDescription>
+                </EmptyHeader>
+              </Empty>
+            )}
+          </CardContent>
+        </Card>
       </div>
     </AppPageShell>
   );

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

@@ -540,7 +540,7 @@ export function AddProviderModelDialog({
                   };
                   return (
                     <FormItem>
-                      <FormLabel>Client Alias ID</FormLabel>
+                      <FormLabel>Upstream Model ID</FormLabel>
                       <FormControl>
                         <div className='flex gap-2'>
                           <Input
@@ -565,8 +565,8 @@ export function AddProviderModelDialog({
                         </div>
                       </FormControl>
                       <FormDescription>
-                        Alternate ID that clients can use to reference this
-                        model. Defaults to the model&apos;s own ID.
+                        Model ID sent to the upstream provider. Defaults to the
+                        model&apos;s own ID.
                       </FormDescription>
                       <FormMessage />
                     </FormItem>

ui/components/api-endpoint-tester.tsx

@@ -471,11 +471,7 @@ export function ApiEndpointTester({ models }: ApiEndpointTesterProps) {
     testEndpointMutation.mutate(requestData);
   };
 
-  const enabledModels = Array.from(
-    new Map(
-      models.filter((model) => model.isEnabled).map((m) => [m.id, m])
-    ).values()
-  );
+  const enabledModels = models.filter((model) => model.isEnabled);
   const credentials = selectedModel ? getModelCredentials(selectedModel) : null;
   const endpointUrl = credentials
     ? buildEndpointUrl(

ui/components/model-tester.tsx

@@ -197,11 +197,7 @@ export function ModelTester({ models }: ModelTesterProps) {
     testModelMutation.mutate(request);
   };
 
-  const enabledModels = Array.from(
-    new Map(
-      models.filter((model) => model.isEnabled).map((m) => [m.id, m])
-    ).values()
-  );
+  const enabledModels = models.filter((model) => model.isEnabled);
   const credentials = selectedModel ? getModelCredentials(selectedModel) : null;
 
   return (

ui/components/models-page.tsx

@@ -124,14 +124,12 @@ export function ModelsPage() {
             >
               Basic Testing
             </TabsTrigger>
-            {/*
             <TabsTrigger
               value='test-api'
               className='h-9 snap-start px-2 text-[13px] sm:h-10 sm:px-2.5 sm:text-sm'
             >
               API Endpoints
             </TabsTrigger>
-            */}
           </TabsList>
 
           <TabsContent value='manage' className='mt-0'>

ui/components/settings/cli-tokens-settings.tsx

@@ -1,265 +0,0 @@
-'use client';
-
-import * as React from 'react';
-import { useState, useEffect, useCallback } from 'react';
-import {
-  AdminService,
-  type CliTokenListItem,
-  type CliTokenCreated,
-} from '@/lib/api/services/admin';
-import {
-  Card,
-  CardContent,
-  CardHeader,
-  CardTitle,
-  CardDescription,
-} from '@/components/ui/card';
-import { Button } from '@/components/ui/button';
-import { Input } from '@/components/ui/input';
-import { Label } from '@/components/ui/label';
-import { Skeleton } from '@/components/ui/skeleton';
-import { Alert, AlertDescription } from '@/components/ui/alert';
-import { AlertCircle, Copy, Trash2, Check } from 'lucide-react';
-import { toast } from 'sonner';
-
-function formatTs(ts: number | null): string {
-  if (!ts) return '—';
-  return new Date(ts * 1000).toLocaleString();
-}
-
-export function CliTokensSettings(): React.ReactElement {
-  const [tokens, setTokens] = useState<CliTokenListItem[]>([]);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState<string | null>(null);
-  const [name, setName] = useState('');
-  const [expiresInDays, setExpiresInDays] = useState<string>('');
-  const [creating, setCreating] = useState(false);
-  const [newToken, setNewToken] = useState<CliTokenCreated | null>(null);
-  const [copied, setCopied] = useState(false);
-
-  const loadTokens = useCallback(async (): Promise<void> => {
-    setLoading(true);
-    setError(null);
-    try {
-      const data = await AdminService.listCliTokens();
-      setTokens(data);
-    } catch (err: unknown) {
-      const message =
-        err instanceof Error ? err.message : 'Failed to load tokens';
-      setError(message);
-    } finally {
-      setLoading(false);
-    }
-  }, []);
-
-  useEffect(() => {
-    void loadTokens();
-  }, [loadTokens]);
-
-  async function handleCreate(): Promise<void> {
-    const trimmed = name.trim();
-    if (!trimmed) {
-      toast.error('Name is required');
-      return;
-    }
-    const days = expiresInDays.trim()
-      ? Number.parseInt(expiresInDays.trim(), 10)
-      : undefined;
-    if (days !== undefined && (Number.isNaN(days) || days <= 0)) {
-      toast.error('Expiry must be a positive number of days');
-      return;
-    }
-
-    setCreating(true);
-    try {
-      const created = await AdminService.createCliToken(trimmed, days);
-      setNewToken(created);
-      setName('');
-      setExpiresInDays('');
-      await loadTokens();
-      toast.success('Token created. Copy it now — it will not be shown again.');
-    } catch (err: unknown) {
-      const message =
-        err instanceof Error ? err.message : 'Failed to create token';
-      toast.error(message);
-    } finally {
-      setCreating(false);
-    }
-  }
-
-  async function handleRevoke(id: string): Promise<void> {
-    if (
-      !confirm('Revoke this token? Any CLI/agent using it will lose access.')
-    ) {
-      return;
-    }
-    try {
-      await AdminService.revokeCliToken(id);
-      await loadTokens();
-      toast.success('Token revoked');
-    } catch (err: unknown) {
-      const message =
-        err instanceof Error ? err.message : 'Failed to revoke token';
-      toast.error(message);
-    }
-  }
-
-  async function handleCopy(): Promise<void> {
-    if (!newToken) return;
-    await navigator.clipboard.writeText(newToken.token);
-    setCopied(true);
-    setTimeout(() => setCopied(false), 2000);
-  }
-
-  return (
-    <div className='space-y-6'>
-      <Card>
-        <CardHeader>
-          <CardTitle>Create CLI Token</CardTitle>
-          <CardDescription>
-            Generate a long-lived bearer token for the Routstr CLI or AI agents.
-            Use this token in <code>~/.routstr/config.json</code> or with{' '}
-            <code>routstr init --token &lt;token&gt;</code>.
-          </CardDescription>
-        </CardHeader>
-        <CardContent className='space-y-4'>
-          {newToken && (
-            <Alert className='border-green-500/50 bg-green-500/10'>
-              <AlertDescription className='space-y-3'>
-                <div className='font-medium text-green-700 dark:text-green-400'>
-                  Token created. Copy it now — it will not be shown again.
-                </div>
-                <div className='flex items-center gap-2'>
-                  <code className='bg-muted flex-1 rounded px-3 py-2 text-xs break-all'>
-                    {newToken.token}
-                  </code>
-                  <Button
-                    type='button'
-                    variant='outline'
-                    size='sm'
-                    onClick={handleCopy}
-                  >
-                    {copied ? (
-                      <Check className='h-4 w-4' />
-                    ) : (
-                      <Copy className='h-4 w-4' />
-                    )}
-                  </Button>
-                </div>
-                <Button
-                  type='button'
-                  variant='ghost'
-                  size='sm'
-                  onClick={() => setNewToken(null)}
-                >
-                  Dismiss
-                </Button>
-              </AlertDescription>
-            </Alert>
-          )}
-          <div className='grid grid-cols-1 gap-4 md:grid-cols-2'>
-            <div className='space-y-2'>
-              <Label htmlFor='cli-token-name'>Name</Label>
-              <Input
-                id='cli-token-name'
-                placeholder='e.g. dev-laptop, ci-runner'
-                value={name}
-                onChange={(e) => setName(e.target.value)}
-                disabled={creating}
-              />
-            </div>
-            <div className='space-y-2'>
-              <Label htmlFor='cli-token-expiry'>
-                Expires in days (optional)
-              </Label>
-              <Input
-                id='cli-token-expiry'
-                type='number'
-                min='1'
-                placeholder='Never expires if blank'
-                value={expiresInDays}
-                onChange={(e) => setExpiresInDays(e.target.value)}
-                disabled={creating}
-              />
-            </div>
-          </div>
-          <Button onClick={handleCreate} disabled={creating || !name.trim()}>
-            {creating ? 'Creating…' : 'Create Token'}
-          </Button>
-        </CardContent>
-      </Card>
-
-      <Card>
-        <CardHeader>
-          <CardTitle>Active Tokens</CardTitle>
-          <CardDescription>
-            Tokens authorize CLI/agent calls to admin endpoints. Revoke any
-            token that may have been exposed.
-          </CardDescription>
-        </CardHeader>
-        <CardContent>
-          {error && (
-            <Alert variant='destructive' className='mb-4'>
-              <AlertCircle className='h-4 w-4' />
-              <AlertDescription>{error}</AlertDescription>
-            </Alert>
-          )}
-          {loading ? (
-            <div className='space-y-2'>
-              <Skeleton className='h-12 w-full' />
-              <Skeleton className='h-12 w-full' />
-            </div>
-          ) : tokens.length === 0 ? (
-            <p className='text-muted-foreground text-sm'>
-              No tokens yet. Create one above.
-            </p>
-          ) : (
-            <div className='overflow-x-auto'>
-              <table className='w-full text-sm'>
-                <thead>
-                  <tr className='text-muted-foreground border-b text-left'>
-                    <th className='py-2 pr-4 font-medium'>Name</th>
-                    <th className='py-2 pr-4 font-medium'>Token</th>
-                    <th className='py-2 pr-4 font-medium'>Created</th>
-                    <th className='py-2 pr-4 font-medium'>Last used</th>
-                    <th className='py-2 pr-4 font-medium'>Expires</th>
-                    <th className='py-2 font-medium'></th>
-                  </tr>
-                </thead>
-                <tbody>
-                  {tokens.map((t) => (
-                    <tr key={t.id} className='border-b last:border-0'>
-                      <td className='py-2 pr-4'>{t.name}</td>
-                      <td className='py-2 pr-4 font-mono text-xs'>
-                        {t.token_preview}
-                      </td>
-                      <td className='text-muted-foreground py-2 pr-4'>
-                        {formatTs(t.created_at)}
-                      </td>
-                      <td className='text-muted-foreground py-2 pr-4'>
-                        {formatTs(t.last_used_at)}
-                      </td>
-                      <td className='text-muted-foreground py-2 pr-4'>
-                        {t.expires_at ? formatTs(t.expires_at) : 'Never'}
-                      </td>
-                      <td className='py-2'>
-                        <Button
-                          type='button'
-                          variant='ghost'
-                          size='sm'
-                          onClick={() => void handleRevoke(t.id)}
-                        >
-                          <Trash2 className='h-4 w-4' />
-                        </Button>
-                      </td>
-                    </tr>
-                  ))}
-                </tbody>
-              </table>
-            </div>
-          )}
-        </CardContent>
-      </Card>
-    </div>
-  );
-}

ui/lib/api/services/admin.ts

@@ -891,17 +891,13 @@ export class AdminService {
     type?: string,
     status?: string,
     search?: string,
-    source?: string,
-    limit: number = 50,
-    offset: number = 0
+    limit: number = 100
   ): Promise<TransactionsResponse> {
     const params = new URLSearchParams();
     if (type) params.append('type', type);
     if (status) params.append('status', status);
     if (search) params.append('search', search);
-    if (source) params.append('source', source);
     params.append('limit', limit.toString());
-    params.append('offset', offset.toString());
 
     return await apiClient.get<TransactionsResponse>(
       `/admin/api/transactions?${params.toString()}`
@@ -966,45 +962,6 @@ export class AdminService {
       balance_data: number | null | Record<string, unknown>;
     }>(`/admin/api/upstream-providers/${providerId}/balance`);
   }
-
-  // ── CLI Tokens ──
-
-  static async listCliTokens(): Promise<CliTokenListItem[]> {
-    return await apiClient.get<CliTokenListItem[]>('/admin/api/cli-tokens');
-  }
-
-  static async createCliToken(
-    name: string,
-    expiresInDays?: number
-  ): Promise<CliTokenCreated> {
-    return await apiClient.post<CliTokenCreated>('/admin/api/cli-tokens', {
-      name,
-      expires_in_days: expiresInDays ?? null,
-    });
-  }
-
-  static async revokeCliToken(tokenId: string): Promise<{ ok: boolean }> {
-    return await apiClient.delete<{ ok: boolean }>(
-      `/admin/api/cli-tokens/${encodeURIComponent(tokenId)}`
-    );
-  }
-}
-
-export interface CliTokenListItem {
-  id: string;
-  name: string;
-  token_preview: string;
-  created_at: number;
-  last_used_at: number | null;
-  expires_at: number | null;
-}
-
-export interface CliTokenCreated {
-  id: string;
-  name: string;
-  token: string;
-  created_at: number;
-  expires_at: number | null;
 }
 
 export const TemporaryBalanceSchema = z.object({
@@ -1178,8 +1135,6 @@ export interface Transaction {
   created_at: number;
   collected: boolean;
   swept: boolean;
-  source: 'x-cashu' | 'apikey';
-  api_key_hashed_key?: string;
 }
 
 export interface TransactionsResponse {

uv.lock

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