feat(server): add Anthropic Messages API endpoint (/v1/messages)

Enables Claude Code and other Anthropic-compatible tools to use ATOM
as a backend. Translates between Anthropic Messages format and ATOM's
internal OpenAI format.

Supports:
- Non-streaming and streaming responses
- System messages, multi-turn conversations
- Thinking/reasoning content separation (via ReasoningFilter)
- Anthropic SSE event format (message_start, content_block_delta, etc.)
- Tool definitions translation (Anthropic → OpenAI format)

Usage with Claude Code:
  ANTHROPIC_BASE_URL=http://localhost:8000 \
  ANTHROPIC_AUTH_TOKEN=dummy \
  ANTHROPIC_MODEL=MiniMax-M2.7 \
  claude

Author: carlushuang

atom/entrypoints/openai/api_server.py

@@ -44,6 +44,18 @@
     stream_chat_response,
     stream_chat_response_fanout,
 )
+from .serving_anthropic import (
+    AnthropicMessagesRequest,
+    anthropic_to_openai_messages,
+    anthropic_to_openai_tools,
+    build_anthropic_response,
+    stream_content_block_delta,
+    stream_content_block_start,
+    stream_content_block_stop,
+    stream_message_delta,
+    stream_message_start,
+    stream_message_stop,
+)
 from .serving_completion import (
     build_completion_response,
     build_completion_response_multi,
@@ -773,6 +785,146 @@ async def completions(request: CompletionRequest):
         raise HTTPException(status_code=500, detail=str(e))
 
 
+@app.post("/v1/messages")
+async def anthropic_messages(request: AnthropicMessagesRequest, raw_request: Request):
+    """Handle Anthropic Messages API requests.
+
+    Translates Anthropic format to OpenAI format internally, runs inference,
+    and returns Anthropic-formatted responses. Enables Claude Code and other
+    Anthropic-compatible tools to use ATOM as a backend.
+    """
+    global engine, tokenizer, model_name
+
+    try:
+        # Convert Anthropic messages to OpenAI format
+        openai_messages = anthropic_to_openai_messages(request.messages, request.system)
+
+        # Apply chat template
+        from .protocol import ChatMessage
+
+        messages = [ChatMessage(**m) for m in openai_messages]
+
+        merged_kwargs = dict(default_chat_template_kwargs)
+        prompt = apply_chat_template(
+            tokenizer,
+            custom_message_encoder,
+            [msg.to_template_dict() for msg in messages],
+            tools=None,
+            **merged_kwargs,
+        )
+
+        sampling_params = _build_sampling_params(
+            temperature=request.temperature or 1.0,
+            max_tokens=request.max_tokens,
+            stop_strings=request.stop_sequences,
+            top_k=request.top_k,
+            top_p=request.top_p,
+        )
+
+        request_id = uuid.uuid4().hex[:24]
+        input_tokens = len(tokenizer.encode(prompt))
+
+        if request.stream:
+            # Streaming response
+            seq_id, stream_queue = await setup_streaming_request(
+                prompt, sampling_params, request_id
+            )
+
+            async def generate_anthropic_stream():
+                from .reasoning import ReasoningFilter
+
+                reasoning_filter = ReasoningFilter()
+                block_index = 0
+                started_text = False
+                started_thinking = False
+                output_tokens = 0
+
+                yield stream_message_start(request_id, model_name, input_tokens)
+
+                try:
+                    while True:
+                        chunk_data = await stream_queue.get()
+                        new_text = chunk_data["text"]
+                        output_tokens += len(chunk_data.get("token_ids", []))
+                        finished = chunk_data.get("finished", False)
+
+                        segments = reasoning_filter.process(new_text)
+                        if finished:
+                            segments.extend(reasoning_filter.flush())
+
+                        for field, text in segments:
+                            if not text:
+                                continue
+
+                            if field == "reasoning_content":
+                                if not started_thinking:
+                                    yield stream_content_block_start(block_index, "thinking")
+                                    started_thinking = True
+                                yield stream_content_block_delta(block_index, text, "thinking")
+                            else:
+                                if started_thinking and not started_text:
+                                    yield stream_content_block_stop(block_index)
+                                    block_index += 1
+                                if not started_text:
+                                    yield stream_content_block_start(block_index, "text")
+                                    started_text = True
+                                yield stream_content_block_delta(block_index, text, "text")
+
+                        if finished:
+                            if started_thinking and not started_text:
+                                yield stream_content_block_stop(block_index)
+                                block_index += 1
+                                yield stream_content_block_start(block_index, "text")
+                                yield stream_content_block_delta(block_index, "", "text")
+                            yield stream_content_block_stop(block_index)
+                            yield stream_message_delta("end_turn", output_tokens)
+                            yield stream_message_stop()
+                            break
+                finally:
+                    cleanup_streaming_request(seq_id)
+
+            return StreamingResponse(
+                generate_anthropic_stream(),
+                media_type="text/event-stream",
+                headers={
+                    "anthropic-version": "2023-06-01",
+                    "x-request-id": request_id,
+                },
+            )
+
+        # Non-streaming response
+        from .reasoning import separate_reasoning
+
+        final_output = None
+        async for output in generate_async(prompt, sampling_params, request_id):
+            final_output = output
+        if final_output is None:
+            raise RuntimeError("No output generated")
+
+        raw_text = final_output["text"]
+        reasoning_content, content = separate_reasoning(raw_text)
+        output_tokens = len(tokenizer.encode(raw_text))
+
+        return build_anthropic_response(
+            request_id=request_id,
+            model=model_name,
+            content_text=content,
+            reasoning_content=reasoning_content,
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+        )
+
+    except Exception as e:
+        logger.error(f"Error in anthropic_messages: {e}", exc_info=True)
+        return JSONResponse(
+            status_code=500,
+            content={
+                "type": "error",
+                "error": {"type": "api_error", "message": str(e)},
+            },
+        )
+
+
 @app.get("/v1/models")
 async def list_models():
     """List available models."""