Upload 4 files

README.md

@@ -1,24 +1,26 @@
 ---
-title: veureu-schat
-emoji: 💬
-colorFrom: purple
-colorTo: red
+title: veureu-stools
+emoji: 🛠️
+colorFrom: yellow
+colorTo: yellow
 sdk: gradio
 sdk_version: "4.44.1"
 app_file: app.py
 pinned: false
 ---
 
-# 💬 veureu-schat (Salamandra-7B-Instruct · ZeroGPU)
+# 🛠️ veureu-stools (Salamandra-7B-Tools · ZeroGPU)
 
 ## Endpoints
-- **`/api/predict`** (Gradio): entrada `["<prompt>"]` → salida `"<texto>"`.  
+- **`/api/predict`** (Gradio): entrada `[ "<messages_json>", "<tools_json>" ]` → salida `{ "text": "...", "tool_calls": [...], "tool_results": [...] }`.  
   ➜ Este es el endpoint que usa el Space **engine**.
-- **`/api/generate`** (Gradio): entrada `[prompt, system, max_new_tokens, temperature, top_p]` → salida `"<texto>"`.
+- **`/api/chat`** (Gradio): entrada `[ "<messages_json>", "<tools_json>", max_new_tokens, temperature, top_p ]` → salida idéntica.
 
 ### Variables de entorno
-- `MODEL_ID` (opcional): por defecto `BSC-LT/salamandra-7b-instruct`.
+- `MODEL_ID` (opcional): por defecto `BSC-LT/salamandra-7b-tools`.  
+  Puedes apuntar a `BSC-LT/salamandra-7b-instruct` si prefieres.
 
 ### Notas
-- El modelo usa `chat_template` si existe; si no, se compone un prompt clásico con bloque `system`.
-- GPU: se activa con `@spaces.GPU` automáticamente (ZeroGPU).
+- El modelo **no ejecuta** herramientas reales salvo un **ejemplo local**: `calculator` (seguro).  
+  Si el modelo devuelve `{"tool_calls":[...]}`, el Space intentará ejecutar esas llamadas en sandbox y añadirá `tool_results`.  
+  Puedes desactivar la ejecución poniendo `EXECUTE_TOOLS=False` en `app.py`.

app.py

@@ -1,19 +1,15 @@
-# app.py — veureu/schat (Salamandra 7B Instruct · ZeroGPU) — compatible con ENGINE
+# app.py — veureu/stools (Salamandra 7B Tools · ZeroGPU) — compatible con ENGINE
 from __future__ import annotations
-import os, json
-from typing import List, Dict, Optional, Tuple
+import os, json, re
+from typing import List, Dict, Any, Optional, Tuple
 
 import gradio as gr
 import spaces
 import torch
-from transformers import (
-    AutoTokenizer,
-    AutoModelForCausalLM,
-    TextIteratorStreamer,
-)
-
-# ===== Config =====
-MODEL_ID = os.environ.get("MODEL_ID", "BSC-LT/salamandra-7b-instruct")
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+# ================= Config =================
+MODEL_ID = os.environ.get("MODEL_ID", "BSC-LT/salamandra-7b-tools")
 DTYPE = torch.float16 if torch.cuda.is_available() else torch.float32
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 
@@ -34,36 +30,121 @@ def _lazy_load() -> Tuple[AutoTokenizer, AutoModelForCausalLM]:
         ).to(DEVICE)
     return _tok, _model
 
-def _build_prompt(prompt: str, system: Optional[str]) -> str:
+
+# =============== Helpers ===============
+
+def _render_tools_md(tools: List[Dict[str, Any]]) -> str:
+    """Convierte la especificación OpenAI-style de tools a un bloque breve markdown para el prompt."""
+    if not tools:
+        return ""
+    lines = ["Herramientas disponibles (formato JSON):"]
+    for t in tools:
+        name = t.get("function", {}).get("name") or t.get("name") or "tool"
+        desc = t.get("function", {}).get("description") or t.get("description") or ""
+        params = t.get("function", {}).get("parameters") or t.get("parameters") or {}
+        lines.append(f"- **{name}**: {desc} | parámetros: {json.dumps(params)[:600]}")
+    return "\n".join(lines)
+
+def _compose_chat_prompt(messages: List[Dict[str, str]], tools_md: str) -> str:
     """
-    Si el tokenizer posee 'chat_template', lo usamos con mensajes [system?, user].
-    Si no, hacemos un prompt plano con system arriba.
+    Soporta mensajes estilo OpenAI: [{"role":"system|user|assistant", "content":"..."}]
+    Usa chat_template si está disponible.
     """
     tok, _ = _lazy_load()
-    messages = []
-    if system and system.strip():
-        messages.append({"role": "system", "content": system.strip()})
-    messages.append({"role": "user", "content": prompt})
+    sys_text = ""
+    usr_msgs: List[Dict[str, str]] = []
+    for m in messages:
+        role = m.get("role", "")
+        content = (m.get("content") or "").strip()
+        if role == "system":
+            sys_text += ("\n" + content) if sys_text else content
+        else:
+            usr_msgs.append({"role": role, "content": content})
+
+    # injerta descripción de tools en el system
+    if tools_md:
+        sys_text = (sys_text + "\n\n" if sys_text else "") + tools_md + \
+                   "\n\nSi decides llamar a una herramienta, devuelve un objeto JSON con la clave 'tool_calls' " \
+                   "y describe tus razonamientos de forma concisa en 'thought' (opcional)."
+
+    # reconstruimos la conversación con system delante
+    conv: List[Dict[str, str]] = []
+    if sys_text:
+        conv.append({"role":"system", "content": sys_text})
+    conv.extend(usr_msgs)
 
     chat_template = getattr(tok, "chat_template", None)
     if chat_template:
-        return tok.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-    # Fallback sin chat template
-    sys_part = (f"<<SYS>>\n{system.strip()}\n<</SYS>>\n\n" if system and system.strip() else "")
-    return sys_part + f"### Instrucción\n{prompt}\n\n### Respuesta\n"
+        return tok.apply_chat_template(conv, tokenize=False, add_generation_prompt=True)
+
+    # Fallback sin plantilla
+    rendered = ""
+    if sys_text:
+        rendered += f"<<SYS>>\n{sys_text}\n<</SYS>>\n\n"
+    for m in usr_msgs:
+        if m["role"] == "user":
+            rendered += f"### Usuario\n{m['content']}\n\n"
+        elif m["role"] == "assistant":
+            rendered += f"### Asistente\n{m['content']}\n\n"
+    rendered += "### Asistente\n"
+    return rendered
+
+
+# =============== (Opcional) Mini-ejecutor local de herramientas seguras ===============
+# Si el LLM devuelve {"tool_calls":[{"name":"calculator","arguments":{"expr":"2+2"}}]}
+# podemos ejecutar algunas herramientas inofensivas de ejemplo.
+# Nota: mantén esto muy simple/seguro. Puedes desactivarlo poniendo EXECUTE_TOOLS=False.
+EXECUTE_TOOLS = True
+
+def _safe_calculator(expr: str) -> str:
+    # Permite solo dígitos, espacios, (), y +-*/.%**
+    if not re.fullmatch(r"[0-9\.\s\+\-\*\/\%\(\)\^eE]+", expr.replace("**","^")):
+        return "Rejected expression."
+    # soporta ^ como potencia -> **
+    expr = expr.replace("^", "**")
+    try:
+        return str(eval(expr, {"__builtins__":{}}, {}))
+    except Exception as e:
+        return f"Error: {e}"
+
+LOCAL_TOOLBOX = {
+    "calculator": lambda args: _safe_calculator(str(args.get("expr",""))),
+}
+
+def maybe_execute_tool_calls(tool_calls: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    if not EXECUTE_TOOLS:
+        return []
+    results = []
+    for call in tool_calls:
+        name = call.get("name")
+        args = call.get("arguments", {})
+        fn = LOCAL_TOOLBOX.get(name)
+        if fn is None:
+            results.append({"name": name, "error": "tool_not_available"})
+            continue
+        try:
+            out = fn(args)
+            results.append({"name": name, "output": out})
+        except Exception as e:
+            results.append({"name": name, "error": str(e)})
+    return results
+
+
+# =============== Core generation ===============
 
 @spaces.GPU  # usa GPU si está disponible (ZeroGPU)
-def _generate(
-    prompt: str,
-    system: str = "",
+def _generate_with_tools(
+    messages: List[Dict[str, str]],
+    tools: List[Dict[str, Any]],
     max_new_tokens: int = 512,
     temperature: float = 0.7,
     top_p: float = 0.95,
-) -> str:
+) -> Dict[str, Any]:
     tok, model = _lazy_load()
-    text = _build_prompt(prompt, system or "")
-    inputs = tok(text, return_tensors="pt").to(DEVICE)
+    tools_md = _render_tools_md(tools)
+    prompt = _compose_chat_prompt(messages, tools_md)
 
+    inputs = tok(prompt, return_tensors="pt").to(DEVICE)
     with torch.inference_mode():
         out = model.generate(
             **inputs,
@@ -74,40 +155,77 @@ def _generate(
             pad_token_id=tok.eos_token_id,
             eos_token_id=tok.eos_token_id,
         )
-    return tok.decode(out[0], skip_special_tokens=True).strip()
+    text = tok.decode(out[0], skip_special_tokens=True).strip()
+
+    # Si el modelo devuelve un bloque JSON con 'tool_calls', lo intentamos extraer.
+    tool_calls: List[Dict[str, Any]] = []
+    try:
+        # busca el último {...} que contenga "tool_calls"
+        matches = list(re.finditer(r"\{.*?\"tool_calls\".*?\}", text, flags=re.S))
+        if matches:
+            block = text[matches[-1].start():matches[-1].end()]
+            obj = json.loads(block)
+            tc = obj.get("tool_calls", [])
+            if isinstance(tc, list):
+                tool_calls = tc
+    except Exception:
+        pass
+
+    tool_results = maybe_execute_tool_calls(tool_calls) if tool_calls else []
+
+    return {"text": text, "tool_calls": tool_calls, "tool_results": tool_results}
+
+
+# =================== Gradio Endpoints ===================
+
+def predict_for_engine(messages_json: str, tools_json: str) -> Dict[str, Any]:
+    """
+    Endpoint esperado por ENGINE (ToolsClient.chat):
+      - messages_json: JSON de [{"role":"user|assistant|system","content":"..."}]
+      - tools_json: JSON OpenAI-like de herramientas (opcional)
+    Devuelve: {"text": "...", "tool_calls": [...], "tool_results": [...]}
+    """
+    try:
+        messages = json.loads(messages_json) if messages_json else []
+    except Exception:
+        messages = []
+    try:
+        tools = json.loads(tools_json) if tools_json else []
+    except Exception:
+        tools = []
+    return _generate_with_tools(messages, tools, max_new_tokens=512, temperature=0.7, top_p=0.95)
+
+def chat_advanced(messages_json: str, tools_json: str, max_new_tokens: int, temperature: float, top_p: float) -> Dict[str, Any]:
+    try:
+        messages = json.loads(messages_json) if messages_json else []
+    except Exception:
+        messages = []
+    try:
+        tools = json.loads(tools_json) if tools_json else []
+    except Exception:
+        tools = []
+    return _generate_with_tools(messages, tools, max_new_tokens=int(max_new_tokens), temperature=float(temperature), top_p=float(top_p))
 
-# ------------------- Gradio Endpoints -------------------
-# 1) /predict — lo que espera el ENGINE (solo 'prompt' → string)
-def predict_for_engine(prompt: str) -> str:
-    return _generate(prompt=prompt, system="", max_new_tokens=512, temperature=0.7, top_p=0.95)
 
-# 2) /generate — más controles (prompt + system + params)
-def generate_advanced(prompt: str, system: str, max_new_tokens: int, temperature: float, top_p: float) -> str:
-    return _generate(prompt=prompt, system=system, max_new_tokens=max_new_tokens, temperature=temperature, top_p=top_p)
+# =================== UI ===================
 
-# ------------------- HTTP (opcional, clientes puros) -------------------
-# Si quieres, puedes añadir un endpoint HTTP POST /generate (FastAPI),
-# pero con Gradio Client es suficiente para engine/local.
+with gr.Blocks(title="Salamandra 7B Tools · ZeroGPU") as demo:
+    gr.Markdown("## Salamandra-7B-Tools · ZeroGPU\nChat con especificación de herramientas (function-calling).")
 
-# ------------------- UI -------------------
-with gr.Blocks(title="Salamandra 7B Instruct · ZeroGPU") as demo:
-    gr.Markdown("## Salamandra-7B-Instruct · ZeroGPU\nTexto → respuesta instruccional.")
     with gr.Row():
-        with gr.Column(scale=1):
-            in_system = gr.Textbox(label="System (opcional)", value="")
-            in_prompt = gr.Textbox(label="Prompt", placeholder="Escribe tu instrucción…", lines=6)
+        with gr.Column():
+            messages = gr.Textbox(label="messages_json", value='[{"role":"user","content":"¿Cuánto es (2+2)^3?"}]', lines=6)
+            tools = gr.Textbox(label="tools_json (opcional)", value='[{"type":"function","function":{"name":"calculator","description":"Evalúa expresiones aritméticas básicas.","parameters":{"type":"object","properties":{"expr":{"type":"string"}},"required":["expr"]}}}]', lines=6)
             max_new = gr.Slider(16, 2048, value=512, step=16, label="max_new_tokens")
             temp = gr.Slider(0.0, 1.5, value=0.7, step=0.05, label="temperature")
-            top_p = gr.Slider(0.1, 1.0, value=0.95, step=0.01, label="top_p")
+            topp = gr.Slider(0.1, 1.0, value=0.95, step=0.01, label="top_p")
             btn = gr.Button("Generar", variant="primary")
-        with gr.Column(scale=1):
-            out = gr.Textbox(label="Respuesta", lines=18)
+        with gr.Column():
+            out = gr.JSON(label="Salida")
 
-    btn.click(generate_advanced, [in_prompt, in_system, max_new, temp, top_p], out, api_name="generate")
+    btn.click(chat_advanced, [messages, tools, max_new, temp, topp], out, api_name="chat")
 
-    # Endpoint minimalista compatible con el ENGINE (/predict: solo prompt)
-    in_prompt_engine = gr.Textbox(label="Prompt (ENGINE)", value="Di hola en una frase.")
-    out_engine = gr.Textbox(label="Respuesta (ENGINE)")
-    gr.Button("Probar /predict").click(predict_for_engine, [in_prompt_engine], out_engine, api_name="predict")
+    # Endpoint minimalista /predict para ENGINE (mensajes + tools)
+    gr.Button("Probar /predict").click(predict_for_engine, [messages, tools], out, api_name="predict")
 
 demo.queue(concurrency_count=1, max_size=16).launch()