feat: adiciona suporte a tool calling (groq/mistral/openrouter/gemini)

app.py

@@ -411,6 +411,23 @@ logger.info("Construindo índices de conhecimento (RAG) e skills...")
 reload_indexes()
 
 # ── Schemas ────────────────────────────────────────────────────────────────────
+class ToolFunctionParameters(BaseModel):
+    type: str = "object"
+    properties: dict = {}
+    required: Optional[List[str]] = None
+
+
+class ToolFunction(BaseModel):
+    name: str
+    description: Optional[str] = None
+    parameters: Optional[ToolFunctionParameters] = None
+
+
+class Tool(BaseModel):
+    type: Literal["function"] = "function"
+    function: ToolFunction
+
+
 class Message(BaseModel):
     role: Literal["system", "user", "assistant"]
     content: constr(min_length=1, max_length=10000)
@@ -430,6 +447,8 @@ class ChatRequest(BaseModel):
     messages: List[Message] = Field(min_length=1, description="Lista de mensagens")
     max_tokens: Optional[int] = Field(default=8192, ge=1, le=1000000, description="Máximo de tokens")
     temperature: Optional[float] = Field(default=0.7, ge=0.0, le=2.0, description="Temperatura de geração")
+    tools: Optional[List[Tool]] = Field(default=None, description="Ferramentas disponíveis (formato OpenAI)")
+    tool_choice: Optional[str] = Field(default="auto", description="'auto', 'none', ou nome de uma tool")
 
     @field_validator("model")
     @classmethod
@@ -645,6 +664,27 @@ def convert_to_gemini_format(chat_messages, system_content=None):
     return payload
 
 
+def convert_tools_to_gemini_format(tools):
+    if not tools:
+        return None
+    declarations = []
+    for t in tools:
+        fn = t.function if hasattr(t, "function") else t["function"]
+        name = fn.name if hasattr(fn, "name") else fn["name"]
+        description = (fn.description if hasattr(fn, "description") else fn.get("description")) or ""
+        parameters = (
+            fn.parameters.model_dump(exclude_none=True)
+            if hasattr(fn, "parameters") and fn.parameters
+            else {"type": "object", "properties": {}}
+        )
+        declarations.append({
+            "name": name,
+            "description": description,
+            "parameters": parameters,
+        })
+    return [{"functionDeclarations": declarations}]
+
+
 # ── Helper: Sanitiza mensagens para GGUF ──────────────────────────────────────
 def sanitize_chat_for_gguf(chat_messages):
     messages = [{"role": m["role"], "content": m["content"]} for m in chat_messages]
@@ -685,6 +725,8 @@ def chat_completions(req: ChatRequest):
         t0 = time.time()
 
         if backend == "transformers":
+            if req.tools:
+                logger.warning("Backend 'transformers' não suporta tool calling — tools será ignorado.")
             tokenizer = state["tokenizer"]
             model = state["model"]
 
@@ -710,6 +752,8 @@ def chat_completions(req: ChatRequest):
             completion_tokens = len(generated)
 
         elif backend == "gguf":
+            if req.tools:
+                logger.warning("Backend 'gguf' não suporta tool calling — tools será ignorado.")
             llm = state["model"]
             safe_chat = sanitize_chat_for_gguf(chat)
             result = llm.create_chat_completion(
@@ -723,6 +767,8 @@ def chat_completions(req: ChatRequest):
             completion_tokens = usage.get("completion_tokens", 0)
 
         elif backend == "kilo":
+            if req.tools:
+                logger.warning("Backend 'kilo' não suporta tool calling — tools será ignorado.")
             model_id = state["model"]
             kilo_api_key = os.environ.get("KILO_API_KEY")
             if not kilo_api_key:
@@ -787,10 +833,11 @@ def chat_completions(req: ChatRequest):
                 "max_tokens": max_tokens,
                 "temperature": temperature if temperature else 0.0,
             }
+            if req.tools:
+                payload["tools"] = [t.model_dump(exclude_none=True) for t in req.tools]
+                payload["tool_choice"] = req.tool_choice or "auto"
 
-            @async_retry_with_backoff(max_retries=3, initial_delay=1, backoff_factor=2)
-            async def call_openrouter_api():
-                async with httpx.AsyncClient() as client:
+            async with httpx.AsyncClient() as client:
                     resp = await client.post(
                         "https://openrouter.ai/api/v1/chat/completions",
                         json=payload,
@@ -815,7 +862,9 @@ def chat_completions(req: ChatRequest):
             if "choices" not in data or not data["choices"]:
                 raise APIError(f"Resposta inválida da OpenRouter API: {data}")
 
-            text = data["choices"][0]["message"]["content"]
+            message_obj = data["choices"][0]["message"]
+            text = message_obj.get("content", "") or ""
+            tool_calls = message_obj.get("tool_calls")
             usage = data.get("usage", {})
             prompt_tokens = usage.get("prompt_tokens", 0)
             completion_tokens = usage.get("completion_tokens", 0)
@@ -836,6 +885,9 @@ def chat_completions(req: ChatRequest):
                 "max_tokens": max_tokens,
                 "temperature": temperature if temperature else 0.0,
             }
+            if req.tools:
+                payload["tools"] = [t.model_dump(exclude_none=True) for t in req.tools]
+                payload["tool_choice"] = req.tool_choice or "auto"
 
             payload_bytes = len(json.dumps(payload))
             logger.info(f"[GROQ DEBUG] Payload size: {payload_bytes} bytes, Messages: {len(chat)}")
@@ -867,7 +919,9 @@ def chat_completions(req: ChatRequest):
             if "choices" not in data or not data["choices"]:
                 raise APIError(f"Resposta inválida da Groq API: {data}")
 
-            text = data["choices"][0]["message"]["content"]
+            message_obj = data["choices"][0]["message"]
+            text = message_obj.get("content", "") or ""
+            tool_calls = message_obj.get("tool_calls")
             usage = data.get("usage", {})
             prompt_tokens = usage.get("prompt_tokens", 0)
             completion_tokens = usage.get("completion_tokens", 0)
@@ -888,6 +942,9 @@ def chat_completions(req: ChatRequest):
                 "max_tokens": max_tokens,
                 "temperature": temperature if temperature else 0.0,
             }
+            if req.tools:
+                payload["tools"] = [t.model_dump(exclude_none=True) for t in req.tools]
+                payload["tool_choice"] = req.tool_choice or "auto"
 
             @async_retry_with_backoff(max_retries=3, initial_delay=1, backoff_factor=2)
             async def call_mistral_api():
@@ -916,7 +973,9 @@ def chat_completions(req: ChatRequest):
             if "choices" not in data or not data["choices"]:
                 raise APIError(f"Resposta inválida da Mistral API: {data}")
 
-            text = data["choices"][0]["message"]["content"]
+            message_obj = data["choices"][0]["message"]
+            text = message_obj.get("content", "") or ""
+            tool_calls = message_obj.get("tool_calls")
             usage = data.get("usage", {})
             prompt_tokens = usage.get("prompt_tokens", 0)
             completion_tokens = usage.get("completion_tokens", 0)
@@ -935,6 +994,9 @@ def chat_completions(req: ChatRequest):
                 "temperature": temperature if temperature else 0.0,
             }
 
+            if req.tools:
+                gemini_payload["tools"] = convert_tools_to_gemini_format(req.tools)
+
             if model_id.startswith("gemini"):
                 gemini_payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": 0}
 
@@ -969,7 +1031,10 @@ def chat_completions(req: ChatRequest):
 
             logger.info(f"[GEMINI DEBUG] finishReason={data['candidates'][0].get('finishReason')}, content={data['candidates'][0].get('content', {})}")
 
-            text = data["candidates"][0]["content"]["parts"][0]["text"]
+            parts = data["candidates"][0]["content"]["parts"]
+            text_parts = [p.get("text", "") for p in parts if "text" in p]
+            text = "".join(text_parts)
+            function_calls = [p["functionCall"] for p in parts if "functionCall" in p]
             usage = data.get("usageMetadata", {})
             prompt_tokens = usage.get("promptTokenCount", 0)
             completion_tokens = usage.get("candidatesTokenCount", 0)
@@ -977,13 +1042,31 @@ def chat_completions(req: ChatRequest):
             finish_reason = "stop"
             if data["candidates"][0].get("finishReason") == "MAX_TOKENS":
                 finish_reason = "length"
-
         else:
             raise BackendError("Backend inválido")
 
         elapsed = time.time() - t0
         logger.info(f"Resposta gerada em {elapsed:.1f}s ({backend}, web={req.web})")
 
+        message = {"role": "assistant", "content": text}
+        openai_tool_calls = None
+        if tool_calls:
+            openai_tool_calls = tool_calls
+        elif function_calls:
+            openai_tool_calls = [
+                {
+                    "id": f"call_{uuid.uuid4().hex[:8]}",
+                    "type": "function",
+                    "function": {
+                        "name": fc["name"],
+                        "arguments": json.dumps(fc.get("args", {})),
+                    },
+                }
+                for fc in function_calls
+            ]
+        if openai_tool_calls:
+            message["tool_calls"] = openai_tool_calls
+
         return {
             "id": f"chatcmpl-{uuid.uuid4().hex[:8]}",
             "object": "chat.completion",
@@ -992,8 +1075,8 @@ def chat_completions(req: ChatRequest):
             "mode": req.mode,
             "choices": [{
                 "index": 0,
-                "message": {"role": "assistant", "content": text},
-                "finish_reason": "stop"
+                "message": message,
+                "finish_reason": "tool_calls" if openai_tool_calls else (finish_reason or "stop"),
             }],
             "usage": {
                 "prompt_tokens": prompt_tokens,
@@ -1212,6 +1295,8 @@ async def chat_completions_async(req: ChatRequest):
         t0 = time.time()
 
         if backend == "transformers":
+            if req.tools:
+                logger.warning("Backend 'transformers' não suporta tool calling — tools será ignorado.")
             tokenizer = state["tokenizer"]
             model = state["model"]
 
@@ -1237,6 +1322,8 @@ async def chat_completions_async(req: ChatRequest):
             completion_tokens = len(generated)
 
         elif backend == "gguf":
+            if req.tools:
+                logger.warning("Backend 'gguf' não suporta tool calling — tools será ignorado.")
             llm = state["model"]
             safe_chat = sanitize_chat_for_gguf(chat)
             result = llm.create_chat_completion(
@@ -1250,6 +1337,8 @@ async def chat_completions_async(req: ChatRequest):
             completion_tokens = usage.get("completion_tokens", 0)
 
         elif backend == "kilo":
+            if req.tools:
+                logger.warning("Backend 'kilo' não suporta tool calling — tools será ignorado.")
             model_id = state["model"]
             kilo_api_key = os.environ.get("KILO_API_KEY")
             if not kilo_api_key:
@@ -1310,6 +1399,9 @@ async def chat_completions_async(req: ChatRequest):
                 "max_tokens": max_tokens,
                 "temperature": temperature if temperature else 0.0,
             }
+            if req.tools:
+                payload["tools"] = [t.model_dump(exclude_none=True) for t in req.tools]
+                payload["tool_choice"] = req.tool_choice or "auto"
 
             async with httpx.AsyncClient() as client:
                 resp = await client.post(
@@ -1334,7 +1426,9 @@ async def chat_completions_async(req: ChatRequest):
             if "choices" not in data or not data["choices"]:
                 raise APIError(f"Resposta inválida da OpenRouter API: {data}")
 
-            text = data["choices"][0]["message"]["content"]
+            message_obj = data["choices"][0]["message"]
+            text = message_obj.get("content", "") or ""
+            tool_calls = message_obj.get("tool_calls")
             usage = data.get("usage", {})
             prompt_tokens = usage.get("prompt_tokens", 0)
             completion_tokens = usage.get("completion_tokens", 0)
@@ -1355,6 +1449,9 @@ async def chat_completions_async(req: ChatRequest):
                 "max_tokens": max_tokens,
                 "temperature": temperature if temperature else 0.0,
             }
+            if req.tools:
+                payload["tools"] = [t.model_dump(exclude_none=True) for t in req.tools]
+                payload["tool_choice"] = req.tool_choice or "auto"
 
             payload_bytes = len(json.dumps(payload))
             logger.info(f"[GROQ DEBUG] Payload size: {payload_bytes} bytes, Messages: {len(chat)}")
@@ -1382,7 +1479,9 @@ async def chat_completions_async(req: ChatRequest):
             if "choices" not in data or not data["choices"]:
                 raise APIError(f"Resposta inválida da Groq API: {data}")
 
-            text = data["choices"][0]["message"]["content"]
+            message_obj = data["choices"][0]["message"]
+            text = message_obj.get("content", "") or ""
+            tool_calls = message_obj.get("tool_calls")
             usage = data.get("usage", {})
             prompt_tokens = usage.get("prompt_tokens", 0)
             completion_tokens = usage.get("completion_tokens", 0)
@@ -1403,6 +1502,9 @@ async def chat_completions_async(req: ChatRequest):
                 "max_tokens": max_tokens,
                 "temperature": temperature if temperature else 0.0,
             }
+            if req.tools:
+                payload["tools"] = [t.model_dump(exclude_none=True) for t in req.tools]
+                payload["tool_choice"] = req.tool_choice or "auto"
 
             async with httpx.AsyncClient() as client:
                 resp = await client.post(
@@ -1427,7 +1529,9 @@ async def chat_completions_async(req: ChatRequest):
             if "choices" not in data or not data["choices"]:
                 raise APIError(f"Resposta inválida da Mistral API: {data}")
 
-            text = data["choices"][0]["message"]["content"]
+            message_obj = data["choices"][0]["message"]
+            text = message_obj.get("content", "") or ""
+            tool_calls = message_obj.get("tool_calls")
             usage = data.get("usage", {})
             prompt_tokens = usage.get("prompt_tokens", 0)
             completion_tokens = usage.get("completion_tokens", 0)
@@ -1446,6 +1550,9 @@ async def chat_completions_async(req: ChatRequest):
                 "temperature": temperature if temperature else 0.0,
             }
 
+            if req.tools:
+                gemini_payload["tools"] = convert_tools_to_gemini_format(req.tools)
+
             if model_id.startswith("gemini"):
                 gemini_payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": 0}
 
@@ -1476,7 +1583,10 @@ async def chat_completions_async(req: ChatRequest):
 
             logger.info(f"[GEMINI DEBUG] finishReason={data['candidates'][0].get('finishReason')}, content={data['candidates'][0].get('content', {})}")
 
-            text = data["candidates"][0]["content"]["parts"][0]["text"]
+            parts = data["candidates"][0]["content"]["parts"]
+            text_parts = [p.get("text", "") for p in parts if "text" in p]
+            text = "".join(text_parts)
+            function_calls = [p["functionCall"] for p in parts if "functionCall" in p]
             usage = data.get("usageMetadata", {})
             prompt_tokens = usage.get("promptTokenCount", 0)
             completion_tokens = usage.get("candidatesTokenCount", 0)
@@ -1491,6 +1601,25 @@ async def chat_completions_async(req: ChatRequest):
         elapsed = time.time() - t0
         logger.info(f"Resposta gerada em {elapsed:.1f}s ({backend}, web={req.web})")
 
+        message = {"role": "assistant", "content": text}
+        openai_tool_calls = None
+        if tool_calls:
+            openai_tool_calls = tool_calls
+        elif function_calls:
+            openai_tool_calls = [
+                {
+                    "id": f"call_{uuid.uuid4().hex[:8]}",
+                    "type": "function",
+                    "function": {
+                        "name": fc["name"],
+                        "arguments": json.dumps(fc.get("args", {})),
+                    },
+                }
+                for fc in function_calls
+            ]
+        if openai_tool_calls:
+            message["tool_calls"] = openai_tool_calls
+
         return {
             "id": f"chatcmpl-{uuid.uuid4().hex[:8]}",
             "object": "chat.completion",
@@ -1499,8 +1628,8 @@ async def chat_completions_async(req: ChatRequest):
             "mode": req.mode,
             "choices": [{
                 "index": 0,
-                "message": {"role": "assistant", "content": text},
-                "finish_reason": "stop"
+                "message": message,
+                "finish_reason": "tool_calls" if openai_tool_calls else (finish_reason or "stop"),
             }],
             "usage": {
                 "prompt_tokens": prompt_tokens,