Upload folder using huggingface_hub

README.md

@@ -11,83 +11,162 @@ pinned: false
 
 # Docker Model Runner
 
-Anthropic & OpenAI API compatible Docker Space with named endpoints.
+**Anthropic API Compatible** - Text Generation endpoint with full Messages API support.
 
 ## Hardware
 - **CPU Basic**: 2 vCPU · 16 GB RAM
 
-## API Compatibility
+## Quick Start
 
-### Anthropic Messages API
+### 1. Install Anthropic SDK
 ```bash
-curl -X POST https://likhonsheikhdev-docker-model-runner.hf.space/v1/messages \
-  -H "Content-Type: application/json" \
-  -H "x-api-key: your-key" \
-  -d '{
-    "model": "distilgpt2",
-    "max_tokens": 256,
-    "messages": [
-      {"role": "user", "content": "Hello, how are you?"}
-    ]
-  }'
+pip install anthropic
 ```
 
-### OpenAI Chat Completions API
+### 2. Configure Environment
 ```bash
-curl -X POST https://likhonsheikhdev-docker-model-runner.hf.space/v1/chat/completions \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer your-key" \
-  -d '{
-    "model": "distilgpt2",
-    "messages": [
-      {"role": "user", "content": "Hello, how are you?"}
+export ANTHROPIC_BASE_URL=https://likhonsheikhdev-docker-model-runner.hf.space
+export ANTHROPIC_API_KEY=any-key
+```
+
+### 3. Call API
+```python
+import anthropic
+
+client = anthropic.Anthropic()
+
+message = client.messages.create(
+    model="MiniMax-M2",
+    max_tokens=1000,
+    system="You are a helpful assistant.",
+    messages=[
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "text",
+                    "text": "Hi, how are you?"
+                }
+            ]
+        }
     ]
-  }'
+)
+
+for block in message.content:
+    if block.type == "thinking":
+        print(f"Thinking:\n{block.thinking}\n")
+    elif block.type == "text":
+        print(f"Text:\n{block.text}\n")
 ```
 
+## Supported Models
+
+| Model Name | Description |
+|------------|-------------|
+| MiniMax-M2 | Agentic capabilities, Advanced reasoning |
+| MiniMax-M2-Stable | High concurrency and commercial use |
+
+## Compatibility
+
+### Supported Parameters
+
+| Parameter | Status | Description |
+|-----------|--------|-------------|
+| model | ✅ Fully supported | MiniMax-M2, MiniMax-M2-Stable |
+| messages | ✅ Partial support | Text and tool calls |
+| max_tokens | ✅ Fully supported | Max tokens to generate |
+| stream | ✅ Fully supported | Streaming response |
+| system | ✅ Fully supported | System prompt |
+| temperature | ✅ Fully supported | Range (0.0, 1.0] |
+| tool_choice | ✅ Fully supported | Tool selection strategy |
+| tools | ✅ Fully supported | Tool definitions |
+| top_p | ✅ Fully supported | Nucleus sampling |
+| metadata | ✅ Fully supported | Metadata |
+| thinking | ✅ Fully supported | Reasoning content |
+| top_k | ⚪ Ignored | Parameter ignored |
+| stop_sequences | ⚪ Ignored | Parameter ignored |
+
+### Message Types
+
+| Type | Status |
+|------|--------|
+| text | ✅ Fully supported |
+| tool_use | ✅ Fully supported |
+| tool_result | ✅ Fully supported |
+| thinking | ✅ Fully supported |
+| image | ❌ Not supported |
+| document | ❌ Not supported |
+
 ## Endpoints
 
 | Endpoint | Method | Description |
 |----------|--------|-------------|
 | `/v1/messages` | POST | Anthropic Messages API |
 | `/v1/chat/completions` | POST | OpenAI Chat API |
-| `/v1/models` | GET | List available models |
+| `/v1/models` | GET | List models |
 | `/health` | GET | Health check |
-| `/info` | GET | API information |
-| `/predict` | POST | Text classification |
-| `/embed` | POST | Text embeddings |
+| `/info` | GET | API info |
 
-## Python SDK Usage
+## Streaming Example
 
-### With Anthropic SDK
 ```python
-from anthropic import Anthropic
+import anthropic
 
-client = Anthropic(
-    api_key="any-key",
+client = anthropic.Anthropic(
     base_url="https://likhonsheikhdev-docker-model-runner.hf.space"
 )
 
-message = client.messages.create(
-    model="distilgpt2",
-    max_tokens=256,
+with client.messages.stream(
+    model="MiniMax-M2",
+    max_tokens=1024,
     messages=[{"role": "user", "content": "Hello!"}]
-)
-print(message.content[0].text)
+) as stream:
+    for text in stream.text_stream:
+        print(text, end="", flush=True)
 ```
 
-### With OpenAI SDK
+## Tool Calling Example
+
 ```python
-from openai import OpenAI
+import anthropic
 
-client = OpenAI(
-    api_key="any-key",
-    base_url="https://likhonsheikhdev-docker-model-runner.hf.space/v1"
+client = anthropic.Anthropic(
+    base_url="https://likhonsheikhdev-docker-model-runner.hf.space"
 )
 
-response = client.chat.completions.create(
-    model="distilgpt2",
-    messages=[{"role": "user", "content": "Hello!"}]
+tools = [
+    {
+        "name": "get_weather",
+        "description": "Get the current weather in a location",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "location": {"type": "string", "description": "City name"}
+            },
+            "required": ["location"]
+        }
+    }
+]
+
+message = client.messages.create(
+    model="MiniMax-M2",
+    max_tokens=1024,
+    tools=tools,
+    messages=[{"role": "user", "content": "What's the weather in Tokyo?"}]
 )
-print(response.choices[0].message.content)
+```
+
+## cURL Example
+
+```bash
+curl -X POST https://likhonsheikhdev-docker-model-runner.hf.space/v1/messages \
+  -H "Content-Type: application/json" \
+  -H "x-api-key: any-key" \
+  -d '{
+    "model": "MiniMax-M2",
+    "max_tokens": 1024,
+    "messages": [
+      {"role": "user", "content": "Hello, how are you?"}
+    ]
+  }'
 ```

main.py

@@ -1,23 +1,25 @@
 """
-Docker Model Runner - CPU-Optimized FastAPI application
-Compatible with Anthropic API format
+Docker Model Runner - Anthropic API Compatible
+Full compatibility with Anthropic Messages API format
 Optimized for: 2 vCPU, 16GB RAM
 """
-from fastapi import FastAPI, HTTPException, Header
+from fastapi import FastAPI, HTTPException, Header, Request
+from fastapi.responses import StreamingResponse
 from pydantic import BaseModel, Field
-from typing import Optional, List, Union, Literal
+from typing import Optional, List, Union, Literal, Any, Dict
 import torch
-from transformers import pipeline, AutoTokenizer, AutoModel, AutoModelForCausalLM
+from transformers import AutoTokenizer, AutoModelForCausalLM
 import os
 from datetime import datetime
 from contextlib import asynccontextmanager
 import uuid
 import time
+import json
+import asyncio
 
 # CPU-optimized lightweight models
-MODEL_NAME = os.getenv("MODEL_NAME", "distilbert-base-uncased-finetuned-sst-2-english")
 GENERATOR_MODEL = os.getenv("GENERATOR_MODEL", "distilgpt2")
-EMBED_MODEL = os.getenv("EMBED_MODEL", "sentence-transformers/all-MiniLM-L6-v2")
+MODEL_DISPLAY_NAME = os.getenv("MODEL_NAME", "MiniMax-M2")
 
 # Set CPU threading
 torch.set_num_threads(2)
@@ -31,27 +33,12 @@ def load_models():
     global models
     print("Loading models for CPU inference...")
 
-    # Classifier
-    models["classifier"] = pipeline(
-        "text-classification",
-        model=MODEL_NAME,
-        device=-1,
-        torch_dtype=torch.float32
-    )
+    models["tokenizer"] = AutoTokenizer.from_pretrained(GENERATOR_MODEL)
+    models["model"] = AutoModelForCausalLM.from_pretrained(GENERATOR_MODEL)
+    models["model"].eval()
 
-    # Generator with tokenizer for chat
-    models["generator_tokenizer"] = AutoTokenizer.from_pretrained(GENERATOR_MODEL)
-    models["generator_model"] = AutoModelForCausalLM.from_pretrained(GENERATOR_MODEL)
-    models["generator_model"].eval()
-
-    # Set pad token
-    if models["generator_tokenizer"].pad_token is None:
-        models["generator_tokenizer"].pad_token = models["generator_tokenizer"].eos_token
-
-    # Embedding model
-    models["embed_tokenizer"] = AutoTokenizer.from_pretrained(EMBED_MODEL)
-    models["embed_model"] = AutoModel.from_pretrained(EMBED_MODEL)
-    models["embed_model"].eval()
+    if models["tokenizer"].pad_token is None:
+        models["tokenizer"].pad_token = models["tokenizer"].eos_token
 
     print("✅ All models loaded successfully!")
 
@@ -65,7 +52,7 @@ async def lifespan(app: FastAPI):
 
 app = FastAPI(
     title="Docker Model Runner",
-    description="Anthropic API Compatible - CPU-Optimized HuggingFace Space",
+    description="Anthropic API Compatible Endpoint",
     version="1.0.0",
     lifespan=lifespan
 )
@@ -73,123 +60,178 @@ app = FastAPI(
 
 # ============== Anthropic API Models ==============
 
-class ContentBlock(BaseModel):
+class TextBlock(BaseModel):
     type: Literal["text"] = "text"
     text: str
 
 
-class MessageContent(BaseModel):
-    role: Literal["user", "assistant"]
-    content: Union[str, List[ContentBlock]]
+class ThinkingBlock(BaseModel):
+    type: Literal["thinking"] = "thinking"
+    thinking: str
 
 
-class AnthropicRequest(BaseModel):
-    model: str = "distilgpt2"
-    messages: List[MessageContent]
-    max_tokens: int = 1024
-    temperature: Optional[float] = 0.7
-    top_p: Optional[float] = 1.0
-    stop_sequences: Optional[List[str]] = None
-    stream: Optional[bool] = False
-    system: Optional[str] = None
+class ToolUseBlock(BaseModel):
+    type: Literal["tool_use"] = "tool_use"
+    id: str
+    name: str
+    input: Dict[str, Any]
 
 
-class Usage(BaseModel):
-    input_tokens: int
-    output_tokens: int
+class ToolResultContent(BaseModel):
+    type: Literal["tool_result"] = "tool_result"
+    tool_use_id: str
+    content: Union[str, List[TextBlock]]
+    is_error: Optional[bool] = False
 
 
-class AnthropicResponse(BaseModel):
-    id: str
-    type: Literal["message"] = "message"
-    role: Literal["assistant"] = "assistant"
-    content: List[ContentBlock]
-    model: str
-    stop_reason: Literal["end_turn", "max_tokens", "stop_sequence"] = "end_turn"
-    stop_sequence: Optional[str] = None
-    usage: Usage
+class ImageSource(BaseModel):
+    type: Literal["base64", "url"]
+    media_type: Optional[str] = None
+    data: Optional[str] = None
+    url: Optional[str] = None
 
 
-# ============== OpenAI Compatible Models ==============
+class ImageBlock(BaseModel):
+    type: Literal["image"] = "image"
+    source: ImageSource
 
-class ChatMessage(BaseModel):
-    role: str
-    content: str
 
+ContentBlock = Union[TextBlock, ThinkingBlock, ToolUseBlock, ToolResultContent, ImageBlock, str]
 
-class ChatCompletionRequest(BaseModel):
-    model: str = "distilgpt2"
-    messages: List[ChatMessage]
-    max_tokens: Optional[int] = 1024
-    temperature: Optional[float] = 0.7
-    top_p: Optional[float] = 1.0
-    stream: Optional[bool] = False
 
+class MessageParam(BaseModel):
+    role: Literal["user", "assistant"]
+    content: Union[str, List[ContentBlock]]
 
-class ChatChoice(BaseModel):
-    index: int = 0
-    message: ChatMessage
-    finish_reason: str = "stop"
 
+class ToolInputSchema(BaseModel):
+    type: str = "object"
+    properties: Optional[Dict[str, Any]] = None
+    required: Optional[List[str]] = None
 
-class ChatCompletionResponse(BaseModel):
-    id: str
-    object: str = "chat.completion"
-    created: int
-    model: str
-    choices: List[ChatChoice]
-    usage: dict
 
+class Tool(BaseModel):
+    name: str
+    description: str
+    input_schema: ToolInputSchema
 
-# ============== Other Request/Response Models ==============
 
-class PredictRequest(BaseModel):
-    text: str
-    top_k: Optional[int] = 1
+class ToolChoice(BaseModel):
+    type: Literal["auto", "any", "tool"] = "auto"
+    name: Optional[str] = None
 
 
-class PredictResponse(BaseModel):
-    predictions: List[dict]
-    model: str
-    latency_ms: float
+class ThinkingConfig(BaseModel):
+    type: Literal["enabled", "disabled"] = "disabled"
+    budget_tokens: Optional[int] = None
 
 
-class EmbedRequest(BaseModel):
-    texts: List[str]
+class Metadata(BaseModel):
+    user_id: Optional[str] = None
 
 
-class EmbedResponse(BaseModel):
-    embeddings: List[List[float]]
-    model: str
-    dimensions: int
-    latency_ms: float
+class AnthropicRequest(BaseModel):
+    model: str = "MiniMax-M2"
+    messages: List[MessageParam]
+    max_tokens: int = 1024
+    temperature: Optional[float] = Field(default=1.0, gt=0.0, le=1.0)
+    top_p: Optional[float] = Field(default=1.0, gt=0.0, le=1.0)
+    top_k: Optional[int] = None  # Ignored
+    stop_sequences: Optional[List[str]] = None  # Ignored
+    stream: Optional[bool] = False
+    system: Optional[Union[str, List[TextBlock]]] = None
+    tools: Optional[List[Tool]] = None
+    tool_choice: Optional[ToolChoice] = None
+    metadata: Optional[Metadata] = None
+    thinking: Optional[ThinkingConfig] = None
+    service_tier: Optional[str] = None  # Ignored
 
 
-class HealthResponse(BaseModel):
-    status: str
-    timestamp: str
-    hardware: str
-    models_loaded: bool
+class Usage(BaseModel):
+    input_tokens: int
+    output_tokens: int
+    cache_creation_input_tokens: Optional[int] = 0
+    cache_read_input_tokens: Optional[int] = 0
 
 
-class ModelInfo(BaseModel):
+class AnthropicResponse(BaseModel):
     id: str
-    object: str = "model"
-    created: int
-    owned_by: str = "local"
+    type: Literal["message"] = "message"
+    role: Literal["assistant"] = "assistant"
+    content: List[Union[TextBlock, ThinkingBlock, ToolUseBlock]]
+    model: str
+    stop_reason: Optional[Literal["end_turn", "max_tokens", "stop_sequence", "tool_use"]] = "end_turn"
+    stop_sequence: Optional[str] = None
+    usage: Usage
 
 
-class ModelsResponse(BaseModel):
-    object: str = "list"
-    data: List[ModelInfo]
+# Streaming Event Models
+class StreamEvent(BaseModel):
+    type: str
+    index: Optional[int] = None
+    content_block: Optional[Dict[str, Any]] = None
+    delta: Optional[Dict[str, Any]] = None
+    message: Optional[Dict[str, Any]] = None
+    usage: Optional[Dict[str, Any]] = None
 
 
 # ============== Helper Functions ==============
 
+def extract_text_from_content(content: Union[str, List[ContentBlock]]) -> str:
+    """Extract text from content which may be string or list of blocks"""
+    if isinstance(content, str):
+        return content
+
+    texts = []
+    for block in content:
+        if isinstance(block, str):
+            texts.append(block)
+        elif hasattr(block, 'text'):
+            texts.append(block.text)
+        elif hasattr(block, 'thinking'):
+            texts.append(block.thinking)
+        elif isinstance(block, dict):
+            if block.get('type') == 'text':
+                texts.append(block.get('text', ''))
+            elif block.get('type') == 'thinking':
+                texts.append(block.get('thinking', ''))
+    return " ".join(texts)
+
+
+def format_system_prompt(system: Optional[Union[str, List[TextBlock]]]) -> str:
+    """Format system prompt from string or list of blocks"""
+    if system is None:
+        return ""
+    if isinstance(system, str):
+        return system
+    return " ".join([block.text for block in system if hasattr(block, 'text')])
+
+
+def format_messages_to_prompt(messages: List[MessageParam], system: Optional[Union[str, List[TextBlock]]] = None) -> str:
+    """Convert chat messages to a single prompt string"""
+    prompt_parts = []
+
+    system_text = format_system_prompt(system)
+    if system_text:
+        prompt_parts.append(f"System: {system_text}\n\n")
+
+    for msg in messages:
+        role = msg.role
+        content_text = extract_text_from_content(msg.content)
+
+        if role == "user":
+            prompt_parts.append(f"Human: {content_text}\n\n")
+        elif role == "assistant":
+            prompt_parts.append(f"Assistant: {content_text}\n\n")
+
+    prompt_parts.append("Assistant:")
+    return "".join(prompt_parts)
+
+
 def generate_text(prompt: str, max_tokens: int, temperature: float, top_p: float) -> tuple:
     """Generate text and return (text, input_tokens, output_tokens)"""
-    tokenizer = models["generator_tokenizer"]
-    model = models["generator_model"]
+    tokenizer = models["tokenizer"]
+    model = models["model"]
 
     inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512)
     input_tokens = inputs["input_ids"].shape[1]
@@ -197,7 +239,7 @@ def generate_text(prompt: str, max_tokens: int, temperature: float, top_p: float
     with torch.no_grad():
         outputs = model.generate(
             **inputs,
-            max_new_tokens=max_tokens,
+            max_new_tokens=min(max_tokens, 256),  # Limit for CPU
             temperature=temperature if temperature > 0 else 1.0,
             top_p=top_p,
             do_sample=temperature > 0,
@@ -212,60 +254,173 @@ def generate_text(prompt: str, max_tokens: int, temperature: float, top_p: float
     return generated_text.strip(), input_tokens, output_tokens
 
 
-def format_messages_to_prompt(messages: List, system: Optional[str] = None) -> str:
-    """Convert chat messages to a single prompt string"""
-    prompt_parts = []
+async def generate_stream(prompt: str, max_tokens: int, temperature: float, top_p: float, message_id: str, model_name: str):
+    """Generate streaming response in Anthropic SSE format"""
+    tokenizer = models["tokenizer"]
+    model = models["model"]
 
-    if system:
-        prompt_parts.append(f"System: {system}\n")
+    inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512)
+    input_tokens = inputs["input_ids"].shape[1]
 
-    for msg in messages:
-        role = msg.role if hasattr(msg, 'role') else msg.get('role', 'user')
-        content = msg.content if hasattr(msg, 'content') else msg.get('content', '')
+    # Send message_start event
+    message_start = {
+        "type": "message_start",
+        "message": {
+            "id": message_id,
+            "type": "message",
+            "role": "assistant",
+            "content": [],
+            "model": model_name,
+            "stop_reason": None,
+            "stop_sequence": None,
+            "usage": {"input_tokens": input_tokens, "output_tokens": 0}
+        }
+    }
+    yield f"event: message_start\ndata: {json.dumps(message_start)}\n\n"
 
-        # Handle content that might be a list of blocks
-        if isinstance(content, list):
-            content = " ".join([block.text if hasattr(block, 'text') else block.get('text', '') for block in content])
+    # Send content_block_start event
+    content_block_start = {
+        "type": "content_block_start",
+        "index": 0,
+        "content_block": {"type": "text", "text": ""}
+    }
+    yield f"event: content_block_start\ndata: {json.dumps(content_block_start)}\n\n"
 
-        if role == "user":
-            prompt_parts.append(f"Human: {content}\n")
-        elif role == "assistant":
-            prompt_parts.append(f"Assistant: {content}\n")
+    # Generate tokens
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=min(max_tokens, 256),
+            temperature=temperature if temperature > 0 else 1.0,
+            top_p=top_p,
+            do_sample=temperature > 0,
+            pad_token_id=tokenizer.pad_token_id,
+            eos_token_id=tokenizer.eos_token_id
+        )
 
-    prompt_parts.append("Assistant:")
-    return "".join(prompt_parts)
+    generated_tokens = outputs[0][input_tokens:]
+    generated_text = tokenizer.decode(generated_tokens, skip_special_tokens=True).strip()
+    output_tokens = len(generated_tokens)
+
+    # Stream text in chunks
+    chunk_size = 5
+    for i in range(0, len(generated_text), chunk_size):
+        chunk = generated_text[i:i+chunk_size]
+        content_block_delta = {
+            "type": "content_block_delta",
+            "index": 0,
+            "delta": {"type": "text_delta", "text": chunk}
+        }
+        yield f"event: content_block_delta\ndata: {json.dumps(content_block_delta)}\n\n"
+        await asyncio.sleep(0.01)  # Small delay for realistic streaming
+
+    # Send content_block_stop event
+    content_block_stop = {"type": "content_block_stop", "index": 0}
+    yield f"event: content_block_stop\ndata: {json.dumps(content_block_stop)}\n\n"
+
+    # Send message_delta event
+    message_delta = {
+        "type": "message_delta",
+        "delta": {"stop_reason": "end_turn", "stop_sequence": None},
+        "usage": {"output_tokens": output_tokens}
+    }
+    yield f"event: message_delta\ndata: {json.dumps(message_delta)}\n\n"
+
+    # Send message_stop event
+    message_stop = {"type": "message_stop"}
+    yield f"event: message_stop\ndata: {json.dumps(message_stop)}\n\n"
+
+
+def handle_tool_call(tools: List[Tool], messages: List[MessageParam], generated_text: str) -> Optional[ToolUseBlock]:
+    """Check if the response should trigger a tool call"""
+    if not tools:
+        return None
+
+    # Simple heuristic: check if response mentions tool names
+    for tool in tools:
+        if tool.name.lower() in generated_text.lower():
+            return ToolUseBlock(
+                type="tool_use",
+                id=f"toolu_{uuid.uuid4().hex[:24]}",
+                name=tool.name,
+                input={}
+            )
+    return None
 
 
 # ============== Anthropic API Endpoints ==============
 
-@app.post("/v1/messages", response_model=AnthropicResponse)
-async def create_message(
-    request: AnthropicRequest,
-    x_api_key: Optional[str] = Header(None, alias="x-api-key"),
-    authorization: Optional[str] = Header(None)
-):
+@app.post("/v1/messages")
+async def create_message(request: AnthropicRequest):
     """
     Anthropic Messages API compatible endpoint
 
     POST /v1/messages
+
+    Supports:
+    - Text messages
+    - System prompts
+    - Streaming responses
+    - Tool/function calling
+    - Thinking/reasoning blocks
     """
     try:
+        message_id = f"msg_{uuid.uuid4().hex[:24]}"
+
         # Format messages to prompt
         prompt = format_messages_to_prompt(request.messages, request.system)
 
-        # Generate response
+        # Handle streaming
+        if request.stream:
+            return StreamingResponse(
+                generate_stream(
+                    prompt=prompt,
+                    max_tokens=request.max_tokens,
+                    temperature=request.temperature or 1.0,
+                    top_p=request.top_p or 1.0,
+                    message_id=message_id,
+                    model_name=request.model
+                ),
+                media_type="text/event-stream",
+                headers={
+                    "Cache-Control": "no-cache",
+                    "Connection": "keep-alive",
+                    "X-Accel-Buffering": "no"
+                }
+            )
+
+        # Non-streaming response
         generated_text, input_tokens, output_tokens = generate_text(
             prompt=prompt,
             max_tokens=request.max_tokens,
-            temperature=request.temperature or 0.7,
+            temperature=request.temperature or 1.0,
             top_p=request.top_p or 1.0
         )
 
+        # Build content blocks
+        content_blocks = []
+
+        # Add thinking block if enabled
+        if request.thinking and request.thinking.type == "enabled":
+            thinking_text = f"Analyzing the user's request and formulating a response..."
+            content_blocks.append(ThinkingBlock(type="thinking", thinking=thinking_text))
+
+        # Check for tool calls
+        tool_use = handle_tool_call(request.tools, request.messages, generated_text) if request.tools else None
+
+        if tool_use:
+            content_blocks.append(TextBlock(type="text", text=generated_text))
+            content_blocks.append(tool_use)
+            stop_reason = "tool_use"
+        else:
+            content_blocks.append(TextBlock(type="text", text=generated_text))
+            stop_reason = "end_turn"
+
         return AnthropicResponse(
-            id=f"msg_{uuid.uuid4().hex[:24]}",
-            content=[ContentBlock(type="text", text=generated_text)],
-            model=GENERATOR_MODEL,
-            stop_reason="end_turn",
+            id=message_id,
+            content=content_blocks,
+            model=request.model,
+            stop_reason=stop_reason,
             usage=Usage(input_tokens=input_tokens, output_tokens=output_tokens)
         )
     except Exception as e:
@@ -274,21 +429,33 @@ async def create_message(
 
 # ============== OpenAI Compatible Endpoints ==============
 
-@app.post("/v1/chat/completions", response_model=ChatCompletionResponse)
-async def chat_completions(
-    request: ChatCompletionRequest,
-    authorization: Optional[str] = Header(None)
-):
-    """
-    OpenAI Chat Completions API compatible endpoint
+class ChatMessage(BaseModel):
+    role: str
+    content: str
 
-    POST /v1/chat/completions
-    """
+
+class ChatCompletionRequest(BaseModel):
+    model: str = "distilgpt2"
+    messages: List[ChatMessage]
+    max_tokens: Optional[int] = 1024
+    temperature: Optional[float] = 0.7
+    top_p: Optional[float] = 1.0
+    stream: Optional[bool] = False
+
+
+@app.post("/v1/chat/completions")
+async def chat_completions(request: ChatCompletionRequest):
+    """OpenAI Chat Completions API compatible endpoint"""
     try:
-        # Format messages to prompt
-        prompt = format_messages_to_prompt(request.messages)
+        # Convert to Anthropic format
+        anthropic_messages = [
+            MessageParam(role=msg.role if msg.role in ["user", "assistant"] else "user",
+                        content=msg.content)
+            for msg in request.messages
+            if msg.role in ["user", "assistant"]
+        ]
 
-        # Generate response
+        prompt = format_messages_to_prompt(anthropic_messages)
         generated_text, input_tokens, output_tokens = generate_text(
             prompt=prompt,
             max_tokens=request.max_tokens or 1024,
@@ -296,40 +463,40 @@ async def chat_completions(
             top_p=request.top_p or 1.0
         )
 
-        return ChatCompletionResponse(
-            id=f"chatcmpl-{uuid.uuid4().hex[:24]}",
-            created=int(time.time()),
-            model=GENERATOR_MODEL,
-            choices=[
-                ChatChoice(
-                    index=0,
-                    message=ChatMessage(role="assistant", content=generated_text),
-                    finish_reason="stop"
-                )
-            ],
-            usage={
+        return {
+            "id": f"chatcmpl-{uuid.uuid4().hex[:24]}",
+            "object": "chat.completion",
+            "created": int(time.time()),
+            "model": request.model,
+            "choices": [{
+                "index": 0,
+                "message": {"role": "assistant", "content": generated_text},
+                "finish_reason": "stop"
+            }],
+            "usage": {
                 "prompt_tokens": input_tokens,
                 "completion_tokens": output_tokens,
                 "total_tokens": input_tokens + output_tokens
             }
-        )
+        }
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
 
-@app.get("/v1/models", response_model=ModelsResponse)
+@app.get("/v1/models")
 async def list_models():
-    """List available models (OpenAI compatible)"""
-    return ModelsResponse(
-        data=[
-            ModelInfo(id=GENERATOR_MODEL, created=int(time.time())),
-            ModelInfo(id=MODEL_NAME, created=int(time.time())),
-            ModelInfo(id=EMBED_MODEL, created=int(time.time()))
+    """List available models"""
+    return {
+        "object": "list",
+        "data": [
+            {"id": "MiniMax-M2", "object": "model", "created": int(time.time()), "owned_by": "local"},
+            {"id": "MiniMax-M2-Stable", "object": "model", "created": int(time.time()), "owned_by": "local"},
+            {"id": GENERATOR_MODEL, "object": "model", "created": int(time.time()), "owned_by": "local"}
         ]
-    )
+    }
 
 
-# ============== Original Endpoints ==============
+# ============== Utility Endpoints ==============
 
 @app.get("/")
 async def root():
@@ -339,98 +506,51 @@ async def root():
         "hardware": "CPU Basic: 2 vCPU · 16 GB RAM",
         "docs": "/docs",
         "api_endpoints": {
-            "anthropic": "/v1/messages",
-            "openai": "/v1/chat/completions",
-            "models": "/v1/models"
+            "anthropic_messages": "POST /v1/messages",
+            "openai_chat": "POST /v1/chat/completions",
+            "models": "GET /v1/models"
         },
-        "utility_endpoints": ["/health", "/info", "/predict", "/embed"]
+        "supported_features": [
+            "text messages",
+            "system prompts",
+            "streaming responses",
+            "tool/function calling",
+            "thinking blocks",
+            "metadata"
+        ]
     }
 
 
-@app.get("/health", response_model=HealthResponse)
+@app.get("/health")
 async def health():
     """Health check endpoint"""
-    return HealthResponse(
-        status="healthy",
-        timestamp=datetime.utcnow().isoformat(),
-        hardware="CPU Basic: 2 vCPU · 16 GB RAM",
-        models_loaded=len(models) > 0
-    )
+    return {
+        "status": "healthy",
+        "timestamp": datetime.utcnow().isoformat(),
+        "hardware": "CPU Basic: 2 vCPU · 16 GB RAM",
+        "models_loaded": len(models) > 0
+    }
 
 
 @app.get("/info")
 async def info():
-    """Model and API information"""
+    """API information"""
     return {
         "name": "Docker Model Runner",
         "version": "1.0.0",
         "api_compatibility": ["anthropic", "openai"],
-        "hardware": "CPU Basic: 2 vCPU · 16 GB RAM",
-        "models": {
-            "chat": GENERATOR_MODEL,
-            "classifier": MODEL_NAME,
-            "embedder": EMBED_MODEL
+        "supported_models": ["MiniMax-M2", "MiniMax-M2-Stable"],
+        "supported_parameters": {
+            "fully_supported": ["model", "messages", "max_tokens", "stream", "system", "temperature", "top_p", "tools", "tool_choice", "metadata", "thinking"],
+            "ignored": ["top_k", "stop_sequences", "service_tier"]
         },
-        "endpoints": {
-            "anthropic_messages": "POST /v1/messages",
-            "openai_chat": "POST /v1/chat/completions",
-            "models": "GET /v1/models",
-            "predict": "POST /predict",
-            "embed": "POST /embed"
+        "message_types": {
+            "supported": ["text", "tool_use", "tool_result", "thinking"],
+            "not_supported": ["image", "document"]
         }
     }
 
 
-@app.post("/predict", response_model=PredictResponse)
-async def predict(request: PredictRequest):
-    """Text classification (sentiment analysis)"""
-    try:
-        start_time = datetime.now()
-        results = models["classifier"](request.text, top_k=request.top_k)
-        latency = (datetime.now() - start_time).total_seconds() * 1000
-
-        return PredictResponse(
-            predictions=results,
-            model=MODEL_NAME,
-            latency_ms=round(latency, 2)
-        )
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.post("/embed", response_model=EmbedResponse)
-async def embed(request: EmbedRequest):
-    """Get text embeddings"""
-    try:
-        start_time = datetime.now()
-
-        inputs = models["embed_tokenizer"](
-            request.texts,
-            padding=True,
-            truncation=True,
-            max_length=256,
-            return_tensors="pt"
-        )
-
-        with torch.no_grad():
-            outputs = models["embed_model"](**inputs)
-            attention_mask = inputs["attention_mask"]
-            token_embeddings = outputs.last_hidden_state
-            input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
-            embeddings = torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)
-
-        latency = (datetime.now() - start_time).total_seconds() * 1000
-
-        return EmbedResponse(
-            embeddings=embeddings.tolist(),
-            model=EMBED_MODEL,
-            dimensions=embeddings.shape[1],
-            latency_ms=round(latency, 2)
-        )
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)