draft to fix azure issue

Dockerfile.full

@@ -1,50 +0,0 @@
-# Multi-stage Dockerfile for Routstr (includes UI build)
-# Stage 1: Build the UI
-FROM node:23-alpine AS ui-builder
-WORKDIR /app/ui
-
-# Install pnpm
-RUN corepack enable pnpm && corepack prepare pnpm@latest --activate
-
-# Copy UI source
-COPY ui/package.json ui/pnpm-lock.yaml* ./
-RUN pnpm install --frozen-lockfile
-
-COPY ui/ ./
-ENV NEXT_TELEMETRY_DISABLED=1
-# Next.js build produces a static export in 'out' directory
-RUN pnpm run build
-
-# Stage 2: Build the Routstr Node
-FROM ghcr.io/astral-sh/uv:python3.11-alpine AS runner
-
-# Install system dependencies
-RUN apk add --no-cache \
-    pkgconf \
-    build-base \
-    automake \
-    autoconf \
-    libtool \
-    m4 \
-    perl \
-    git
-
-WORKDIR /app
-
-# Copy the rest of the application (required for uv sync to find the package)
-COPY . .
-
-# Install dependencies including the specific secp256k1 branch
-RUN uv add git+https://github.com/saschanaz/secp256k1-py.git#branch=upgrade060
-RUN uv sync --no-dev
-
-# Copy the built UI from the ui-builder stage
-COPY --from=ui-builder /app/ui/out ./ui_out
-
-ENV PORT=8000
-ENV PYTHONUNBUFFERED=1
-
-EXPOSE 8000
-
-# Run the application
-CMD ["/app/.venv/bin/fastapi", "run", "routstr", "--host", "0.0.0.0"]

docs/provider/deployment.md

@@ -6,25 +6,30 @@ Production deployment guide for Routstr Provider nodes.
 
 For production, use Docker Compose with persistent storage and optional Tor support.
 
-### Unified Setup (All-in-one)
-To build and run the node with the UI integrated in a single container using the multi-stage build:
+### Basic Setup
 
-```bash
-docker build -f Dockerfile.full -t routstr-full .
-docker run -d -p 8000:8000 --env-file .env routstr-full
+Create a `compose.yml`:
+
+```yaml
+services:
+  routstr:
+    image: ghcr.io/routstr/proxy:latest
+    container_name: routstr
+    restart: unless-stopped
+    ports:
+      - "8000:8000"
+    volumes:
+      - ./data:/app/data
+      - ./logs:/app/logs
 ```
 
-### 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.
+Start the node:
 
 ```bash
 docker compose up -d
 ```
 
-This will:
-1.  **Build the UI**: Compiles the frontend and copies it to a shared volume.
-2.  **Start Routstr**: Runs the Python node, mounting the built UI.
-3.  **Start Tor**: Provides anonymous access via a `.onion` address.
+Then configure everything via the [Admin Dashboard](http://localhost:8000/admin/).
 
 ---
 
@@ -184,20 +189,8 @@ docker compose up -d
 
 ## Building from Source
 
-### Unified Image (UI + Node)
-The easiest way to build everything from source into a single production-ready image:
-
 ```bash
-docker build -f Dockerfile.full -t routstr-full .
-```
-
-### Individual Components
-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 .
+git clone https://github.com/routstr/routstr-core.git
+cd routstr-core
+docker build -t routstr-local .
 ```

docs/provider/quickstart.md

@@ -26,8 +26,6 @@ You bring the API keys, Routstr handles the billing, payments, and client manage
 
 ## 1. Start the Node
 
-You can run the pre-built image directly:
-
 ```bash
 docker run -d \
   --name routstr \
@@ -36,16 +34,6 @@ docker run -d \
   ghcr.io/routstr/proxy:latest
 ```
 
-### 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
-docker build -f Dockerfile.full -t routstr-local .
-docker run -d -p 8000:8000 --name routstr routstr-local
-```
-
 Verify it's running:
 
 ```bash

routstr/upstream/azure.py

@@ -1,9 +1,14 @@
 from typing import TYPE_CHECKING, Mapping
 
+from fastapi import Request
+from fastapi.responses import Response, StreamingResponse
+
 from .base import BaseUpstreamProvider
 
 if TYPE_CHECKING:
-    from ..core.db import UpstreamProviderRow
+    from ..auth import ApiKey
+    from ..core.db import AsyncSession, UpstreamProviderRow
+    from ..payment.models import Model
 
 
 class AzureUpstreamProvider(BaseUpstreamProvider):
@@ -58,19 +63,101 @@ class AzureUpstreamProvider(BaseUpstreamProvider):
             "platform_url": cls.platform_url,
         }
 
+    def prepare_headers(self, request_headers: dict) -> dict:
+        """Prepare headers for Azure OpenAI, adding api-key."""
+        headers = super().prepare_headers(request_headers)
+        if self.api_key:
+            headers["api-key"] = self.api_key
+            headers.pop("Authorization", None)
+            headers.pop("authorization", None)
+        return headers
+
     def prepare_params(
         self, path: str, query_params: Mapping[str, str] | None
     ) -> Mapping[str, str]:
-        """Prepare query parameters for Azure OpenAI, adding API version.
-
-        Args:
-            path: Request path
-            query_params: Original query parameters from the client
-
-        Returns:
-            Query parameters dict with Azure API version added for chat completions
-        """
+        """Prepare query parameters for Azure OpenAI, adding API version."""
         params = dict(query_params or {})
-        if path.endswith("chat/completions"):
-            params["api-version"] = self.api_version
+        # Ensure we use a valid Azure API version format
+        # Strip any hidden characters like Byte Order Marks (BOM) or whitespace
+        version = self.api_version.strip().replace("\ufeff", "")
+        if version == "v1":
+            version = "2024-02-15-preview"
+        params["api-version"] = version
         return params
+
+    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:
+        """Forward request to Azure OpenAI."""
+        # Fix: If base_url contains /openai/v1, remove it
+        actual_base_url = self.base_url
+        if "/openai/v1" in actual_base_url:
+            actual_base_url = actual_base_url.split("/openai/v1")[0]
+
+        # Use canonical_slug as it often stores the deployment name in Azure setups
+        # otherwise fallback to transform_model_name
+        deployment_id = getattr(
+            model_obj, "canonical_slug", None
+        ) or self.transform_model_name(model_obj.id)
+
+        # Ensure deployment_id doesn't contain a provider prefix (e.g., 'openai/' or 'azure/')
+        if "/" in deployment_id:
+            deployment_id = deployment_id.split("/")[-1]
+
+        # Azure format: openai/deployments/{deployment-id}/chat/completions
+        clean_path = path.lstrip("/")
+        azure_path = f"openai/deployments/{deployment_id}/{clean_path}"
+
+        # Temporary backup and restore base_url to use cleaned version
+        original_base = self.base_url
+        self.base_url = actual_base_url
+
+        # The query params are handled by super().forward_request via prepare_params
+        # We don't need to manually append them to full_url for the print if we want to be accurate
+        params = self.prepare_params(path, {})
+        full_url = (
+            f"{actual_base_url}/{azure_path}?api-version={params.get('api-version')}"
+        )
+        print(f"\n[DEBUG] Azure Forwarding URL: {full_url}")
+        print(f"[DEBUG] Deployment ID: {deployment_id}")
+
+        try:
+            response = await super().forward_request(
+                request,
+                azure_path,
+                headers,
+                request_body,
+                key,
+                max_cost_for_model,
+                session,
+                model_obj,
+            )
+
+            # Check if it's an error response to print details
+            if hasattr(response, "status_code") and response.status_code != 200:
+                print(f"[DEBUG] Azure Error Status: {response.status_code}")
+                if hasattr(response, "body"):
+                    print(
+                        f"[DEBUG] Azure Error Body: {response.body.decode() if isinstance(response.body, bytes) else response.body}"
+                    )
+
+            return response
+        except Exception as e:
+            print(f"[DEBUG] Azure Exception: {str(e)}")
+            raise
+        finally:
+            self.base_url = original_base
+
+    def transform_model_name(self, model_id: str) -> str:
+        """Extract deployment name from model ID."""
+        if "/" in model_id:
+            return model_id.split("/")[-1]
+        return model_id