better timeout handling

OpenAI responses api

migrations/versions/b9667ffc5701_alias_ids.py

@@ -0,0 +1,37 @@
+"""alias-ids
+
+Revision ID: b9667ffc5701
+Revises: lightning_invoices
+Create Date: 2025-12-25 19:30:44.673350
+"""
+
+import sqlalchemy as sa
+import sqlmodel
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "b9667ffc5701"
+down_revision = "lightning_invoices"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic ###
+    op.add_column(
+        "models",
+        sa.Column("canonical_slug", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+    )
+    op.add_column(
+        "models",
+        sa.Column("alias_ids", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+    )
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column("models", "alias_ids")
+    op.drop_column("models", "canonical_slug")
+    # ### end Alembic commands ###

routstr/algorithm.py

@@ -1,5 +1,7 @@
 """Model prioritization algorithm for selecting cheapest upstream providers."""
 
+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 
 from .core.logging import get_logger
@@ -157,15 +159,21 @@ def create_model_mappings(
     upstreams: list["BaseUpstreamProvider"],
     overrides_by_id: dict[str, tuple],
     disabled_model_ids: set[str],
-) -> tuple[dict[str, "Model"], dict[str, "BaseUpstreamProvider"], dict[str, "Model"]]:
+) -> tuple[
+    dict[str, "Model"],
+    dict[str, "BaseUpstreamProvider"],
+    dict[str, "Model"],
+    dict[str, list["BaseUpstreamProvider"]],
+]:
     """Create optimal model mappings based on cost and provider preferences.
 
     This is the main entry point for the algorithm. It processes all upstream providers
     and creates three mappings based on cost optimization:
 
     1. model_instances: alias -> Model (all model aliases mapped to their Model objects)
-    2. provider_map: alias -> UpstreamProvider (which provider to use for each alias)
+    2. provider_map: alias -> UpstreamProvider (the BEST provider to use for each alias)
     3. unique_models: base_id -> Model (unique models without provider prefixes)
+    4. provider_candidates_map: alias -> list[UpstreamProvider] (all providers offering the model, sorted by preference)
 
     The algorithm:
     - Processes non-OpenRouter providers first (they're typically cheaper)
@@ -178,7 +186,7 @@ def create_model_mappings(
         disabled_model_ids: Set of model IDs that should be excluded
 
     Returns:
-        Tuple of (model_instances, provider_map, unique_models)
+        Tuple of (model_instances, provider_map, unique_models, provider_candidates_map)
     """
     from .payment.models import _row_to_model
     from .upstream.helpers import resolve_model_alias
@@ -186,9 +194,10 @@ def create_model_mappings(
     model_instances: dict[str, "Model"] = {}
     provider_map: dict[str, "BaseUpstreamProvider"] = {}
     unique_models: dict[str, "Model"] = {}
+    provider_candidates_map: dict[str, list["BaseUpstreamProvider"]] = {}
 
     # Separate OpenRouter from other providers
-    openrouter: "BaseUpstreamProvider" | None = None
+    openrouter: BaseUpstreamProvider | None = None
     other_upstreams: list["BaseUpstreamProvider"] = []
 
     for upstream in upstreams:
@@ -206,19 +215,27 @@ def create_model_mappings(
         alias: str, model: "Model", provider: "BaseUpstreamProvider"
     ) -> None:
         """Set alias to model/provider if not set or if new model is preferred."""
-        existing_model = model_instances.get(alias)
+        alias_lower = alias.lower()
+
+        # Add to candidates list, to be used later as fallback
+        if alias_lower not in provider_candidates_map:
+            provider_candidates_map[alias_lower] = [provider]
+        else:
+            provider_candidates_map[alias_lower].append(provider)
+
+        existing_model = model_instances.get(alias_lower)
         if not existing_model:
             # No existing mapping, set it
-            model_instances[alias] = model
-            provider_map[alias] = provider
+            model_instances[alias_lower] = model
+            provider_map[alias_lower] = provider
         else:
             # Check if candidate should replace existing
-            existing_provider = provider_map[alias]
+            existing_provider = provider_map[alias_lower]
             if should_prefer_model(
                 model, provider, existing_model, existing_provider, alias
             ):
-                model_instances[alias] = model
-                provider_map[alias] = provider
+                model_instances[alias_lower] = model
+                provider_map[alias_lower] = provider
 
     def process_provider_models(
         upstream: "BaseUpstreamProvider", is_openrouter: bool = False
@@ -275,6 +292,26 @@ def create_model_mappings(
     if openrouter:
         process_provider_models(openrouter, is_openrouter=True)
 
+    # Sort and filter provider candidates for each alias using provider_map as reference
+    # We only keep entries that have more than one provider.
+    final_candidates_map: dict[str, list["BaseUpstreamProvider"]] = {}
+    for alias_lower, best_provider in provider_map.items():
+        candidates = provider_candidates_map.get(alias_lower, [])
+        # Remove duplicates
+        unique_candidates = []
+        seen = set()
+        for c in candidates:
+            if c not in seen:
+                unique_candidates.append(c)
+                seen.add(c)
+
+        if len(unique_candidates) > 1:
+            # Keep the best one at the front, others follow.
+            if best_provider in unique_candidates:
+                unique_candidates.remove(best_provider)
+            unique_candidates.insert(0, best_provider)
+            final_candidates_map[alias_lower] = unique_candidates
+
     # Log provider distribution
     provider_counts: dict[str, int] = {}
     for provider in provider_map.values():
@@ -286,4 +323,4 @@ def create_model_mappings(
         extra={"provider_distribution": provider_counts},
     )
 
-    return model_instances, provider_map, unique_models
+    return model_instances, provider_map, unique_models, provider_candidates_map

routstr/core/admin.py

@@ -1493,20 +1493,8 @@ class ModelCreate(BaseModel):
     per_request_limits: dict[str, object] | None = None
     top_provider: dict[str, object] | None = None
     upstream_provider_id: int | None = None
-    enabled: bool = True
-
-
-class ModelUpdate(BaseModel):
-    id: str
-    name: str
-    description: str
-    created: int
-    context_length: int
-    architecture: dict[str, object]
-    pricing: dict[str, object]
-    per_request_limits: dict[str, object] | None = None
-    top_provider: dict[str, object] | None = None
-    upstream_provider_id: int | None = None
+    canonical_slug: str | None = None
+    alias_ids: list[str] | None = None
     enabled: bool = True
 
 
@@ -2416,44 +2404,80 @@ async def admin_upstream_providers(request: Request) -> str:
     "/api/upstream-providers/{provider_id}/models",
     dependencies=[Depends(require_admin_api)],
 )
-async def create_provider_model(
+async def upsert_provider_model(
     provider_id: int, payload: ModelCreate
 ) -> dict[str, object]:
+    print(payload)
+    logger.info(
+        f"UPSERT_PROVIDER_MODEL called: provider_id={provider_id}, model_id={payload.id}"
+    )
     async with create_session() as session:
         provider = await session.get(UpstreamProviderRow, provider_id)
         if not provider:
             raise HTTPException(status_code=404, detail="Provider not found")
 
-        exists = await session.get(ModelRow, (payload.id, provider_id))
-        if exists:
-            raise HTTPException(
-                status_code=409,
-                detail="Model with this ID already exists for this provider",
-            )
+        # Try to get existing model
+        existing_row = await session.get(ModelRow, (payload.id, provider_id))
 
-        row = ModelRow(
-            id=payload.id,
-            name=payload.name,
-            description=payload.description,
-            created=int(payload.created),
-            context_length=int(payload.context_length),
-            architecture=json.dumps(payload.architecture),
-            pricing=json.dumps(payload.pricing),
-            sats_pricing=None,
-            per_request_limits=(
+        if existing_row:
+            # Update existing model
+            logger.info(f"Updating existing model: {payload.id}")
+            existing_row.name = payload.name
+            existing_row.description = payload.description
+            existing_row.created = int(payload.created)
+            existing_row.context_length = int(payload.context_length)
+            existing_row.architecture = json.dumps(payload.architecture)
+            existing_row.pricing = json.dumps(payload.pricing)
+            existing_row.sats_pricing = None
+            existing_row.per_request_limits = (
                 json.dumps(payload.per_request_limits)
                 if payload.per_request_limits is not None
                 else None
-            ),
-            top_provider=(
+            )
+            existing_row.top_provider = (
                 json.dumps(payload.top_provider) if payload.top_provider else None
-            ),
-            upstream_provider_id=provider_id,
-            enabled=payload.enabled,
-        )
-        session.add(row)
-        await session.commit()
-        await session.refresh(row)
+            )
+            existing_row.canonical_slug = payload.canonical_slug
+            existing_row.alias_ids = (
+                json.dumps(payload.alias_ids) if payload.alias_ids else None
+            )
+            existing_row.enabled = payload.enabled
+
+            session.add(existing_row)
+            await session.commit()
+            await session.refresh(existing_row)
+            row = existing_row
+
+        else:
+            # Create new model
+            logger.info(f"Creating new model: {payload.id}")
+            row = ModelRow(
+                id=payload.id,
+                name=payload.name,
+                description=payload.description,
+                created=int(payload.created),
+                context_length=int(payload.context_length),
+                architecture=json.dumps(payload.architecture),
+                pricing=json.dumps(payload.pricing),
+                sats_pricing=None,
+                per_request_limits=(
+                    json.dumps(payload.per_request_limits)
+                    if payload.per_request_limits is not None
+                    else None
+                ),
+                top_provider=(
+                    json.dumps(payload.top_provider) if payload.top_provider else None
+                ),
+                canonical_slug=payload.canonical_slug,
+                alias_ids=(
+                    json.dumps(payload.alias_ids) if payload.alias_ids else None
+                ),
+                upstream_provider_id=provider_id,
+                enabled=payload.enabled,
+            )
+            session.add(row)
+            await session.commit()
+            await session.refresh(row)
 
     await refresh_model_maps()
     return _row_to_model(
@@ -2461,6 +2485,20 @@ async def create_provider_model(
     ).dict()  # type: ignore
 
 
+@admin_router.patch(
+    "/api/upstream-providers/{provider_id}/models/{model_id:path}",
+    dependencies=[Depends(require_admin_api)],
+)
+async def update_provider_model_legacy(
+    provider_id: int, model_id: str, payload: ModelCreate
+) -> dict[str, object]:
+    """Legacy PATCH endpoint - redirects to upsert POST endpoint for backward compatibility."""
+    logger.info(
+        f"LEGACY_PATCH_UPDATE called: provider_id={provider_id}, model_id={model_id}"
+    )
+    return await upsert_provider_model(provider_id, payload)
+
+
 @admin_router.get(
     "/api/upstream-providers/{provider_id}/models/{model_id:path}",
     dependencies=[Depends(require_admin_api)],
@@ -2481,76 +2519,6 @@ async def get_provider_model(provider_id: int, model_id: str) -> dict[str, objec
         ).dict()  # type: ignore
 
 
-@admin_router.patch(
-    "/api/upstream-providers/{provider_id}/models/{model_id:path}",
-    dependencies=[Depends(require_admin_api)],
-)
-async def update_provider_model(
-    provider_id: int, model_id: str, payload: ModelUpdate
-) -> dict[str, object]:
-    if payload.id != model_id:
-        raise HTTPException(status_code=400, detail="Path id does not match payload id")
-
-    async with create_session() as session:
-        provider = await session.get(UpstreamProviderRow, provider_id)
-        if not provider:
-            raise HTTPException(status_code=404, detail="Provider not found")
-
-        row = await session.get(ModelRow, (model_id, provider_id))
-        if not row:
-            raise HTTPException(
-                status_code=404, detail="Model not found for this provider"
-            )
-
-        row.name = payload.name
-        row.description = payload.description
-        row.created = int(payload.created)
-        row.context_length = int(payload.context_length)
-        row.architecture = json.dumps(payload.architecture)
-        row.pricing = json.dumps(payload.pricing)
-        row.sats_pricing = None
-        row.per_request_limits = (
-            json.dumps(payload.per_request_limits)
-            if payload.per_request_limits is not None
-            else None
-        )
-        row.top_provider = (
-            json.dumps(payload.top_provider) if payload.top_provider else None
-        )
-        was_disabled = not row.enabled
-        row.enabled = payload.enabled
-
-        session.add(row)
-        await session.commit()
-        await session.refresh(row)
-
-    if was_disabled and payload.enabled:
-        from ..payment.models import _cleanup_enabled_models_once
-
-        try:
-            await _cleanup_enabled_models_once()
-        except Exception as e:
-            logger.warning(
-                f"Failed to run model cleanup after enabling: {e}",
-                extra={"model_id": model_id, "error": str(e)},
-            )
-
-    await refresh_model_maps()
-    return _row_to_model(
-        row, apply_provider_fee=True, provider_fee=provider.provider_fee
-    ).dict()  # type: ignore
-
-
-@admin_router.put(
-    "/api/upstream-providers/{provider_id}/models/{model_id:path}",
-    dependencies=[Depends(require_admin_api)],
-)
-async def update_provider_model_put(
-    provider_id: int, model_id: str, payload: ModelUpdate
-) -> dict[str, object]:
-    return await update_provider_model(provider_id, model_id, payload)
-
-
 @admin_router.delete(
     "/api/upstream-providers/{provider_id}/models/{model_id:path}",
     dependencies=[Depends(require_admin_api)],

routstr/core/db.py

@@ -68,6 +68,10 @@ class ModelRow(SQLModel, table=True):  # type: ignore
     sats_pricing: str | None = Field(default=None)
     per_request_limits: str | None = Field(default=None)
     top_provider: str | None = Field(default=None)
+    canonical_slug: str | None = Field(default=None, description="Canonical model slug")
+    alias_ids: str | None = Field(
+        default=None, description="JSON array of model alias IDs"
+    )
     enabled: bool = Field(default=True, description="Whether this model is enabled")
     upstream_provider: "UpstreamProviderRow" = Relationship(back_populates="models")
 

routstr/core/main.py

@@ -14,7 +14,6 @@ from ..balance import balance_router, deprecated_wallet_router
 from ..discovery import providers_cache_refresher, providers_router
 from ..nip91 import announce_provider
 from ..payment.models import (
-    cleanup_enabled_models_periodically,
     models_router,
     update_sats_pricing,
 )
@@ -49,7 +48,6 @@ async def lifespan(_: FastAPI) -> AsyncGenerator[None, None]:
     nip91_task = None
     providers_task = None
     models_refresh_task = None
-    models_cleanup_task = None
     model_maps_refresh_task = None
 
     try:
@@ -80,13 +78,17 @@ async def lifespan(_: FastAPI) -> AsyncGenerator[None, None]:
         _update_prices_task = asyncio.create_task(_update_prices())
         _initialize_upstreams_task = asyncio.create_task(initialize_upstreams())
 
+        # ensure both setup tasks complete
+        await asyncio.gather(
+            _update_prices_task, _initialize_upstreams_task, return_exceptions=True
+        )
+
         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:
             models_refresh_task = asyncio.create_task(
                 refresh_upstreams_models_periodically(get_upstreams())
             )
-        models_cleanup_task = asyncio.create_task(cleanup_enabled_models_periodically())
         model_maps_refresh_task = asyncio.create_task(refresh_model_maps_periodically())
         payout_task = asyncio.create_task(periodic_payout())
         if global_settings.nsec:
@@ -94,11 +96,6 @@ async def lifespan(_: FastAPI) -> AsyncGenerator[None, None]:
         if global_settings.providers_refresh_interval_seconds > 0:
             providers_task = asyncio.create_task(providers_cache_refresher())
 
-        # ensure both setup tasks complete
-        await asyncio.gather(
-            _update_prices_task, _initialize_upstreams_task, return_exceptions=True
-        )
-
         yield
 
     except asyncio.CancelledError:
@@ -125,8 +122,6 @@ async def lifespan(_: FastAPI) -> AsyncGenerator[None, None]:
             providers_task.cancel()
         if models_refresh_task is not None:
             models_refresh_task.cancel()
-        if models_cleanup_task is not None:
-            models_cleanup_task.cancel()
         if model_maps_refresh_task is not None:
             model_maps_refresh_task.cancel()
 
@@ -144,8 +139,6 @@ async def lifespan(_: FastAPI) -> AsyncGenerator[None, None]:
                 tasks_to_wait.append(providers_task)
             if models_refresh_task is not None:
                 tasks_to_wait.append(models_refresh_task)
-            if models_cleanup_task is not None:
-                tasks_to_wait.append(models_cleanup_task)
             if model_maps_refresh_task is not None:
                 tasks_to_wait.append(model_maps_refresh_task)
 

routstr/core/middleware.py

@@ -55,7 +55,16 @@ class LoggingMiddleware(BaseHTTPMiddleware):
                 "headers": {
                     k: v
                     for k, v in request.headers.items()
-                    if k.lower() not in ["authorization", "x-cashu", "cookie"]
+                    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,
             },

routstr/core/settings.py

@@ -6,7 +6,7 @@ import os
 from datetime import datetime, timezone
 from typing import Any
 
-from pydantic.v1 import BaseModel, BaseSettings, Field
+from pydantic.v1 import BaseModel, BaseSettings, Field, validator
 from sqlmodel.ext.asyncio.session import AsyncSession
 
 
@@ -37,6 +37,13 @@ class Settings(BaseSettings):
 
     # Cashu
     cashu_mints: list[str] = Field(default_factory=list, env="CASHU_MINTS")
+
+    @validator("cashu_mints", pre=True, each_item=True)
+    def normalize_mint_url(cls, v: str) -> str:
+        if isinstance(v, str):
+            return v.rstrip("/")
+        return v
+
     receive_ln_address: str = Field(default="", env="RECEIVE_LN_ADDRESS")
     primary_mint: str = Field(default="", env="PRIMARY_MINT_URL")
     primary_mint_unit: str = Field(default="sat", env="PRIMARY_MINT_UNIT")

routstr/payment/cost_calculation.py

@@ -191,6 +191,10 @@ async def calculate_cost(  # todo: can be sync
         output_tokens if output_tokens != 0 else usage_data.get("output_tokens", 0)
     )
 
+    # added for response api
+    input_tokens = input_tokens if input_tokens != 0 else  response_data.get("usage", {}).get("input_tokens", 0)
+    output_tokens = output_tokens if output_tokens != 0 else  response_data.get("usage", {}).get("output_tokens", 0)
+
     input_msats = round(input_tokens / 1000 * MSATS_PER_1K_INPUT_TOKENS, 3)
 
     output_msats = round(output_tokens / 1000 * MSATS_PER_1K_OUTPUT_TOKENS, 3)

routstr/payment/models.py

@@ -5,10 +5,9 @@ import random
 import httpx
 from fastapi import APIRouter, Depends
 from pydantic.v1 import BaseModel
-from sqlmodel import select
 from sqlmodel.ext.asyncio.session import AsyncSession
 
-from ..core.db import ModelRow, create_session, 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
@@ -185,6 +184,7 @@ def _row_to_model(
         enabled=row.enabled,
         upstream_provider_id=row.upstream_provider_id,
         canonical_slug=getattr(row, "canonical_slug", None),
+        alias_ids=json.loads(row.alias_ids) if row.alias_ids else None,
     )
 
     if apply_provider_fee:
@@ -382,7 +382,7 @@ def _update_model_sats_pricing(model: Model, sats_to_usd: float) -> Model:
 
 async def _update_sats_pricing_once() -> None:
     """Update sats pricing once for all provider models (in-memory only)."""
-    from ..proxy import get_upstreams
+    from ..proxy import get_upstreams, refresh_model_maps
 
     upstreams = get_upstreams()
     sats_to_usd = sats_usd_price()
@@ -399,6 +399,7 @@ async def _update_sats_pricing_once() -> None:
 
     if updated_count > 0:
         logger.info("Updated sats pricing", extra={"models_updated": updated_count})
+        await refresh_model_maps()
 
 
 async def update_sats_pricing() -> None:
@@ -409,7 +410,13 @@ async def update_sats_pricing() -> None:
     except Exception:
         pass
 
-    await _update_sats_pricing_once()
+    try:
+        await _update_sats_pricing_once()
+    except Exception as e:
+        logger.warning(
+            "Initial sats pricing update failed (will retry in loop)",
+            extra={"error": str(e)},
+        )
 
     while True:
         try:
@@ -433,114 +440,6 @@ async def update_sats_pricing() -> None:
             logger.error(f"Error updating sats pricing: {e}")
 
 
-async def cleanup_enabled_models_periodically() -> None:
-    """Background task to clean up enabled models that match upstream pricing.
-
-    When model is enabled (enabled=True), remove it from DB if it matches upstream pricing.
-    Keep it in DB only if pricing differs from upstream or if it's disabled.
-    """
-    interval = getattr(
-        settings, "models_cleanup_interval_seconds", 300
-    )  # 5 minutes default
-    if not interval or interval <= 0:
-        return
-
-    while True:
-        try:
-            await _cleanup_enabled_models_once()
-        except asyncio.CancelledError:
-            break
-        except Exception as e:
-            logger.error(
-                "Error during enabled models cleanup",
-                extra={"error": str(e), "error_type": type(e).__name__},
-            )
-
-        try:
-            jitter = max(0.0, float(interval) * 0.1)
-            await asyncio.sleep(interval + random.uniform(0, jitter))
-        except asyncio.CancelledError:
-            break
-
-
-async def _cleanup_enabled_models_once() -> None:
-    """Clean up enabled models that match upstream pricing."""
-    from ..proxy import get_upstreams
-
-    async with create_session() as session:
-        # Get all enabled models from DB
-        result = await session.exec(
-            select(ModelRow).where(
-                ModelRow.enabled,  # Only enabled models
-            )
-        )
-        db_models = result.all()
-
-        if not db_models:
-            return
-
-        upstreams = get_upstreams()
-        models_to_remove = []
-
-        for db_model in db_models:
-            # Find corresponding upstream model
-            upstream_model = None
-            for upstream in upstreams:
-                upstream_model = upstream.get_cached_model_by_id(db_model.id)
-                if upstream_model:
-                    break
-
-            if not upstream_model:
-                continue
-
-            # Compare pricing to see if they match
-            db_pricing = json.loads(db_model.pricing)
-            upstream_pricing = upstream_model.pricing.dict()
-
-            # Check if pricing matches (with small tolerance for float comparison)
-            pricing_matches = _pricing_matches(db_pricing, upstream_pricing)
-
-            if pricing_matches:
-                models_to_remove.append(db_model)
-                logger.info(
-                    f"Removing enabled model {db_model.id} - matches upstream pricing",
-                    extra={"model_id": db_model.id},
-                )
-
-        # Remove models that match upstream pricing
-        for model in models_to_remove:
-            await session.delete(model)
-
-        if models_to_remove:
-            await session.commit()
-            logger.info(
-                f"Cleaned up {len(models_to_remove)} enabled models that match upstream pricing"
-            )
-
-
-def _pricing_matches(
-    db_pricing: dict, upstream_pricing: dict, tolerance: float = 0.0
-) -> bool:
-    """Check if pricing dictionaries match within tolerance."""
-    keys_to_compare = [
-        "prompt",
-        "completion",
-        "request",
-        "image",
-        "web_search",
-        "internal_reasoning",
-    ]
-
-    for key in keys_to_compare:
-        db_val = int(float(db_pricing.get(key, 0.0)) * 1000000)
-        upstream_val = int(float(upstream_pricing.get(key, 0.0)) * 1000000)
-
-        if abs(db_val - upstream_val) > tolerance:
-            return False
-
-    return True
-
-
 @models_router.get("/v1/models")
 @models_router.get("/models", include_in_schema=False)
 async def models(session: AsyncSession = Depends(get_session)) -> dict:

routstr/proxy.py

@@ -1,6 +1,7 @@
 import json
 from typing import Any
 
+import httpx
 from fastapi import APIRouter, Depends, HTTPException, Request
 from fastapi.responses import Response, StreamingResponse
 from sqlmodel import select
@@ -16,6 +17,7 @@ from .core.db import (
     create_session,
     get_session,
 )
+from .core.settings import settings
 from .payment.helpers import (
     calculate_discounted_max_cost,
     check_token_balance,
@@ -25,6 +27,7 @@ from .payment.helpers import (
 from .payment.models import Model
 from .upstream import BaseUpstreamProvider
 from .upstream.helpers import init_upstreams
+from .wallet import deserialize_token_from_string, recieve_token
 
 logger = get_logger(__name__)
 proxy_router = APIRouter()
@@ -32,6 +35,9 @@ proxy_router = APIRouter()
 _upstreams: list[BaseUpstreamProvider] = []
 _model_instances: dict[str, Model] = {}  # All aliases -> Model
 _provider_map: dict[str, BaseUpstreamProvider] = {}  # All aliases -> Provider
+_provider_candidates_map: dict[
+    str, list[BaseUpstreamProvider]
+] = {}  # All aliases -> [Providers]
 _unique_models: dict[str, Model] = {}  # Unique model.id -> Model (no duplicates)
 
 
@@ -70,7 +76,22 @@ def get_model_instance(model_id: str) -> Model | None:
 
 def get_provider_for_model(model_id: str) -> BaseUpstreamProvider | None:
     """Get UpstreamProvider for model ID from global cache."""
-    return _provider_map.get(model_id)
+    return _provider_map.get(model_id.lower())
+
+
+def get_providers_for_model(model_id: str) -> list[BaseUpstreamProvider]:
+    """Get list of prioritized UpstreamProviders for model ID from global cache.
+
+    If multiple providers are available, returns the sorted list.
+    Otherwise, returns a list containing only the single best provider.
+    """
+    candidates = _provider_candidates_map.get(model_id.lower(), [])
+    if candidates:
+        return candidates
+
+    # Fallback to the single best provider if no multi-provider candidates exist
+    best = get_provider_for_model(model_id)
+    return [best] if best else []
 
 
 def get_unique_models() -> list[Model]:
@@ -80,36 +101,34 @@ def get_unique_models() -> list[Model]:
 
 async def refresh_model_maps() -> None:
     """Refresh global model and provider maps using the cost-based algorithm."""
-    global _model_instances, _provider_map, _unique_models
+    from sqlalchemy.orm import selectinload
+
+    global _model_instances, _provider_map, _unique_models, _provider_candidates_map
 
-    # Gather database overrides and disabled models
     async with create_session() as session:
-        result = await session.exec(select(ModelRow).where(ModelRow.enabled))
-        override_rows = result.all()
-
-        provider_result = await session.exec(select(UpstreamProviderRow))
-        providers_by_id = {p.id: p for p in provider_result.all()}
-
-        overrides_by_id: dict[str, tuple[ModelRow, float]] = {
-            row.id: (
-                row,
-                providers_by_id[row.upstream_provider_id].provider_fee
-                if row.upstream_provider_id in providers_by_id
-                else 1.01,
-            )
-            for row in override_rows
-            if row.upstream_provider_id is not None
-        }
-
-        disabled_result = await session.exec(
-            select(ModelRow.id).where(ModelRow.enabled == False)  # noqa: E712
+        # Fetch all providers with their models in a single logical operation
+        query = select(UpstreamProviderRow).options(
+            selectinload(UpstreamProviderRow.models)  # type: ignore
         )
-        disabled_model_ids = {row for row in disabled_result.all()}
+        result = await session.exec(query)
+        provider_rows = result.all()
 
-    _model_instances, _provider_map, _unique_models = create_model_mappings(
-        upstreams=_upstreams,
-        overrides_by_id=overrides_by_id,
-        disabled_model_ids=disabled_model_ids,
+    overrides_by_id: dict[str, tuple[ModelRow, float]] = {}
+    disabled_model_ids: set[str] = set()
+
+    for provider in provider_rows:
+        for model in provider.models:
+            if model.enabled:
+                overrides_by_id[model.id] = (model, provider.provider_fee)
+            else:
+                disabled_model_ids.add(model.id)
+
+    _model_instances, _provider_map, _unique_models, _provider_candidates_map = (
+        create_model_mappings(
+            upstreams=_upstreams,
+            overrides_by_id=overrides_by_id,
+            disabled_model_ids=disabled_model_ids,
+        )
     )
 
 
@@ -141,20 +160,32 @@ async def proxy(
             "unauthorized", "Unauthorized", 401, request=request
         )
 
-    logger.info(  # TODO: move to middleware, async
-        "Received proxy request",
-        extra={
-            "method": request.method,
-            "path": path,
-            "client_host": request.client.host if request.client else "unknown",
-            "user_agent": request.headers.get("user-agent", "unknown")[:100],
-        },
-    )
-
+    is_responses_api = path.startswith("v1/responses") or path.startswith("responses")
     request_body = await request.body()
     request_body_dict = parse_request_body_json(request_body, path)
 
-    model_id = request_body_dict.get("model", "unknown")
+    if is_responses_api:
+        model_id = extract_model_from_responses_request(request_body_dict)
+    else:
+        model_id = request_body_dict.get("model", "unknown")
+
+    if "https://testnut.cashu.space" in settings.cashu_mints:
+        try:
+            token_str = None
+            if x_cashu_header := headers.get("x-cashu"):
+                token_str = x_cashu_header
+            elif auth_header := headers.get("authorization"):
+                parts = auth_header.split(" ")
+                if len(parts) > 1 and not parts[1].startswith("sk-"):
+                    token_str = parts[1]
+
+            if token_str:
+                token_obj = deserialize_token_from_string(token_str)
+                if token_obj.mint == "https://testnut.cashu.space":
+                    model_id = "mock/gpt-420-mock"
+                    request_body_dict["model"] = model_id
+        except Exception:
+            pass
 
     model_obj = get_model_instance(model_id)
     if not model_obj:
@@ -162,8 +193,8 @@ async def proxy(
             "invalid_model", f"Model '{model_id}' not found", 400, request=request
         )
 
-    upstream = get_provider_for_model(model_id)
-    if not upstream:
+    upstreams = get_providers_for_model(model_id)
+    if not upstreams:
         return create_error_response(
             "invalid_model",
             f"No provider found for model '{model_id}'",
@@ -180,10 +211,81 @@ async def proxy(
     check_token_balance(headers, request_body_dict, max_cost_for_model)
 
     if x_cashu := headers.get("x-cashu", None):
-        return await upstream.handle_x_cashu(
-            request, x_cashu, path, max_cost_for_model, model_obj
+        # Redeem token once before trying any providers
+        amount, unit, mint = await recieve_token(x_cashu)
+
+        # Fallback for X-Cashu payments
+        last_exception = None
+        for i, upstream in enumerate(upstreams):
+            try:
+                # Prepare headers for this specific upstream
+                upstream_headers = upstream.prepare_headers(dict(request.headers))
+
+                if is_responses_api:
+                    return await upstream.forward_x_cashu_responses_request(
+                        request,
+                        path,
+                        upstream_headers,
+                        amount,
+                        unit,
+                        max_cost_for_model,
+                        model_obj,
+                        mint,
+                    )
+                else:
+                    return await upstream.forward_x_cashu_request(
+                        request,
+                        path,
+                        upstream_headers,
+                        amount,
+                        unit,
+                        max_cost_for_model,
+                        model_obj,
+                        mint,
+                    )
+            except (httpx.TimeoutException, httpx.ConnectError) as e:
+                logger.warning(
+                    f"Upstream provider {i + 1}/{len(upstreams)} ({upstream.provider_type}) timed out, trying fallback",
+                    extra={
+                        "model": model_id,
+                        "error": str(e),
+                        "attempt": i + 1,
+                    },
+                )
+                last_exception = e
+                continue
+
+        # If we get here, all providers failed
+        # Since the token was already redeemed, we must issue a refund
+        logger.error(
+            "All providers failed for X-Cashu request, issuing emergency refund",
+            extra={"amount": amount, "unit": unit, "mint": mint},
         )
 
+        # Try to use the first provider's refund mechanism
+        refund_token = await upstreams[0].send_refund(amount - 60, unit, mint)
+
+        error_message = "All upstream providers timed out"
+        if isinstance(last_exception, httpx.ConnectError):
+            error_message = "Unable to connect to any upstream service"
+
+        error_response = Response(
+            content=json.dumps(
+                {
+                    "error": {
+                        "message": error_message,
+                        "type": "upstream_error",
+                        "code": 504,
+                        "refund_token": refund_token,
+                    }
+                }
+            ),
+            status_code=504,
+            media_type="application/json",
+        )
+        error_response.headers["X-Cashu"] = refund_token
+        return error_response
+
     elif auth := headers.get("authorization", None):
         key = await get_bearer_token_key(headers, path, session, auth)
 
@@ -197,48 +299,102 @@ async def proxy(
             )
 
         logger.debug("Processing unauthenticated GET request", extra={"path": path})
-        # TODO: why is this needed? can we remove it?
-        headers = upstream.prepare_headers(dict(request.headers))
-        return await upstream.forward_get_request(request, path, headers)
 
-    # Only pay for request if we have request body data (for completions endpoints)
+        # Try fallback for GET requests too
+        last_exception = None
+        for i, upstream in enumerate(upstreams):
+            try:
+                headers = upstream.prepare_headers(dict(request.headers))
+                return await upstream.forward_get_request(request, path, headers)
+            except (httpx.TimeoutException, httpx.ConnectError) as e:
+                logger.warning(
+                    f"Upstream GET provider {i + 1}/{len(upstreams)} ({upstream.provider_type}) timed out, trying fallback",
+                    extra={"path": path, "error": str(e)},
+                )
+                last_exception = e
+                continue
+
+        error_message = "Upstream service request timed out"
+        if isinstance(last_exception, httpx.ConnectError):
+            error_message = "Unable to connect to upstream service"
+
+        return create_error_response(
+            "upstream_error", error_message, 502, request=request
+        )
+
     if request_body_dict:
         await pay_for_request(key, max_cost_for_model, session)
 
-    # Prepare headers for upstream
-    headers = upstream.prepare_headers(dict(request.headers))
+    # Fallback for API Key payments
+    last_exception = None
+    for i, upstream in enumerate(upstreams):
+        try:
+            headers = upstream.prepare_headers(dict(request.headers))
+            if is_responses_api:
+                response = await upstream.forward_responses_request(
+                    request,
+                    path,
+                    headers,
+                    request_body,
+                    key,
+                    max_cost_for_model,
+                    session,
+                    model_obj,
+                )
+            else:
+                response = await upstream.forward_request(
+                    request,
+                    path,
+                    headers,
+                    request_body,
+                    key,
+                    max_cost_for_model,
+                    session,
+                    model_obj,
+                )
 
-    # Forward to upstream and handle response
-    response = await upstream.forward_request(
-        request,
-        path,
-        headers,
-        request_body,
-        key,
-        max_cost_for_model,
-        session,
-        model_obj,
-    )
+            if response.status_code != 200:
+                # If it's a 429 (rate limit) or 503 (service unavailable), we might also want to fallback
+                if response.status_code in (429, 503, 502) and i < len(upstreams) - 1:
+                    logger.warning(
+                        f"Upstream provider {i + 1}/{len(upstreams)} returned {response.status_code}, trying fallback",
+                        extra={"model": model_id, "status": response.status_code},
+                    )
+                    continue
 
-    if response.status_code != 200:
-        await revert_pay_for_request(key, session, max_cost_for_model)
-        logger.warning(
-            "Upstream request failed, revert payment",
-            extra={
-                "status_code": response.status_code,
-                "path": path,
-                "key_hash": key.hashed_key[:8] + "...",
-                "key_balance": key.balance,
-                "max_cost_for_model": max_cost_for_model,
-                "upstream_headers": response.headers
-                if hasattr(response, "headers")
-                else None,
-            },
-        )
-        # Return the mapped error response generated earlier rather than masking with 502
-        return response
+                await revert_pay_for_request(key, session, max_cost_for_model)
+                logger.warning(
+                    "Upstream request failed, revert payment",
+                    extra={
+                        "status_code": response.status_code,
+                        "path": path,
+                        "key_hash": key.hashed_key[:8] + "...",
+                        "key_balance": key.balance,
+                        "max_cost_for_model": max_cost_for_model,
+                        "upstream_headers": response.headers
+                        if hasattr(response, "headers")
+                        else None,
+                    },
+                )
+                return response
 
-    return response
+            return response
+
+        except (httpx.TimeoutException, httpx.ConnectError) as e:
+            logger.warning(
+                f"Upstream provider {i + 1}/{len(upstreams)} ({upstream.provider_type}) timed out, trying fallback",
+                extra={"model": model_id, "error": str(e)},
+            )
+            last_exception = e
+            continue
+
+    # All providers failed with timeout/connect error
+    await revert_pay_for_request(key, session, max_cost_for_model)
+    error_message = "Upstream service request timed out"
+    if isinstance(last_exception, httpx.ConnectError):
+        error_message = "Unable to connect to upstream service"
+
+    return create_error_response("upstream_error", error_message, 502, request=request)
 
 
 async def get_bearer_token_key(
@@ -321,6 +477,24 @@ async def get_bearer_token_key(
         raise
 
 
+def extract_model_from_responses_request(request_body_dict: dict[str, Any]) -> str:
+    if model := request_body_dict.get("model"):
+        return model
+
+    if input_data := request_body_dict.get("input"):
+        if isinstance(input_data, dict) and (model := input_data.get("model")):
+            return model
+
+    if request_body_dict.get("messages"):
+        return "unknown"
+
+    logger.warning(
+        "No model found in Responses API request",
+        extra={"body_keys": list(request_body_dict.keys())},
+    )
+    return "unknown"
+
+
 def parse_request_body_json(request_body: bytes, path: str) -> dict[str, Any]:
     request_body_dict = {}
     if request_body:

routstr/upstream/fake.py

@@ -0,0 +1,265 @@
+import asyncio
+import json
+import random
+from typing import AsyncIterator
+
+from fastapi import Request
+from fastapi.responses import Response, StreamingResponse
+
+from ..core.db import ApiKey, AsyncSession
+from ..payment.models import Architecture, Model, Pricing
+from .base import BaseUpstreamProvider
+
+
+class MockUpstreamProvider(BaseUpstreamProvider):
+    """Fack Mock Upstream provider specifically for Testing."""
+
+    provider_type = "mock"
+
+    async def forward_request(
+        self,
+        request: Request,
+        path: str,
+        headers: dict,
+        request_body: bytes | None,
+        key: ApiKey,
+        max_cost_for_model: int,
+        session: AsyncSession,
+        model_obj: Model,
+    ) -> Response | StreamingResponse:
+        if path.endswith("chat/completions"):
+            is_streaming = False
+            if request_body:
+                request_data = json.loads(request_body)
+                is_streaming = request_data.get("stream", False)
+
+            if is_streaming:
+
+                async def fake_streaming_response(
+                    chunk_size: int | None = None,
+                ) -> AsyncIterator[bytes]:
+                    suffix = random.randint(1000, 9999)
+                    req_id = f"gen-mock-stream-{suffix}"
+                    created = 1766138895
+                    model = "mock/gpt-420-mock"
+
+                    def make_chunk(
+                        delta: dict,
+                        finish_reason: str | None = None,
+                        usage: dict | None = None,
+                    ) -> bytes:
+                        chunk = {
+                            "id": req_id,
+                            "provider": "MockProvider",
+                            "model": model,
+                            "object": "chat.completion.chunk",
+                            "created": created,
+                            "choices": [
+                                {
+                                    "index": 0,
+                                    "delta": delta,
+                                    "finish_reason": finish_reason,
+                                    "native_finish_reason": "completed"
+                                    if finish_reason
+                                    else None,
+                                    "logprobs": None,
+                                }
+                            ],
+                        }
+                        if usage:
+                            chunk["usage"] = usage
+                        return f"data: {json.dumps(chunk)}\n\n".encode()
+
+                    # 1. Initial chunk
+                    yield make_chunk({"role": "assistant", "content": ""})
+                    await asyncio.sleep(0.02)
+
+                    # 2. Reasoning chunks
+                    reasoning_tokens = ["Mock", " reason", "ing", "..."]
+                    for token in reasoning_tokens:
+                        delta = {
+                            "role": "assistant",
+                            "content": "",
+                            "reasoning": token,
+                            "reasoning_details": [
+                                {
+                                    "type": "reasoning.summary",
+                                    "summary": token,
+                                    "format": "openai-responses-v1",
+                                    "index": 0,
+                                }
+                            ],
+                        }
+                        yield make_chunk(delta)
+                        await asyncio.sleep(0.03)
+
+                    # 3. Content chunks
+                    content_tokens = ["This", " is", " a", " mock", " stream", "."]
+                    for token in content_tokens:
+                        yield make_chunk({"role": "assistant", "content": token})
+                        await asyncio.sleep(0.03)
+
+                    # 4. Finish chunk
+                    yield make_chunk(
+                        {"role": "assistant", "content": ""}, finish_reason="stop"
+                    )
+
+                    # 5. Usage chunk
+                    usage_data = {
+                        "prompt_tokens": 10,
+                        "completion_tokens": 20,
+                        "total_tokens": 30,
+                        "cost": 0.001,
+                        "is_byok": False,
+                        "prompt_tokens_details": {
+                            "cached_tokens": 0,
+                            "audio_tokens": 0,
+                            "video_tokens": 0,
+                        },
+                        "cost_details": {
+                            "upstream_inference_cost": None,
+                            "upstream_inference_prompt_cost": 0,
+                            "upstream_inference_completions_cost": 0.001,
+                        },
+                        "completion_tokens_details": {
+                            "reasoning_tokens": 10,
+                            "image_tokens": 0,
+                        },
+                    }
+
+                    usage_chunk = {
+                        "id": req_id,
+                        "provider": "MockProvider",
+                        "model": model,
+                        "object": "chat.completion.chunk",
+                        "created": created,
+                        "choices": [
+                            {
+                                "index": 0,
+                                "delta": {"role": "assistant", "content": ""},
+                                "finish_reason": None,
+                                "native_finish_reason": None,
+                                "logprobs": None,
+                            }
+                        ],
+                        "usage": usage_data,
+                    }
+                    yield f"data: {json.dumps(usage_chunk)}\n\n".encode()
+
+                    # 6. DONE
+                    yield b"data: [DONE]\n\n"
+
+                    # 7. Cost
+                    cost_chunk = {
+                        "cost": {
+                            "base_msats": 0,
+                            "input_msats": 2,
+                            "output_msats": 10,
+                            "total_msats": 12,
+                        }
+                    }
+                    yield f"data: {json.dumps(cost_chunk)}\n\n".encode()
+
+                return StreamingResponse(
+                    fake_streaming_response(),
+                    200,
+                )
+
+            else:
+                suffix = random.randint(1000, 9999)
+                content_dict = {
+                    "id": f"gen-mock-{suffix}",
+                    "provider": "MockProvider",
+                    "model": "mock/gpt-5-mini",
+                    "object": "chat.completion",
+                    "created": 1766138655,
+                    "choices": [
+                        {
+                            "logprobs": None,
+                            "finish_reason": "length",
+                            "native_finish_reason": "max_output_tokens",
+                            "index": 0,
+                            "message": {
+                                "role": "assistant",
+                                "content": f"Mock Content {suffix}",
+                                "refusal": None,
+                                "reasoning": f"Mock Reasoning {suffix}",
+                                "reasoning_details": [
+                                    {
+                                        "format": "openai-responses-v1",
+                                        "index": 0,
+                                        "type": "reasoning.summary",
+                                        "summary": f"Mock Summary {suffix}",
+                                    },
+                                    {
+                                        "id": f"rs_mock_{suffix}",
+                                        "format": "openai-responses-v1",
+                                        "index": 0,
+                                        "type": "reasoning.encrypted",
+                                        "data": "mock_encrypted_data",
+                                    },
+                                ],
+                            },
+                        }
+                    ],
+                    "usage": {
+                        "prompt_tokens": 10,
+                        "completion_tokens": 10,
+                        "total_tokens": 20,
+                        "cost": 0,
+                        "is_byok": False,
+                        "prompt_tokens_details": {
+                            "cached_tokens": 0,
+                            "audio_tokens": 0,
+                            "video_tokens": 0,
+                        },
+                        "cost_details": {
+                            "upstream_inference_cost": None,
+                            "upstream_inference_prompt_cost": 0,
+                            "upstream_inference_completions_cost": 0,
+                        },
+                        "completion_tokens_details": {
+                            "reasoning_tokens": 5,
+                            "image_tokens": 0,
+                        },
+                    },
+                    "cost": {
+                        "base_msats": 0,
+                        "input_msats": 0,
+                        "output_msats": 0,
+                        "total_msats": 0,
+                    },
+                }
+                return Response(json.dumps(content_dict).encode(), 200)
+
+        elif path.endswith("embeddings"):
+            raise NotImplementedError
+        elif path.endswith("responses"):
+            raise NotImplementedError
+        else:
+            raise NotImplementedError
+
+    async def fetch_models(self) -> list[Model]:
+        return [
+            Model(
+                id="mock/gpt-420-mock",
+                name="mock/gpt-420-mock",
+                created=0,
+                description="mock model for testing",
+                context_length=8192,
+                architecture=Architecture(
+                    modality="text",
+                    input_modalities=["text"],
+                    output_modalities=["text"],
+                    tokenizer="",
+                    instruct_type=None,
+                ),
+                pricing=Pricing(prompt=0.01, completion=0.01),
+            ),
+        ]
+
+    def transform_model_name(self, model_id: str) -> str:
+        return "fake-model"
+
+    async def get_balance(self) -> float | None:
+        return 420.69

routstr/upstream/helpers.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import os
 import re
 from typing import TYPE_CHECKING
@@ -7,6 +8,7 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from ..core.settings import Settings
 
+from sqlmodel import select
 
 from ..core import get_logger
 from ..core.db import AsyncSession, ModelRow, UpstreamProviderRow, create_session
@@ -145,6 +147,17 @@ async def refresh_upstreams_models_periodically(
                         f"Error refreshing models for {upstream.base_url}",
                         extra={"error": str(e), "error_type": type(e).__name__},
                     )
+
+            try:
+                from ..payment.models import _update_sats_pricing_once
+
+                await _update_sats_pricing_once()
+            except Exception as e:
+                logger.warning(f"Failed to update pricing after model refresh: {e}")
+                from ..proxy import refresh_model_maps
+
+                await refresh_model_maps()
+
         except asyncio.CancelledError:
             break
         except Exception as e:
@@ -166,8 +179,6 @@ async def init_upstreams() -> list[BaseUpstreamProvider]:
     Seeds database with providers from settings if empty, then loads and instantiates
     provider instances from database records, and refreshes their models cache.
     """
-    from sqlmodel import select
-
     from ..core.settings import settings
 
     async with create_session() as session:
@@ -183,16 +194,16 @@ async def init_upstreams() -> list[BaseUpstreamProvider]:
             result = await session.exec(select(UpstreamProviderRow))
             existing_providers = result.all()
 
-        upstreams: list[BaseUpstreamProvider] = []
-        for provider_row in existing_providers:
+        async def _init_single_provider(
+            provider_row: UpstreamProviderRow,
+        ) -> BaseUpstreamProvider | None:
             if not provider_row.enabled:
                 logger.debug(f"Skipping disabled provider: {provider_row.base_url}")
-                continue
+                return None
 
             provider = _instantiate_provider(provider_row)
             if provider:
                 await provider.refresh_models_cache()
-                upstreams.append(provider)
                 logger.debug(
                     f"Initialized {provider_row.provider_type} provider",
                     extra={
@@ -200,6 +211,20 @@ async def init_upstreams() -> list[BaseUpstreamProvider]:
                         "models_cached": len(provider.get_cached_models()),
                     },
                 )
+                return provider
+            return None
+
+        tasks = [_init_single_provider(row) for row in existing_providers]
+        results = await asyncio.gather(*tasks)
+        upstreams = [p for p in results if p is not None]
+
+        if "https://testnut.cashu.space" in settings.cashu_mints:
+            from .fake import MockUpstreamProvider
+
+            mock_provider = MockUpstreamProvider("mock", "mock")
+            await mock_provider.refresh_models_cache()
+            upstreams.append(mock_provider)
+            logger.info("Initialized MockUpstreamProvider for testnut mint")
 
         return upstreams
 

routstr/wallet.py

@@ -313,6 +313,8 @@ async def periodic_payout() -> None:
         try:
             async with db.create_session() as session:
                 for mint_url in settings.cashu_mints:
+                    if mint_url == "https://testnut.cashu.space":
+                        continue
                     for unit in ["sat", "msat"]:
                         wallet = await get_wallet(mint_url, unit)
                         proofs = get_proofs_per_mint_and_unit(

ui/components/ModelSearchFilter.tsx

@@ -41,6 +41,10 @@ export function ModelSearchFilter({
           model.name.toLowerCase().includes(query) ||
           model.full_name.toLowerCase().includes(query) ||
           model.provider.toLowerCase().includes(query) ||
+          (model.alias_ids &&
+            model.alias_ids.some((alias) =>
+              alias.toLowerCase().includes(query)
+            )) ||
           (model.description &&
             model.description.toLowerCase().includes(query)) ||
           model.modelType.toLowerCase().includes(query)

ui/components/ModelSelector.tsx

@@ -542,6 +542,7 @@ export function ModelSelector({
       top_provider: null,
       upstream_provider_id: providerId,
       enabled: model.isEnabled,
+      alias_ids: model.alias_ids || null,
     };
 
     setModelDialogState({
@@ -585,6 +586,7 @@ export function ModelSelector({
       top_provider: null,
       upstream_provider_id: providerId,
       enabled: model.isEnabled,
+      alias_ids: model.alias_ids || null,
     };
 
     setModelDialogState({

ui/lib/api/schemas/models.ts

@@ -31,6 +31,7 @@ export const ModelSchema = z.object({
   // API key type indicators
   has_own_api_key: z.boolean(),
   api_key_type: z.string(), // "individual" or "group"
+  alias_ids: z.array(z.string()).nullable().optional(),
 });
 
 // Schema for a model with additional provider-specific settings

ui/lib/api/services/admin.ts

@@ -121,6 +121,7 @@ export interface AdminModelAsModel {
   soft_deleted?: boolean;
   has_own_api_key: boolean;
   api_key_type: string;
+  alias_ids?: string[] | null;
 }
 
 export interface AdminModelGroup {
@@ -207,6 +208,7 @@ export class AdminService {
       soft_deleted: !adminModel.enabled,
       has_own_api_key: false,
       api_key_type: 'group',
+      alias_ids: adminModel.alias_ids,
     };
   }
 
@@ -354,8 +356,9 @@ export class AdminService {
       original: data.pricing,
       converted: payload.pricing,
     });
-    const model = await apiClient.patch<AdminModel>(
-      `/admin/api/upstream-providers/${providerId}/models/${encodeURIComponent(modelId)}`,
+    // Use the same POST endpoint for both create and update (upsert)
+    const model = await apiClient.post<AdminModel>(
+      `/admin/api/upstream-providers/${providerId}/models`,
       payload
     );
     return {