Upload 5 files

app.py

@@ -1,9 +1,6 @@
 """
-Jade Code IDE - HuggingFace Space Backend
-BYOK (Bring Your Own Key) Architecture
-
-Cada usuário fornece sua própria API key via header.
-O backend nunca armazena keys - só repassa pro LLM.
+Jade Code IDE - HuggingFace Space Backend v3.0
+Modo Agêntico + Multi-Provider (Groq, Cerebras, OpenRouter)
 """
 
 import os
@@ -14,20 +11,22 @@ import base64
 import traceback
 import re
 from contextlib import redirect_stdout, redirect_stderr
-from typing import Optional
+from typing import Optional, List, Dict
 
-from fastapi import FastAPI, HTTPException, Request, Header
+from fastapi import FastAPI, HTTPException, Header
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 import gradio as gr
 
+from providers import get_provider, list_all_providers, GroqProvider, CerebrasProvider, OpenRouterProvider
+from tools import AGENT_TOOLS, ToolExecutor, parse_tool_calls, get_response_content, has_tool_calls
+
 # ============== App Setup ==============
-app = FastAPI(title="Jade Code IDE API", version="2.0")
+app = FastAPI(title="Jade Code IDE API", version="3.0")
 
-# CORS - permitir GitHub Pages e localhost para dev
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # Em produção, restringir para seu domínio
+    allow_origins=["*"],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
@@ -37,8 +36,12 @@ app.add_middleware(
 # ============== Request Models ==============
 class ChatRequest(BaseModel):
     message: str
-    current_file_content: Optional[str] = ""
-    history: Optional[list] = []
+    provider: str = "groq"
+    model: str = "llama-3.3-70b-versatile"
+    files: Optional[Dict[str, str]] = {}  # {filename: content}
+    current_file: Optional[str] = None
+    agentic: bool = True  # Modo agêntico ativado por padrão
+    history: Optional[List[Dict]] = []
 
 class RunRequest(BaseModel):
     code: str
@@ -47,24 +50,33 @@ class CompleteRequest(BaseModel):
     prefix: str
     suffix: str = ""
     language: str = "python"
+    provider: str = "groq"
+    model: str = "llama-3.3-70b-versatile"
 
 
-# ============== Helper: Get Groq Client ==============
-def get_groq_client(api_key: str):
-    """Cria cliente Groq com a key do usuário (não armazena)."""
-    from groq import Groq
-    return Groq(api_key=api_key)
+# ============== System Prompt ==============
+SYSTEM_PROMPT = """Você é CodeJade, um assistente de programação avançado integrado a uma IDE.
 
+CAPACIDADES:
+- Você pode explorar o projeto do usuário usando ferramentas
+- Você tem acesso aos arquivos do projeto
+- Você pode ajudar a escrever, debugar e explicar código
 
-# ============== System Prompt ==============
-SYSTEM_PROMPT = """Você é CodeJade, um assistente de programação avançado.
-Seu objetivo é ajudar o usuário a escrever código, corrigir bugs e explicar conceitos.
+FERRAMENTAS DISPONÍVEIS:
+1. list_files - Lista todos os arquivos do projeto
+2. read_file - Lê o conteúdo de um arquivo específico
+3. search_code - Busca texto nos arquivos do projeto
 
-Regras:
+REGRAS:
+- Use as ferramentas quando precisar entender o contexto do projeto
 - Seja direto e técnico
-- Use código Python por padrão
+- Quando sugerir código, use blocos ```python
 - Explique o que está fazendo
-- Se o usuário compartilhar código, analise e sugira melhorias
+
+EXEMPLO:
+Usuário: "Me explica o que esse projeto faz"
+Você: [usa list_files para ver estrutura, depois read_file nos arquivos importantes]
+Depois explica baseado no que leu.
 """
 
 
@@ -72,69 +84,124 @@ Regras:
 
 @app.get("/")
 async def root():
-    """Health check."""
-    return {"status": "ok", "message": "Jade Code IDE API v2.0 - BYOK Mode"}
+    return {"status": "ok", "message": "Jade Code IDE API v3.0 - Agentic Mode", "version": "3.0"}
+
+
+@app.get("/providers")
+async def get_providers():
+    """Lista providers disponíveis."""
+    return {"providers": list_all_providers()}
+
+
+@app.get("/models/{provider}")
+async def get_models(provider: str):
+    """Lista modelos de um provider."""
+    try:
+        # Cria provider com key dummy só pra pegar os modelos
+        prov = get_provider(provider, "dummy")
+        return {"models": prov.list_models()}
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
 
 
 @app.post("/chat")
 async def chat(req: ChatRequest, x_api_key: str = Header(..., alias="X-API-Key")):
     """
-    Chat com o agente usando a API key do usuário.
+    Chat com modo agêntico.
+    O LLM pode usar ferramentas para explorar o projeto.
     """
     if not x_api_key or len(x_api_key) < 10:
         raise HTTPException(status_code=401, detail="API Key inválida")
     
     try:
-        client = get_groq_client(x_api_key)
+        provider = get_provider(req.provider, x_api_key)
+        tool_executor = ToolExecutor(req.files)
         
-        # Monta mensagens
+        # Monta mensagens iniciais
         messages = [{"role": "system", "content": SYSTEM_PROMPT}]
         
-        # Adiciona histórico se existir
-        for msg in (req.history or [])[-10:]:  # Últimas 10 mensagens
+        # Adiciona histórico
+        for msg in (req.history or [])[-10:]:
             messages.append(msg)
         
-        # Adiciona contexto do arquivo se existir
+        # Contexto do arquivo atual
+        context_parts = []
+        if req.files:
+            context_parts.append(f"📁 Projeto tem {len(req.files)} arquivo(s): {', '.join(req.files.keys())}")
+        if req.current_file and req.current_file in (req.files or {}):
+            content = req.files[req.current_file][:2000]
+            context_parts.append(f"📄 Arquivo aberto ({req.current_file}):\n```\n{content}\n```")
+        
         user_msg = req.message
-        if req.current_file_content:
-            user_msg = f"[Código atual do usuário]\n```\n{req.current_file_content[:3000]}\n```\n\n{req.message}"
+        if context_parts:
+            user_msg = "\n".join(context_parts) + f"\n\n💬 Mensagem: {req.message}"
         
         messages.append({"role": "user", "content": user_msg})
         
-        # Chama o modelo
-        response = client.chat.completions.create(
-            messages=messages,
-            model="llama-3.3-70b-versatile",
-            temperature=0.3,
-            max_tokens=2000
-        )
+        # Loop agêntico
+        max_iterations = 5
+        tool_results = []
+        
+        for i in range(max_iterations):
+            # Chama LLM
+            if req.agentic:
+                response = provider.chat(messages, req.model, tools=AGENT_TOOLS)
+            else:
+                response = provider.chat(messages, req.model)
+            
+            # Verifica se tem tool calls
+            if has_tool_calls(response):
+                tool_calls = parse_tool_calls(response)
+                
+                # Adiciona resposta do assistente com tool calls
+                assistant_msg = response["choices"][0]["message"]
+                messages.append(assistant_msg)
+                
+                # Executa cada tool
+                for tc in tool_calls:
+                    result = tool_executor.execute(tc["name"], tc["args"])
+                    tool_results.append({"tool": tc["name"], "result": result[:500]})
+                    
+                    # Adiciona resultado como mensagem de tool
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": tc["id"],
+                        "content": result
+                    })
+                
+                # Continua o loop
+                continue
+            else:
+                # Resposta final
+                content = get_response_content(response)
+                return {
+                    "response": content,
+                    "tool_calls": tool_results if tool_results else None
+                }
         
-        return {"response": response.choices[0].message.content}
+        # Se chegou aqui, atingiu limite
+        return {
+            "response": "⚠️ Limite de iterações atingido. Tente uma pergunta mais específica.",
+            "tool_calls": tool_results
+        }
     
     except Exception as e:
+        traceback.print_exc()
         error_msg = str(e)
-        if "authentication" in error_msg.lower() or "api key" in error_msg.lower():
-            raise HTTPException(status_code=401, detail="API Key inválida ou expirada")
+        if "401" in error_msg or "authentication" in error_msg.lower():
+            raise HTTPException(status_code=401, detail="API Key inválida para este provider")
         raise HTTPException(status_code=500, detail=f"Erro: {error_msg}")
 
 
 @app.post("/run")
 async def run_code(req: RunRequest):
-    """
-    Executa código Python (sandbox limitado).
-    Não precisa de API key - é só execução local.
-    """
+    """Executa código Python."""
     code = req.code
-    
-    # Captura stdout/stderr
     f_out = io.StringIO()
     f_err = io.StringIO()
-    
-    # Variável para capturar matplotlib
     image_base64 = None
     
     try:
-        # Prepara ambiente
         import matplotlib
         matplotlib.use('Agg')
         import matplotlib.pyplot as plt
@@ -145,7 +212,6 @@ async def run_code(req: RunRequest):
             "plt": plt,
         }
         
-        # Importa libs comuns
         try:
             import numpy as np
             exec_globals["np"] = np
@@ -159,11 +225,9 @@ async def run_code(req: RunRequest):
         except ImportError:
             pass
         
-        # Executa
         with redirect_stdout(f_out), redirect_stderr(f_err):
             exec(code, exec_globals)
         
-        # Captura figura matplotlib
         if plt.get_fignums():
             buf = io.BytesIO()
             plt.savefig(buf, format='png', dpi=100, bbox_inches='tight',
@@ -188,16 +252,14 @@ async def run_code(req: RunRequest):
 
 @app.post("/complete")
 async def autocomplete(req: CompleteRequest, x_api_key: str = Header(..., alias="X-API-Key")):
-    """
-    Autocomplete via LLM usando a key do usuário.
-    """
+    """Autocomplete via LLM."""
     if not x_api_key or len(x_api_key) < 10:
         raise HTTPException(status_code=401, detail="API Key inválida")
     
     try:
-        client = get_groq_client(x_api_key)
+        provider = get_provider(req.provider, x_api_key)
         
-        prompt = f"""Você é um autocomplete de código. Sugira completions para o código abaixo.
+        prompt = f"""Você é um autocomplete de código. Sugira completions.
 
 CÓDIGO ANTES DO CURSOR:
 ```{req.language}
@@ -214,19 +276,16 @@ Responda APENAS com um JSON array:
 
 Máximo 5 sugestões. Tipos: Function, Variable, Class, Module, Keyword, Snippet"""
 
-        response = client.chat.completions.create(
+        response = provider.chat(
             messages=[
                 {"role": "system", "content": "Responda APENAS JSON válido."},
                 {"role": "user", "content": prompt}
             ],
-            model="llama-3.3-70b-versatile",
-            temperature=0.1,
-            max_tokens=500
+            model=req.model
         )
         
-        response_text = response.choices[0].message.content
+        response_text = get_response_content(response) or ""
         
-        # Parse JSON
         match = re.search(r'\[.*\]', response_text, re.DOTALL)
         if match:
             suggestions = json.loads(match.group(0))
@@ -238,52 +297,55 @@ Máximo 5 sugestões. Tipos: Function, Variable, Class, Module, Keyword, Snippet
         return {"suggestions": [], "error": str(e)}
 
 
-# ============== Gradio Interface (for HF Spaces UI) ==============
-def gradio_chat(message, api_key):
-    """Interface Gradio simples para testar."""
+# ============== Gradio UI ==============
+def gradio_chat(message, provider, model, api_key):
     if not api_key:
-        return "❌ Coloque sua API Key do Groq"
+        return "❌ Coloque sua API Key"
     
     try:
-        client = get_groq_client(api_key)
-        response = client.chat.completions.create(
+        prov = get_provider(provider, api_key)
+        response = prov.chat(
             messages=[
                 {"role": "system", "content": SYSTEM_PROMPT},
                 {"role": "user", "content": message}
             ],
-            model="llama-3.3-70b-versatile",
-            temperature=0.3
+            model=model
         )
-        return response.choices[0].message.content
+        return get_response_content(response) or "Sem resposta"
     except Exception as e:
         return f"❌ Erro: {str(e)}"
 
 
-# Gradio UI
 with gr.Blocks(title="Jade Code IDE API") as demo:
-    gr.Markdown("# 🟢 Jade Code IDE - API Backend")
-    gr.Markdown("Esta é a API do Jade Code IDE. Use a IDE web para a experiência completa.")
-    gr.Markdown("**API Docs**: `/docs`")
+    gr.Markdown("# 🟢 Jade Code IDE - API Backend v3.0")
+    gr.Markdown("**Modo Agêntico** | Multi-Provider | API Docs: `/docs`")
     
     with gr.Row():
-        api_key_input = gr.Textbox(label="Sua API Key do Groq", type="password")
-    
-    with gr.Row():
-        msg_input = gr.Textbox(label="Mensagem de teste", lines=3)
-    
-    with gr.Row():
-        send_btn = gr.Button("Testar Chat")
+        provider_dd = gr.Dropdown(
+            choices=["groq", "cerebras", "openrouter"],
+            value="groq",
+            label="Provider"
+        )
+        model_dd = gr.Dropdown(
+            choices=["llama-3.3-70b-versatile", "llama-3.1-8b-instant"],
+            value="llama-3.3-70b-versatile",
+            label="Model"
+        )
     
+    api_key_input = gr.Textbox(label="API Key", type="password")
+    msg_input = gr.Textbox(label="Mensagem", lines=3)
+    send_btn = gr.Button("Enviar")
     output = gr.Textbox(label="Resposta", lines=10)
     
-    send_btn.click(gradio_chat, inputs=[msg_input, api_key_input], outputs=output)
-
+    send_btn.click(
+        gradio_chat,
+        inputs=[msg_input, provider_dd, model_dd, api_key_input],
+        outputs=output
+    )
 
-# Mount Gradio app
 app = gr.mount_gradio_app(app, demo, path="/ui")
 
 
-# ============== Run ==============
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)

providers.py

@@ -0,0 +1,178 @@
+"""
+Jade Code IDE - LLM Providers
+Suporte a múltiplos providers: Groq, Cerebras, OpenRouter
+"""
+
+from abc import ABC, abstractmethod
+from typing import Optional, List, Dict, Any
+import httpx
+
+
+class LLMProvider(ABC):
+    """Classe base para providers de LLM."""
+    
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+    
+    @abstractmethod
+    def chat(self, messages: List[Dict], model: str, tools: Optional[List] = None) -> Dict:
+        """Envia mensagem pro LLM e retorna resposta."""
+        pass
+    
+    @abstractmethod
+    def list_models(self) -> List[Dict]:
+        """Lista modelos disponíveis."""
+        pass
+
+
+class GroqProvider(LLMProvider):
+    """Provider para Groq API."""
+    
+    BASE_URL = "https://api.groq.com/openai/v1"
+    
+    MODELS = [
+        {"id": "llama-3.3-70b-versatile", "name": "Llama 3.3 70B", "context": 128000},
+        {"id": "llama-3.1-8b-instant", "name": "Llama 3.1 8B (Fast)", "context": 128000},
+        {"id": "mixtral-8x7b-32768", "name": "Mixtral 8x7B", "context": 32768},
+        {"id": "gemma2-9b-it", "name": "Gemma 2 9B", "context": 8192},
+    ]
+    
+    def chat(self, messages: List[Dict], model: str, tools: Optional[List] = None) -> Dict:
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        payload = {
+            "model": model,
+            "messages": messages,
+            "temperature": 0.3,
+            "max_tokens": 4096
+        }
+        
+        if tools:
+            payload["tools"] = tools
+            payload["tool_choice"] = "auto"
+        
+        with httpx.Client(timeout=60.0) as client:
+            response = client.post(
+                f"{self.BASE_URL}/chat/completions",
+                headers=headers,
+                json=payload
+            )
+            response.raise_for_status()
+            return response.json()
+    
+    def list_models(self) -> List[Dict]:
+        return self.MODELS
+
+
+class CerebrasProvider(LLMProvider):
+    """Provider para Cerebras API (extremamente rápido)."""
+    
+    BASE_URL = "https://api.cerebras.ai/v1"
+    
+    MODELS = [
+        {"id": "llama3.1-70b", "name": "Llama 3.1 70B", "context": 128000},
+        {"id": "llama3.1-8b", "name": "Llama 3.1 8B (Ultra Fast)", "context": 128000},
+    ]
+    
+    def chat(self, messages: List[Dict], model: str, tools: Optional[List] = None) -> Dict:
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        payload = {
+            "model": model,
+            "messages": messages,
+            "temperature": 0.3,
+            "max_tokens": 4096
+        }
+        
+        # Cerebras suporta tools também
+        if tools:
+            payload["tools"] = tools
+            payload["tool_choice"] = "auto"
+        
+        with httpx.Client(timeout=60.0) as client:
+            response = client.post(
+                f"{self.BASE_URL}/chat/completions",
+                headers=headers,
+                json=payload
+            )
+            response.raise_for_status()
+            return response.json()
+    
+    def list_models(self) -> List[Dict]:
+        return self.MODELS
+
+
+class OpenRouterProvider(LLMProvider):
+    """Provider para OpenRouter (acesso a múltiplos modelos)."""
+    
+    BASE_URL = "https://openrouter.ai/api/v1"
+    
+    MODELS = [
+        {"id": "anthropic/claude-3.5-sonnet", "name": "Claude 3.5 Sonnet", "context": 200000},
+        {"id": "google/gemini-2.0-flash-exp:free", "name": "Gemini 2.0 Flash (Free)", "context": 1000000},
+        {"id": "meta-llama/llama-3.3-70b-instruct", "name": "Llama 3.3 70B", "context": 128000},
+        {"id": "deepseek/deepseek-chat", "name": "DeepSeek V3", "context": 64000},
+        {"id": "qwen/qwen-2.5-coder-32b-instruct", "name": "Qwen 2.5 Coder 32B", "context": 32000},
+    ]
+    
+    def chat(self, messages: List[Dict], model: str, tools: Optional[List] = None) -> Dict:
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": "https://jade-code-ide.github.io",
+            "X-Title": "Jade Code IDE"
+        }
+        
+        payload = {
+            "model": model,
+            "messages": messages,
+            "temperature": 0.3,
+            "max_tokens": 4096
+        }
+        
+        if tools:
+            payload["tools"] = tools
+            payload["tool_choice"] = "auto"
+        
+        with httpx.Client(timeout=120.0) as client:
+            response = client.post(
+                f"{self.BASE_URL}/chat/completions",
+                headers=headers,
+                json=payload
+            )
+            response.raise_for_status()
+            return response.json()
+    
+    def list_models(self) -> List[Dict]:
+        return self.MODELS
+
+
+# === Factory ===
+def get_provider(provider_name: str, api_key: str) -> LLMProvider:
+    """Retorna o provider correto baseado no nome."""
+    providers = {
+        "groq": GroqProvider,
+        "cerebras": CerebrasProvider,
+        "openrouter": OpenRouterProvider
+    }
+    
+    provider_class = providers.get(provider_name.lower())
+    if not provider_class:
+        raise ValueError(f"Provider '{provider_name}' não suportado. Use: {list(providers.keys())}")
+    
+    return provider_class(api_key)
+
+
+def list_all_providers() -> List[Dict]:
+    """Lista todos os providers disponíveis."""
+    return [
+        {"id": "groq", "name": "Groq", "description": "Rápido e gratuito"},
+        {"id": "cerebras", "name": "Cerebras", "description": "Ultra rápido"},
+        {"id": "openrouter", "name": "OpenRouter", "description": "Acesso a múltiplos modelos"},
+    ]

requirements.txt

@@ -7,3 +7,4 @@ pydantic
 matplotlib
 numpy
 pandas
+httpx

tools.py

@@ -0,0 +1,175 @@
+"""
+Jade Code IDE - Agentic Tools
+Ferramentas que o LLM pode usar para explorar o projeto
+"""
+
+from typing import Dict, List, Any, Optional
+
+
+# === Tool Definitions (OpenAI format) ===
+AGENT_TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "list_files",
+            "description": "Lista todos os arquivos do projeto do usuário. Use para entender a estrutura do projeto.",
+            "parameters": {
+                "type": "object",
+                "properties": {},
+                "required": []
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "read_file",
+            "description": "Lê o conteúdo de um arquivo específico do projeto.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "filename": {
+                        "type": "string",
+                        "description": "Nome do arquivo para ler (ex: 'utils.py', 'README.md')"
+                    }
+                },
+                "required": ["filename"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "search_code",
+            "description": "Busca um texto em todos os arquivos do projeto.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Texto ou padrão para buscar nos arquivos"
+                    }
+                },
+                "required": ["query"]
+            }
+        }
+    }
+]
+
+
+class ToolExecutor:
+    """Executa ferramentas do agente usando os arquivos fornecidos pelo frontend."""
+    
+    def __init__(self, files: Dict[str, str]):
+        """
+        Args:
+            files: Dicionário {filename: content} com os arquivos do projeto
+        """
+        self.files = files or {}
+    
+    def execute(self, tool_name: str, args: Dict[str, Any]) -> str:
+        """Executa uma ferramenta e retorna o resultado como string."""
+        
+        if tool_name == "list_files":
+            return self._list_files()
+        elif tool_name == "read_file":
+            return self._read_file(args.get("filename", ""))
+        elif tool_name == "search_code":
+            return self._search_code(args.get("query", ""))
+        else:
+            return f"❌ Ferramenta desconhecida: {tool_name}"
+    
+    def _list_files(self) -> str:
+        """Lista arquivos do projeto."""
+        if not self.files:
+            return "📁 Nenhum arquivo no projeto."
+        
+        file_list = []
+        for name, content in self.files.items():
+            lines = content.count('\n') + 1 if content else 0
+            size = len(content)
+            file_list.append(f"  📄 {name} ({lines} linhas, {size} bytes)")
+        
+        return f"📁 Arquivos do projeto ({len(self.files)}):\n" + "\n".join(file_list)
+    
+    def _read_file(self, filename: str) -> str:
+        """Lê conteúdo de um arquivo."""
+        if not filename:
+            return "❌ Nome do arquivo não especificado."
+        
+        content = self.files.get(filename)
+        if content is None:
+            available = ", ".join(self.files.keys()) if self.files else "nenhum"
+            return f"❌ Arquivo '{filename}' não encontrado. Disponíveis: {available}"
+        
+        # Limita tamanho pra não estourar contexto
+        if len(content) > 5000:
+            content = content[:5000] + f"\n\n... [truncado, {len(content)} bytes total]"
+        
+        return f"📄 Conteúdo de '{filename}':\n```\n{content}\n```"
+    
+    def _search_code(self, query: str) -> str:
+        """Busca texto nos arquivos."""
+        if not query:
+            return "❌ Query de busca não especificada."
+        
+        query_lower = query.lower()
+        results = []
+        
+        for filename, content in self.files.items():
+            lines = content.split('\n')
+            for i, line in enumerate(lines, 1):
+                if query_lower in line.lower():
+                    # Mostra contexto
+                    snippet = line.strip()[:100]
+                    results.append(f"  {filename}:{i} → {snippet}")
+        
+        if not results:
+            return f"🔍 Nenhum resultado para '{query}'."
+        
+        return f"🔍 Resultados para '{query}' ({len(results)} encontrados):\n" + "\n".join(results[:20])
+
+
+def parse_tool_calls(response: Dict) -> List[Dict]:
+    """Extrai tool calls da resposta do LLM."""
+    choices = response.get("choices", [])
+    if not choices:
+        return []
+    
+    message = choices[0].get("message", {})
+    tool_calls = message.get("tool_calls", [])
+    
+    parsed = []
+    for tc in tool_calls:
+        try:
+            import json
+            parsed.append({
+                "id": tc.get("id"),
+                "name": tc.get("function", {}).get("name"),
+                "args": json.loads(tc.get("function", {}).get("arguments", "{}"))
+            })
+        except:
+            pass
+    
+    return parsed
+
+
+def get_response_content(response: Dict) -> Optional[str]:
+    """Extrai o conteúdo de texto da resposta."""
+    choices = response.get("choices", [])
+    if not choices:
+        return None
+    
+    message = choices[0].get("message", {})
+    return message.get("content")
+
+
+def has_tool_calls(response: Dict) -> bool:
+    """Verifica se a resposta contém tool calls."""
+    choices = response.get("choices", [])
+    if not choices:
+        return False
+    
+    message = choices[0].get("message", {})
+    tool_calls = message.get("tool_calls", [])
+    return len(tool_calls) > 0