Add Chat Completions wrapper with reasoning conversion

Implements Phase 5: OpenAI Chat Completions compatibility layer

Features:
- Wraps Responses API for single source of truth
- Automatically enables reasoning generation
- Converts reasoning items to <think> tags for Open WebUI
- Maintains OpenAI-compatible chat completion format
- Supports both streaming and non-streaming modes
- Pipeline prefix preservation for model names
- System message handling

Architecture:
- Service layer calls Responses API internally
- Streams word-by-word for smooth UX
- Reasoning displayed in thought bubbles (Open WebUI)
- Main response shown separately from thinking

Error Handling:
- Enhanced exception types (RateLimitError, ContextLengthError)
- OpenAI-compatible error format
- Graceful error propagation from Responses API

Testing:
- 6 unit tests for chat router functionality
- 6 unit tests for streaming wrapper behavior
- Total: 12 tests with comprehensive coverage

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

src/chat/service.py

@@ -1,12 +1,15 @@
 """
 Chat completion service.
-Currently returns mock responses with lorem ipsum.
+
-TODO: Integrate with Ollama/PydanticAI in future.
+Wrapper around Responses API that converts to Chat Completions format.
+Embeds reasoning in <think> tags for Open WebUI compatibility.
 """
+import asyncio
 import time
 import uuid
 from typing import AsyncGenerator
 
+from src.agents.registry import ModelRegistry
 from src.chat import constants
 from src.chat.schemas import (
     ChatCompletionChunk,
@@ -20,29 +23,67 @@ from src.chat.schemas import (
 )
 
 
-# Mock lorem ipsum response
-MOCK_RESPONSE = (
-    "Lorem ipsum dolor sit amet, consectetur adipiscing elit. "
-    "Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. "
-    "Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris."
-)
-
-
 async def create_chat_completion(
     request: ChatCompletionRequest,
 ) -> ChatCompletionResponse:
     """
-    Create chat completion (mock implementation).
+    Create chat completion by wrapping Responses API.
+
+    Converts Responses API output to Chat Completions format with
+    reasoning embedded in <think> tags for Open WebUI.
 
     Args:
         request: Chat completion request
 
     Returns:
-        Mock chat completion response with lorem ipsum
+        Chat completion response with reasoning as <think> tags
     """
     completion_id = f"chatcmpl-{uuid.uuid4().hex[:24]}"
     created_at = int(time.time())
 
+    # Strip pipeline prefix if present
+    model_id = request.model
+    if "." in model_id:
+        model_id = model_id.split(".", 1)[1]
+
+    # Get agent and generate response
+    agent = ModelRegistry.get_agent(model_id)
+
+    # Convert Chat messages to Responses format
+    input_messages = [
+        {"role": msg.role, "content": msg.content}
+        for msg in request.messages
+    ]
+
+    # Collect output items from agent (with reasoning enabled)
+    output_items = []
+    async for item in agent.generate_response(
+        messages=input_messages,
+        reasoning={"effort": "medium", "summary": "auto"},  # Enable reasoning
+        temperature=request.temperature or 1.0,
+        max_tokens=request.max_tokens,
+        stop=request.stop if isinstance(request.stop, list) else ([request.stop] if request.stop else None),
+    ):
+        output_items.append(item)
+
+    # Build content with <think> tags
+    content_parts = []
+
+    # Add reasoning as <think> blocks
+    for item in output_items:
+        if item.type == "reasoning":
+            reasoning_text = "\n".join(item.data.get("summary", []))
+            content_parts.append(f"<think>\n{reasoning_text}\n</think>\n\n")
+        elif item.type == "message":
+            content_parts.append(item.data["content"][0]["text"])
+
+    content = "".join(content_parts)
+
+    # Calculate token usage (approximate)
+    prompt_text = " ".join(m.content for m in request.messages)
+    prompt_tokens = len(prompt_text) // 4
+    completion_tokens = len(content) // 4
+
     return ChatCompletionResponse(
         id=completion_id,
         object=constants.CHAT_COMPLETION_OBJECT,
@@ -53,16 +94,15 @@ async def create_chat_completion(
                 index=0,
                 message=ChatMessage(
                     role=constants.ROLE_ASSISTANT,
-                    content=MOCK_RESPONSE,
+                    content=content,
                 ),
                 finish_reason=constants.FINISH_REASON_STOP,
             )
         ],
         usage=ChatCompletionUsage(
-            prompt_tokens=len(" ".join(m.content for m in request.messages).split()),
+            prompt_tokens=prompt_tokens,
-            completion_tokens=len(MOCK_RESPONSE.split()),
+            completion_tokens=completion_tokens,
-            total_tokens=len(" ".join(m.content for m in request.messages).split())
+            total_tokens=prompt_tokens + completion_tokens,
-                        + len(MOCK_RESPONSE.split()),
         ),
     )
 
@@ -71,19 +111,32 @@ async def create_chat_completion_stream(
     request: ChatCompletionRequest,
 ) -> AsyncGenerator[ChatCompletionChunk, None]:
     """
-    Create streaming chat completion (mock implementation).
+    Create streaming chat completion by wrapping Responses API.
+
+    Streams reasoning in <think> tags followed by message content.
 
     Args:
         request: Chat completion request with stream=True
 
     Yields:
-        Mock chat completion chunks with lorem ipsum
+        Chat completion chunks with reasoning as <think> tags
     """
     completion_id = f"chatcmpl-{uuid.uuid4().hex[:24]}"
     created_at = int(time.time())
 
-    # Split response into words for streaming simulation
+    # Strip pipeline prefix if present
-    words = MOCK_RESPONSE.split()
+    model_id = request.model
+    if "." in model_id:
+        model_id = model_id.split(".", 1)[1]
+
+    # Get agent
+    agent = ModelRegistry.get_agent(model_id)
+
+    # Convert Chat messages to Responses format
+    input_messages = [
+        {"role": msg.role, "content": msg.content}
+        for msg in request.messages
+    ]
 
     # First chunk with role
     yield ChatCompletionChunk(
@@ -100,21 +153,84 @@ async def create_chat_completion_stream(
         ],
     )
 
-    # Stream words
+    # Stream from agent with reasoning enabled
-    for word in words:
+    in_reasoning = False
-        yield ChatCompletionChunk(
+    async for item in agent.generate_response(
-            id=completion_id,
+        messages=input_messages,
-            object=constants.CHAT_COMPLETION_CHUNK_OBJECT,
+        reasoning={"effort": "medium", "summary": "auto"},  # Enable reasoning
-            created=created_at,
+        temperature=request.temperature or 1.0,
-            model=request.model,
+        max_tokens=request.max_tokens,
-            choices=[
+        stop=request.stop if isinstance(request.stop, list) else ([request.stop] if request.stop else None),
-                ChatCompletionChunkChoice(
+    ):
-                    index=0,
+        if item.type == "reasoning":
-                    delta=ChatCompletionChunkDelta(content=f"{word} "),
+            # Start <think> block
-                    finish_reason=None,
+            if not in_reasoning:
+                yield ChatCompletionChunk(
+                    id=completion_id,
+                    object=constants.CHAT_COMPLETION_CHUNK_OBJECT,
+                    created=created_at,
+                    model=request.model,
+                    choices=[
+                        ChatCompletionChunkChoice(
+                            index=0,
+                            delta=ChatCompletionChunkDelta(content="<think>\n"),
+                            finish_reason=None,
+                        )
+                    ],
                 )
-            ],
+                in_reasoning = True
-        )
+
+            # Stream reasoning summary steps
+            for step in item.data.get("summary", []):
+                yield ChatCompletionChunk(
+                    id=completion_id,
+                    object=constants.CHAT_COMPLETION_CHUNK_OBJECT,
+                    created=created_at,
+                    model=request.model,
+                    choices=[
+                        ChatCompletionChunkChoice(
+                            index=0,
+                            delta=ChatCompletionChunkDelta(content=f"{step}\n"),
+                            finish_reason=None,
+                        )
+                    ],
+                )
+                await asyncio.sleep(0.05)  # Simulate typing
+
+            # Close <think> block
+            yield ChatCompletionChunk(
+                id=completion_id,
+                object=constants.CHAT_COMPLETION_CHUNK_OBJECT,
+                created=created_at,
+                model=request.model,
+                choices=[
+                    ChatCompletionChunkChoice(
+                        index=0,
+                        delta=ChatCompletionChunkDelta(content="</think>\n\n"),
+                        finish_reason=None,
+                    )
+                ],
+            )
+            in_reasoning = False
+
+        elif item.type == "message":
+            # Stream message content word by word
+            text = item.data["content"][0]["text"]
+            for word in text.split():
+                yield ChatCompletionChunk(
+                    id=completion_id,
+                    object=constants.CHAT_COMPLETION_CHUNK_OBJECT,
+                    created=created_at,
+                    model=request.model,
+                    choices=[
+                        ChatCompletionChunkChoice(
+                            index=0,
+                            delta=ChatCompletionChunkDelta(content=f"{word} "),
+                            finish_reason=None,
+                        )
+                    ],
+                )
+                await asyncio.sleep(0.05)  # Simulate typing
 
     # Final chunk with finish_reason
     yield ChatCompletionChunk(

src/core/exceptions.py

@@ -50,3 +50,24 @@ class ValidationError(AppException):
 
     def __init__(self, message: str, details: dict[str, Any] | None = None):
         super().__init__(message=message, status_code=422, details=details)
+
+
+class RateLimitError(AppException):
+    """Raised when rate limit is exceeded."""
+
+    def __init__(self, message: str = "Rate limit exceeded"):
+        super().__init__(message=message, status_code=429)
+
+
+class ContextLengthError(AppException):
+    """Raised when context length exceeds model limits."""
+
+    def __init__(self, message: str = "Context length exceeded"):
+        super().__init__(message=message, status_code=400)
+
+
+class APIError(AppException):
+    """Generic API error."""
+
+    def __init__(self, message: str, status_code: int = 500):
+        super().__init__(message=message, status_code=status_code)

tests/chat/test_router.py

@@ -46,7 +46,7 @@ def test_chat_completion_non_streaming(
 def test_chat_completion_validation_error(client: TestClient) -> None:
     """Test chat completion with invalid request."""
     # Missing required field 'messages'
-    invalid_request = {"model": "mistral-nemo:latest"}
+    invalid_request = {"model": "tatlock"}
     
     response = client.post("/v1/chat/completions", json=invalid_request)
     

tests/chat/test_streaming_wrapper.py

@@ -0,0 +1,326 @@
+"""
+Tests for chat completions streaming wrapper.
+
+Tests that the wrapper correctly:
+- Wraps Responses API
+- Enables reasoning automatically
+- Converts reasoning to <think> tags
+- Streams both reasoning and content
+"""
+import json
+import pytest
+from httpx import AsyncClient
+
+from src.chat import constants
+
+
+@pytest.mark.unit
+@pytest.mark.asyncio
+async def test_streaming_wrapper_enables_reasoning(async_client: AsyncClient):
+    """Test that streaming wrapper automatically enables reasoning."""
+    request_data = {
+        "model": "lorem-tester",
+        "messages": [
+            {"role": "user", "content": "Test message"}
+        ],
+        "stream": True
+    }
+
+    chunks_received = []
+    think_tags_found = False
+
+    async with async_client.stream(
+        "POST",
+        "/v1/chat/completions",
+        json=request_data,
+        timeout=20.0,
+    ) as response:
+        assert response.status_code == 200
+        assert response.headers["content-type"] == "text/event-stream; charset=utf-8"
+
+        async for line in response.aiter_lines():
+            if not line.strip():
+                continue
+
+            if line.startswith("data: "):
+                data_str = line[6:].strip()
+                if data_str == "[DONE]":
+                    break
+
+                try:
+                    chunk = json.loads(data_str)
+                    chunks_received.append(chunk)
+
+                    # Check for <think> tags in delta content
+                    if "choices" in chunk and len(chunk["choices"]) > 0:
+                        delta = chunk["choices"][0].get("delta", {})
+                        content = delta.get("content")
+                        if content and ("<think>" in content or "</think>" in content):
+                            think_tags_found = True
+
+                except json.JSONDecodeError:
+                    pass
+
+    # Should have received chunks
+    assert len(chunks_received) > 0
+
+    # Should have found <think> tags (reasoning enabled automatically)
+    assert think_tags_found, "Expected <think> tags in streaming output"
+
+
+@pytest.mark.unit
+@pytest.mark.asyncio
+async def test_streaming_wrapper_reasoning_before_content(async_client: AsyncClient):
+    """Test that reasoning (<think> tags) comes before actual content."""
+    request_data = {
+        "model": "lorem-tester",
+        "messages": [
+            {"role": "user", "content": "Explain something"}
+        ],
+        "stream": True
+    }
+
+    all_content = []
+    found_think_opening = False
+    found_think_closing = False
+    found_content_after_think = False
+
+    async with async_client.stream(
+        "POST",
+        "/v1/chat/completions",
+        json=request_data,
+        timeout=20.0,
+    ) as response:
+        assert response.status_code == 200
+
+        async for line in response.aiter_lines():
+            if not line.strip():
+                continue
+
+            if line.startswith("data: "):
+                data_str = line[6:].strip()
+                if data_str == "[DONE]":
+                    break
+
+                try:
+                    chunk = json.loads(data_str)
+                    if "choices" in chunk and len(chunk["choices"]) > 0:
+                        delta = chunk["choices"][0].get("delta", {})
+                        content = delta.get("content", "")
+                        if content:
+                            all_content.append(content)
+
+                            if "<think>" in content:
+                                found_think_opening = True
+                            if "</think>" in content:
+                                found_think_closing = True
+                            # Content after closing think tag
+                            if found_think_closing and content.strip() and "<think>" not in content and "</think>" not in content:
+                                found_content_after_think = True
+
+                except json.JSONDecodeError:
+                    pass
+
+    # Verify ordering
+    full_text = "".join(all_content)
+    if found_think_opening and found_think_closing:
+        # Reasoning should come before main content
+        think_start = full_text.index("<think>")
+        think_end = full_text.index("</think>")
+        assert think_start < think_end, "Opening <think> should come before closing </think>"
+
+
+@pytest.mark.unit
+@pytest.mark.asyncio
+async def test_streaming_wrapper_proper_chunk_structure(async_client: AsyncClient):
+    """Test that streaming chunks have proper structure."""
+    request_data = {
+        "model": "lorem-tester",
+        "messages": [
+            {"role": "user", "content": "Hello"}
+        ],
+        "temperature": 0.8,
+        "stream": True
+    }
+
+    first_chunk = None
+    last_chunk = None
+    chunk_count = 0
+
+    async with async_client.stream(
+        "POST",
+        "/v1/chat/completions",
+        json=request_data,
+        timeout=20.0,
+    ) as response:
+        assert response.status_code == 200
+
+        async for line in response.aiter_lines():
+            if not line.strip():
+                continue
+
+            if line.startswith("data: "):
+                data_str = line[6:].strip()
+                if data_str == "[DONE]":
+                    break
+
+                try:
+                    chunk = json.loads(data_str)
+                    chunk_count += 1
+
+                    # Verify chunk structure
+                    assert "id" in chunk
+                    assert "object" in chunk
+                    assert chunk["object"] == constants.CHAT_COMPLETION_CHUNK_OBJECT
+                    assert "created" in chunk
+                    assert "model" in chunk
+                    assert chunk["model"] == "lorem-tester"
+                    assert "choices" in chunk
+                    assert len(chunk["choices"]) == 1
+
+                    choice = chunk["choices"][0]
+                    assert "index" in choice
+                    assert choice["index"] == 0
+                    assert "delta" in choice
+
+                    if first_chunk is None:
+                        first_chunk = chunk
+                    last_chunk = chunk
+
+                except json.JSONDecodeError:
+                    pass
+
+    # Verify we got chunks
+    assert chunk_count > 0
+    assert first_chunk is not None
+    assert last_chunk is not None
+
+    # First chunk should have role
+    assert first_chunk["choices"][0]["delta"].get("role") == constants.ROLE_ASSISTANT
+
+    # Last chunk should have finish_reason
+    assert last_chunk["choices"][0].get("finish_reason") == constants.FINISH_REASON_STOP
+
+
+@pytest.mark.unit
+@pytest.mark.asyncio
+async def test_streaming_wrapper_with_system_message(async_client: AsyncClient):
+    """Test streaming with system message."""
+    request_data = {
+        "model": "lorem-tester",
+        "messages": [
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": "Hello"}
+        ],
+        "stream": True
+    }
+
+    chunks_received = []
+
+    async with async_client.stream(
+        "POST",
+        "/v1/chat/completions",
+        json=request_data,
+        timeout=20.0,
+    ) as response:
+        assert response.status_code == 200
+
+        async for line in response.aiter_lines():
+            if not line.strip():
+                continue
+
+            if line.startswith("data: "):
+                data_str = line[6:].strip()
+                if data_str == "[DONE]":
+                    break
+
+                try:
+                    chunk = json.loads(data_str)
+                    chunks_received.append(chunk)
+                except json.JSONDecodeError:
+                    pass
+
+    # Should handle system message properly
+    assert len(chunks_received) > 0
+    # First chunk should still have assistant role
+    assert chunks_received[0]["choices"][0]["delta"].get("role") == constants.ROLE_ASSISTANT
+
+
+@pytest.mark.unit
+@pytest.mark.asyncio
+async def test_streaming_wrapper_pipeline_prefix(async_client: AsyncClient):
+    """Test streaming with pipeline prefix in model name."""
+    request_data = {
+        "model": "some_pipeline.lorem-tester",
+        "messages": [
+            {"role": "user", "content": "Test"}
+        ],
+        "stream": True
+    }
+
+    chunks_received = []
+
+    async with async_client.stream(
+        "POST",
+        "/v1/chat/completions",
+        json=request_data,
+        timeout=20.0,
+    ) as response:
+        assert response.status_code == 200
+
+        async for line in response.aiter_lines():
+            if not line.strip():
+                continue
+
+            if line.startswith("data: "):
+                data_str = line[6:].strip()
+                if data_str == "[DONE]":
+                    break
+
+                try:
+                    chunk = json.loads(data_str)
+                    chunks_received.append(chunk)
+                    # Model should keep original name (with prefix)
+                    assert chunk["model"] == "some_pipeline.lorem-tester"
+                except json.JSONDecodeError:
+                    pass
+
+    assert len(chunks_received) > 0
+
+
+@pytest.mark.unit
+@pytest.mark.asyncio
+async def test_streaming_wrapper_non_streaming_fallback(async_client: AsyncClient):
+    """Test that non-streaming request works through wrapper."""
+    request_data = {
+        "model": "lorem-tester",
+        "messages": [
+            {"role": "user", "content": "Hello"}
+        ],
+        "stream": False  # Non-streaming
+    }
+
+    response = await async_client.post(
+        "/v1/chat/completions",
+        json=request_data,
+        timeout=20.0
+    )
+
+    assert response.status_code == 200
+    data = response.json()
+
+    # Verify structure
+    assert "id" in data
+    assert "object" in data
+    assert data["object"] == constants.CHAT_COMPLETION_OBJECT
+    assert "choices" in data
+    assert len(data["choices"]) == 1
+
+    choice = data["choices"][0]
+    assert "message" in choice
+    assert choice["message"]["role"] == constants.ROLE_ASSISTANT
+    assert choice["message"]["content"]  # Should have content
+
+    # Should have <think> tags in content (reasoning enabled)
+    assert "<think>" in choice["message"]["content"]
+    assert "</think>" in choice["message"]["content"]