enforce model price calculation

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/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")

routstr/balance.py

@@ -10,13 +10,7 @@ from pydantic import BaseModel
 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
@@ -316,17 +310,6 @@ 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:
         # Re-raise HTTP exceptions (like 400 for balance too small)
         raise
@@ -351,20 +334,6 @@ async def refund_wallet_endpoint(
     session.add(key)
     await session.commit()
 
-    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",
-            )
-        except Exception:
-            pass  # store_cashu_transaction already logs
-
     logger.info(
         "refund_wallet_endpoint: refund successful",
         extra={

routstr/core/db.py

@@ -10,7 +10,6 @@ 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, func, select, update
 from sqlmodel.ext.asyncio.session import AsyncSession
@@ -155,10 +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",
-    )
 
 
 async def store_cashu_transaction(
@@ -170,7 +165,6 @@ async def store_cashu_transaction(
     request_id: str | None = None,
     collected: bool = False,
     created_at: int | None = None,
-    source: str = "x-cashu",
 ) -> None:
     try:
         async with create_session() as session:
@@ -183,7 +177,6 @@ async def store_cashu_transaction(
                 request_id=request_id,
                 collected=collected,
                 created_at=created_at or int(time.time()),
-                source=source,
             )
             session.add(tx)
             await session.commit()
@@ -338,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/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.
 
@@ -563,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 = (
@@ -721,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
@@ -737,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", {})
@@ -815,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.
 
@@ -1052,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
@@ -1068,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", {})
@@ -1184,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,
@@ -1227,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:
@@ -1238,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(
@@ -1265,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,
@@ -1294,11 +1200,6 @@ class BaseUpstreamProvider:
                                     new_session,
                                     max_cost_for_model,
                                 )
-
-                                self.inject_cost_metadata(
-                                    combined_data, cost_data, fresh_key
-                                )
-
                                 usage_finalized = True
                                 yield f"event: cost\ndata: {json.dumps({'cost': cost_data})}\n\n".encode()
                             except Exception:
@@ -1338,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}
@@ -1361,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",
@@ -1420,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)
 
@@ -1516,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)
@@ -1530,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()
@@ -1545,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()
@@ -1595,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
@@ -1608,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:
@@ -1727,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)
 
@@ -1817,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()
@@ -1831,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:
@@ -2261,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
@@ -2306,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
@@ -2409,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
@@ -2467,6 +2320,7 @@ class BaseUpstreamProvider:
                 extra={
                     "original_amount": amount,
                     "refund_amount": emergency_refund,
+                    "deduction": 60,
                 },
             )
 
@@ -2641,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),
                     )
 
@@ -2936,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),
                     )
 
@@ -3203,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
@@ -3248,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
@@ -3339,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
@@ -3397,6 +3237,7 @@ class BaseUpstreamProvider:
                 extra={
                     "original_amount": amount,
                     "refund_amount": emergency_refund,
+                    "deduction": 60,
                 },
             )
 

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

@@ -155,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,
@@ -549,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",

tests/unit/test_balance.py

@@ -1,11 +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.core.db import CashuTransaction
 
 
 def _make_cashu_tx(
@@ -114,137 +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.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"
-
-
-@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.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.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"

tests/unit/test_stream_id_injection.py

@@ -1,109 +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}
-        )
-        base.create_session = MagicMock()
-
-        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/transactions/page.tsx

@@ -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,
@@ -48,8 +47,6 @@ import {
   Copy,
   Check,
   Receipt,
-  Key,
-  Zap,
 } from 'lucide-react';
 import { AdminService, type Transaction } from '@/lib/api/services/admin';
 import { format } from 'date-fns';
@@ -57,118 +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]'>
-      <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>
-          {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={() => 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>
-    </ScrollArea>
-  );
-}
-
 export default function TransactionsPage() {
   const [search, setSearch] = useState('');
   const [type, setType] = useState<string>('all');
@@ -260,41 +145,12 @@ export default function TransactionsPage() {
     .filter(Boolean)
     .join(' • ');
 
-  const xcashuTxs =
-    data?.transactions.filter((tx) => !tx.source || tx.source === 'x-cashu') ??
-    [];
-  const apikeyTxs =
-    data?.transactions.filter((tx) => tx.source === 'apikey') ?? [];
-
-  const renderCardContent = (txs: Transaction[]) => {
-    if (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>
-      );
-    }
-    return (
-      <TransactionTable
-        transactions={txs}
-        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={() => refetch()}
@@ -372,64 +228,138 @@ export default function TransactionsPage() {
           </CardContent>
         </Card>
 
-        <Tabs defaultValue='x-cashu'>
-          <TabsList className='mb-4'>
-            <TabsTrigger value='x-cashu' className='flex items-center gap-2'>
-              <Zap className='h-4 w-4' />
-              X-Cashu
+        <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' className='ml-1'>
-                  {xcashuTxs.length}
+                <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 Refunds
-              {data && (
-                <Badge variant='secondary' className='ml-1'>
-                  {apikeyTxs.length}
-                </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(xcashuTxs)}
-              </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 Refund History</CardTitle>
-                  {hasActiveFilters && (
-                    <CardDescription>
-                      Filtered by {activeFilterDescription}
-                    </CardDescription>
-                  )}
-                </div>
-              </CardHeader>
-              <CardContent className='overflow-hidden'>
-                {renderCardContent(apikeyTxs)}
-              </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/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/lib/api/services/admin.ts

@@ -1135,7 +1135,6 @@ export interface Transaction {
   created_at: number;
   collected: boolean;
   swept: boolean;
-  source: 'x-cashu' | 'apikey';
 }
 
 export interface TransactionsResponse {