from __future__ import annotations from dataclasses import dataclass from pathlib import Path from typing import Any, Awaitable, Callable import orjson from fastapi import HTTPException, Request from gemini_webapi import ModelOutput from loguru import logger from ..models import ( AnthropicMessageRequest, ContentItem, FunctionCall, Message, Tool, ToolCall, ToolChoiceFunction, ToolChoiceFunctionDetail, ToolFunctionDefinition, ) from ..services.client import GeminiClientWrapper from ..services.lmdb import LMDBConversationStore StreamFactory = Callable[..., Any] PersistConversationFn = Callable[..., str | None] ProcessOutputFn = Callable[..., tuple[str | None, str, str, list[Any]]] CalculateUsageFn = Callable[..., tuple[int, int, int, int]] ExecuteCoreSessionFn = Callable[ ..., Awaitable[tuple[Any, str, int, Any, Any, LMDBConversationStore, Any, list[Any], Any]] ] @dataclass(slots=True) class AnthropicHandlerDependencies: """Injected runtime hooks extracted from the chat router.""" execute_core_chat_session: ExecuteCoreSessionFn create_anthropic_streaming_response: StreamFactory process_llm_output: ProcessOutputFn calculate_usage: CalculateUsageFn persist_conversation: PersistConversationFn def _convert_system_prompt(system: str | list[dict[str, str]] | None) -> list[Message]: """Convert Anthropic system payload into internal system messages.""" if not system: return [] system_content = "" if isinstance(system, str): system_content = system elif isinstance(system, list): for item in system: if item.get("type") == "text": system_content += item.get("text", "") + "\n" if not system_content: return [] return [Message(role="system", content=system_content)] def _convert_messages(messages: list[Any]) -> list[Message]: """Convert Anthropic message blocks into internal message/tool structures.""" converted_messages: list[Message] = [] for raw_message in messages: if isinstance(raw_message, Message): message = raw_message.model_copy(deep=True) role = message.role original_content = message.content elif isinstance(raw_message, dict): role = str(raw_message.get("role") or "user") original_content = raw_message.get("content") message = Message(role=role, content=None) else: continue if not isinstance(original_content, list): if isinstance(original_content, (str, type(None))): message.content = original_content else: try: message.content = orjson.dumps(original_content).decode("utf-8") except Exception: message.content = str(original_content) converted_messages.append(message) continue if role == "assistant": text_parts: list[ContentItem] = [] tool_calls: list[ToolCall] = [] for part in original_content: if not isinstance(part, dict): continue part_type = part.get("type") if part_type == "text": text_value = part.get("text") if text_value: text_parts.append(ContentItem(type="text", text=text_value)) elif part_type == "tool_use": tool_name = part.get("name") tool_id = part.get("id") tool_input = part.get("input", {}) if not tool_name or not tool_id: continue try: tool_arguments = orjson.dumps(tool_input).decode("utf-8") except Exception: tool_arguments = orjson.dumps({"raw": tool_input}).decode("utf-8") tool_calls.append( ToolCall( id=tool_id, type="function", function=FunctionCall(name=tool_name, arguments=tool_arguments), ) ) elif part_type == "image" and "source" in part: source = part["source"] if source.get("type") == "base64": data = source.get("data") media_type = source.get("media_type") text_parts.append( ContentItem( type="image_url", image_url={"url": f"data:{media_type};base64,{data}"}, ) ) message.content = text_parts or None # type: ignore[assignment] message.tool_calls = tool_calls or None converted_messages.append(message) continue if role == "user": user_text_parts: list[ContentItem] = [] for part in original_content: if not isinstance(part, dict): continue part_type = part.get("type") if part_type == "text": text_value = part.get("text") if text_value: user_text_parts.append(ContentItem(type="text", text=text_value)) elif part_type == "image" and "source" in part: source = part["source"] if source.get("type") == "base64": data = source.get("data") media_type = source.get("media_type") user_text_parts.append( ContentItem( type="image_url", image_url={"url": f"data:{media_type};base64,{data}"}, ) ) elif part_type == "tool_result": tool_result_id = part.get("tool_use_id") if not tool_result_id: continue result_content = part.get("content") if isinstance(result_content, str): tool_content = result_content elif isinstance(result_content, list): tool_text_parts: list[str] = [] for result_part in result_content: if isinstance(result_part, dict): if result_part.get("type") == "text": text_value = result_part.get("text") if text_value: tool_text_parts.append(text_value) else: tool_text_parts.append( orjson.dumps(result_part).decode("utf-8") ) elif result_part is not None: tool_text_parts.append(str(result_part)) tool_content = "\n".join(tool_text_parts).strip() or "{}" elif result_content is None: tool_content = "{}" else: try: tool_content = orjson.dumps(result_content).decode("utf-8") except Exception: tool_content = str(result_content) if part.get("is_error"): tool_content = f'{{"is_error": true, "content": {orjson.dumps(tool_content).decode("utf-8")}}}' converted_messages.append( Message( role="tool", content=tool_content, tool_call_id=tool_result_id, ) ) if user_text_parts: message.content = user_text_parts # type: ignore[assignment] converted_messages.append(message) elif not any( isinstance(part, dict) and part.get("type") == "tool_result" for part in original_content ): message.content = None converted_messages.append(message) continue new_content: list[ContentItem] = [] for part in original_content: if not isinstance(part, dict): continue part_type = part.get("type") if part_type == "text": new_content.append(ContentItem(type="text", text=part.get("text"))) elif part_type == "image" and "source" in part: source = part["source"] if source.get("type") == "base64": data = source.get("data") media_type = source.get("media_type") new_content.append( ContentItem( type="image_url", image_url={"url": f"data:{media_type};base64,{data}"}, ) ) message.content = new_content or None # type: ignore[assignment] converted_messages.append(message) return converted_messages def _convert_tools(tools: list[dict[str, Any]] | None) -> list[Tool] | None: """Convert Anthropic tool schema into internal OpenAI-style Tool objects.""" if not tools: return None converted_tools: list[Tool] = [] for tool in tools: if not isinstance(tool, dict): continue tool_name = tool.get("name") tool_description = tool.get("description", "") tool_parameters = tool.get("input_schema") or tool.get("parameters", {}) if not tool_name: continue converted_tools.append( Tool( type="function", function=ToolFunctionDefinition( name=tool_name, description=tool_description, parameters=tool_parameters, ), ) ) return converted_tools or None def _convert_tool_choice( tool_choice: dict[str, Any] | str | None, ) -> str | ToolChoiceFunction | None: """Convert Anthropic tool choice into internal tool choice format.""" if not tool_choice: return None if isinstance(tool_choice, dict): choice_type = tool_choice.get("type") if choice_type == "tool": tool_name = tool_choice.get("name") if tool_name: return ToolChoiceFunction( type="function", function=ToolChoiceFunctionDetail(name=tool_name), ) if choice_type in ("auto", "any"): return "auto" if choice_type == "none": return "none" return None if isinstance(tool_choice, str): if tool_choice == "none": return "none" return "auto" return None async def handle_anthropic_messages( request: AnthropicMessageRequest, raw_request: Request, tmp_dir: Path, deps: AnthropicHandlerDependencies, ) -> Any: """ Handle the Anthropic-compatible messages endpoint. This module keeps Anthropic protocol adaptation separate from the main router while reusing the existing Gemini execution and persistence runtime hooks. """ _ = raw_request converted_messages: list[Message] = [] converted_messages.extend(_convert_system_prompt(request.system)) converted_messages.extend(_convert_messages(request.messages)) converted_tools = _convert_tools(request.tools) converted_tool_choice = _convert_tool_choice(request.tool_choice) ( response_or_stream, completion_id, created_time, session, client, db, model, prepared_messages, _structured_requirement, ) = await deps.execute_core_chat_session( request_model=request.model, messages=converted_messages, tmp_dir=tmp_dir, tools=converted_tools, tool_choice=converted_tool_choice, stream=bool(request.stream), response_format=None, ) if request.stream: return await deps.create_anthropic_streaming_response( response_or_stream, completion_id, created_time, model.model_name, prepared_messages, db, model, client, session, ) if not isinstance(response_or_stream, ModelOutput): raise HTTPException(status_code=502, detail="Malformed non-stream response.") try: thoughts = getattr(response_or_stream, "thoughts", None) raw_clean = GeminiClientWrapper.extract_output(response_or_stream, include_thoughts=False) except Exception as exc: logger.exception("Anthropic-compatible response parsing failed.") raise HTTPException(status_code=502, detail="Malformed response") from exc thoughts, assistant_visible, assistant_storage, tool_calls = deps.process_llm_output( thoughts, raw_clean, None, ) content_blocks: list[dict[str, Any]] = [] if thoughts: content_blocks.append({"type": "thinking", "thinking": thoughts}) if assistant_visible: content_blocks.append({"type": "text", "text": assistant_visible}) if tool_calls: for tool_call in tool_calls: tool_input: Any = {} if tool_call.function.arguments: try: tool_input = orjson.loads(tool_call.function.arguments) except orjson.JSONDecodeError: tool_input = {"raw": tool_call.function.arguments} content_blocks.append( { "type": "tool_use", "id": tool_call.id, "name": tool_call.function.name, "input": tool_input, } ) input_tokens, output_tokens, _total_tokens, _reasoning_tokens = deps.calculate_usage( converted_messages, assistant_visible, tool_calls, thoughts, ) stop_reason = "tool_use" if tool_calls else "end_turn" deps.persist_conversation( db, model.model_name, client.id, session.metadata, prepared_messages, assistant_storage, tool_calls, thoughts, ) return { "id": completion_id, "type": "message", "role": "assistant", "content": content_blocks, "model": model.model_name, "stop_reason": stop_reason, "stop_sequence": None, "usage": { "input_tokens": input_tokens, "output_tokens": output_tokens, }, }