Fix actual models

README.md

@@ -1,12 +1,41 @@
 ---
 title: Llm Proxy
-emoji: 🚀
+emoji: "🤗"
 colorFrom: red
 colorTo: indigo
 sdk: docker
 pinned: false
 license: mit
-short_description: LLM proxy
+short_description: OpenAI-compatible proxy for Hugging Face Inference Providers
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# LLM proxy
+
+The service exposes an OpenAI-like `/v1/chat/completions` endpoint and routes calls through Hugging Face Inference Providers.
+
+## Configuration
+
+- `HF_TOKEN`: Hugging Face user token with the **Inference Providers** permission. `HF_API_KEY` remains supported for compatibility.
+- `API_KEYS`: comma-separated bearer tokens accepted by this proxy.
+- `HF_MODELS`: optional comma-separated `alias=model-id` mappings. Default: `gpt-oss=openai/gpt-oss-120b:cerebras`.
+- `HF_TIMEOUT_SECONDS`: optional provider timeout, default `60`.
+
+Do not append a provider suffix unless you intentionally want to pin one. With a plain model ID, the Hugging Face router can select an available provider.
+
+Example `.env`:
+
+```dotenv
+HF_TOKEN=hf_your_token
+API_KEYS=local-secret
+HF_MODELS=gpt-oss=openai/gpt-oss-120b:cerebras
+```
+
+Run locally with `start.bat`, then call:
+
+```powershell
+$headers = @{ Authorization = "Bearer local-secret" }
+$body = @{ model = "gpt-oss"; messages = @(@{ role = "user"; content = "Привет!" }) } | ConvertTo-Json -Depth 4
+Invoke-RestMethod http://127.0.0.1:8000/v1/chat/completions -Method Post -Headers $headers -ContentType "application/json" -Body $body
+```
+
+Free Hugging Face accounts receive only a small monthly inference credit. Requests stop after the credit is exhausted unless additional credits are purchased.

app/factory.py

@@ -1,25 +1,13 @@
-from .providers.hf_openai import HFOpenAIProvider
+from .providers.hf_openai import HFOpenAIProvider, configured_models
+
 
 class ProviderFactory:
-    _providers = {
-        "arch-router": HFOpenAIProvider,
-        "phi-3-mini": HFOpenAIProvider,
-        "gemma-2b": HFOpenAIProvider,
-        "mistral-7b": HFOpenAIProvider,
-        "llama-3b": HFOpenAIProvider,
-        "qwen-3b": HFOpenAIProvider,
-    }
-    
-    _instances = {}
+    _instance = None
 
     @classmethod
-    def get_provider(cls, model_name: str):
-        if model_name not in cls._providers:
+    def get_provider(cls, model_name: str) -> HFOpenAIProvider:
+        if model_name not in configured_models():
             raise ValueError(f"Unsupported model: {model_name}")
-        
-        provider_class = cls._providers[model_name]
-        cache_key = provider_class.__name__
-        if cache_key not in cls._instances:
-            cls._instances[cache_key] = provider_class()
-        
-        return cls._instances[cache_key]
+        if cls._instance is None:
+            cls._instance = HFOpenAIProvider()
+        return cls._instance

app/main.py

@@ -1,55 +1,66 @@
-import os
-import sys
-from fastapi import FastAPI, Depends, HTTPException
+from contextlib import asynccontextmanager
+from uuid import uuid4
+
 from dotenv import load_dotenv
+from fastapi import Depends, FastAPI, HTTPException
 
 load_dotenv()
 
 from .auth import verify_api_key
 from .factory import ProviderFactory
 from .models import ChatRequest, ChatResponse
+from .providers.hf_openai import configured_models
+
+
+@asynccontextmanager
+async def lifespan(_: FastAPI):
+    yield
+    if ProviderFactory._instance is not None:
+        await ProviderFactory._instance.client.close()
+
+
+app = FastAPI(title="LLM API Proxy", version="2.0.0", lifespan=lifespan)
 
-app = FastAPI(title="LLM API Proxy", version="1.0.0")
 
 @app.get("/")
 async def root():
-    return {"message": "LLM API Proxy is running", "version": "1.0.0"}
+    return {"message": "LLM API Proxy is running", "version": "2.0.0"}
+
 
 @app.get("/v1/models")
-async def list_models(api_key: str = Depends(verify_api_key)):
-    """Возвращает список доступных моделей"""
+async def list_models(_: str = Depends(verify_api_key)):
     return {
-        "models": [
-            {"id": "arch-router", "name": "Arch Router 1.5B (HF)", "provider": "huggingface"},
-            {"id": "phi-3-mini", "name": "Phi-3 Mini 4K (HF)", "provider": "huggingface"},
-            {"id": "gemma-2b", "name": "Gemma 2 2B (HF)", "provider": "huggingface"},
-            {"id": "mistral-7b", "name": "Mistral 7B (HF)", "provider": "huggingface"},
-            {"id": "llama-3b", "name": "Llama 3.2 3B (HF)", "provider": "huggingface"},
-            {"id": "qwen-3b", "name": "Qwen 2.5 3B (HF)", "provider": "huggingface"},
-        ]
+        "object": "list",
+        "data": [
+            {"id": alias, "object": "model", "owned_by": "huggingface", "hf_model": model_id}
+            for alias, model_id in configured_models().items()
+        ],
     }
 
+
 @app.post("/v1/chat/completions")
-async def chat_completion(
-    request: ChatRequest,
-    api_key: str = Depends(verify_api_key)
-):
+async def chat_completion(request: ChatRequest, _: str = Depends(verify_api_key)):
     try:
         provider = ProviderFactory.get_provider(request.model)
         result = await provider.generate(
             messages=[{"role": m.role, "content": m.content} for m in request.messages],
             max_tokens=request.max_tokens,
             temperature=request.temperature,
-            model=request.model
+            model=request.model,
         )
-        
         return ChatResponse(
-            id=f"chat-{hash(str(request.messages))}",
-            choices=[{"message": {"content": result["content"]}}],
-            usage={"total_tokens": result.get("total_tokens", 0)},
-            model=request.model
+            id=f"chatcmpl-{uuid4().hex}",
+            choices=[
+                {
+                    "index": 0,
+                    "message": {"role": "assistant", "content": result["content"]},
+                    "finish_reason": "stop",
+                }
+            ],
+            usage={"total_tokens": result["total_tokens"]},
+            model=request.model,
         )
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-    except Exception as e:
-        raise HTTPException(status_code=502, detail=f"Provider error: {str(e)}")
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    except Exception as exc:
+        raise HTTPException(status_code=502, detail=f"Hugging Face error: {exc}") from exc

app/models.py

@@ -1,18 +1,22 @@
-from pydantic import BaseModel
-from typing import List, Optional
+from typing import List
+
+from pydantic import BaseModel, Field
+
 
 class Message(BaseModel):
     role: str
     content: str
 
+
 class ChatRequest(BaseModel):
-    model: str
+    model: str = "gpt-oss"
     messages: List[Message]
-    max_tokens: Optional[int] = 500
-    temperature: Optional[float] = 0.7
+    max_tokens: int = Field(default=256, ge=1, le=4096)
+    temperature: float = Field(default=0.7, ge=0, le=2)
+
 
 class ChatResponse(BaseModel):
     id: str
     choices: List[dict]
     usage: dict
-    model: str
+    model: str

app/providers/hf_openai.py

@@ -1,52 +1,64 @@
 import os
-from openai import OpenAI
-from typing import List, Dict, Any
+from typing import Any, Dict, List
+
+from openai import AsyncOpenAI
+
 from .base import BaseLLMProvider
 
+
+DEFAULT_MODEL = "openai/gpt-oss-120b:cerebras"
+
+
+def configured_models() -> Dict[str, str]:
+    """Read aliases from HF_MODELS: alias=model,alias2=model2."""
+    raw = os.getenv("HF_MODELS", f"gpt-oss={DEFAULT_MODEL}")
+    models: Dict[str, str] = {}
+    for item in raw.split(","):
+        if not item.strip():
+            continue
+        alias, separator, model_id = item.partition("=")
+        alias = alias.strip()
+        model_id = model_id.strip() if separator else alias
+        if alias and model_id:
+            models[alias] = model_id
+    if not models:
+        raise ValueError("HF_MODELS does not contain any valid model definitions")
+    return models
+
+
 class HFOpenAIProvider(BaseLLMProvider):
-    """Провайдер для Hugging Face через OpenAI-совместимый API"""
-    
-    SUPPORTED_MODELS = {
-        "arch-router": "katanemo/Arch-Router-1.5B:hf-inference",
-        "phi-3-mini": "microsoft/Phi-3-mini-4k-instruct:hf-inference",
-        "gemma-2b": "google/gemma-2-2b-it:hf-inference",
-        "mistral-7b": "mistralai/Mistral-7B-Instruct-v0.3:hf-inference",
-        "llama-3b": "meta-llama/Llama-3.2-3B-Instruct:hf-inference",
-        "qwen-3b": "Qwen/Qwen2.5-3B-Instruct:hf-inference",
-    }
-    
-    def __init__(self):
-        self.api_key = os.getenv("HF_API_KEY")
-        if not self.api_key:
-            raise ValueError("HF_API_KEY not set")
-        
-        self.client = OpenAI(
+    """Hugging Face Inference Providers through its OpenAI-compatible router."""
+
+    def __init__(self) -> None:
+        token = os.getenv("HF_TOKEN") or os.getenv("HF_API_KEY")
+        if not token:
+            raise ValueError("HF_TOKEN (or legacy HF_API_KEY) is not set")
+        self.models = configured_models()
+        self.client = AsyncOpenAI(
             base_url="https://router.huggingface.co/v1",
-            api_key=self.api_key
+            api_key=token,
+            timeout=float(os.getenv("HF_TIMEOUT_SECONDS", "60")),
+            max_retries=2,
         )
-        print(f"🤗 HF OpenAI Provider initialized")
-    
-    def _get_model_id(self, model_name: str) -> str:
-        if model_name in self.SUPPORTED_MODELS:
-            return self.SUPPORTED_MODELS[model_name]
-        return "katanemo/Arch-Router-1.5B:hf-inference"
-    
-    async def generate(self, messages: List[Dict[str, str]], **kwargs):
-        model = self._get_model_id(kwargs.get("model", "arch-router"))
-        
+
+    async def generate(
+        self, messages: List[Dict[str, str]], **kwargs: Any
+    ) -> Dict[str, Any]:
+        alias = kwargs.get("model", next(iter(self.models)))
         try:
-            response = self.client.chat.completions.create(
-                model=model,
-                messages=messages,
-                max_tokens=kwargs.get("max_tokens", 500),
-                temperature=kwargs.get("temperature", 0.7)
-            )
-            
-            return {
-                "content": response.choices[0].message.content,
-                "total_tokens": response.usage.total_tokens if response.usage else 0,
-                "model": model
-            }
-        except Exception as e:
-            print(f"❌ Error: {e}")
-            raise
+            model_id = self.models[alias]
+        except KeyError as exc:
+            raise ValueError(f"Unsupported model: {alias}") from exc
+
+        response = await self.client.chat.completions.create(
+            model=model_id,
+            messages=messages,
+            max_tokens=kwargs.get("max_tokens", 256),
+            temperature=kwargs.get("temperature", 0.7),
+        )
+        usage = response.usage
+        return {
+            "content": response.choices[0].message.content or "",
+            "total_tokens": usage.total_tokens if usage else 0,
+            "model": model_id,
+        }