Upload folder using huggingface_hub

README.md

@@ -11,25 +11,19 @@ pinned: false
 
 # Docker Model Runner
 
-**Anthropic API Compatible** - Text Generation endpoint with full Messages API support.
+**Anthropic API Compatible** with **Interleaved Thinking** support.
 
 ## Hardware
 - **CPU Basic**: 2 vCPU · 16 GB RAM
 
 ## Quick Start
 
-### 1. Install Anthropic SDK
 ```bash
 pip install anthropic
-```
-
-### 2. Configure Environment
-```bash
 export ANTHROPIC_BASE_URL=https://likhonsheikhdev-docker-model-runner.hf.space
 export ANTHROPIC_API_KEY=any-key
 ```
 
-### 3. Call API
 ```python
 import anthropic
 
@@ -39,17 +33,7 @@ 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?"
-                }
-            ]
-        }
-    ]
+    messages=[{"role": "user", "content": "Hi, how are you?"}]
 )
 
 for block in message.content:
@@ -59,55 +43,36 @@ for block in message.content:
         print(f"Text:\n{block.text}\n")
 ```
 
-## Supported Models
+## Interleaved Thinking
 
-| Model Name | Description |
-|------------|-------------|
-| MiniMax-M2 | Agentic capabilities, Advanced reasoning |
-| MiniMax-M2-Stable | High concurrency and commercial use |
+Enable thinking to get reasoning steps interleaved with responses:
 
-## 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
+```python
+import anthropic
 
-| Type | Status |
-|------|--------|
-| text | ✅ Fully supported |
-| tool_use | ✅ Fully supported |
-| tool_result | ✅ Fully supported |
-| thinking | ✅ Fully supported |
-| image | ❌ Not supported |
-| document | ❌ Not supported |
+client = anthropic.Anthropic(
+    base_url="https://likhonsheikhdev-docker-model-runner.hf.space"
+)
 
-## Endpoints
+message = client.messages.create(
+    model="MiniMax-M2",
+    max_tokens=1024,
+    thinking={
+        "type": "enabled",
+        "budget_tokens": 200
+    },
+    messages=[{"role": "user", "content": "Explain quantum computing"}]
+)
 
-| Endpoint | Method | Description |
-|----------|--------|-------------|
-| `/v1/messages` | POST | Anthropic Messages API |
-| `/v1/chat/completions` | POST | OpenAI Chat API |
-| `/v1/models` | GET | List models |
-| `/health` | GET | Health check |
-| `/info` | GET | API info |
+# Response contains interleaved thinking and text blocks
+for block in message.content:
+    if block.type == "thinking":
+        print(f"💭 Thinking: {block.thinking}")
+    elif block.type == "text":
+        print(f"📝 Response: {block.text}")
+```
 
-## Streaming Example
+## Streaming with Thinking
 
 ```python
 import anthropic
@@ -119,13 +84,23 @@ client = anthropic.Anthropic(
 with client.messages.stream(
     model="MiniMax-M2",
     max_tokens=1024,
+    thinking={"type": "enabled", "budget_tokens": 100},
     messages=[{"role": "user", "content": "Hello!"}]
 ) as stream:
-    for text in stream.text_stream:
-        print(text, end="", flush=True)
+    for event in stream:
+        if hasattr(event, 'type'):
+            if event.type == 'content_block_start':
+                print(f"\n[{event.content_block.type}]", end=" ")
+            elif event.type == 'content_block_delta':
+                if hasattr(event.delta, 'thinking'):
+                    print(event.delta.thinking, end="")
+                elif hasattr(event.delta, 'text'):
+                    print(event.delta.text, end="")
 ```
 
-## Tool Calling Example
+## Multi-Turn with Thinking History
+
+**Important**: In multi-turn conversations, append the complete model response (including thinking blocks) to maintain reasoning chain continuity.
 
 ```python
 import anthropic
@@ -134,28 +109,82 @@ client = anthropic.Anthropic(
     base_url="https://likhonsheikhdev-docker-model-runner.hf.space"
 )
 
-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"]
-        }
-    }
-]
+messages = [{"role": "user", "content": "What is 2+2?"}]
 
-message = client.messages.create(
+# First turn
+response = client.messages.create(
     model="MiniMax-M2",
     max_tokens=1024,
-    tools=tools,
-    messages=[{"role": "user", "content": "What's the weather in Tokyo?"}]
+    thinking={"type": "enabled", "budget_tokens": 100},
+    messages=messages
+)
+
+# Append full response (including thinking) to history
+messages.append({
+    "role": "assistant",
+    "content": response.content  # Includes both thinking and text blocks
+})
+
+# Second turn
+messages.append({"role": "user", "content": "Now multiply that by 3"})
+
+response2 = client.messages.create(
+    model="MiniMax-M2",
+    max_tokens=1024,
+    thinking={"type": "enabled", "budget_tokens": 100},
+    messages=messages
 )
 ```
 
+## Supported Models
+
+| Model | Description |
+|-------|-------------|
+| MiniMax-M2 | Agentic capabilities, Advanced reasoning |
+| MiniMax-M2-Stable | High concurrency and commercial use |
+
+## API Compatibility
+
+### Parameters
+
+| Parameter | Status |
+|-----------|--------|
+| model | ✅ Fully supported |
+| messages | ✅ Partial (text, tool calls) |
+| max_tokens | ✅ Fully supported |
+| stream | ✅ Fully supported |
+| system | ✅ Fully supported |
+| temperature | ✅ Range (0.0, 1.0] |
+| thinking | ✅ Fully supported |
+| thinking.budget_tokens | ✅ Fully supported |
+| tools | ✅ Fully supported |
+| tool_choice | ✅ Fully supported |
+| top_p | ✅ Fully supported |
+| metadata | ✅ Fully supported |
+| top_k | ⚪ Ignored |
+| stop_sequences | ⚪ Ignored |
+
+### Message Types
+
+| Type | Status |
+|------|--------|
+| text | ✅ Supported |
+| thinking | ✅ Supported |
+| tool_use | ✅ Supported |
+| tool_result | ✅ 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 models |
+| `/health` | GET | Health check |
+| `/info` | GET | API info |
+
 ## cURL Example
 
 ```bash
@@ -165,8 +194,9 @@ curl -X POST https://likhonsheikhdev-docker-model-runner.hf.space/v1/messages \
   -d '{
     "model": "MiniMax-M2",
     "max_tokens": 1024,
+    "thinking": {"type": "enabled", "budget_tokens": 100},
     "messages": [
-      {"role": "user", "content": "Hello, how are you?"}
+      {"role": "user", "content": "Explain AI briefly"}
     ]
   }'
 ```

main.py

@@ -1,6 +1,6 @@
 """
 Docker Model Runner - Anthropic API Compatible
-Full compatibility with Anthropic Messages API format
+Full compatibility with Anthropic Messages API + Interleaved Thinking
 Optimized for: 2 vCPU, 16GB RAM
 """
 from fastapi import FastAPI, HTTPException, Header, Request
@@ -16,6 +16,7 @@ import uuid
 import time
 import json
 import asyncio
+import re
 
 # CPU-optimized lightweight models
 GENERATOR_MODEL = os.getenv("GENERATOR_MODEL", "distilgpt2")
@@ -52,7 +53,7 @@ async def lifespan(app: FastAPI):
 
 app = FastAPI(
     title="Docker Model Runner",
-    description="Anthropic API Compatible Endpoint",
+    description="Anthropic API Compatible with Interleaved Thinking",
     version="1.0.0",
     lifespan=lifespan
 )
@@ -70,6 +71,11 @@ class ThinkingBlock(BaseModel):
     thinking: str
 
 
+class SignatureBlock(BaseModel):
+    type: Literal["signature"] = "signature"
+    signature: str
+
+
 class ToolUseBlock(BaseModel):
     type: Literal["tool_use"] = "tool_use"
     id: str
@@ -96,7 +102,7 @@ class ImageBlock(BaseModel):
     source: ImageSource
 
 
-ContentBlock = Union[TextBlock, ThinkingBlock, ToolUseBlock, ToolResultContent, ImageBlock, str]
+ContentBlock = Union[TextBlock, ThinkingBlock, SignatureBlock, ToolUseBlock, ToolResultContent, ImageBlock, str]
 
 
 class MessageParam(BaseModel):
@@ -119,6 +125,7 @@ class Tool(BaseModel):
 class ToolChoice(BaseModel):
     type: Literal["auto", "any", "tool"] = "auto"
     name: Optional[str] = None
+    disable_parallel_tool_use: Optional[bool] = False
 
 
 class ThinkingConfig(BaseModel):
@@ -141,7 +148,7 @@ class AnthropicRequest(BaseModel):
     stream: Optional[bool] = False
     system: Optional[Union[str, List[TextBlock]]] = None
     tools: Optional[List[Tool]] = None
-    tool_choice: Optional[ToolChoice] = None
+    tool_choice: Optional[Union[ToolChoice, Dict[str, Any]]] = None
     metadata: Optional[Metadata] = None
     thinking: Optional[ThinkingConfig] = None
     service_tier: Optional[str] = None  # Ignored
@@ -158,23 +165,13 @@ class AnthropicResponse(BaseModel):
     id: str
     type: Literal["message"] = "message"
     role: Literal["assistant"] = "assistant"
-    content: List[Union[TextBlock, ThinkingBlock, ToolUseBlock]]
+    content: List[Union[TextBlock, ThinkingBlock, SignatureBlock, ToolUseBlock]]
     model: str
     stop_reason: Optional[Literal["end_turn", "max_tokens", "stop_sequence", "tool_use"]] = "end_turn"
     stop_sequence: Optional[str] = None
     usage: Usage
 
 
-# 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:
@@ -207,7 +204,7 @@ def format_system_prompt(system: Optional[Union[str, List[TextBlock]]]) -> str:
     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:
+def format_messages_to_prompt(messages: List[MessageParam], system: Optional[Union[str, List[TextBlock]]] = None, include_thinking: bool = False) -> str:
     """Convert chat messages to a single prompt string"""
     prompt_parts = []
 
@@ -217,12 +214,34 @@ def format_messages_to_prompt(messages: List[MessageParam], system: Optional[Uni
 
     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")
+        content = msg.content
+
+        # Handle interleaved thinking in message history
+        if isinstance(content, list):
+            for block in content:
+                if isinstance(block, dict):
+                    block_type = block.get('type', 'text')
+                    if block_type == 'thinking' and include_thinking:
+                        prompt_parts.append(f"<thinking>{block.get('thinking', '')}</thinking>\n")
+                    elif block_type == 'text':
+                        if role == "user":
+                            prompt_parts.append(f"Human: {block.get('text', '')}\n\n")
+                        else:
+                            prompt_parts.append(f"Assistant: {block.get('text', '')}\n\n")
+                elif hasattr(block, 'type'):
+                    if block.type == 'thinking' and include_thinking:
+                        prompt_parts.append(f"<thinking>{block.thinking}</thinking>\n")
+                    elif block.type == 'text':
+                        if role == "user":
+                            prompt_parts.append(f"Human: {block.text}\n\n")
+                        else:
+                            prompt_parts.append(f"Assistant: {block.text}\n\n")
+        else:
+            content_text = content if isinstance(content, str) else extract_text_from_content(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)
@@ -239,7 +258,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=min(max_tokens, 256),  # Limit for CPU
+            max_new_tokens=min(max_tokens, 256),
             temperature=temperature if temperature > 0 else 1.0,
             top_p=top_p,
             do_sample=temperature > 0,
@@ -254,13 +273,51 @@ def generate_text(prompt: str, max_tokens: int, temperature: float, top_p: float
     return generated_text.strip(), input_tokens, output_tokens
 
 
-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"""
+def generate_thinking(prompt: str, budget_tokens: int = 100) -> tuple:
+    """Generate thinking/reasoning content"""
+    tokenizer = models["tokenizer"]
+    model = models["model"]
+
+    thinking_prompt = f"{prompt}\n\nLet me think through this step by step:\n"
+
+    inputs = tokenizer(thinking_prompt, return_tensors="pt", truncation=True, max_length=512)
+    input_tokens = inputs["input_ids"].shape[1]
+
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=min(budget_tokens, 128),
+            temperature=0.7,
+            top_p=0.9,
+            do_sample=True,
+            pad_token_id=tokenizer.pad_token_id,
+            eos_token_id=tokenizer.eos_token_id
+        )
+
+    generated_tokens = outputs[0][input_tokens:]
+    thinking_tokens = len(generated_tokens)
+    thinking_text = tokenizer.decode(generated_tokens, skip_special_tokens=True)
+
+    return thinking_text.strip(), thinking_tokens
+
+
+async def generate_stream_with_thinking(
+    prompt: str,
+    max_tokens: int,
+    temperature: float,
+    top_p: float,
+    message_id: str,
+    model_name: str,
+    thinking_enabled: bool = False,
+    thinking_budget: int = 100
+):
+    """Generate streaming response with interleaved thinking in Anthropic SSE format"""
     tokenizer = models["tokenizer"]
     model = models["model"]
 
     inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512)
     input_tokens = inputs["input_ids"].shape[1]
+    total_output_tokens = 0
 
     # Send message_start event
     message_start = {
@@ -278,15 +335,49 @@ async def generate_stream(prompt: str, max_tokens: int, temperature: float, top_
     }
     yield f"event: message_start\ndata: {json.dumps(message_start)}\n\n"
 
-    # Send content_block_start event
-    content_block_start = {
+    content_index = 0
+
+    # Generate thinking block if enabled
+    if thinking_enabled:
+        # Send thinking content_block_start
+        thinking_block_start = {
+            "type": "content_block_start",
+            "index": content_index,
+            "content_block": {"type": "thinking", "thinking": ""}
+        }
+        yield f"event: content_block_start\ndata: {json.dumps(thinking_block_start)}\n\n"
+
+        # Generate thinking content
+        thinking_text, thinking_tokens = generate_thinking(prompt, thinking_budget)
+        total_output_tokens += thinking_tokens
+
+        # Stream thinking in chunks
+        chunk_size = 10
+        for i in range(0, len(thinking_text), chunk_size):
+            chunk = thinking_text[i:i+chunk_size]
+            thinking_delta = {
+                "type": "content_block_delta",
+                "index": content_index,
+                "delta": {"type": "thinking_delta", "thinking": chunk}
+            }
+            yield f"event: content_block_delta\ndata: {json.dumps(thinking_delta)}\n\n"
+            await asyncio.sleep(0.01)
+
+        # Send thinking content_block_stop
+        thinking_block_stop = {"type": "content_block_stop", "index": content_index}
+        yield f"event: content_block_stop\ndata: {json.dumps(thinking_block_stop)}\n\n"
+
+        content_index += 1
+
+    # Send text content_block_start
+    text_block_start = {
         "type": "content_block_start",
-        "index": 0,
+        "index": content_index,
         "content_block": {"type": "text", "text": ""}
     }
-    yield f"event: content_block_start\ndata: {json.dumps(content_block_start)}\n\n"
+    yield f"event: content_block_start\ndata: {json.dumps(text_block_start)}\n\n"
 
-    # Generate tokens
+    # Generate main response
     with torch.no_grad():
         outputs = model.generate(
             **inputs,
@@ -300,29 +391,29 @@ async def generate_stream(prompt: str, max_tokens: int, temperature: float, top_
 
     generated_tokens = outputs[0][input_tokens:]
     generated_text = tokenizer.decode(generated_tokens, skip_special_tokens=True).strip()
-    output_tokens = len(generated_tokens)
+    total_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 = {
+        text_delta = {
             "type": "content_block_delta",
-            "index": 0,
+            "index": content_index,
             "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
+        yield f"event: content_block_delta\ndata: {json.dumps(text_delta)}\n\n"
+        await asyncio.sleep(0.01)
 
-    # 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 text content_block_stop
+    text_block_stop = {"type": "content_block_stop", "index": content_index}
+    yield f"event: content_block_stop\ndata: {json.dumps(text_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}
+        "usage": {"output_tokens": total_output_tokens}
     }
     yield f"event: message_delta\ndata: {json.dumps(message_delta)}\n\n"
 
@@ -336,7 +427,6 @@ def handle_tool_call(tools: List[Tool], messages: List[MessageParam], generated_
     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(
@@ -353,7 +443,7 @@ def handle_tool_call(tools: List[Tool], messages: List[MessageParam], generated_
 @app.post("/v1/messages")
 async def create_message(request: AnthropicRequest):
     """
-    Anthropic Messages API compatible endpoint
+    Anthropic Messages API compatible endpoint with Interleaved Thinking
 
     POST /v1/messages
 
@@ -362,24 +452,39 @@ async def create_message(request: AnthropicRequest):
     - System prompts
     - Streaming responses
     - Tool/function calling
-    - Thinking/reasoning blocks
+    - Interleaved thinking blocks
+    - Thinking budget tokens
+    - Metadata
     """
     try:
         message_id = f"msg_{uuid.uuid4().hex[:24]}"
 
-        # Format messages to prompt
-        prompt = format_messages_to_prompt(request.messages, request.system)
+        # Check if thinking is enabled
+        thinking_enabled = False
+        thinking_budget = 100
+        if request.thinking:
+            if isinstance(request.thinking, dict):
+                thinking_enabled = request.thinking.get('type') == 'enabled'
+                thinking_budget = request.thinking.get('budget_tokens', 100)
+            else:
+                thinking_enabled = request.thinking.type == 'enabled'
+                thinking_budget = request.thinking.budget_tokens or 100
+
+        # Format messages to prompt (include thinking from history if enabled)
+        prompt = format_messages_to_prompt(request.messages, request.system, include_thinking=thinking_enabled)
 
         # Handle streaming
         if request.stream:
             return StreamingResponse(
-                generate_stream(
+                generate_stream_with_thinking(
                     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
+                    model_name=request.model,
+                    thinking_enabled=thinking_enabled,
+                    thinking_budget=thinking_budget
                 ),
                 media_type="text/event-stream",
                 headers={
@@ -390,20 +495,23 @@ async def create_message(request: AnthropicRequest):
             )
 
         # Non-streaming response
+        content_blocks = []
+        total_output_tokens = 0
+
+        # Generate thinking block if enabled
+        if thinking_enabled:
+            thinking_text, thinking_tokens = generate_thinking(prompt, thinking_budget)
+            total_output_tokens += thinking_tokens
+            content_blocks.append(ThinkingBlock(type="thinking", thinking=thinking_text))
+
+        # Generate main response
         generated_text, input_tokens, output_tokens = generate_text(
             prompt=prompt,
             max_tokens=request.max_tokens,
             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))
+        total_output_tokens += output_tokens
 
         # Check for tool calls
         tool_use = handle_tool_call(request.tools, request.messages, generated_text) if request.tools else None
@@ -421,7 +529,7 @@ async def create_message(request: AnthropicRequest):
             content=content_blocks,
             model=request.model,
             stop_reason=stop_reason,
-            usage=Usage(input_tokens=input_tokens, output_tokens=output_tokens)
+            usage=Usage(input_tokens=input_tokens, output_tokens=total_output_tokens)
         )
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
@@ -447,7 +555,6 @@ class ChatCompletionRequest(BaseModel):
 async def chat_completions(request: ChatCompletionRequest):
     """OpenAI Chat Completions API compatible endpoint"""
     try:
-        # Convert to Anthropic format
         anthropic_messages = [
             MessageParam(role=msg.role if msg.role in ["user", "assistant"] else "user",
                         content=msg.content)
@@ -502,7 +609,7 @@ async def list_models():
 async def root():
     """Welcome endpoint"""
     return {
-        "message": "Docker Model Runner API (Anthropic Compatible)",
+        "message": "Docker Model Runner API (Anthropic Compatible + Interleaved Thinking)",
         "hardware": "CPU Basic: 2 vCPU · 16 GB RAM",
         "docs": "/docs",
         "api_endpoints": {
@@ -515,7 +622,8 @@ async def root():
             "system prompts",
             "streaming responses",
             "tool/function calling",
-            "thinking blocks",
+            "interleaved thinking blocks",
+            "thinking budget tokens",
             "metadata"
         ]
     }
@@ -537,9 +645,14 @@ async def info():
     """API information"""
     return {
         "name": "Docker Model Runner",
-        "version": "1.0.0",
+        "version": "1.1.0",
         "api_compatibility": ["anthropic", "openai"],
         "supported_models": ["MiniMax-M2", "MiniMax-M2-Stable"],
+        "interleaved_thinking": {
+            "supported": True,
+            "streaming": True,
+            "budget_tokens": True
+        },
         "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"]