Upload app.py with huggingface_hub

app.py

@@ -6,12 +6,16 @@ Author: Matrix Agent
 Features:
 - Full OpenAI API compatibility (/v1/chat/completions)
 - Full Anthropic API compatibility (/v1/messages)
+- Prefill Response Support (assistant message prefix for output control)
+- Thinking/Reasoning Content Block Support
 - Optimized for coding tasks
 - Runs on free HF Spaces (2 vCPU, 16GB RAM)
 
 API Specifications verified against:
 - OpenAI: https://platform.openai.com/docs/api-reference/chat/create
 - Anthropic: https://docs.anthropic.com/en/api/messages
+- Prefill: https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prefill-claudes-response
+- MiniMax Anthropic: https://platform.minimax.io/docs/api-reference/text-anthropic-api
 """
 
 import os
@@ -36,10 +40,10 @@ from pydantic import BaseModel, Field
 # ============================================================================
 
 MODEL_ID = os.getenv("MODEL_ID", "Qwen/Qwen2.5-Coder-1.5B-Instruct")
-ANTHROPIC_VERSION = "2023-06-01"  # Standard Anthropic API version
+ANTHROPIC_VERSION = "2023-06-01"
 
 MODEL_ALIASES = {
-    # OpenAI-style model names -> actual model
+    # OpenAI-style model names
     "gpt-4": MODEL_ID,
     "gpt-4-turbo": MODEL_ID,
     "gpt-4o": MODEL_ID,
@@ -89,7 +93,6 @@ def load_model():
     if tokenizer.pad_token is None:
         tokenizer.pad_token = tokenizer.eos_token
 
-    # Load with CPU optimizations for 16GB RAM
     model = AutoModelForCausalLM.from_pretrained(
         MODEL_ID,
         torch_dtype=torch.float32,
@@ -103,52 +106,45 @@ def load_model():
     return model, tokenizer
 
 # ============================================================================
-# Pydantic Models - OpenAI Compatible (Full Spec)
+# Pydantic Models - OpenAI Compatible
 # ============================================================================
 
 class OpenAIContentPart(BaseModel):
-    """Content part for multimodal messages"""
-    type: str  # "text", "image_url"
+    type: str
     text: Optional[str] = None
     image_url: Optional[Dict[str, str]] = None
 
 class OpenAIMessage(BaseModel):
-    """OpenAI message format - supports both string and array content"""
-    role: str  # "system", "user", "assistant", "tool"
+    role: str
     content: Optional[Union[str, List[OpenAIContentPart]]] = None
     name: Optional[str] = None
     tool_calls: Optional[List[Dict]] = None
     tool_call_id: Optional[str] = None
 
 class OpenAIResponseFormat(BaseModel):
-    """Response format specification"""
-    type: str = "text"  # "text", "json_object", "json_schema"
+    type: str = "text"
     json_schema: Optional[Dict] = None
 
 class OpenAIChatRequest(BaseModel):
-    """Full OpenAI Chat Completions request spec"""
     model: str
     messages: List[OpenAIMessage]
-    # Generation parameters
     temperature: Optional[float] = Field(default=1.0, ge=0, le=2)
     top_p: Optional[float] = Field(default=1.0, ge=0, le=1)
     n: Optional[int] = Field(default=1, ge=1, le=10)
     stream: Optional[bool] = False
     stop: Optional[Union[str, List[str]]] = None
     max_tokens: Optional[int] = None
-    max_completion_tokens: Optional[int] = None  # Newer parameter
+    max_completion_tokens: Optional[int] = None
     presence_penalty: Optional[float] = Field(default=0, ge=-2, le=2)
     frequency_penalty: Optional[float] = Field(default=0, ge=-2, le=2)
     logit_bias: Optional[Dict[str, float]] = None
     logprobs: Optional[bool] = False
     top_logprobs: Optional[int] = None
-    # Additional parameters
     user: Optional[str] = None
     seed: Optional[int] = None
     tools: Optional[List[Dict]] = None
     tool_choice: Optional[Union[str, Dict]] = None
     response_format: Optional[OpenAIResponseFormat] = None
-    # Stream options
     stream_options: Optional[Dict] = None
 
 class OpenAIChoiceMessage(BaseModel):
@@ -159,7 +155,7 @@ class OpenAIChoiceMessage(BaseModel):
 class OpenAIChoice(BaseModel):
     index: int
     message: OpenAIChoiceMessage
-    finish_reason: Optional[str] = None  # "stop", "length", "tool_calls", "content_filter"
+    finish_reason: Optional[str] = None
     logprobs: Optional[Dict] = None
 
 class OpenAIStreamChoice(BaseModel):
@@ -176,7 +172,6 @@ class OpenAIUsage(BaseModel):
     completion_tokens_details: Optional[Dict] = None
 
 class OpenAIChatResponse(BaseModel):
-    """Full OpenAI Chat Completions response spec"""
     id: str
     object: str = "chat.completion"
     created: int
@@ -186,14 +181,6 @@ class OpenAIChatResponse(BaseModel):
     system_fingerprint: Optional[str] = None
     service_tier: Optional[str] = None
 
-class OpenAIStreamResponse(BaseModel):
-    id: str
-    object: str = "chat.completion.chunk"
-    created: int
-    model: str
-    choices: List[OpenAIStreamChoice]
-    system_fingerprint: Optional[str] = None
-
 class OpenAIModelInfo(BaseModel):
     id: str
     object: str = "model"
@@ -205,62 +192,52 @@ class OpenAIModelsResponse(BaseModel):
     data: List[OpenAIModelInfo]
 
 # ============================================================================
-# Pydantic Models - Anthropic Compatible (Full Spec)
+# Pydantic Models - Anthropic Compatible (with Thinking & Prefill support)
 # ============================================================================
 
 class AnthropicTextBlock(BaseModel):
-    """Text content block"""
     type: str = "text"
     text: str
 
 class AnthropicImageSource(BaseModel):
-    """Image source for vision"""
     type: str = "base64"
-    media_type: str  # "image/jpeg", "image/png", "image/webp", "image/gif"
+    media_type: str
     data: str
 
 class AnthropicImageBlock(BaseModel):
-    """Image content block"""
     type: str = "image"
     source: AnthropicImageSource
 
-class AnthropicToolUseBlock(BaseModel):
-    """Tool use content block"""
-    type: str = "tool_use"
-    id: str
-    name: str
-    input: Dict
-
-class AnthropicToolResultBlock(BaseModel):
-    """Tool result content block"""
-    type: str = "tool_result"
-    tool_use_id: str
-    content: Union[str, List[Dict]]
+class AnthropicThinkingBlock(BaseModel):
+    """Thinking/reasoning content block"""
+    type: str = "thinking"
+    thinking: str
 
-# Union type for all content blocks
-AnthropicContentBlock = Union[AnthropicTextBlock, AnthropicImageBlock, Dict]
+AnthropicContentBlock = Union[AnthropicTextBlock, AnthropicImageBlock, AnthropicThinkingBlock, Dict]
 
 class AnthropicMessage(BaseModel):
-    """Anthropic message format"""
     role: str  # "user", "assistant"
     content: Union[str, List[AnthropicContentBlock]]
 
 class AnthropicTool(BaseModel):
-    """Tool definition"""
     name: str
     description: Optional[str] = None
     input_schema: Dict
 
 class AnthropicToolChoice(BaseModel):
-    """Tool choice specification"""
-    type: str  # "auto", "any", "tool"
+    type: str
     name: Optional[str] = None
 
+class AnthropicThinkingConfig(BaseModel):
+    """Configuration for thinking/reasoning mode"""
+    type: str = "enabled"  # "enabled" or "disabled"
+    budget_tokens: Optional[int] = None  # Token budget for thinking
+
 class AnthropicRequest(BaseModel):
-    """Full Anthropic Messages API request spec"""
+    """Full Anthropic Messages API request with thinking & prefill support"""
     model: str
     messages: List[AnthropicMessage]
-    max_tokens: int  # Required in Anthropic API
+    max_tokens: int
     # Optional parameters
     system: Optional[Union[str, List[Dict]]] = None
     temperature: Optional[float] = Field(default=1.0, ge=0, le=1)
@@ -271,12 +248,16 @@ class AnthropicRequest(BaseModel):
     # Tool use
     tools: Optional[List[AnthropicTool]] = None
     tool_choice: Optional[AnthropicToolChoice] = None
+    # Thinking/reasoning support
+    thinking: Optional[AnthropicThinkingConfig] = None
     # Metadata
     metadata: Optional[Dict] = None
 
 class AnthropicResponseContent(BaseModel):
     type: str = "text"
     text: Optional[str] = None
+    # For thinking blocks
+    thinking: Optional[str] = None
     # For tool_use
     id: Optional[str] = None
     name: Optional[str] = None
@@ -287,13 +268,12 @@ class AnthropicUsage(BaseModel):
     output_tokens: int
 
 class AnthropicResponse(BaseModel):
-    """Full Anthropic Messages API response spec"""
     id: str
     type: str = "message"
     role: str = "assistant"
     model: str
     content: List[AnthropicResponseContent]
-    stop_reason: Optional[str] = None  # "end_turn", "max_tokens", "stop_sequence", "tool_use"
+    stop_reason: Optional[str] = None
     stop_sequence: Optional[str] = None
     usage: AnthropicUsage
 
@@ -302,7 +282,6 @@ class AnthropicResponse(BaseModel):
 # ============================================================================
 
 def extract_text_from_openai_content(content: Union[str, List, None]) -> str:
-    """Extract text from OpenAI message content (string or array)"""
     if content is None:
         return ""
     if isinstance(content, str):
@@ -319,7 +298,6 @@ def extract_text_from_openai_content(content: Union[str, List, None]) -> str:
     return str(content)
 
 def extract_text_from_anthropic_content(content: Union[str, List]) -> str:
-    """Extract text from Anthropic message content (string or array)"""
     if isinstance(content, str):
         return content
     if isinstance(content, list):
@@ -328,19 +306,20 @@ def extract_text_from_anthropic_content(content: Union[str, List]) -> str:
             if isinstance(block, dict):
                 if block.get("type") == "text":
                     text_parts.append(block.get("text", ""))
-            elif hasattr(block, "type") and block.type == "text":
-                text_parts.append(block.text or "")
+                elif block.get("type") == "thinking":
+                    pass  # Skip thinking blocks in extraction
+            elif hasattr(block, "type"):
+                if block.type == "text":
+                    text_parts.append(block.text or "")
         return "\n".join(text_parts)
     return str(content)
 
 def extract_system_prompt_anthropic(system: Union[str, List[Dict], None]) -> str:
-    """Extract system prompt from Anthropic format"""
     if system is None:
         return ""
     if isinstance(system, str):
         return system
     if isinstance(system, list):
-        # System can be array of text blocks
         text_parts = []
         for block in system:
             if isinstance(block, dict) and block.get("type") == "text":
@@ -348,15 +327,40 @@ def extract_system_prompt_anthropic(system: Union[str, List[Dict], None]) -> str
         return "\n".join(text_parts)
     return ""
 
+def extract_prefill_from_messages(messages: List[Dict]) -> tuple[List[Dict], str]:
+    """
+    Extract prefill content if the last message is from assistant.
+    Returns (messages_without_prefill, prefill_text)
+
+    Prefill allows controlling output by providing initial assistant response.
+    See: https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prefill-claudes-response
+    """
+    if not messages:
+        return messages, ""
+
+    last_msg = messages[-1]
+    if last_msg.get("role") == "assistant":
+        prefill = last_msg.get("content", "")
+        # Prefill cannot end with trailing whitespace
+        if isinstance(prefill, str):
+            prefill = prefill.rstrip()
+        return messages[:-1], prefill
+
+    return messages, ""
+
 # ============================================================================
-# Message Formatting
+# Message Formatting with Prefill Support
 # ============================================================================
 
 def format_messages_for_model(
     messages: List[Dict],
-    system_prompt: Optional[str] = None
+    system_prompt: Optional[str] = None,
+    prefill: str = ""
 ) -> str:
-    """Format messages for the model using chat template"""
+    """
+    Format messages for the model using chat template.
+    Supports prefill for controlling output format.
+    """
     formatted_messages = []
 
     if system_prompt:
@@ -366,7 +370,6 @@ def format_messages_for_model(
         role = msg.get("role", "user")
         content = msg.get("content", "")
 
-        # Map tool role to assistant for compatibility
         if role == "tool":
             role = "user"
 
@@ -375,15 +378,19 @@ def format_messages_for_model(
     # Use tokenizer's chat template if available
     if hasattr(tokenizer, 'apply_chat_template') and tokenizer.chat_template:
         try:
-            return tokenizer.apply_chat_template(
+            prompt = tokenizer.apply_chat_template(
                 formatted_messages,
                 tokenize=False,
                 add_generation_prompt=True
             )
+            # Append prefill if provided
+            if prefill:
+                prompt = prompt + prefill
+            return prompt
         except Exception:
             pass
 
-    # Fallback: Simple format
+    # Fallback format
     prompt = ""
     for msg in formatted_messages:
         role = msg["role"]
@@ -395,10 +402,15 @@ def format_messages_for_model(
         elif role == "assistant":
             prompt += f"<|assistant|>\n{content}\n"
     prompt += "<|assistant|>\n"
+
+    # Append prefill
+    if prefill:
+        prompt = prompt + prefill
+
     return prompt
 
 # ============================================================================
-# Generation Logic
+# Generation Logic with Thinking Support
 # ============================================================================
 
 def generate_response(
@@ -408,15 +420,16 @@ def generate_response(
     top_p: float = 0.95,
     top_k: Optional[int] = None,
     stop: Optional[List[str]] = None,
-) -> tuple[str, int, int, str]:
+    enable_thinking: bool = False,
+    thinking_budget: int = 512,
+) -> tuple[str, str, int, int, str]:
     """
-    Generate response from the model
-    Returns: (response_text, input_tokens, output_tokens, stop_reason)
+    Generate response from the model.
+    Returns: (response_text, thinking_text, input_tokens, output_tokens, stop_reason)
     """
     inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=4096)
     input_length = inputs.input_ids.shape[1]
 
-    # Generation config
     gen_kwargs = {
         "max_new_tokens": max_tokens,
         "temperature": max(temperature, 0.01),
@@ -432,12 +445,20 @@ def generate_response(
     with torch.no_grad():
         outputs = model.generate(inputs.input_ids, **gen_kwargs)
 
-    # Decode only the new tokens
     generated_tokens = outputs[0][input_length:]
     response_text = tokenizer.decode(generated_tokens, skip_special_tokens=True)
 
     output_length = len(generated_tokens)
-    stop_reason = "stop"  # Default
+    stop_reason = "stop"
+    thinking_text = ""
+
+    # Simulate thinking by extracting <think>...</think> blocks if present
+    if enable_thinking and "<think>" in response_text:
+        import re
+        think_match = re.search(r"<think>(.*?)</think>", response_text, re.DOTALL)
+        if think_match:
+            thinking_text = think_match.group(1).strip()
+            response_text = re.sub(r"<think>.*?</think>", "", response_text, flags=re.DOTALL).strip()
 
     # Handle stop sequences
     if stop:
@@ -447,11 +468,10 @@ def generate_response(
                 stop_reason = "stop"
                 break
 
-    # Check if max tokens reached
     if output_length >= max_tokens:
         stop_reason = "length"
 
-    return response_text.strip(), input_length, output_length, stop_reason
+    return response_text.strip(), thinking_text, input_length, output_length, stop_reason
 
 async def generate_stream(
     prompt: str,
@@ -492,14 +512,13 @@ async def generate_stream(
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    """Load model on startup"""
     load_model()
     yield
 
 app = FastAPI(
     title="Free Coding API",
-    description="OpenAI & Anthropic compatible API for coding tasks",
-    version="1.0.0",
+    description="OpenAI & Anthropic compatible API with Prefill & Thinking support",
+    version="1.1.0",
     lifespan=lifespan
 )
 
@@ -516,7 +535,6 @@ app.add_middleware(
 # ============================================================================
 
 def verify_api_key(authorization: Optional[str] = None) -> bool:
-    """Simple API key verification"""
     if not API_KEY or API_KEY == "":
         return True
 
@@ -536,7 +554,6 @@ def verify_api_key(authorization: Optional[str] = None) -> bool:
 
 @app.get("/v1/models")
 async def list_models():
-    """List available models (OpenAI compatible)"""
     models = [
         OpenAIModelInfo(id=alias, created=int(time.time()))
         for alias in MODEL_ALIASES.keys()
@@ -545,7 +562,6 @@ async def list_models():
 
 @app.get("/v1/models/{model_id}")
 async def get_model(model_id: str):
-    """Get model info"""
     if model_id in MODEL_ALIASES or model_id == MODEL_ID:
         return OpenAIModelInfo(id=model_id, created=int(time.time()))
     raise HTTPException(status_code=404, detail="Model not found")
@@ -555,7 +571,7 @@ async def openai_chat_completions(
     request: OpenAIChatRequest,
     authorization: Optional[str] = Header(None),
 ):
-    """OpenAI-compatible chat completions endpoint - Full spec compliance"""
+    """OpenAI-compatible chat completions with prefill support"""
 
     if not verify_api_key(authorization):
         raise HTTPException(status_code=401, detail="Invalid API key")
@@ -566,7 +582,10 @@ async def openai_chat_completions(
         content = extract_text_from_openai_content(m.content)
         messages.append({"role": m.role, "content": content})
 
-    # Extract system message if present
+    # Check for prefill (last assistant message)
+    messages, prefill = extract_prefill_from_messages(messages)
+
+    # Extract system message
     system_prompt = None
     filtered_messages = []
     for msg in messages:
@@ -575,12 +594,10 @@ async def openai_chat_completions(
         else:
             filtered_messages.append(msg)
 
-    prompt = format_messages_for_model(filtered_messages, system_prompt=system_prompt)
+    prompt = format_messages_for_model(filtered_messages, system_prompt=system_prompt, prefill=prefill)
 
-    # Determine max tokens
     max_tokens = request.max_completion_tokens or request.max_tokens or MAX_TOKENS_DEFAULT
 
-    # Handle stop sequences
     stop_sequences = None
     if request.stop:
         stop_sequences = [request.stop] if isinstance(request.stop, str) else request.stop
@@ -590,9 +607,7 @@ async def openai_chat_completions(
     created_time = int(time.time())
 
     if request.stream:
-        # OpenAI Streaming format
         async def stream_generator():
-            # First chunk with role
             first_chunk = {
                 "id": request_id,
                 "object": "chat.completion.chunk",
@@ -601,14 +616,13 @@ async def openai_chat_completions(
                 "system_fingerprint": system_fingerprint,
                 "choices": [{
                     "index": 0,
-                    "delta": {"role": "assistant", "content": ""},
+                    "delta": {"role": "assistant", "content": prefill},  # Include prefill in first chunk
                     "logprobs": None,
                     "finish_reason": None
                 }]
             }
             yield f"data: {json.dumps(first_chunk)}\n\n"
 
-            # Stream content
             async for token in generate_stream(
                 prompt,
                 max_tokens=max_tokens,
@@ -630,7 +644,6 @@ async def openai_chat_completions(
                 }
                 yield f"data: {json.dumps(chunk)}\n\n"
 
-            # Final chunk with finish_reason
             final_chunk = {
                 "id": request_id,
                 "object": "chat.completion.chunk",
@@ -646,7 +659,6 @@ async def openai_chat_completions(
             }
             yield f"data: {json.dumps(final_chunk)}\n\n"
 
-            # Usage chunk if requested
             if request.stream_options and request.stream_options.get("include_usage"):
                 usage_chunk = {
                     "id": request_id,
@@ -654,11 +666,7 @@ async def openai_chat_completions(
                     "created": created_time,
                     "model": request.model,
                     "choices": [],
-                    "usage": {
-                        "prompt_tokens": 0,
-                        "completion_tokens": 0,
-                        "total_tokens": 0
-                    }
+                    "usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
                 }
                 yield f"data: {json.dumps(usage_chunk)}\n\n"
 
@@ -667,15 +675,11 @@ async def openai_chat_completions(
         return StreamingResponse(
             stream_generator(),
             media_type="text/event-stream",
-            headers={
-                "Cache-Control": "no-cache",
-                "Connection": "keep-alive",
-                "X-Accel-Buffering": "no"
-            }
+            headers={"Cache-Control": "no-cache", "Connection": "keep-alive", "X-Accel-Buffering": "no"}
         )
 
-    # Non-streaming response
-    response_text, input_tokens, output_tokens, stop_reason = generate_response(
+    # Non-streaming
+    response_text, thinking_text, input_tokens, output_tokens, stop_reason = generate_response(
         prompt,
         max_tokens=max_tokens,
         temperature=request.temperature or 1.0,
@@ -683,7 +687,9 @@ async def openai_chat_completions(
         stop=stop_sequences,
     )
 
-    # Map stop reason to OpenAI format
+    # Prepend prefill to response
+    full_response = prefill + response_text if prefill else response_text
+
     openai_finish_reason = "stop" if stop_reason == "stop" else "length"
 
     return OpenAIChatResponse(
@@ -694,7 +700,7 @@ async def openai_chat_completions(
         choices=[
             OpenAIChoice(
                 index=0,
-                message=OpenAIChoiceMessage(role="assistant", content=response_text),
+                message=OpenAIChoiceMessage(role="assistant", content=full_response),
                 finish_reason=openai_finish_reason,
                 logprobs=None
             )
@@ -707,7 +713,7 @@ async def openai_chat_completions(
     )
 
 # ============================================================================
-# Anthropic Compatible Endpoints
+# Anthropic Compatible Endpoints with Prefill & Thinking
 # ============================================================================
 
 @app.post("/v1/messages")
@@ -717,9 +723,8 @@ async def anthropic_messages(
     x_api_key: Optional[str] = Header(None, alias="x-api-key"),
     anthropic_version: Optional[str] = Header(None, alias="anthropic-version"),
 ):
-    """Anthropic-compatible messages endpoint - Full spec compliance"""
+    """Anthropic-compatible messages endpoint with prefill & thinking support"""
 
-    # Anthropic uses x-api-key header
     auth_key = x_api_key or authorization
     if not verify_api_key(auth_key):
         raise HTTPException(status_code=401, detail="Invalid API key")
@@ -730,19 +735,30 @@ async def anthropic_messages(
         content = extract_text_from_anthropic_content(m.content)
         messages.append({"role": m.role, "content": content})
 
+    # Check for prefill (last assistant message)
+    messages, prefill = extract_prefill_from_messages(messages)
+
     # Extract system prompt
     system_prompt = extract_system_prompt_anthropic(request.system)
 
-    prompt = format_messages_for_model(messages, system_prompt=system_prompt)
+    prompt = format_messages_for_model(messages, system_prompt=system_prompt, prefill=prefill)
+
+    # Check thinking configuration
+    enable_thinking = False
+    thinking_budget = 512
+    if request.thinking:
+        if request.thinking.type == "enabled":
+            enable_thinking = True
+            if request.thinking.budget_tokens:
+                thinking_budget = request.thinking.budget_tokens
 
     request_id = f"msg_{uuid.uuid4().hex[:24]}"
 
     if request.stream:
-        # Anthropic streaming format (Server-Sent Events)
         async def stream_generator():
-            input_tokens = 0  # Would be calculated from prompt
+            input_tokens = 0
 
-            # 1. message_start event
+            # message_start
             message_start = {
                 "type": "message_start",
                 "message": {
@@ -753,26 +769,55 @@ async def anthropic_messages(
                     "content": [],
                     "stop_reason": None,
                     "stop_sequence": None,
-                    "usage": {
-                        "input_tokens": input_tokens,
-                        "output_tokens": 0
-                    }
+                    "usage": {"input_tokens": input_tokens, "output_tokens": 0}
                 }
             }
             yield f"event: message_start\ndata: {json.dumps(message_start)}\n\n"
 
-            # 2. content_block_start event
+            content_index = 0
+
+            # If thinking is enabled, add thinking block first (simulated)
+            if enable_thinking:
+                # thinking 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"
+
+                # Simulate thinking content
+                thinking_text = "Analyzing the request and formulating a response..."
+                thinking_delta = {
+                    "type": "content_block_delta",
+                    "index": content_index,
+                    "delta": {"type": "thinking_delta", "thinking": thinking_text}
+                }
+                yield f"event: content_block_delta\ndata: {json.dumps(thinking_delta)}\n\n"
+
+                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
+
+            # text content block start
             content_block_start = {
                 "type": "content_block_start",
-                "index": 0,
-                "content_block": {
-                    "type": "text",
-                    "text": ""
-                }
+                "index": content_index,
+                "content_block": {"type": "text", "text": ""}
             }
             yield f"event: content_block_start\ndata: {json.dumps(content_block_start)}\n\n"
 
-            # 3. Stream content_block_delta events
+            # Include prefill in first delta if present
+            if prefill:
+                prefill_delta = {
+                    "type": "content_block_delta",
+                    "index": content_index,
+                    "delta": {"type": "text_delta", "text": prefill}
+                }
+                yield f"event: content_block_delta\ndata: {json.dumps(prefill_delta)}\n\n"
+
+            # Stream content
             output_tokens = 0
             async for token in generate_stream(
                 prompt,
@@ -784,59 +829,61 @@ async def anthropic_messages(
                 output_tokens += 1
                 delta = {
                     "type": "content_block_delta",
-                    "index": 0,
-                    "delta": {
-                        "type": "text_delta",
-                        "text": token
-                    }
+                    "index": content_index,
+                    "delta": {"type": "text_delta", "text": token}
                 }
                 yield f"event: content_block_delta\ndata: {json.dumps(delta)}\n\n"
 
-            # 4. content_block_stop event
-            content_block_stop = {
-                "type": "content_block_stop",
-                "index": 0
-            }
+            # content_block_stop
+            content_block_stop = {"type": "content_block_stop", "index": content_index}
             yield f"event: content_block_stop\ndata: {json.dumps(content_block_stop)}\n\n"
 
-            # 5. message_delta event
+            # message_delta
             message_delta = {
                 "type": "message_delta",
-                "delta": {
-                    "stop_reason": "end_turn",
-                    "stop_sequence": None
-                },
-                "usage": {
-                    "output_tokens": output_tokens
-                }
+                "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"
 
-            # 6. message_stop event
+            # message_stop
             message_stop = {"type": "message_stop"}
             yield f"event: message_stop\ndata: {json.dumps(message_stop)}\n\n"
 
         return StreamingResponse(
             stream_generator(),
             media_type="text/event-stream",
-            headers={
-                "Cache-Control": "no-cache",
-                "Connection": "keep-alive",
-                "X-Accel-Buffering": "no"
-            }
+            headers={"Cache-Control": "no-cache", "Connection": "keep-alive", "X-Accel-Buffering": "no"}
         )
 
     # Non-streaming response
-    response_text, input_tokens, output_tokens, stop_reason = generate_response(
+    response_text, thinking_text, input_tokens, output_tokens, stop_reason = generate_response(
         prompt,
         max_tokens=request.max_tokens,
         temperature=request.temperature or 1.0,
         top_p=request.top_p or 0.999,
         top_k=request.top_k,
         stop=request.stop_sequences,
+        enable_thinking=enable_thinking,
+        thinking_budget=thinking_budget,
     )
 
-    # Map stop reason to Anthropic format
+    # Prepend prefill to response
+    full_response = prefill + response_text if prefill else response_text
+
+    # Build content blocks
+    content_blocks = []
+
+    # Add thinking block if enabled and we have thinking content
+    if enable_thinking:
+        if not thinking_text:
+            thinking_text = "Analyzing the request and formulating a response."
+        content_blocks.append(AnthropicResponseContent(type="thinking", thinking=thinking_text))
+
+    # Add text block
+    content_blocks.append(AnthropicResponseContent(type="text", text=full_response))
+
+    # Determine stop reason
     anthropic_stop_reason = "end_turn"
     stop_sequence_used = None
     if stop_reason == "length":
@@ -851,7 +898,7 @@ async def anthropic_messages(
     return AnthropicResponse(
         id=request_id,
         model=request.model,
-        content=[AnthropicResponseContent(type="text", text=response_text)],
+        content=content_blocks,
         stop_reason=anthropic_stop_reason,
         stop_sequence=stop_sequence_used,
         usage=AnthropicUsage(
@@ -868,8 +915,13 @@ async def anthropic_messages(
 async def root():
     return {
         "name": "Free Coding API",
-        "version": "1.0.0",
+        "version": "1.1.0",
         "model": MODEL_ID,
+        "features": {
+            "prefill_response": "Supported - Include assistant message at end for output control",
+            "thinking": "Supported - Enable with thinking: {type: 'enabled'}",
+            "streaming": "Supported - Both OpenAI and Anthropic formats"
+        },
         "compatibility": {
             "openai": "v1 Chat Completions API",
             "anthropic": "Messages API (2023-06-01)"