Upload folder using huggingface_hub

README.md

@@ -1,15 +1,48 @@
 ---
 title: CoderInstruc
-emoji: 💬
-colorFrom: yellow
-colorTo: purple
+emoji: 🌵
+colorFrom: green
+colorTo: indigo
 sdk: gradio
-sdk_version: 6.5.1
+sdk_version: 6.20.0
 app_file: app.py
 pinned: false
-hf_oauth: true
-hf_oauth_scopes:
-- inference-api
+license: apache-2.0
+short_description: CoderInstruc coding assistant (Qwen3-Coder + post-train)
 ---
 
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+# CoderInstruc
+
+Chat Gradio + API para agents. Inferência remota via Hugging Face Inference Router
+(não baixa o modelo 30B neste Space).
+
+## Agents
+
+```bash
+curl https://huggingface.co/spaces/amarorn/CoderInstruc/agents.md
+```
+
+O `agents.md` é **gerado automaticamente** pela HF para todo Gradio Space. Agents (Claude Code, Codex, etc.) leem esse arquivo e chamam a API Gradio.
+
+Endpoint útil neste app: **`ask`** (`prompt` → `answer`).
+
+## Secrets (Settings → Variables and secrets)
+
+| Name | Valor |
+|------|--------|
+| `HF_TOKEN` | token com permissão Inference |
+| `CODERINSTRUC_HF_INFERENCE_MODEL` | `Qwen/Qwen3-Coder-30B-A3B-Instruct` (depois: seu adapter) |
+| `CODERINSTRUC_HF_INFERENCE_ENDPOINT` | `https://router.huggingface.co/v1` (opcional) |
+
+## Deploy a partir do GitHub
+
+Repo código: `CodeModel` → pasta `spaces/coderinstruc-chat/`  
+Space alvo: **`amarorn/CoderInstruc`**
+
+```bash
+uv run python scripts/deploy_space.py --space amarorn/CoderInstruc
+```
+
+Ou GitHub Action `deploy-hf-space` (secret `HF_TOKEN`).
+
+> Hosting Gradio no CPU free pode exigir [HF PRO](https://huggingface.co/pro). Sem PRO: `uv run coderinstruc space`

app.py

@@ -1,69 +1,150 @@
+"""CoderInstruc Gradio Space — UI + agent-friendly API (agents.md /api_name)."""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
 import gradio as gr
-from huggingface_hub import InferenceClient
+import httpx
+
+DEFAULT_MODEL = "Qwen/Qwen3-Coder-30B-A3B-Instruct"
+DEFAULT_ENDPOINT = "https://router.huggingface.co/v1"
+SYSTEM_PROMPT = (
+    "You are CoderInstruc, a coding assistant specialized in Python, TypeScript, Go, and SQL. "
+    "Prefer correct, minimal, production-ready code. Use tools/schema style answers when asked "
+    "to edit files or run tests. Refuse requests for malware or secret exfiltration."
+)
+
 
+def _settings() -> dict[str, str]:
+    token = os.getenv("HF_TOKEN") or os.getenv("CODERINSTRUC_HF_TOKEN") or ""
+    model = os.getenv("CODERINSTRUC_HF_INFERENCE_MODEL") or DEFAULT_MODEL
+    endpoint = (
+        os.getenv("CODERINSTRUC_HF_INFERENCE_ENDPOINT") or DEFAULT_ENDPOINT
+    ).rstrip("/")
+    return {"token": token, "model": model, "endpoint": endpoint}
 
-def respond(
-    message,
-    history: list[dict[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-    hf_token: gr.OAuthToken,
-):
-    """
-    For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-    """
-    client = InferenceClient(token=hf_token.token, model="openai/gpt-oss-20b")
 
-    messages = [{"role": "system", "content": system_message}]
+def _is_unsafe(text: str) -> bool:
+    lowered = text.lower()
+    blocked = (
+        "ignore previous instructions",
+        "bypass safety",
+        "write ransomware",
+        "create malware to steal",
+    )
+    return any(b in lowered for b in blocked)
 
-    messages.extend(history)
 
+def complete(message: str, history: list[dict[str, str]] | None = None) -> str:
+    """Core completion used by UI and agent API."""
+    cfg = _settings()
+    if not message.strip():
+        return "Envie uma pergunta de código."
+    if _is_unsafe(message):
+        return "Request blocked by safety filter."
+    if not cfg["token"]:
+        return (
+            "Configure o secret `HF_TOKEN` no Space "
+            "(Settings → Variables and secrets) para habilitar a inferência."
+        )
+
+    messages: list[dict[str, Any]] = [{"role": "system", "content": SYSTEM_PROMPT}]
+    for turn in history or []:
+        role = turn.get("role")
+        content = turn.get("content")
+        if role in {"user", "assistant"} and content:
+            messages.append({"role": role, "content": content})
     messages.append({"role": "user", "content": message})
 
-    response = ""
+    payload = {
+        "model": cfg["model"],
+        "messages": messages,
+        "max_tokens": 2048,
+        "temperature": 0.7,
+        "top_p": 0.8,
+        "stream": False,
+    }
+    headers = {
+        "Authorization": f"Bearer {cfg['token']}",
+        "Content-Type": "application/json",
+    }
+    url = f"{cfg['endpoint']}/chat/completions"
+    try:
+        with httpx.Client(timeout=180.0) as client:
+            resp = client.post(url, json=payload, headers=headers)
+            if resp.status_code >= 400:
+                return f"Erro HF ({resp.status_code}): {resp.text[:600]}"
+            data = resp.json()
+        return data["choices"][0]["message"]["content"]
+    except Exception as exc:  # noqa: BLE001
+        return f"Falha ao chamar inference: {exc}"
 
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        choices = message.choices
-        token = ""
-        if len(choices) and choices[0].delta.content:
-            token = choices[0].delta.content
 
-        response += token
-        yield response
+def ask(prompt: str) -> str:
+    """Stateless agent endpoint — exposed as api_name='ask' for /agents.md clients."""
+    return complete(prompt, history=None)
 
 
+def build_ui() -> gr.Blocks:
+    cfg = _settings()
+    with gr.Blocks(title="CoderInstruc") as demo:
+        gr.Markdown(
+            f"""
+# CoderInstruc
+Assistente de código (base Qwen3-Coder → post-train CoderInstruc).
+
+**Modelo:** `{cfg["model"]}` · Inferência remota (pesos fora deste Space)
+
+**Agents:** `curl https://huggingface.co/spaces/amarorn/CoderInstruc/agents.md`
 """
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-chatbot = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
+        )
+        with gr.Tab("Chat"):
+            chatbot = gr.Chatbot(height=480)
+            msg = gr.Textbox(
+                placeholder="Ex.: Write a Python binary search with tests",
+                label="Mensagem",
+                lines=3,
+            )
+            with gr.Row():
+                send = gr.Button("Enviar", variant="primary")
+                clear = gr.Button("Limpar")
+
+            def respond(user_msg: str, history: list[dict[str, str]] | None):
+                reply = complete(user_msg, history)
+                history = list(history or [])
+                history.append({"role": "user", "content": user_msg})
+                history.append({"role": "assistant", "content": reply})
+                return history, ""
+
+            send.click(respond, inputs=[msg, chatbot], outputs=[chatbot, msg])
+            msg.submit(respond, inputs=[msg, chatbot], outputs=[chatbot, msg])
+            clear.click(lambda: ([], ""), outputs=[chatbot, msg])
+
+            gr.Examples(
+                examples=[
+                    "Write a Python function that reverses a string",
+                    "TypeScript debounce utility with generics",
+                    "SQL: top 5 users by order count",
+                ],
+                inputs=msg,
+            )
+
+        with gr.Tab("Agent API"):
+            gr.Markdown(
+                "Endpoint estático para agents (`api_name=ask`). "
+                "Também disponível via Gradio API / `agents.md`."
+            )
+            prompt = gr.Textbox(label="prompt", lines=4)
+            answer = gr.Textbox(label="answer", lines=12)
+            ask_btn = gr.Button("Ask", variant="primary")
+            ask_btn.click(ask, inputs=prompt, outputs=answer, api_name="ask")
+
+    return demo
 
-with gr.Blocks() as demo:
-    with gr.Sidebar():
-        gr.LoginButton()
-    chatbot.render()
 
+demo = build_ui()
 
 if __name__ == "__main__":
     demo.launch()

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=5.23.0,<7
+httpx>=0.28.0
+python-dotenv>=1.0.0