Update app.py

app.py

@@ -1,61 +1,100 @@
 import os
-import subprocess
+import json
 import time
-import requests
+from typing import List, Optional
 import gradio as gr
-from fastapi import FastAPI, Request
-from fastapi.responses import StreamingResponse
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import StreamingResponse, JSONResponse
+from pydantic import BaseModel
+from huggingface_hub import InferenceClient
+
 # Configuración del modelo
-MODEL_ID = os.getenv("MODEL_ID", "Qwen/Qwen3.8-27B")
-VLLM_PORT = 8001
-print(f"Iniciando vLLM en segundo plano con el modelo: {MODEL_ID}...")
-# 1. Ejecutar el servidor de vLLM en segundo plano en el puerto 8001
-vllm_cmd = [
-"python3", "-m", "vllm.entrypoints.openai.api_server",
-"--model", MODEL_ID,
-"--port", str(VLLM_PORT),
-"--host", "127.0.0.1",
-"--trust-remote-code",
-"--max-model-len", "8192",
-"--gpu-memory-utilization", "0.95"
-]
-# Si el modelo está cuantizado (ej. AWQ), puedes añadir la opción:
-# vllm_cmd.extend(["--quantization", "awq"])
-process = subprocess.Popen(vllm_cmd)
-# 2. Inicializar la app FastAPI
-app = FastAPI(title="Qwen OpenAI API Proxy")
-# Redirigir todas las peticiones a /v1 directamente hacia vLLM
-@app.api_route("/v1/{path:path}", methods=["GET", "POST", "PUT", "DELETE"])
-async def proxy_v1(request: Request, path: str):
-url = f"http://127.0.0.1:{VLLM_PORT}/v1/{path}"
-body = await request.body()
-headers = {k: v for k, v in request.headers.items() if k.lower() != "host"}
-# Manejar respuestas en streaming para OpenCode
-resp = requests.request(
-method=request.method,
-url=url,
-headers=headers,
-data=body,
-stream=True
-)
-return StreamingResponse(
-resp.iter_content(chunk_size=1024),
-status_code=resp.status_code,
-headers=dict(resp.headers)
-)
-# 3. Interfaz visual con Gradio
-with gr.Blocks(title="Qwen OpenCode API Endpoint") as demo:
-gr.Markdown("# 🚀 Servidor Qwen Activo")
-gr.Markdown(f"**Modelo cargado:** `{MODEL_ID}`")
-gr.Markdown("""
-### 📡 Configuración para OpenCode
-Copia la siguiente **Base URL** en la configuración de OpenCode:
-""")
-gr.Code("https://https://huggingface.co/spaces/acsaco.hf.space/v1", language="bash")
-gr.Markdown("""
-* **API Key:** `dummy` (si el Space es público) o tu `HF_TOKEN` (si el Spac
-* **Model Name:** El mismo ID cargado en el servidor (`Qwen/Qwen3.8-27B
-""")
-
-# Montar Gradio en el path raíz de FastAPI
+MODEL_ID = "Qwen/Qwen3.8-27B"  # Cambiar al modelo deseado
+HF_TOKEN = os.getenv("HF_TOKEN")
+
+client = InferenceClient(model=MODEL_ID, token=HF_TOKEN)
+app = FastAPI(title="OpenAI Compatible HF Space API")
+
+# --- Esquemas Pydantic para OpenAI API ---
+class ChatMessage(BaseModel):
+    role: str
+    content: str
+
+class ChatCompletionRequest(BaseModel):
+    model: Optional[str] = MODEL_ID
+    messages: List[ChatMessage]
+    temperature: Optional[float] = 0.7
+    max_tokens: Optional[int] = 2048
+    stream: Optional[bool] = False
+
+# --- Endpoints OpenAI ---
+@app.get("/v1/models")
+async def list_models():
+    return {
+        "object": "list",
+        "data": [{"id": MODEL_ID, "object": "model", "owned_by": "huggingface"}]
+    }
+
+@app.post("/v1/chat/completions")
+async def chat_completions(req: ChatCompletionRequest):
+    formatted_messages = [{"role": m.role, "content": m.content} for m in req.messages]
+
+    if req.stream:
+        async def stream_generator():
+            stream = client.chat_completion(
+                messages=formatted_messages,
+                temperature=req.temperature,
+                max_tokens=req.max_tokens,
+                stream=True
+            )
+            for chunk in stream:
+                delta = chunk.choices[0].delta.content or ""
+                payload = {
+                    "id": f"chatcmpl-{int(time.time())}",
+                    "object": "chat.completion.chunk",
+                    "created": int(time.time()),
+                    "model": MODEL_ID,
+                    "choices": [{"index": 0, "delta": {"content": delta}, "finish_reason": None}]
+                }
+                yield f"data: {json.dumps(payload)}\n\n"
+            yield "data: [DONE]\n\n"
+
+        return StreamingResponse(stream_generator(), media_type="text/event-stream")
+    else:
+        response = client.chat_completion(
+            messages=formatted_messages,
+            temperature=req.temperature,
+            max_tokens=req.max_tokens,
+            stream=False
+        )
+        return {
+            "id": f"chatcmpl-{int(time.time())}",
+            "object": "chat.completion",
+            "created": int(time.time()),
+            "model": MODEL_ID,
+            "choices": [{
+                "index": 0,
+                "message": {"role": "assistant", "content": response.choices[0].message.content},
+                "finish_reason": "stop"
+            }]
+        }
+
+# --- Interfaz Web Gradio ---
+def gradio_chat(message, history):
+    messages = []
+    for user_msg, bot_msg in history:
+        messages.append({"role": "user", "content": user_msg})
+        messages.append({"role": "assistant", "content": bot_msg})
+    messages.append({"role": "user", "content": message})
+
+    response = ""
+    for chunk in client.chat_completion(messages=messages, stream=True, max_tokens=2048):
+        response += chunk.choices[0].delta.content or ""
+        yield response
+
+with gr.Blocks(title="AI Chat & API Hub") as demo:
+    gr.Markdown(f"# 🤖 Interfaz de Chat & API\n**Modelo Activo:** `{MODEL_ID}`\n\nConéctate desde Cursor/OpenCode usando:\n`https:huggingface.co/spaces/acsaco.hf.space/v1`")
+    gr.ChatInterface(fn=gradio_chat)
+
+# Montar Gradio dentro de FastAPI
 app = gr.mount_gradio_app(app, demo, path="/")