feat(app): /v1/messages agora suporta tools e formato Anthropic

app.py

@@ -645,6 +645,59 @@ 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}]
+
+
+def convert_anthropic_tools_to_openai(tools: List[AnthropicTool]) -> List[dict]:
+    converted = []
+    for t in tools:
+        schema = t.input_schema or {"type": "object", "properties": {}}
+        converted.append({
+            "type": "function",
+            "function": {
+                "name": t.name,
+                "description": t.description or "",
+                "parameters": schema,
+            }
+        })
+    return converted
+
+
+def convert_openai_tool_calls_to_anthropic(tool_calls: List[dict]) -> List[dict]:
+    blocks = []
+    for tc in tool_calls:
+        fn = tc.get("function", {})
+        try:
+            arguments = json.loads(fn.get("arguments", "{}"))
+        except (json.JSONDecodeError, TypeError):
+            arguments = {}
+        blocks.append({
+            "type": "tool_use",
+            "id": tc.get("id", f"toolu_{uuid.uuid4().hex[:8]}"),
+            "name": fn.get("name", ""),
+            "input": arguments,
+        })
+    return blocks
+
+
 # ── Helper: Sanitiza mensagens para GGUF ──────────────────────────────────────
 def sanitize_chat_for_gguf(chat_messages):
     messages = [{"role": m["role"], "content": m["content"]} for m in chat_messages]
@@ -1223,6 +1276,20 @@ class AnthropicMessage(BaseModel):
     role: str
     content: str
 
+
+class AnthropicTool(BaseModel):
+    name: str
+    description: Optional[str] = None
+    input_schema: Optional[dict] = Field(default=None, alias="input_schema")
+
+    @field_validator("input_schema", mode="before")
+    @classmethod
+    def coerce_input_schema(cls, v):
+        if v is None:
+            return {"type": "object", "properties": {}}
+        return v
+
+
 class AnthropicRequest(BaseModel):
     model: Optional[str] = Field(default=DEFAULT_MODEL_KEY)
     messages: List[AnthropicMessage]
@@ -1230,6 +1297,15 @@ class AnthropicRequest(BaseModel):
     temperature: Optional[float] = Field(default=0.7)
     system: Optional[str] = None
     stream: Optional[bool] = False
+    tools: Optional[List[AnthropicTool]] = Field(default=None, description="Ferramentas no formato Anthropic")
+    tool_choice: Optional[str] = Field(default="auto", description="'auto', 'any', ou nome de uma tool")
+
+    @field_validator("messages")
+    @classmethod
+    def messages_not_empty(cls, v):
+        if not v:
+            raise ValueError("messages não pode estar vazio")
+        return v
 
 
 async def chat_completions_async(req: ChatRequest):
@@ -1591,6 +1667,22 @@ async def chat_completions_async(req: ChatRequest):
         raise ChatError(str(e) + "\n" + err)
 
 
+def build_anthropic_content(message: dict) -> List[dict]:
+    tool_calls = message.get("tool_calls") or []
+    if tool_calls:
+        return [
+            {
+                "type": "tool_use",
+                "id": tc.get("id", f"toolu_{uuid.uuid4().hex[:8]}"),
+                "name": tc.get("function", {}).get("name", ""),
+                "input": json.loads(tc.get("function", {}).get("arguments", "{}")),
+            }
+            for tc in tool_calls
+        ]
+    text = message.get("content", "") or ""
+    return [{"type": "text", "text": text}]
+
+
 @app.post("/v1/messages")
 async def anthropic_messages(req: AnthropicRequest, request: Request):
     """Rota compatível com SDK Anthropic — suporta stream=true (SSE) e stream=false (JSON)."""
@@ -1601,6 +1693,7 @@ async def anthropic_messages(req: AnthropicRequest, request: Request):
     for m in req.messages:
         msgs.append(Message(role=m.role, content=m.content))
 
+    openai_tools = convert_anthropic_tools_to_openai(req.tools) if req.tools else None
     chat_req = ChatRequest(
         model=req.model,
         messages=msgs,
@@ -1609,6 +1702,8 @@ async def anthropic_messages(req: AnthropicRequest, request: Request):
         mode="medium",
         web=False,
         free_mode=False,
+        tools=openai_tools,
+        tool_choice=req.tool_choice or "auto",
     )
 
     if req.stream:
@@ -1621,34 +1716,44 @@ async def anthropic_messages(req: AnthropicRequest, request: Request):
 
             try:
                 result = await chat_completions_async(chat_req)
-                reply = result["choices"][0]["message"]["content"]
+                message = result["choices"][0]["message"]
                 usage = result.get("usage", {})
+                content_blocks = build_anthropic_content(message)
+                stop_reason = "tool_use" if any(b.get("type") == "tool_use" for b in content_blocks) else "end_turn"
             except Exception as e:
-                reply = f"Erro: {str(e)}"
+                content_blocks = [{"type": "text", "text": f"Erro: {str(e)}"}]
                 usage = {}
-
-            chunk_size = 20
-            for i in range(0, len(reply), chunk_size):
-                chunk = reply[i:i+chunk_size]
-                yield f"event: content_block_delta\ndata: {json.dumps({'type':'content_block_delta','index':0,'delta':{'type':'text_delta','text':chunk}})}\n\n"
-                await asyncio.sleep(0.01)
+                stop_reason = "end_turn"
+
+            for block in content_blocks:
+                block_type = block.get("type", "text")
+                if block_type == "text":
+                    chunk_size = 20
+                    for i in range(0, len(block.get("text", "")), chunk_size):
+                        chunk = block["text"][i:i+chunk_size]
+                        yield f"event: content_block_delta\ndata: {json.dumps({'type':'content_block_delta','index':0,'delta':{'type':'text_delta','text':chunk}})}\n\n"
+                        await asyncio.sleep(0.01)
+                elif block_type == "tool_use":
+                    yield f"event: content_block_delta\ndata: {json.dumps({'type':'content_block_delta','index':0,'delta':{'type':'tool_use_delta','input':block.get('input', {})}})}\n\n"
 
             yield f"event: content_block_stop\ndata: {json.dumps({'type':'content_block_stop','index':0})}\n\n"
-            yield f"event: message_delta\ndata: {json.dumps({'type':'message_delta','delta':{'stop_reason':'end_turn','stop_sequence':None},'usage':{'output_tokens':usage.get('completion_tokens',0)}})}\n\n"
+            yield f"event: message_delta\ndata: {json.dumps({'type':'message_delta','delta':{'stop_reason':stop_reason,'stop_sequence':None},'usage':{'output_tokens':usage.get('completion_tokens',0)}})}\n\n"
             yield f"event: message_stop\ndata: {json.dumps({'type':'message_stop'})}\n\n"
 
         return StreamingResponse(event_stream(), media_type="text/event-stream")
 
     result = await chat_completions_async(chat_req)
-    reply = result["choices"][0]["message"]["content"]
+    message = result["choices"][0]["message"]
     usage = result.get("usage", {})
+    content_blocks = build_anthropic_content(message)
+    stop_reason = "tool_use" if any(b.get("type") == "tool_use" for b in content_blocks) else "end_turn"
     return {
         "id": f"msg_thc_{uuid.uuid4().hex[:8]}",
         "type": "message",
         "role": "assistant",
-        "content": [{"type": "text", "text": reply}],
+        "content": content_blocks,
         "model": req.model,
-        "stop_reason": "end_turn",
+        "stop_reason": stop_reason,
         "stop_sequence": None,
         "usage": {
             "input_tokens": usage.get("prompt_tokens", 0),
@@ -1666,6 +1771,7 @@ async def anthropic_messages_stream(req: AnthropicRequest, request: Request):
     for m in req.messages:
         msgs.append(Message(role=m.role, content=m.content))
 
+    openai_tools = convert_anthropic_tools_to_openai(req.tools) if req.tools else None
     chat_req = ChatRequest(
         model=req.model,
         messages=msgs,
@@ -1674,15 +1780,20 @@ async def anthropic_messages_stream(req: AnthropicRequest, request: Request):
         mode="medium",
         web=False,
         free_mode=False,
+        tools=openai_tools,
+        tool_choice=req.tool_choice or "auto",
     )
 
     try:
         result = await chat_completions_async(chat_req)
-        reply = result["choices"][0]["message"]["content"]
+        message = result["choices"][0]["message"]
         usage = result.get("usage", {})
+        content_blocks = build_anthropic_content(message)
+        stop_reason = "tool_use" if any(b.get("type") == "tool_use" for b in content_blocks) else "end_turn"
     except Exception as e:
-        reply = f"Erro: {str(e)}"
+        content_blocks = [{"type": "text", "text": f"Erro: {str(e)}"}]
         usage = {}
+        stop_reason = "end_turn"
 
     async def event_stream():
         msg_id = f"msg_thc_{uuid.uuid4().hex[:8]}"
@@ -1691,14 +1802,19 @@ async def anthropic_messages_stream(req: AnthropicRequest, request: Request):
         yield f"event: content_block_start\ndata: {json.dumps({'type':'content_block_start','index':0,'content_block':{'type':'text','text':''}})}\n\n"
         yield f"event: ping\ndata: {json.dumps({'type':'ping'})}\n\n"
 
-        chunk_size = 20
-        for i in range(0, len(reply), chunk_size):
-            chunk = reply[i:i+chunk_size]
-            yield f"event: content_block_delta\ndata: {json.dumps({'type':'content_block_delta','index':0,'delta':{'type':'text_delta','text':chunk}})}\n\n"
-            await asyncio.sleep(0.01)
+        for block in content_blocks:
+            block_type = block.get("type", "text")
+            if block_type == "text":
+                chunk_size = 20
+                for i in range(0, len(block.get("text", "")), chunk_size):
+                    chunk = block["text"][i:i+chunk_size]
+                    yield f"event: content_block_delta\ndata: {json.dumps({'type':'content_block_delta','index':0,'delta':{'type':'text_delta','text':chunk}})}\n\n"
+                    await asyncio.sleep(0.01)
+            elif block_type == "tool_use":
+                yield f"event: content_block_delta\ndata: {json.dumps({'type':'content_block_delta','index':0,'delta':{'type':'tool_use_delta','input':block.get('input', {})}})}\n\n"
 
         yield f"event: content_block_stop\ndata: {json.dumps({'type':'content_block_stop','index':0})}\n\n"
-        yield f"event: message_delta\ndata: {json.dumps({'type':'message_delta','delta':{'stop_reason':'end_turn','stop_sequence':None},'usage':{'output_tokens':usage.get('completion_tokens',0)}})}\n\n"
+        yield f"event: message_delta\ndata: {json.dumps({'type':'message_delta','delta':{'stop_reason':stop_reason,'stop_sequence':None},'usage':{'output_tokens':usage.get('completion_tokens',0)}})}\n\n"
         yield f"event: message_stop\ndata: {json.dumps({'type':'message_stop'})}\n\n"
 
     return StreamingResponse(event_stream(), media_type="text/event-stream")