Upload app.py with huggingface_hub

app.py

@@ -1,7 +1,8 @@
 """
-Anthropic-Compatible API Endpoint
+Dual-Compatible API Endpoint (OpenAI + Anthropic)
 Lightweight CPU-based implementation for Hugging Face Spaces
-Full Anthropic API parameter compatibility with Extended Thinking support
+- OpenAI format: /v1/chat/completions
+- Anthropic format: /anthropic/v1/messages
 """
 
 import os
@@ -44,14 +45,14 @@ console_handler.setFormatter(log_format)
 console_handler.setLevel(logging.INFO)
 
 logging.basicConfig(level=logging.DEBUG, handlers=[file_handler, console_handler])
-logger = logging.getLogger("anthropic-api")
+logger = logging.getLogger("dual-api")
 
 for uvicorn_logger in ["uvicorn", "uvicorn.error", "uvicorn.access"]:
     uv_log = logging.getLogger(uvicorn_logger)
     uv_log.handlers = [file_handler, console_handler]
 
 logger.info("=" * 60)
-logger.info(f"Application Startup at {datetime.now().isoformat()}")
+logger.info(f"Dual API (OpenAI + Anthropic) Startup at {datetime.now().isoformat()}")
 logger.info(f"Log file: {LOG_FILE}")
 logger.info("=" * 60)
 
@@ -83,8 +84,12 @@ async def lifespan(app: FastAPI):
     del model, tokenizer
 
 app = FastAPI(
-    title="Anthropic-Compatible API",
-    description="Lightweight CPU-based API with full Anthropic Messages API compatibility including Extended Thinking",
+    title="Dual-Compatible API (OpenAI + Anthropic)",
+    description="""
+    Lightweight CPU-based API with dual compatibility:
+    - OpenAI format: /v1/chat/completions
+    - Anthropic format: /anthropic/v1/messages
+    """,
     version="1.0.0",
     lifespan=lifespan
 )
@@ -112,170 +117,216 @@ async def log_requests(request: Request, call_next):
         logger.error(f"[{request_id}] {request.method} {request.url.path} - Error: {e} ({duration:.2f}ms)")
         raise
 
-# ============== Anthropic-Compatible Pydantic Models ==============
+# ============================================================
+# ANTHROPIC-COMPATIBLE MODELS (under /anthropic)
+# ============================================================
 
-# Content block types (matching Anthropic exactly)
-class TextBlock(BaseModel):
+class AnthropicTextBlock(BaseModel):
     type: Literal["text"] = "text"
     text: str
 
-class ImageSource(BaseModel):
+class AnthropicImageSource(BaseModel):
     type: Literal["base64", "url"] = "base64"
     media_type: Optional[str] = None
     data: Optional[str] = None
     url: Optional[str] = None
 
-class ImageBlock(BaseModel):
+class AnthropicImageBlock(BaseModel):
     type: Literal["image"] = "image"
-    source: ImageSource
+    source: AnthropicImageSource
 
-class ToolUseBlock(BaseModel):
+class AnthropicToolUseBlock(BaseModel):
     type: Literal["tool_use"] = "tool_use"
     id: str
     name: str
     input: Dict[str, Any]
 
-class ToolResultBlock(BaseModel):
+class AnthropicToolResultBlock(BaseModel):
     type: Literal["tool_result"] = "tool_result"
     tool_use_id: str
-    content: Optional[Union[str, List[TextBlock]]] = None
+    content: Optional[Union[str, List[AnthropicTextBlock]]] = None
     is_error: Optional[bool] = False
 
-ContentBlock = Union[TextBlock, ImageBlock, ToolUseBlock, ToolResultBlock]
+AnthropicContentBlock = Union[AnthropicTextBlock, AnthropicImageBlock, AnthropicToolUseBlock, AnthropicToolResultBlock]
 
-# Message structure (matching Anthropic exactly)
-class Message(BaseModel):
+class AnthropicMessage(BaseModel):
     role: Literal["user", "assistant"]
-    content: Union[str, List[ContentBlock]]
+    content: Union[str, List[AnthropicContentBlock]]
 
-# Tool definition (matching Anthropic exactly)
-class ToolInputSchema(BaseModel):
+class AnthropicToolInputSchema(BaseModel):
     type: Literal["object"] = "object"
     properties: Optional[Dict[str, Any]] = None
     required: Optional[List[str]] = None
 
-class Tool(BaseModel):
+class AnthropicTool(BaseModel):
     name: str
     description: Optional[str] = None
-    input_schema: ToolInputSchema
+    input_schema: AnthropicToolInputSchema
 
-# Tool choice (matching Anthropic exactly)
-class ToolChoiceAuto(BaseModel):
+class AnthropicToolChoiceAuto(BaseModel):
     type: Literal["auto"] = "auto"
     disable_parallel_tool_use: Optional[bool] = None
 
-class ToolChoiceAny(BaseModel):
+class AnthropicToolChoiceAny(BaseModel):
     type: Literal["any"] = "any"
     disable_parallel_tool_use: Optional[bool] = None
 
-class ToolChoiceTool(BaseModel):
+class AnthropicToolChoiceTool(BaseModel):
     type: Literal["tool"] = "tool"
     name: str
     disable_parallel_tool_use: Optional[bool] = None
 
-ToolChoice = Union[ToolChoiceAuto, ToolChoiceAny, ToolChoiceTool]
+AnthropicToolChoice = Union[AnthropicToolChoiceAuto, AnthropicToolChoiceAny, AnthropicToolChoiceTool]
 
-# Metadata (matching Anthropic exactly)
-class Metadata(BaseModel):
+class AnthropicMetadata(BaseModel):
     user_id: Optional[str] = None
 
-# System content (matching Anthropic exactly)
-class SystemContent(BaseModel):
+class AnthropicSystemContent(BaseModel):
     type: Literal["text"] = "text"
     text: str
     cache_control: Optional[Dict[str, str]] = None
 
-# ============== Extended Thinking (ThinkingConfig) ==============
-class ThinkingConfig(BaseModel):
-    """
-    Extended thinking configuration (matching Anthropic's ThinkingConfig)
-    Enables Claude to think through complex problems before responding
-    """
+class AnthropicThinkingConfig(BaseModel):
     type: Literal["enabled", "disabled"] = "enabled"
-    # Budget tokens for thinking (Anthropic uses budget_tokens)
     budget_tokens: Optional[int] = Field(default=1024, ge=1, le=128000)
 
-# Main request model (matching Anthropic exactly)
-class MessageRequest(BaseModel):
-    # Required parameters
+class AnthropicMessageRequest(BaseModel):
     model: str
     max_tokens: int
-    messages: List[Message]
-
-    # Optional parameters (matching Anthropic exactly)
-    metadata: Optional[Metadata] = None
+    messages: List[AnthropicMessage]
+    metadata: Optional[AnthropicMetadata] = None
     stop_sequences: Optional[List[str]] = None
     stream: Optional[bool] = False
-    system: Optional[Union[str, List[SystemContent]]] = None
+    system: Optional[Union[str, List[AnthropicSystemContent]]] = None
     temperature: Optional[float] = Field(default=1.0, ge=0.0, le=1.0)
-    tool_choice: Optional[ToolChoice] = None
-    tools: Optional[List[Tool]] = None
+    tool_choice: Optional[AnthropicToolChoice] = None
+    tools: Optional[List[AnthropicTool]] = None
     top_k: Optional[int] = Field(default=None, ge=0)
     top_p: Optional[float] = Field(default=None, ge=0.0, le=1.0)
+    thinking: Optional[AnthropicThinkingConfig] = None
 
-    # Extended Thinking (ThinkingConfig)
-    thinking: Optional[ThinkingConfig] = None
-
-# Usage model (matching Anthropic exactly with thinking tokens)
-class Usage(BaseModel):
+class AnthropicUsage(BaseModel):
     input_tokens: int
     output_tokens: int
     cache_creation_input_tokens: Optional[int] = None
     cache_read_input_tokens: Optional[int] = None
 
-# Response content blocks
-class ResponseTextBlock(BaseModel):
+class AnthropicResponseTextBlock(BaseModel):
     type: Literal["text"] = "text"
     text: str
 
-class ResponseThinkingBlock(BaseModel):
-    """Thinking block in response (matching Anthropic's thinking content block)"""
+class AnthropicResponseThinkingBlock(BaseModel):
     type: Literal["thinking"] = "thinking"
     thinking: str
 
-class ResponseToolUseBlock(BaseModel):
+class AnthropicResponseToolUseBlock(BaseModel):
     type: Literal["tool_use"] = "tool_use"
     id: str
     name: str
     input: Dict[str, Any]
 
-ResponseContentBlock = Union[ResponseTextBlock, ResponseThinkingBlock, ResponseToolUseBlock]
+AnthropicResponseContentBlock = Union[AnthropicResponseTextBlock, AnthropicResponseThinkingBlock, AnthropicResponseToolUseBlock]
 
-# Main response model (matching Anthropic exactly)
-class MessageResponse(BaseModel):
+class AnthropicMessageResponse(BaseModel):
     id: str
     type: Literal["message"] = "message"
     role: Literal["assistant"] = "assistant"
-    content: List[ResponseContentBlock]
+    content: List[AnthropicResponseContentBlock]
     model: str
     stop_reason: Optional[Literal["end_turn", "max_tokens", "stop_sequence", "tool_use"]] = None
     stop_sequence: Optional[str] = None
-    usage: Usage
+    usage: AnthropicUsage
+
+class AnthropicTokenCountRequest(BaseModel):
+    model: str
+    messages: List[AnthropicMessage]
+    system: Optional[Union[str, List[AnthropicSystemContent]]] = None
+    tools: Optional[List[AnthropicTool]] = None
+    thinking: Optional[AnthropicThinkingConfig] = None
+
+class AnthropicTokenCountResponse(BaseModel):
+    input_tokens: int
 
-# Error response (matching Anthropic exactly)
-class ErrorDetail(BaseModel):
+# ============================================================
+# OPENAI-COMPATIBLE MODELS (under /v1)
+# ============================================================
+
+class OpenAIMessage(BaseModel):
+    role: Literal["system", "user", "assistant", "tool"]
+    content: Optional[Union[str, List[Dict[str, Any]]]] = None
+    name: Optional[str] = None
+    tool_calls: Optional[List[Dict[str, Any]]] = None
+    tool_call_id: Optional[str] = None
+
+class OpenAITool(BaseModel):
+    type: Literal["function"] = "function"
+    function: Dict[str, Any]
+
+class OpenAIToolChoice(BaseModel):
     type: str
-    message: str
+    function: Optional[Dict[str, str]] = None
 
-class ErrorResponse(BaseModel):
-    type: Literal["error"] = "error"
-    error: ErrorDetail
+class OpenAIChatRequest(BaseModel):
+    model: str
+    messages: List[OpenAIMessage]
+    max_tokens: Optional[int] = 1024
+    temperature: Optional[float] = Field(default=1.0, ge=0.0, le=2.0)
+    top_p: Optional[float] = Field(default=1.0, ge=0.0, le=1.0)
+    n: Optional[int] = 1
+    stream: Optional[bool] = False
+    stop: Optional[Union[str, List[str]]] = None
+    presence_penalty: Optional[float] = 0.0
+    frequency_penalty: Optional[float] = 0.0
+    logit_bias: Optional[Dict[str, float]] = None
+    user: Optional[str] = None
+    tools: Optional[List[OpenAITool]] = None
+    tool_choice: Optional[Union[str, OpenAIToolChoice]] = None
+    seed: Optional[int] = None
+
+class OpenAIUsage(BaseModel):
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+
+class OpenAIChoice(BaseModel):
+    index: int
+    message: Dict[str, Any]
+    finish_reason: Optional[str] = None
+
+class OpenAIChatResponse(BaseModel):
+    id: str
+    object: Literal["chat.completion"] = "chat.completion"
+    created: int
+    model: str
+    choices: List[OpenAIChoice]
+    usage: OpenAIUsage
+    system_fingerprint: Optional[str] = None
+
+class OpenAIStreamChoice(BaseModel):
+    index: int
+    delta: Dict[str, Any]
+    finish_reason: Optional[str] = None
 
-# Token count request/response (matching Anthropic exactly)
-class TokenCountRequest(BaseModel):
+class OpenAIStreamResponse(BaseModel):
+    id: str
+    object: Literal["chat.completion.chunk"] = "chat.completion.chunk"
+    created: int
     model: str
-    messages: List[Message]
-    system: Optional[Union[str, List[SystemContent]]] = None
-    tools: Optional[List[Tool]] = None
-    thinking: Optional[ThinkingConfig] = None
+    choices: List[OpenAIStreamChoice]
 
-class TokenCountResponse(BaseModel):
-    input_tokens: int
+class OpenAIModel(BaseModel):
+    id: str
+    object: Literal["model"] = "model"
+    created: int
+    owned_by: str
+
+class OpenAIModelList(BaseModel):
+    object: Literal["list"] = "list"
+    data: List[OpenAIModel]
 
 # ============== Helper Functions ==============
 
-def extract_text_content(content: Union[str, List[ContentBlock]]) -> str:
-    """Extract text from content (string or list of blocks)"""
+def extract_anthropic_text(content: Union[str, List[AnthropicContentBlock]]) -> str:
     if isinstance(content, str):
         return content
     texts = []
@@ -287,8 +338,7 @@ def extract_text_content(content: Union[str, List[ContentBlock]]) -> str:
             texts.append(block.text)
     return " ".join(texts)
 
-def extract_system_content(system: Optional[Union[str, List[SystemContent]]]) -> Optional[str]:
-    """Extract system prompt from string or list of system content blocks"""
+def extract_anthropic_system(system: Optional[Union[str, List[AnthropicSystemContent]]]) -> Optional[str]:
     if system is None:
         return None
     if isinstance(system, str):
@@ -301,18 +351,26 @@ def extract_system_content(system: Optional[Union[str, List[SystemContent]]]) ->
             texts.append(block.text)
     return " ".join(texts)
 
-def format_messages_with_thinking(
-    messages: List[Message],
-    system: Optional[Union[str, List[SystemContent]]] = None,
+def extract_openai_content(content: Optional[Union[str, List[Dict[str, Any]]]]) -> str:
+    if content is None:
+        return ""
+    if isinstance(content, str):
+        return content
+    texts = []
+    for item in content:
+        if isinstance(item, dict) and item.get("type") == "text":
+            texts.append(item.get("text", ""))
+    return " ".join(texts)
+
+def format_anthropic_messages(
+    messages: List[AnthropicMessage],
+    system: Optional[Union[str, List[AnthropicSystemContent]]] = None,
     thinking_enabled: bool = False,
     budget_tokens: int = 1024
 ) -> str:
-    """Format messages with optional thinking prompt"""
     formatted_messages = []
+    system_text = extract_anthropic_system(system)
 
-    system_text = extract_system_content(system)
-
-    # Add thinking instructions to system prompt if enabled
     if thinking_enabled:
         thinking_instruction = f"""You are a helpful AI assistant with extended thinking capabilities.
 
@@ -325,7 +383,6 @@ When responding to complex problems:
 Budget for thinking: up to {budget_tokens} tokens for reasoning.
 
 Think deeply and thoroughly before responding."""
-
         if system_text:
             system_text = f"{thinking_instruction}\n\n{system_text}"
         else:
@@ -335,13 +392,27 @@ Think deeply and thoroughly before responding."""
         formatted_messages.append({"role": "system", "content": system_text})
 
     for msg in messages:
-        content = extract_text_content(msg.content)
+        content = extract_anthropic_text(msg.content)
         formatted_messages.append({"role": msg.role, "content": content})
 
     if tokenizer.chat_template:
-        return tokenizer.apply_chat_template(
-            formatted_messages, tokenize=False, add_generation_prompt=True
-        )
+        return tokenizer.apply_chat_template(formatted_messages, tokenize=False, add_generation_prompt=True)
+
+    prompt = ""
+    for msg in formatted_messages:
+        role = msg["role"].capitalize()
+        prompt += f"{role}: {msg['content']}\n"
+    prompt += "Assistant: "
+    return prompt
+
+def format_openai_messages(messages: List[OpenAIMessage]) -> str:
+    formatted_messages = []
+    for msg in messages:
+        content = extract_openai_content(msg.content)
+        formatted_messages.append({"role": msg.role, "content": content})
+
+    if tokenizer.chat_template:
+        return tokenizer.apply_chat_template(formatted_messages, tokenize=False, add_generation_prompt=True)
 
     prompt = ""
     for msg in formatted_messages:
@@ -351,41 +422,206 @@ Think deeply and thoroughly before responding."""
     return prompt
 
 def parse_thinking_response(text: str) -> tuple:
-    """
-    Parse response to extract thinking and final answer
-    Returns: (thinking_text, answer_text)
-    """
     thinking_pattern = r'<thinking>(.*?)</thinking>'
     thinking_matches = re.findall(thinking_pattern, text, re.DOTALL)
-
     if thinking_matches:
         thinking_text = "\n".join(thinking_matches).strip()
-        # Remove thinking blocks from response
         answer_text = re.sub(thinking_pattern, '', text, flags=re.DOTALL).strip()
         return thinking_text, answer_text
-    else:
-        return None, text.strip()
+    return None, text.strip()
 
-def generate_id() -> str:
-    return f"msg_{uuid.uuid4().hex[:24]}"
+def generate_id(prefix: str = "msg") -> str:
+    return f"{prefix}_{uuid.uuid4().hex[:24]}"
 
-# ============== API Endpoints ==============
+# ============== ROOT ENDPOINTS ==============
 
 @app.get("/")
 async def root():
-    logger.debug("Root endpoint accessed")
     return {
         "status": "healthy",
         "model": MODEL_ID,
-        "api_version": "2023-06-01",
-        "compatibility": "anthropic-messages-api",
-        "features": ["extended-thinking", "streaming", "tool-use"],
+        "endpoints": {
+            "openai": "/v1/chat/completions",
+            "anthropic": "/anthropic/v1/messages"
+        },
+        "base_urls": {
+            "openai_sdk": "https://likhonsheikh-anthropic-compatible-api.hf.space/v1",
+            "anthropic_sdk": "https://likhonsheikh-anthropic-compatible-api.hf.space/anthropic"
+        },
+        "features": ["extended-thinking", "streaming", "dual-compatibility"],
         "log_file": LOG_FILE
     }
 
+@app.get("/logs")
+async def get_logs(lines: int = 100):
+    try:
+        with open(LOG_FILE, 'r') as f:
+            all_lines = f.readlines()
+            recent_lines = all_lines[-lines:] if len(all_lines) > lines else all_lines
+            return {"log_file": LOG_FILE, "total_lines": len(all_lines), "returned_lines": len(recent_lines), "logs": "".join(recent_lines)}
+    except FileNotFoundError:
+        return {"error": "Log file not found", "log_file": LOG_FILE}
+
+@app.get("/health")
+async def health():
+    return {"status": "ok", "model_loaded": model is not None, "log_file": LOG_FILE, "features": ["openai-compatible", "anthropic-compatible", "extended-thinking"]}
+
+# ============================================================
+# OPENAI-COMPATIBLE ENDPOINTS (/v1)
+# ============================================================
+
 @app.get("/v1/models")
-async def list_models():
-    logger.debug("Models list requested")
+async def openai_list_models():
+    """List models (OpenAI format)"""
+    return OpenAIModelList(
+        data=[OpenAIModel(id="smollm2-135m", created=int(time.time()), owned_by="huggingface")]
+    )
+
+@app.post("/v1/chat/completions")
+async def openai_chat_completions(
+    request: OpenAIChatRequest,
+    authorization: Optional[str] = Header(None)
+):
+    """Chat completions (OpenAI format)"""
+    chat_id = generate_id("chatcmpl")
+    logger.info(f"[{chat_id}] OpenAI chat - model: {request.model}, max_tokens: {request.max_tokens}, stream: {request.stream}")
+
+    try:
+        prompt = format_openai_messages(request.messages)
+        inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
+        input_token_count = inputs.input_ids.shape[1]
+
+        if request.stream:
+            return await openai_stream_response(request, inputs, input_token_count, chat_id)
+
+        gen_kwargs = {
+            "max_new_tokens": request.max_tokens or 1024,
+            "do_sample": request.temperature > 0 if request.temperature else False,
+            "pad_token_id": tokenizer.eos_token_id,
+            "eos_token_id": tokenizer.eos_token_id,
+        }
+
+        if request.temperature and request.temperature > 0:
+            gen_kwargs["temperature"] = min(request.temperature, 1.0)
+        if request.top_p:
+            gen_kwargs["top_p"] = request.top_p
+
+        if request.stop:
+            stop_seqs = [request.stop] if isinstance(request.stop, str) else request.stop
+            stop_ids = []
+            for seq in stop_seqs:
+                tokens = tokenizer.encode(seq, add_special_tokens=False)
+                if tokens:
+                    stop_ids.extend(tokens)
+            if stop_ids:
+                gen_kwargs["eos_token_id"] = list(set([tokenizer.eos_token_id] + stop_ids))
+
+        gen_start = time.time()
+        with torch.no_grad():
+            outputs = model.generate(**inputs, **gen_kwargs)
+        gen_time = time.time() - gen_start
+
+        generated_tokens = outputs[0][input_token_count:]
+        generated_text = tokenizer.decode(generated_tokens, skip_special_tokens=True)
+        output_token_count = len(generated_tokens)
+
+        finish_reason = "stop"
+        if output_token_count >= (request.max_tokens or 1024):
+            finish_reason = "length"
+
+        logger.info(f"[{chat_id}] Generated {output_token_count} tokens in {gen_time:.2f}s")
+
+        return OpenAIChatResponse(
+            id=chat_id,
+            created=int(time.time()),
+            model=request.model,
+            choices=[OpenAIChoice(
+                index=0,
+                message={"role": "assistant", "content": generated_text.strip()},
+                finish_reason=finish_reason
+            )],
+            usage=OpenAIUsage(
+                prompt_tokens=input_token_count,
+                completion_tokens=output_token_count,
+                total_tokens=input_token_count + output_token_count
+            )
+        )
+
+    except Exception as e:
+        logger.error(f"[{chat_id}] Error: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+async def openai_stream_response(request: OpenAIChatRequest, inputs, input_token_count: int, chat_id: str):
+    """Stream response in OpenAI format"""
+
+    async def generate():
+        created = int(time.time())
+
+        # Initial chunk with role
+        initial_chunk = {
+            "id": chat_id,
+            "object": "chat.completion.chunk",
+            "created": created,
+            "model": request.model,
+            "choices": [{"index": 0, "delta": {"role": "assistant", "content": ""}, "finish_reason": None}]
+        }
+        yield f"data: {json.dumps(initial_chunk)}\n\n"
+
+        streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
+
+        gen_kwargs = {
+            **inputs,
+            "max_new_tokens": request.max_tokens or 1024,
+            "do_sample": request.temperature > 0 if request.temperature else False,
+            "pad_token_id": tokenizer.eos_token_id,
+            "eos_token_id": tokenizer.eos_token_id,
+            "streamer": streamer,
+        }
+
+        if request.temperature and request.temperature > 0:
+            gen_kwargs["temperature"] = min(request.temperature, 1.0)
+        if request.top_p:
+            gen_kwargs["top_p"] = request.top_p
+
+        thread = Thread(target=model.generate, kwargs=gen_kwargs)
+        thread.start()
+
+        output_tokens = 0
+        for text in streamer:
+            if text:
+                output_tokens += len(tokenizer.encode(text, add_special_tokens=False))
+                chunk = {
+                    "id": chat_id,
+                    "object": "chat.completion.chunk",
+                    "created": created,
+                    "model": request.model,
+                    "choices": [{"index": 0, "delta": {"content": text}, "finish_reason": None}]
+                }
+                yield f"data: {json.dumps(chunk)}\n\n"
+
+        thread.join()
+
+        # Final chunk
+        finish_reason = "length" if output_tokens >= (request.max_tokens or 1024) else "stop"
+        final_chunk = {
+            "id": chat_id,
+            "object": "chat.completion.chunk",
+            "created": created,
+            "model": request.model,
+            "choices": [{"index": 0, "delta": {}, "finish_reason": finish_reason}]
+        }
+        yield f"data: {json.dumps(final_chunk)}\n\n"
+        yield "data: [DONE]\n\n"
+
+    return StreamingResponse(generate(), media_type="text/event-stream", headers={"Cache-Control": "no-cache", "Connection": "keep-alive"})
+
+# ============================================================
+# ANTHROPIC-COMPATIBLE ENDPOINTS (/anthropic)
+# ============================================================
+
+@app.get("/anthropic/v1/models")
+async def anthropic_list_models():
+    """List models (Anthropic format)"""
     return {
         "object": "list",
         "data": [{
@@ -398,65 +634,34 @@ async def list_models():
         }]
     }
 
-@app.get("/logs")
-async def get_logs(lines: int = 100):
-    try:
-        with open(LOG_FILE, 'r') as f:
-            all_lines = f.readlines()
-            recent_lines = all_lines[-lines:] if len(all_lines) > lines else all_lines
-            return {
-                "log_file": LOG_FILE,
-                "total_lines": len(all_lines),
-                "returned_lines": len(recent_lines),
-                "logs": "".join(recent_lines)
-            }
-    except FileNotFoundError:
-        return {"error": "Log file not found", "log_file": LOG_FILE}
-
-@app.post("/v1/messages", response_model=MessageResponse)
-async def create_message(
-    request: MessageRequest,
+@app.post("/anthropic/v1/messages", response_model=AnthropicMessageResponse)
+async def anthropic_create_message(
+    request: AnthropicMessageRequest,
     x_api_key: Optional[str] = Header(None, alias="x-api-key"),
     anthropic_version: Optional[str] = Header(None, alias="anthropic-version"),
     anthropic_beta: Optional[str] = Header(None, alias="anthropic-beta")
 ):
-    """Create a message (Anthropic Messages API compatible with Extended Thinking)"""
-    message_id = generate_id()
+    """Create message (Anthropic format with Extended Thinking)"""
+    message_id = generate_id("msg")
 
-    # Check if thinking is enabled
     thinking_enabled = False
     budget_tokens = 1024
     if request.thinking:
         thinking_enabled = request.thinking.type == "enabled"
         budget_tokens = request.thinking.budget_tokens or 1024
 
-    logger.info(f"[{message_id}] Creating message - model: {request.model}, max_tokens: {request.max_tokens}, stream: {request.stream}, thinking: {thinking_enabled}")
-    logger.debug(f"[{message_id}] Request params - temp: {request.temperature}, top_p: {request.top_p}, top_k: {request.top_k}, thinking_budget: {budget_tokens}")
+    logger.info(f"[{message_id}] Anthropic msg - model: {request.model}, max_tokens: {request.max_tokens}, thinking: {thinking_enabled}")
 
     try:
-        # Format prompt with thinking if enabled
-        prompt = format_messages_with_thinking(
-            request.messages,
-            request.system,
-            thinking_enabled=thinking_enabled,
-            budget_tokens=budget_tokens
-        )
-        logger.debug(f"[{message_id}] Prompt length: {len(prompt)} chars")
-
+        prompt = format_anthropic_messages(request.messages, request.system, thinking_enabled, budget_tokens)
         inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
         input_token_count = inputs.input_ids.shape[1]
-        logger.info(f"[{message_id}] Input tokens: {input_token_count}")
 
         if request.stream:
-            logger.info(f"[{message_id}] Starting streaming response")
-            return await stream_response(request, inputs, input_token_count, message_id, thinking_enabled, budget_tokens)
+            return await anthropic_stream_response(request, inputs, input_token_count, message_id, thinking_enabled, budget_tokens)
 
-        # Calculate max tokens (include thinking budget if enabled)
-        total_max_tokens = request.max_tokens
-        if thinking_enabled:
-            total_max_tokens += budget_tokens
+        total_max_tokens = request.max_tokens + (budget_tokens if thinking_enabled else 0)
 
-        # Build generation kwargs
         gen_kwargs = {
             "max_new_tokens": total_max_tokens,
             "do_sample": request.temperature > 0 if request.temperature else False,
@@ -464,22 +669,13 @@ async def create_message(
             "eos_token_id": tokenizer.eos_token_id,
         }
 
-        if request.temperature is not None and request.temperature > 0:
+        if request.temperature and request.temperature > 0:
             gen_kwargs["temperature"] = request.temperature
-        if request.top_p is not None:
+        if request.top_p:
             gen_kwargs["top_p"] = request.top_p
-        if request.top_k is not None:
+        if request.top_k:
             gen_kwargs["top_k"] = request.top_k
 
-        if request.stop_sequences:
-            stop_token_ids = []
-            for seq in request.stop_sequences:
-                tokens = tokenizer.encode(seq, add_special_tokens=False)
-                if tokens:
-                    stop_token_ids.extend(tokens)
-            if stop_token_ids:
-                gen_kwargs["eos_token_id"] = list(set([tokenizer.eos_token_id] + stop_token_ids))
-
         gen_start = time.time()
         with torch.no_grad():
             outputs = model.generate(**inputs, **gen_kwargs)
@@ -489,90 +685,55 @@ async def create_message(
         generated_text = tokenizer.decode(generated_tokens, skip_special_tokens=True)
         output_token_count = len(generated_tokens)
 
-        # Parse thinking from response if enabled
         content_blocks = []
         if thinking_enabled:
             thinking_text, answer_text = parse_thinking_response(generated_text)
             if thinking_text:
-                logger.info(f"[{message_id}] Thinking extracted: {len(thinking_text)} chars")
-                content_blocks.append(ResponseThinkingBlock(type="thinking", thinking=thinking_text))
-            content_blocks.append(ResponseTextBlock(type="text", text=answer_text))
+                content_blocks.append(AnthropicResponseThinkingBlock(type="thinking", thinking=thinking_text))
+            content_blocks.append(AnthropicResponseTextBlock(type="text", text=answer_text))
         else:
-            content_blocks.append(ResponseTextBlock(type="text", text=generated_text.strip()))
+            content_blocks.append(AnthropicResponseTextBlock(type="text", text=generated_text.strip()))
 
-        # Determine stop reason
         stop_reason = "end_turn"
-        stop_sequence = None
         if output_token_count >= total_max_tokens:
             stop_reason = "max_tokens"
-        elif request.stop_sequences:
-            for seq in request.stop_sequences:
-                if seq in generated_text:
-                    stop_reason = "stop_sequence"
-                    stop_sequence = seq
-                    break
 
-        tokens_per_sec = output_token_count / gen_time if gen_time > 0 else 0
-        logger.info(f"[{message_id}] Generated {output_token_count} tokens in {gen_time:.2f}s ({tokens_per_sec:.1f} tok/s)")
+        logger.info(f"[{message_id}] Generated {output_token_count} tokens in {gen_time:.2f}s")
 
-        response = MessageResponse(
+        return AnthropicMessageResponse(
             id=message_id,
             content=content_blocks,
             model=request.model,
             stop_reason=stop_reason,
-            stop_sequence=stop_sequence,
-            usage=Usage(
-                input_tokens=input_token_count,
-                output_tokens=output_token_count
-            )
+            usage=AnthropicUsage(input_tokens=input_token_count, output_tokens=output_token_count)
         )
-        return response
 
     except Exception as e:
-        logger.error(f"[{message_id}] Error creating message: {e}", exc_info=True)
+        logger.error(f"[{message_id}] Error: {e}", exc_info=True)
         raise HTTPException(status_code=500, detail=str(e))
 
-async def stream_response(
-    request: MessageRequest,
-    inputs,
-    input_token_count: int,
-    message_id: str,
-    thinking_enabled: bool = False,
-    budget_tokens: int = 1024
-):
-    """Stream response using SSE (Server-Sent Events) - Anthropic format with thinking support"""
+async def anthropic_stream_response(request: AnthropicMessageRequest, inputs, input_token_count: int, message_id: str, thinking_enabled: bool, budget_tokens: int):
+    """Stream response in Anthropic format"""
 
     async def generate():
-        # message_start event
         start_event = {
             "type": "message_start",
             "message": {
-                "id": message_id,
-                "type": "message",
-                "role": "assistant",
-                "content": [],
-                "model": request.model,
-                "stop_reason": None,
-                "stop_sequence": None,
+                "id": message_id, "type": "message", "role": "assistant", "content": [],
+                "model": request.model, "stop_reason": None, "stop_sequence": None,
                 "usage": {"input_tokens": input_token_count, "output_tokens": 0}
             }
         }
         yield f"event: message_start\ndata: {json.dumps(start_event)}\n\n"
+        yield f"event: ping\ndata: {json.dumps({'type': 'ping'})}\n\n"
 
-        # If thinking is enabled, we'll track thinking vs text blocks
         block_index = 0
         in_thinking = False
         thinking_started = False
         text_block_started = False
 
-        # ping event
-        yield f"event: ping\ndata: {json.dumps({'type': 'ping'})}\n\n"
-
         streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
-
-        total_max_tokens = request.max_tokens
-        if thinking_enabled:
-            total_max_tokens += budget_tokens
+        total_max_tokens = request.max_tokens + (budget_tokens if thinking_enabled else 0)
 
         gen_kwargs = {
             **inputs,
@@ -583,14 +744,13 @@ async def stream_response(
             "streamer": streamer,
         }
 
-        if request.temperature is not None and request.temperature > 0:
+        if request.temperature and request.temperature > 0:
             gen_kwargs["temperature"] = request.temperature
-        if request.top_p is not None:
+        if request.top_p:
             gen_kwargs["top_p"] = request.top_p
-        if request.top_k is not None:
+        if request.top_k:
             gen_kwargs["top_k"] = request.top_k
 
-        gen_start = time.time()
         thread = Thread(target=model.generate, kwargs=gen_kwargs)
         thread.start()
 
@@ -603,125 +763,46 @@ async def stream_response(
                 accumulated_text += text
 
                 if thinking_enabled:
-                    # Check for thinking tags
                     if "<thinking>" in accumulated_text and not thinking_started:
-                        # Start thinking block
                         thinking_started = True
                         in_thinking = True
-                        block_start = {
-                            "type": "content_block_start",
-                            "index": block_index,
-                            "content_block": {"type": "thinking", "thinking": ""}
-                        }
-                        yield f"event: content_block_start\ndata: {json.dumps(block_start)}\n\n"
+                        yield f"event: content_block_start\ndata: {json.dumps({'type': 'content_block_start', 'index': block_index, 'content_block': {'type': 'thinking', 'thinking': ''}})}\n\n"
 
                     if in_thinking:
-                        # Stream thinking content
                         clean_text = text.replace("<thinking>", "").replace("</thinking>", "")
                         if clean_text:
-                            delta_event = {
-                                "type": "content_block_delta",
-                                "index": block_index,
-                                "delta": {"type": "thinking_delta", "thinking": clean_text}
-                            }
-                            yield f"event: content_block_delta\ndata: {json.dumps(delta_event)}\n\n"
-
+                            yield f"event: content_block_delta\ndata: {json.dumps({'type': 'content_block_delta', 'index': block_index, 'delta': {'type': 'thinking_delta', 'thinking': clean_text}})}\n\n"
                         if "</thinking>" in accumulated_text:
-                            # End thinking block
                             in_thinking = False
                             yield f"event: content_block_stop\ndata: {json.dumps({'type': 'content_block_stop', 'index': block_index})}\n\n"
                             block_index += 1
-
-                            # Start text block
                             text_block_started = True
-                            block_start = {
-                                "type": "content_block_start",
-                                "index": block_index,
-                                "content_block": {"type": "text", "text": ""}
-                            }
-                            yield f"event: content_block_start\ndata: {json.dumps(block_start)}\n\n"
-
+                            yield f"event: content_block_start\ndata: {json.dumps({'type': 'content_block_start', 'index': block_index, 'content_block': {'type': 'text', 'text': ''}})}\n\n"
                     elif text_block_started:
-                        # Stream text content
-                        delta_event = {
-                            "type": "content_block_delta",
-                            "index": block_index,
-                            "delta": {"type": "text_delta", "text": text}
-                        }
-                        yield f"event: content_block_delta\ndata: {json.dumps(delta_event)}\n\n"
-
+                        yield f"event: content_block_delta\ndata: {json.dumps({'type': 'content_block_delta', 'index': block_index, 'delta': {'type': 'text_delta', 'text': text}})}\n\n"
                 else:
-                    # No thinking - just stream text
                     if not text_block_started:
                         text_block_started = True
-                        block_start = {
-                            "type": "content_block_start",
-                            "index": 0,
-                            "content_block": {"type": "text", "text": ""}
-                        }
-                        yield f"event: content_block_start\ndata: {json.dumps(block_start)}\n\n"
-
-                    delta_event = {
-                        "type": "content_block_delta",
-                        "index": 0,
-                        "delta": {"type": "text_delta", "text": text}
-                    }
-                    yield f"event: content_block_delta\ndata: {json.dumps(delta_event)}\n\n"
+                        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: content_block_delta\ndata: {json.dumps({'type': 'content_block_delta', 'index': 0, 'delta': {'type': 'text_delta', 'text': text}})}\n\n"
 
         thread.join()
-        gen_time = time.time() - gen_start
-        tokens_per_sec = output_tokens / gen_time if gen_time > 0 else 0
-        logger.info(f"[{message_id}] Stream completed: {output_tokens} tokens in {gen_time:.2f}s ({tokens_per_sec:.1f} tok/s)")
 
-        # content_block_stop for final block
         yield f"event: content_block_stop\ndata: {json.dumps({'type': 'content_block_stop', 'index': block_index})}\n\n"
 
-        # message_delta event
         stop_reason = "max_tokens" if output_tokens >= total_max_tokens else "end_turn"
-        delta = {
-            "type": "message_delta",
-            "delta": {"stop_reason": stop_reason, "stop_sequence": None},
-            "usage": {"output_tokens": output_tokens}
-        }
-        yield f"event: message_delta\ndata: {json.dumps(delta)}\n\n"
-
-        # message_stop event
+        yield f"event: message_delta\ndata: {json.dumps({'type': 'message_delta', 'delta': {'stop_reason': stop_reason}, 'usage': {'output_tokens': output_tokens}})}\n\n"
         yield f"event: message_stop\ndata: {json.dumps({'type': 'message_stop'})}\n\n"
 
-    return StreamingResponse(
-        generate(),
-        media_type="text/event-stream",
-        headers={
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive",
-            "X-Accel-Buffering": "no"
-        }
-    )
+    return StreamingResponse(generate(), media_type="text/event-stream", headers={"Cache-Control": "no-cache", "Connection": "keep-alive", "X-Accel-Buffering": "no"})
 
-@app.post("/v1/messages/count_tokens", response_model=TokenCountResponse)
-async def count_tokens(request: TokenCountRequest):
-    """Count tokens for a message request (Anthropic compatible)"""
+@app.post("/anthropic/v1/messages/count_tokens", response_model=AnthropicTokenCountResponse)
+async def anthropic_count_tokens(request: AnthropicTokenCountRequest):
     thinking_enabled = request.thinking and request.thinking.type == "enabled"
     budget_tokens = request.thinking.budget_tokens if request.thinking else 1024
-
-    prompt = format_messages_with_thinking(
-        request.messages,
-        request.system,
-        thinking_enabled=thinking_enabled,
-        budget_tokens=budget_tokens
-    )
+    prompt = format_anthropic_messages(request.messages, request.system, thinking_enabled, budget_tokens)
     tokens = tokenizer.encode(prompt)
-    logger.debug(f"Token count request: {len(tokens)} tokens (thinking: {thinking_enabled})")
-    return TokenCountResponse(input_tokens=len(tokens))
-
-@app.get("/health")
-async def health():
-    return {
-        "status": "ok",
-        "model_loaded": model is not None,
-        "log_file": LOG_FILE,
-        "features": ["extended-thinking", "streaming"]
-    }
+    return AnthropicTokenCountResponse(input_tokens=len(tokens))
 
 if __name__ == "__main__":
     import uvicorn