test(models): add comprehensive Pydantic model validation tests

tests/README.md

@@ -80,7 +80,8 @@ tests/
 │   ├── test_converters_openai.py   # OpenAI Chat API → Kiro converter tests
 │   ├── test_debug_logger.py        # DebugLogger tests (off/errors/all modes)
 │   ├── test_main_cli.py            # CLI argument parsing tests (--host, --port)
-│   ├── test_models_anthropic.py    # Anthropic Pydantic models tests (image content blocks, Issue #30)
+│   ├── test_models_anthropic.py    # Anthropic Pydantic models tests (all content blocks, tools, streaming)
+│   ├── test_models_openai.py       # OpenAI Pydantic models tests (messages, tools, responses, streaming)
 │   ├── test_parsers.py             # AwsEventStreamParser tests
 │   ├── test_routes_anthropic.py    # Anthropic API endpoint tests (/v1/messages)
 │   ├── test_routes_openai.py       # OpenAI API endpoint tests (/v1/chat/completions)

tests/unit/test_models_anthropic.py

@@ -3,27 +3,59 @@
 """
 Unit tests for Anthropic Pydantic models.
 
-Tests for image-related models added in Issue #30 fix:
-- Base64ImageSource
-- URLImageSource
-- ImageContentBlock
-- ContentBlock union with ImageContentBlock
-- AnthropicMessage with image content
+Comprehensive tests for all Anthropic API models:
+- Content blocks (text, image, tool_use, tool_result, thinking)
+- Image sources (base64, URL)
+- Messages and requests
+- Tools and tool choice
+- Responses and streaming events
+- Error models
 """
 
 import pytest
 from pydantic import ValidationError
 
 from kiro.models_anthropic import (
+    # Content blocks
+    TextContentBlock,
+    ThinkingContentBlock,
+    ToolUseContentBlock,
+    ToolResultContentBlock,
+    # Image models
     Base64ImageSource,
     URLImageSource,
     ImageContentBlock,
     ContentBlock,
-    TextContentBlock,
-    ToolUseContentBlock,
-    ToolResultContentBlock,
+    # Message models
     AnthropicMessage,
+    # Tool models
+    AnthropicTool,
+    ToolChoiceAuto,
+    ToolChoiceAny,
+    ToolChoiceTool,
+    ToolChoice,
+    # Request models
+    SystemContentBlock,
     AnthropicMessagesRequest,
+    # Response models
+    AnthropicUsage,
+    AnthropicMessagesResponse,
+    # Streaming models
+    MessageStartEvent,
+    ContentBlockStartEvent,
+    TextDelta,
+    ThinkingDelta,
+    InputJsonDelta,
+    ContentBlockDeltaEvent,
+    ContentBlockStopEvent,
+    MessageDeltaUsage,
+    MessageDeltaEvent,
+    MessageStopEvent,
+    PingEvent,
+    ErrorEvent,
+    # Error models
+    AnthropicErrorDetail,
+    AnthropicErrorResponse,
 )
 
 
@@ -587,3 +619,886 @@ class TestAnthropicMessagesRequestWithImages:
         assert request.messages[2].content == "Can you describe it in more detail?"
         
         print("Multi-turn conversation with images validated successfully!")
+
+
+# ==================================================================================================
+# Tests for TextContentBlock
+# ==================================================================================================
+
+class TestTextContentBlock:
+    """Tests for TextContentBlock Pydantic model."""
+    
+    def test_valid_text_block(self):
+        """
+        What it does: Verifies creation of valid TextContentBlock.
+        Purpose: Ensure model accepts valid text content.
+        """
+        print("Setup: Creating TextContentBlock with valid text...")
+        block = TextContentBlock(text="Hello, world!")
+        
+        print(f"Result: {block}")
+        print(f"Comparing type: Expected 'text', Got '{block.type}'")
+        assert block.type == "text"
+        
+        print(f"Comparing text: Expected 'Hello, world!', Got '{block.text}'")
+        assert block.text == "Hello, world!"
+    
+    def test_type_defaults_to_text(self):
+        """
+        What it does: Verifies that type defaults to "text".
+        Purpose: Ensure default value is set correctly.
+        """
+        print("Setup: Creating TextContentBlock without explicit type...")
+        block = TextContentBlock(text="Test")
+        
+        print(f"Comparing type: Expected 'text', Got '{block.type}'")
+        assert block.type == "text"
+    
+    def test_requires_text(self):
+        """
+        What it does: Verifies that text is required.
+        Purpose: Ensure validation fails without text.
+        """
+        print("Setup: Attempting to create TextContentBlock without text...")
+        
+        print("Action: Creating model (should raise ValidationError)...")
+        with pytest.raises(ValidationError) as exc_info:
+            TextContentBlock()
+        
+        print(f"ValidationError raised: {exc_info.value}")
+        assert "text" in str(exc_info.value)
+    
+    def test_accepts_empty_string(self):
+        """
+        What it does: Verifies that empty string is accepted.
+        Purpose: Ensure empty text is valid.
+        """
+        print("Setup: Creating TextContentBlock with empty string...")
+        block = TextContentBlock(text="")
+        
+        print(f"Comparing text: Expected '', Got '{block.text}'")
+        assert block.text == ""
+    
+    def test_accepts_multiline_text(self):
+        """
+        What it does: Verifies that multiline text is accepted.
+        Purpose: Ensure newlines are preserved.
+        """
+        print("Setup: Creating TextContentBlock with multiline text...")
+        multiline = "Line 1\nLine 2\nLine 3"
+        block = TextContentBlock(text=multiline)
+        
+        print(f"Comparing text: Expected multiline, Got '{block.text}'")
+        assert block.text == multiline
+        assert "\n" in block.text
+
+
+# ==================================================================================================
+# Tests for ThinkingContentBlock
+# ==================================================================================================
+
+class TestThinkingContentBlock:
+    """Tests for ThinkingContentBlock Pydantic model."""
+    
+    def test_valid_thinking_block(self):
+        """
+        What it does: Verifies creation of valid ThinkingContentBlock.
+        Purpose: Ensure model accepts valid thinking content.
+        """
+        print("Setup: Creating ThinkingContentBlock with valid thinking...")
+        block = ThinkingContentBlock(
+            thinking="Let me analyze this step by step...",
+            signature="abc123"
+        )
+        
+        print(f"Result: {block}")
+        print(f"Comparing type: Expected 'thinking', Got '{block.type}'")
+        assert block.type == "thinking"
+        
+        print(f"Comparing thinking: Got '{block.thinking[:30]}...'")
+        assert block.thinking == "Let me analyze this step by step..."
+        
+        print(f"Comparing signature: Expected 'abc123', Got '{block.signature}'")
+        assert block.signature == "abc123"
+    
+    def test_type_defaults_to_thinking(self):
+        """
+        What it does: Verifies that type defaults to "thinking".
+        Purpose: Ensure default value is set correctly.
+        """
+        print("Setup: Creating ThinkingContentBlock without explicit type...")
+        block = ThinkingContentBlock(thinking="Test thinking")
+        
+        print(f"Comparing type: Expected 'thinking', Got '{block.type}'")
+        assert block.type == "thinking"
+    
+    def test_signature_defaults_to_empty(self):
+        """
+        What it does: Verifies that signature defaults to empty string.
+        Purpose: Ensure default value is set correctly.
+        """
+        print("Setup: Creating ThinkingContentBlock without signature...")
+        block = ThinkingContentBlock(thinking="Test")
+        
+        print(f"Comparing signature: Expected '', Got '{block.signature}'")
+        assert block.signature == ""
+    
+    def test_requires_thinking(self):
+        """
+        What it does: Verifies that thinking is required.
+        Purpose: Ensure validation fails without thinking.
+        """
+        print("Setup: Attempting to create ThinkingContentBlock without thinking...")
+        
+        print("Action: Creating model (should raise ValidationError)...")
+        with pytest.raises(ValidationError) as exc_info:
+            ThinkingContentBlock()
+        
+        print(f"ValidationError raised: {exc_info.value}")
+        assert "thinking" in str(exc_info.value)
+
+
+# ==================================================================================================
+# Tests for ToolUseContentBlock
+# ==================================================================================================
+
+class TestToolUseContentBlock:
+    """Tests for ToolUseContentBlock Pydantic model."""
+    
+    def test_valid_tool_use_block(self):
+        """
+        What it does: Verifies creation of valid ToolUseContentBlock.
+        Purpose: Ensure model accepts valid tool use data.
+        """
+        print("Setup: Creating ToolUseContentBlock with valid data...")
+        block = ToolUseContentBlock(
+            id="call_123",
+            name="get_weather",
+            input={"location": "Moscow", "units": "celsius"}
+        )
+        
+        print(f"Result: {block}")
+        print(f"Comparing type: Expected 'tool_use', Got '{block.type}'")
+        assert block.type == "tool_use"
+        
+        print(f"Comparing id: Expected 'call_123', Got '{block.id}'")
+        assert block.id == "call_123"
+        
+        print(f"Comparing name: Expected 'get_weather', Got '{block.name}'")
+        assert block.name == "get_weather"
+        
+        print(f"Comparing input: Got {block.input}")
+        assert block.input == {"location": "Moscow", "units": "celsius"}
+    
+    def test_type_defaults_to_tool_use(self):
+        """
+        What it does: Verifies that type defaults to "tool_use".
+        Purpose: Ensure default value is set correctly.
+        """
+        print("Setup: Creating ToolUseContentBlock without explicit type...")
+        block = ToolUseContentBlock(id="call_1", name="test", input={})
+        
+        print(f"Comparing type: Expected 'tool_use', Got '{block.type}'")
+        assert block.type == "tool_use"
+    
+    def test_requires_id(self):
+        """
+        What it does: Verifies that id is required.
+        Purpose: Ensure validation fails without id.
+        """
+        print("Setup: Attempting to create ToolUseContentBlock without id...")
+        
+        print("Action: Creating model (should raise ValidationError)...")
+        with pytest.raises(ValidationError) as exc_info:
+            ToolUseContentBlock(name="test", input={})
+        
+        print(f"ValidationError raised: {exc_info.value}")
+        assert "id" in str(exc_info.value)
+    
+    def test_requires_name(self):
+        """
+        What it does: Verifies that name is required.
+        Purpose: Ensure validation fails without name.
+        """
+        print("Setup: Attempting to create ToolUseContentBlock without name...")
+        
+        print("Action: Creating model (should raise ValidationError)...")
+        with pytest.raises(ValidationError) as exc_info:
+            ToolUseContentBlock(id="call_1", input={})
+        
+        print(f"ValidationError raised: {exc_info.value}")
+        assert "name" in str(exc_info.value)
+    
+    def test_requires_input(self):
+        """
+        What it does: Verifies that input is required.
+        Purpose: Ensure validation fails without input.
+        """
+        print("Setup: Attempting to create ToolUseContentBlock without input...")
+        
+        print("Action: Creating model (should raise ValidationError)...")
+        with pytest.raises(ValidationError) as exc_info:
+            ToolUseContentBlock(id="call_1", name="test")
+        
+        print(f"ValidationError raised: {exc_info.value}")
+        assert "input" in str(exc_info.value)
+    
+    def test_accepts_empty_input(self):
+        """
+        What it does: Verifies that empty input dict is accepted.
+        Purpose: Ensure tools without parameters work.
+        """
+        print("Setup: Creating ToolUseContentBlock with empty input...")
+        block = ToolUseContentBlock(id="call_1", name="no_params_tool", input={})
+        
+        print(f"Comparing input: Expected {{}}, Got {block.input}")
+        assert block.input == {}
+    
+    def test_accepts_complex_input(self):
+        """
+        What it does: Verifies that complex nested input is accepted.
+        Purpose: Ensure nested structures work.
+        """
+        print("Setup: Creating ToolUseContentBlock with complex input...")
+        complex_input = {
+            "query": "test",
+            "options": {"limit": 10, "offset": 0},
+            "filters": ["active", "recent"]
+        }
+        block = ToolUseContentBlock(id="call_1", name="search", input=complex_input)
+        
+        print(f"Comparing input: Got {block.input}")
+        assert block.input == complex_input
+
+
+# ==================================================================================================
+# Tests for ToolResultContentBlock
+# ==================================================================================================
+
+class TestToolResultContentBlock:
+    """Tests for ToolResultContentBlock Pydantic model."""
+    
+    def test_valid_tool_result_block(self):
+        """
+        What it does: Verifies creation of valid ToolResultContentBlock.
+        Purpose: Ensure model accepts valid tool result data.
+        """
+        print("Setup: Creating ToolResultContentBlock with valid data...")
+        block = ToolResultContentBlock(
+            tool_use_id="call_123",
+            content="Weather in Moscow: Sunny, 25°C"
+        )
+        
+        print(f"Result: {block}")
+        print(f"Comparing type: Expected 'tool_result', Got '{block.type}'")
+        assert block.type == "tool_result"
+        
+        print(f"Comparing tool_use_id: Expected 'call_123', Got '{block.tool_use_id}'")
+        assert block.tool_use_id == "call_123"
+        
+        print(f"Comparing content: Got '{block.content}'")
+        assert block.content == "Weather in Moscow: Sunny, 25°C"
+    
+    def test_type_defaults_to_tool_result(self):
+        """
+        What it does: Verifies that type defaults to "tool_result".
+        Purpose: Ensure default value is set correctly.
+        """
+        print("Setup: Creating ToolResultContentBlock without explicit type...")
+        block = ToolResultContentBlock(tool_use_id="call_1")
+        
+        print(f"Comparing type: Expected 'tool_result', Got '{block.type}'")
+        assert block.type == "tool_result"
+    
+    def test_requires_tool_use_id(self):
+        """
+        What it does: Verifies that tool_use_id is required.
+        Purpose: Ensure validation fails without tool_use_id.
+        """
+        print("Setup: Attempting to create ToolResultContentBlock without tool_use_id...")
+        
+        print("Action: Creating model (should raise ValidationError)...")
+        with pytest.raises(ValidationError) as exc_info:
+            ToolResultContentBlock(content="Result")
+        
+        print(f"ValidationError raised: {exc_info.value}")
+        assert "tool_use_id" in str(exc_info.value)
+    
+    def test_content_is_optional(self):
+        """
+        What it does: Verifies that content is optional.
+        Purpose: Ensure tool results without content work.
+        """
+        print("Setup: Creating ToolResultContentBlock without content...")
+        block = ToolResultContentBlock(tool_use_id="call_1")
+        
+        print(f"Comparing content: Expected None, Got {block.content}")
+        assert block.content is None
+    
+    def test_accepts_list_content(self):
+        """
+        What it does: Verifies that list content is accepted.
+        Purpose: Ensure content can be list of TextContentBlock.
+        """
+        print("Setup: Creating ToolResultContentBlock with list content...")
+        block = ToolResultContentBlock(
+            tool_use_id="call_1",
+            content=[TextContentBlock(text="Part 1"), TextContentBlock(text="Part 2")]
+        )
+        
+        print(f"Comparing content type: Expected list, Got {type(block.content)}")
+        assert isinstance(block.content, list)
+        assert len(block.content) == 2
+    
+    def test_is_error_field(self):
+        """
+        What it does: Verifies that is_error field works.
+        Purpose: Ensure error results can be marked.
+        """
+        print("Setup: Creating ToolResultContentBlock with is_error=True...")
+        block = ToolResultContentBlock(
+            tool_use_id="call_1",
+            content="Error: File not found",
+            is_error=True
+        )
+        
+        print(f"Comparing is_error: Expected True, Got {block.is_error}")
+        assert block.is_error is True
+    
+    def test_is_error_defaults_to_none(self):
+        """
+        What it does: Verifies that is_error defaults to None.
+        Purpose: Ensure default value is correct.
+        """
+        print("Setup: Creating ToolResultContentBlock without is_error...")
+        block = ToolResultContentBlock(tool_use_id="call_1", content="Success")
+        
+        print(f"Comparing is_error: Expected None, Got {block.is_error}")
+        assert block.is_error is None
+
+
+# ==================================================================================================
+# Tests for AnthropicTool
+# ==================================================================================================
+
+class TestAnthropicTool:
+    """Tests for AnthropicTool Pydantic model."""
+    
+    def test_valid_tool(self):
+        """
+        What it does: Verifies creation of valid AnthropicTool.
+        Purpose: Ensure model accepts valid tool definition.
+        """
+        print("Setup: Creating AnthropicTool with valid data...")
+        tool = AnthropicTool(
+            name="get_weather",
+            description="Get weather for a location",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "location": {"type": "string", "description": "City name"}
+                },
+                "required": ["location"]
+            }
+        )
+        
+        print(f"Result: {tool}")
+        print(f"Comparing name: Expected 'get_weather', Got '{tool.name}'")
+        assert tool.name == "get_weather"
+        
+        print(f"Comparing description: Got '{tool.description}'")
+        assert tool.description == "Get weather for a location"
+        
+        print(f"Comparing input_schema: Got {tool.input_schema}")
+        assert "properties" in tool.input_schema
+    
+    def test_requires_name(self):
+        """
+        What it does: Verifies that name is required.
+        Purpose: Ensure validation fails without name.
+        """
+        print("Setup: Attempting to create AnthropicTool without name...")
+        
+        print("Action: Creating model (should raise ValidationError)...")
+        with pytest.raises(ValidationError) as exc_info:
+            AnthropicTool(input_schema={})
+        
+        print(f"ValidationError raised: {exc_info.value}")
+        assert "name" in str(exc_info.value)
+    
+    def test_requires_input_schema(self):
+        """
+        What it does: Verifies that input_schema is required.
+        Purpose: Ensure validation fails without input_schema.
+        """
+        print("Setup: Attempting to create AnthropicTool without input_schema...")
+        
+        print("Action: Creating model (should raise ValidationError)...")
+        with pytest.raises(ValidationError) as exc_info:
+            AnthropicTool(name="test")
+        
+        print(f"ValidationError raised: {exc_info.value}")
+        assert "input_schema" in str(exc_info.value)
+    
+    def test_description_is_optional(self):
+        """
+        What it does: Verifies that description is optional.
+        Purpose: Ensure tools without description work.
+        """
+        print("Setup: Creating AnthropicTool without description...")
+        tool = AnthropicTool(name="simple_tool", input_schema={})
+        
+        print(f"Comparing description: Expected None, Got {tool.description}")
+        assert tool.description is None
+
+
+# ==================================================================================================
+# Tests for ToolChoice models
+# ==================================================================================================
+
+class TestToolChoiceModels:
+    """Tests for ToolChoice Pydantic models."""
+    
+    def test_tool_choice_auto(self):
+        """
+        What it does: Verifies creation of ToolChoiceAuto.
+        Purpose: Ensure auto tool choice works.
+        """
+        print("Setup: Creating ToolChoiceAuto...")
+        choice = ToolChoiceAuto()
+        
+        print(f"Result: {choice}")
+        print(f"Comparing type: Expected 'auto', Got '{choice.type}'")
+        assert choice.type == "auto"
+    
+    def test_tool_choice_any(self):
+        """
+        What it does: Verifies creation of ToolChoiceAny.
+        Purpose: Ensure any tool choice works.
+        """
+        print("Setup: Creating ToolChoiceAny...")
+        choice = ToolChoiceAny()
+        
+        print(f"Result: {choice}")
+        print(f"Comparing type: Expected 'any', Got '{choice.type}'")
+        assert choice.type == "any"
+    
+    def test_tool_choice_tool(self):
+        """
+        What it does: Verifies creation of ToolChoiceTool.
+        Purpose: Ensure specific tool choice works.
+        """
+        print("Setup: Creating ToolChoiceTool...")
+        choice = ToolChoiceTool(name="get_weather")
+        
+        print(f"Result: {choice}")
+        print(f"Comparing type: Expected 'tool', Got '{choice.type}'")
+        assert choice.type == "tool"
+        
+        print(f"Comparing name: Expected 'get_weather', Got '{choice.name}'")
+        assert choice.name == "get_weather"
+    
+    def test_tool_choice_tool_requires_name(self):
+        """
+        What it does: Verifies that ToolChoiceTool requires name.
+        Purpose: Ensure validation fails without name.
+        """
+        print("Setup: Attempting to create ToolChoiceTool without name...")
+        
+        print("Action: Creating model (should raise ValidationError)...")
+        with pytest.raises(ValidationError) as exc_info:
+            ToolChoiceTool()
+        
+        print(f"ValidationError raised: {exc_info.value}")
+        assert "name" in str(exc_info.value)
+
+
+# ==================================================================================================
+# Tests for SystemContentBlock
+# ==================================================================================================
+
+class TestSystemContentBlock:
+    """Tests for SystemContentBlock Pydantic model."""
+    
+    def test_valid_system_block(self):
+        """
+        What it does: Verifies creation of valid SystemContentBlock.
+        Purpose: Ensure model accepts valid system content.
+        """
+        print("Setup: Creating SystemContentBlock with valid data...")
+        block = SystemContentBlock(text="You are a helpful assistant.")
+        
+        print(f"Result: {block}")
+        print(f"Comparing type: Expected 'text', Got '{block.type}'")
+        assert block.type == "text"
+        
+        print(f"Comparing text: Got '{block.text}'")
+        assert block.text == "You are a helpful assistant."
+    
+    def test_with_cache_control(self):
+        """
+        What it does: Verifies SystemContentBlock with cache_control.
+        Purpose: Ensure prompt caching format works.
+        """
+        print("Setup: Creating SystemContentBlock with cache_control...")
+        block = SystemContentBlock(
+            text="You are helpful.",
+            cache_control={"type": "ephemeral"}
+        )
+        
+        print(f"Result: {block}")
+        print(f"Comparing cache_control: Got {block.cache_control}")
+        assert block.cache_control == {"type": "ephemeral"}
+    
+    def test_cache_control_is_optional(self):
+        """
+        What it does: Verifies that cache_control is optional.
+        Purpose: Ensure blocks without cache_control work.
+        """
+        print("Setup: Creating SystemContentBlock without cache_control...")
+        block = SystemContentBlock(text="Test")
+        
+        print(f"Comparing cache_control: Expected None, Got {block.cache_control}")
+        assert block.cache_control is None
+    
+    def test_requires_text(self):
+        """
+        What it does: Verifies that text is required.
+        Purpose: Ensure validation fails without text.
+        """
+        print("Setup: Attempting to create SystemContentBlock without text...")
+        
+        print("Action: Creating model (should raise ValidationError)...")
+        with pytest.raises(ValidationError) as exc_info:
+            SystemContentBlock()
+        
+        print(f"ValidationError raised: {exc_info.value}")
+        assert "text" in str(exc_info.value)
+
+
+# ==================================================================================================
+# Tests for AnthropicUsage
+# ==================================================================================================
+
+class TestAnthropicUsage:
+    """Tests for AnthropicUsage Pydantic model."""
+    
+    def test_valid_usage(self):
+        """
+        What it does: Verifies creation of valid AnthropicUsage.
+        Purpose: Ensure model accepts valid usage data.
+        """
+        print("Setup: Creating AnthropicUsage with valid data...")
+        usage = AnthropicUsage(input_tokens=100, output_tokens=50)
+        
+        print(f"Result: {usage}")
+        print(f"Comparing input_tokens: Expected 100, Got {usage.input_tokens}")
+        assert usage.input_tokens == 100
+        
+        print(f"Comparing output_tokens: Expected 50, Got {usage.output_tokens}")
+        assert usage.output_tokens == 50
+    
+    def test_requires_input_tokens(self):
+        """
+        What it does: Verifies that input_tokens is required.
+        Purpose: Ensure validation fails without input_tokens.
+        """
+        print("Setup: Attempting to create AnthropicUsage without input_tokens...")
+        
+        print("Action: Creating model (should raise ValidationError)...")
+        with pytest.raises(ValidationError) as exc_info:
+            AnthropicUsage(output_tokens=50)
+        
+        print(f"ValidationError raised: {exc_info.value}")
+        assert "input_tokens" in str(exc_info.value)
+    
+    def test_requires_output_tokens(self):
+        """
+        What it does: Verifies that output_tokens is required.
+        Purpose: Ensure validation fails without output_tokens.
+        """
+        print("Setup: Attempting to create AnthropicUsage without output_tokens...")
+        
+        print("Action: Creating model (should raise ValidationError)...")
+        with pytest.raises(ValidationError) as exc_info:
+            AnthropicUsage(input_tokens=100)
+        
+        print(f"ValidationError raised: {exc_info.value}")
+        assert "output_tokens" in str(exc_info.value)
+
+
+# ==================================================================================================
+# Tests for AnthropicMessagesResponse
+# ==================================================================================================
+
+class TestAnthropicMessagesResponse:
+    """Tests for AnthropicMessagesResponse Pydantic model."""
+    
+    def test_valid_response(self):
+        """
+        What it does: Verifies creation of valid AnthropicMessagesResponse.
+        Purpose: Ensure model accepts valid response data.
+        """
+        print("Setup: Creating AnthropicMessagesResponse with valid data...")
+        response = AnthropicMessagesResponse(
+            id="msg_123",
+            model="claude-sonnet-4-5",
+            content=[TextContentBlock(text="Hello!")],
+            usage=AnthropicUsage(input_tokens=10, output_tokens=5)
+        )
+        
+        print(f"Result: {response}")
+        print(f"Comparing id: Expected 'msg_123', Got '{response.id}'")
+        assert response.id == "msg_123"
+        
+        print(f"Comparing type: Expected 'message', Got '{response.type}'")
+        assert response.type == "message"
+        
+        print(f"Comparing role: Expected 'assistant', Got '{response.role}'")
+        assert response.role == "assistant"
+        
+        print(f"Comparing model: Expected 'claude-sonnet-4-5', Got '{response.model}'")
+        assert response.model == "claude-sonnet-4-5"
+    
+    def test_stop_reason_values(self):
+        """
+        What it does: Verifies that stop_reason accepts valid values.
+        Purpose: Ensure all stop reasons work.
+        """
+        print("Setup: Testing various stop_reason values...")
+        stop_reasons = ["end_turn", "max_tokens", "stop_sequence", "tool_use"]
+        
+        for reason in stop_reasons:
+            print(f"Testing stop_reason: {reason}")
+            response = AnthropicMessagesResponse(
+                id="msg_1",
+                model="claude-sonnet-4-5",
+                content=[TextContentBlock(text="Test")],
+                usage=AnthropicUsage(input_tokens=1, output_tokens=1),
+                stop_reason=reason
+            )
+            assert response.stop_reason == reason
+        
+        print("All stop_reason values accepted successfully")
+    
+    def test_stop_reason_is_optional(self):
+        """
+        What it does: Verifies that stop_reason is optional.
+        Purpose: Ensure responses without stop_reason work.
+        """
+        print("Setup: Creating response without stop_reason...")
+        response = AnthropicMessagesResponse(
+            id="msg_1",
+            model="claude-sonnet-4-5",
+            content=[TextContentBlock(text="Test")],
+            usage=AnthropicUsage(input_tokens=1, output_tokens=1)
+        )
+        
+        print(f"Comparing stop_reason: Expected None, Got {response.stop_reason}")
+        assert response.stop_reason is None
+
+
+# ==================================================================================================
+# Tests for Streaming Event Models
+# ==================================================================================================
+
+class TestStreamingEvents:
+    """Tests for streaming event Pydantic models."""
+    
+    def test_message_start_event(self):
+        """
+        What it does: Verifies creation of MessageStartEvent.
+        Purpose: Ensure message_start event works.
+        """
+        print("Setup: Creating MessageStartEvent...")
+        event = MessageStartEvent(
+            message={"id": "msg_1", "type": "message", "role": "assistant"}
+        )
+        
+        print(f"Result: {event}")
+        print(f"Comparing type: Expected 'message_start', Got '{event.type}'")
+        assert event.type == "message_start"
+        assert event.message["id"] == "msg_1"
+    
+    def test_content_block_start_event(self):
+        """
+        What it does: Verifies creation of ContentBlockStartEvent.
+        Purpose: Ensure content_block_start event works.
+        """
+        print("Setup: Creating ContentBlockStartEvent...")
+        event = ContentBlockStartEvent(
+            index=0,
+            content_block={"type": "text", "text": ""}
+        )
+        
+        print(f"Result: {event}")
+        print(f"Comparing type: Expected 'content_block_start', Got '{event.type}'")
+        assert event.type == "content_block_start"
+        assert event.index == 0
+    
+    def test_text_delta(self):
+        """
+        What it does: Verifies creation of TextDelta.
+        Purpose: Ensure text_delta works.
+        """
+        print("Setup: Creating TextDelta...")
+        delta = TextDelta(text="Hello")
+        
+        print(f"Result: {delta}")
+        print(f"Comparing type: Expected 'text_delta', Got '{delta.type}'")
+        assert delta.type == "text_delta"
+        assert delta.text == "Hello"
+    
+    def test_thinking_delta(self):
+        """
+        What it does: Verifies creation of ThinkingDelta.
+        Purpose: Ensure thinking_delta works.
+        """
+        print("Setup: Creating ThinkingDelta...")
+        delta = ThinkingDelta(thinking="Let me think...")
+        
+        print(f"Result: {delta}")
+        print(f"Comparing type: Expected 'thinking_delta', Got '{delta.type}'")
+        assert delta.type == "thinking_delta"
+        assert delta.thinking == "Let me think..."
+    
+    def test_input_json_delta(self):
+        """
+        What it does: Verifies creation of InputJsonDelta.
+        Purpose: Ensure input_json_delta works.
+        """
+        print("Setup: Creating InputJsonDelta...")
+        delta = InputJsonDelta(partial_json='{"loc')
+        
+        print(f"Result: {delta}")
+        print(f"Comparing type: Expected 'input_json_delta', Got '{delta.type}'")
+        assert delta.type == "input_json_delta"
+        assert delta.partial_json == '{"loc'
+    
+    def test_content_block_delta_event(self):
+        """
+        What it does: Verifies creation of ContentBlockDeltaEvent.
+        Purpose: Ensure content_block_delta event works.
+        """
+        print("Setup: Creating ContentBlockDeltaEvent...")
+        event = ContentBlockDeltaEvent(
+            index=0,
+            delta=TextDelta(text="Hello")
+        )
+        
+        print(f"Result: {event}")
+        print(f"Comparing type: Expected 'content_block_delta', Got '{event.type}'")
+        assert event.type == "content_block_delta"
+        assert event.index == 0
+    
+    def test_content_block_stop_event(self):
+        """
+        What it does: Verifies creation of ContentBlockStopEvent.
+        Purpose: Ensure content_block_stop event works.
+        """
+        print("Setup: Creating ContentBlockStopEvent...")
+        event = ContentBlockStopEvent(index=0)
+        
+        print(f"Result: {event}")
+        print(f"Comparing type: Expected 'content_block_stop', Got '{event.type}'")
+        assert event.type == "content_block_stop"
+        assert event.index == 0
+    
+    def test_message_delta_event(self):
+        """
+        What it does: Verifies creation of MessageDeltaEvent.
+        Purpose: Ensure message_delta event works.
+        """
+        print("Setup: Creating MessageDeltaEvent...")
+        event = MessageDeltaEvent(
+            delta={"stop_reason": "end_turn"},
+            usage=MessageDeltaUsage(output_tokens=10)
+        )
+        
+        print(f"Result: {event}")
+        print(f"Comparing type: Expected 'message_delta', Got '{event.type}'")
+        assert event.type == "message_delta"
+        assert event.delta["stop_reason"] == "end_turn"
+    
+    def test_message_stop_event(self):
+        """
+        What it does: Verifies creation of MessageStopEvent.
+        Purpose: Ensure message_stop event works.
+        """
+        print("Setup: Creating MessageStopEvent...")
+        event = MessageStopEvent()
+        
+        print(f"Result: {event}")
+        print(f"Comparing type: Expected 'message_stop', Got '{event.type}'")
+        assert event.type == "message_stop"
+    
+    def test_ping_event(self):
+        """
+        What it does: Verifies creation of PingEvent.
+        Purpose: Ensure ping event works.
+        """
+        print("Setup: Creating PingEvent...")
+        event = PingEvent()
+        
+        print(f"Result: {event}")
+        print(f"Comparing type: Expected 'ping', Got '{event.type}'")
+        assert event.type == "ping"
+    
+    def test_error_event(self):
+        """
+        What it does: Verifies creation of ErrorEvent.
+        Purpose: Ensure error event works.
+        """
+        print("Setup: Creating ErrorEvent...")
+        event = ErrorEvent(error={"type": "invalid_request", "message": "Bad request"})
+        
+        print(f"Result: {event}")
+        print(f"Comparing type: Expected 'error', Got '{event.type}'")
+        assert event.type == "error"
+        assert event.error["type"] == "invalid_request"
+
+
+# ==================================================================================================
+# Tests for Error Models
+# ==================================================================================================
+
+class TestErrorModels:
+    """Tests for error Pydantic models."""
+    
+    def test_anthropic_error_detail(self):
+        """
+        What it does: Verifies creation of AnthropicErrorDetail.
+        Purpose: Ensure error detail model works.
+        """
+        print("Setup: Creating AnthropicErrorDetail...")
+        detail = AnthropicErrorDetail(
+            type="invalid_request_error",
+            message="Invalid API key"
+        )
+        
+        print(f"Result: {detail}")
+        print(f"Comparing type: Expected 'invalid_request_error', Got '{detail.type}'")
+        assert detail.type == "invalid_request_error"
+        
+        print(f"Comparing message: Got '{detail.message}'")
+        assert detail.message == "Invalid API key"
+    
+    def test_anthropic_error_response(self):
+        """
+        What it does: Verifies creation of AnthropicErrorResponse.
+        Purpose: Ensure error response model works.
+        """
+        print("Setup: Creating AnthropicErrorResponse...")
+        response = AnthropicErrorResponse(
+            error=AnthropicErrorDetail(
+                type="authentication_error",
+                message="Invalid API key provided"
+            )
+        )
+        
+        print(f"Result: {response}")
+        print(f"Comparing type: Expected 'error', Got '{response.type}'")
+        assert response.type == "error"
+        
+        print(f"Comparing error.type: Got '{response.error.type}'")
+        assert response.error.type == "authentication_error"

tests/unit/test_models_openai.py

@@ -0,0 +1,1029 @@
+# -*- coding: utf-8 -*-
+
+"""
+Unit tests for OpenAI Pydantic models.
+
+Comprehensive tests for all OpenAI-compatible API models:
+- Model listing (OpenAIModel, ModelList)
+- Chat messages (ChatMessage)
+- Tools (ToolFunction, Tool)
+- Requests (ChatCompletionRequest)
+- Responses (ChatCompletionChoice, ChatCompletionUsage, ChatCompletionResponse)
+- Streaming (ChatCompletionChunk, ChatCompletionChunkChoice, ChatCompletionChunkDelta)
+"""
+
+import pytest
+from pydantic import ValidationError
+
+from kiro.models_openai import (
+    # Model listing
+    OpenAIModel,
+    ModelList,
+    # Chat messages
+    ChatMessage,
+    # Tools
+    ToolFunction,
+    Tool,
+    # Requests
+    ChatCompletionRequest,
+    # Responses
+    ChatCompletionChoice,
+    ChatCompletionUsage,
+    ChatCompletionResponse,
+    # Streaming
+    ChatCompletionChunkDelta,
+    ChatCompletionChunkChoice,
+    ChatCompletionChunk,
+)
+
+
+# ==================================================================================================
+# Tests for OpenAIModel
+# ==================================================================================================
+
+class TestOpenAIModel:
+    """Tests for OpenAIModel Pydantic model."""
+    
+    def test_valid_model(self):
+        """
+        What it does: Verifies creation of valid OpenAIModel.
+        Purpose: Ensure model accepts valid data.
+        """
+        print("Setup: Creating OpenAIModel with valid data...")
+        model = OpenAIModel(
+            id="claude-sonnet-4-5",
+            description="Claude Sonnet 4.5 model"
+        )
+        
+        print(f"Result: {model}")
+        print(f"Comparing id: Expected 'claude-sonnet-4-5', Got '{model.id}'")
+        assert model.id == "claude-sonnet-4-5"
+        
+        print(f"Comparing object: Expected 'model', Got '{model.object}'")
+        assert model.object == "model"
+        
+        print(f"Comparing owned_by: Expected 'anthropic', Got '{model.owned_by}'")
+        assert model.owned_by == "anthropic"
+        
+        print(f"Comparing description: Got '{model.description}'")
+        assert model.description == "Claude Sonnet 4.5 model"
+    
+    def test_requires_id(self):
+        """
+        What it does: Verifies that id is required.
+        Purpose: Ensure validation fails without id.
+        """
+        print("Setup: Attempting to create OpenAIModel without id...")
+        
+        print("Action: Creating model (should raise ValidationError)...")
+        with pytest.raises(ValidationError) as exc_info:
+            OpenAIModel()
+        
+        print(f"ValidationError raised: {exc_info.value}")
+        assert "id" in str(exc_info.value)
+    
+    def test_object_defaults_to_model(self):
+        """
+        What it does: Verifies that object defaults to "model".
+        Purpose: Ensure default value is set correctly.
+        """
+        print("Setup: Creating OpenAIModel without explicit object...")
+        model = OpenAIModel(id="test-model")
+        
+        print(f"Comparing object: Expected 'model', Got '{model.object}'")
+        assert model.object == "model"
+    
+    def test_owned_by_defaults_to_anthropic(self):
+        """
+        What it does: Verifies that owned_by defaults to "anthropic".
+        Purpose: Ensure default value is set correctly.
+        """
+        print("Setup: Creating OpenAIModel without explicit owned_by...")
+        model = OpenAIModel(id="test-model")
+        
+        print(f"Comparing owned_by: Expected 'anthropic', Got '{model.owned_by}'")
+        assert model.owned_by == "anthropic"
+    
+    def test_created_is_auto_generated(self):
+        """
+        What it does: Verifies that created timestamp is auto-generated.
+        Purpose: Ensure timestamp is set automatically.
+        """
+        print("Setup: Creating OpenAIModel without explicit created...")
+        model = OpenAIModel(id="test-model")
+        
+        print(f"Comparing created: Got {model.created}")
+        assert model.created > 0
+        assert isinstance(model.created, int)
+    
+    def test_description_is_optional(self):
+        """
+        What it does: Verifies that description is optional.
+        Purpose: Ensure models without description work.
+        """
+        print("Setup: Creating OpenAIModel without description...")
+        model = OpenAIModel(id="test-model")
+        
+        print(f"Comparing description: Expected None, Got {model.description}")
+        assert model.description is None
+
+
+# ==================================================================================================
+# Tests for ModelList
+# ==================================================================================================
+
+class TestModelList:
+    """Tests for ModelList Pydantic model."""
+    
+    def test_valid_model_list(self):
+        """
+        What it does: Verifies creation of valid ModelList.
+        Purpose: Ensure model list accepts valid data.
+        """
+        print("Setup: Creating ModelList with valid data...")
+        model_list = ModelList(
+            data=[
+                OpenAIModel(id="claude-sonnet-4-5"),
+                OpenAIModel(id="claude-opus-4")
+            ]
+        )
+        
+        print(f"Result: {model_list}")
+        print(f"Comparing object: Expected 'list', Got '{model_list.object}'")
+        assert model_list.object == "list"
+        
+        print(f"Comparing data length: Expected 2, Got {len(model_list.data)}")
+        assert len(model_list.data) == 2
+    
+    def test_object_defaults_to_list(self):
+        """
+        What it does: Verifies that object defaults to "list".
+        Purpose: Ensure default value is set correctly.
+        """
+        print("Setup: Creating ModelList without explicit object...")
+        model_list = ModelList(data=[])
+        
+        print(f"Comparing object: Expected 'list', Got '{model_list.object}'")
+        assert model_list.object == "list"
+    
+    def test_requires_data(self):
+        """
+        What it does: Verifies that data is required.
+        Purpose: Ensure validation fails without data.
+        """
+        print("Setup: Attempting to create ModelList without data...")
+        
+        print("Action: Creating model (should raise ValidationError)...")
+        with pytest.raises(ValidationError) as exc_info:
+            ModelList()
+        
+        print(f"ValidationError raised: {exc_info.value}")
+        assert "data" in str(exc_info.value)
+    
+    def test_accepts_empty_list(self):
+        """
+        What it does: Verifies that empty list is accepted.
+        Purpose: Ensure empty model list works.
+        """
+        print("Setup: Creating ModelList with empty data...")
+        model_list = ModelList(data=[])
+        
+        print(f"Comparing data: Expected [], Got {model_list.data}")
+        assert model_list.data == []
+
+
+# ==================================================================================================
+# Tests for ChatMessage
+# ==================================================================================================
+
+class TestChatMessage:
+    """Tests for ChatMessage Pydantic model."""
+    
+    def test_valid_user_message(self):
+        """
+        What it does: Verifies creation of valid user message.
+        Purpose: Ensure model accepts valid user message.
+        """
+        print("Setup: Creating ChatMessage with user role...")
+        message = ChatMessage(role="user", content="Hello!")
+        
+        print(f"Result: {message}")
+        print(f"Comparing role: Expected 'user', Got '{message.role}'")
+        assert message.role == "user"
+        
+        print(f"Comparing content: Expected 'Hello!', Got '{message.content}'")
+        assert message.content == "Hello!"
+    
+    def test_valid_assistant_message(self):
+        """
+        What it does: Verifies creation of valid assistant message.
+        Purpose: Ensure model accepts valid assistant message.
+        """
+        print("Setup: Creating ChatMessage with assistant role...")
+        message = ChatMessage(role="assistant", content="Hi there!")
+        
+        print(f"Result: {message}")
+        print(f"Comparing role: Expected 'assistant', Got '{message.role}'")
+        assert message.role == "assistant"
+    
+    def test_valid_system_message(self):
+        """
+        What it does: Verifies creation of valid system message.
+        Purpose: Ensure model accepts valid system message.
+        """
+        print("Setup: Creating ChatMessage with system role...")
+        message = ChatMessage(role="system", content="You are helpful.")
+        
+        print(f"Result: {message}")
+        print(f"Comparing role: Expected 'system', Got '{message.role}'")
+        assert message.role == "system"
+    
+    def test_valid_tool_message(self):
+        """
+        What it does: Verifies creation of valid tool message.
+        Purpose: Ensure model accepts valid tool message.
+        """
+        print("Setup: Creating ChatMessage with tool role...")
+        message = ChatMessage(
+            role="tool",
+            content="Tool result",
+            tool_call_id="call_123"
+        )
+        
+        print(f"Result: {message}")
+        print(f"Comparing role: Expected 'tool', Got '{message.role}'")
+        assert message.role == "tool"
+        
+        print(f"Comparing tool_call_id: Expected 'call_123', Got '{message.tool_call_id}'")
+        assert message.tool_call_id == "call_123"
+    
+    def test_requires_role(self):
+        """
+        What it does: Verifies that role is required.
+        Purpose: Ensure validation fails without role.
+        """
+        print("Setup: Attempting to create ChatMessage without role...")
+        
+        print("Action: Creating model (should raise ValidationError)...")
+        with pytest.raises(ValidationError) as exc_info:
+            ChatMessage(content="Hello")
+        
+        print(f"ValidationError raised: {exc_info.value}")
+        assert "role" in str(exc_info.value)
+    
+    def test_content_is_optional(self):
+        """
+        What it does: Verifies that content is optional.
+        Purpose: Ensure messages without content work (e.g., tool calls).
+        """
+        print("Setup: Creating ChatMessage without content...")
+        message = ChatMessage(role="assistant")
+        
+        print(f"Comparing content: Expected None, Got {message.content}")
+        assert message.content is None
+    
+    def test_accepts_list_content(self):
+        """
+        What it does: Verifies that list content is accepted.
+        Purpose: Ensure multimodal content works.
+        """
+        print("Setup: Creating ChatMessage with list content...")
+        message = ChatMessage(
+            role="user",
+            content=[
+                {"type": "text", "text": "What's in this image?"},
+                {"type": "image_url", "image_url": {"url": "https://example.com/img.jpg"}}
+            ]
+        )
+        
+        print(f"Result: {message}")
+        print(f"Comparing content type: Expected list, Got {type(message.content)}")
+        assert isinstance(message.content, list)
+        assert len(message.content) == 2
+    
+    def test_accepts_tool_calls(self):
+        """
+        What it does: Verifies that tool_calls is accepted.
+        Purpose: Ensure assistant messages with tool calls work.
+        """
+        print("Setup: Creating ChatMessage with tool_calls...")
+        message = ChatMessage(
+            role="assistant",
+            content="I'll call a tool",
+            tool_calls=[{
+                "id": "call_123",
+                "type": "function",
+                "function": {"name": "get_weather", "arguments": '{"location": "Moscow"}'}
+            }]
+        )
+        
+        print(f"Result: {message}")
+        print(f"Comparing tool_calls: Got {message.tool_calls}")
+        assert message.tool_calls is not None
+        assert len(message.tool_calls) == 1
+    
+    def test_name_is_optional(self):
+        """
+        What it does: Verifies that name is optional.
+        Purpose: Ensure messages without name work.
+        """
+        print("Setup: Creating ChatMessage without name...")
+        message = ChatMessage(role="user", content="Hello")
+        
+        print(f"Comparing name: Expected None, Got {message.name}")
+        assert message.name is None
+    
+    def test_accepts_name(self):
+        """
+        What it does: Verifies that name is accepted.
+        Purpose: Ensure named messages work.
+        """
+        print("Setup: Creating ChatMessage with name...")
+        message = ChatMessage(role="user", content="Hello", name="John")
+        
+        print(f"Comparing name: Expected 'John', Got '{message.name}'")
+        assert message.name == "John"
+    
+    def test_extra_fields_allowed(self):
+        """
+        What it does: Verifies that extra fields are allowed.
+        Purpose: Ensure model_config extra="allow" works.
+        """
+        print("Setup: Creating ChatMessage with extra field...")
+        message = ChatMessage(role="user", content="Hello", custom_field="value")
+        
+        print(f"Comparing custom_field: Got '{message.custom_field}'")
+        assert message.custom_field == "value"
+
+
+# ==================================================================================================
+# Tests for ToolFunction
+# ==================================================================================================
+
+class TestToolFunction:
+    """Tests for ToolFunction Pydantic model."""
+    
+    def test_valid_tool_function(self):
+        """
+        What it does: Verifies creation of valid ToolFunction.
+        Purpose: Ensure model accepts valid tool function.
+        """
+        print("Setup: Creating ToolFunction with valid data...")
+        func = ToolFunction(
+            name="get_weather",
+            description="Get weather for a location",
+            parameters={
+                "type": "object",
+                "properties": {"location": {"type": "string"}}
+            }
+        )
+        
+        print(f"Result: {func}")
+        print(f"Comparing name: Expected 'get_weather', Got '{func.name}'")
+        assert func.name == "get_weather"
+        
+        print(f"Comparing description: Got '{func.description}'")
+        assert func.description == "Get weather for a location"
+        
+        print(f"Comparing parameters: Got {func.parameters}")
+        assert "properties" in func.parameters
+    
+    def test_requires_name(self):
+        """
+        What it does: Verifies that name is required.
+        Purpose: Ensure validation fails without name.
+        """
+        print("Setup: Attempting to create ToolFunction without name...")
+        
+        print("Action: Creating model (should raise ValidationError)...")
+        with pytest.raises(ValidationError) as exc_info:
+            ToolFunction(description="Test")
+        
+        print(f"ValidationError raised: {exc_info.value}")
+        assert "name" in str(exc_info.value)
+    
+    def test_description_is_optional(self):
+        """
+        What it does: Verifies that description is optional.
+        Purpose: Ensure functions without description work.
+        """
+        print("Setup: Creating ToolFunction without description...")
+        func = ToolFunction(name="test_func")
+        
+        print(f"Comparing description: Expected None, Got {func.description}")
+        assert func.description is None
+    
+    def test_parameters_is_optional(self):
+        """
+        What it does: Verifies that parameters is optional.
+        Purpose: Ensure functions without parameters work.
+        """
+        print("Setup: Creating ToolFunction without parameters...")
+        func = ToolFunction(name="no_params_func")
+        
+        print(f"Comparing parameters: Expected None, Got {func.parameters}")
+        assert func.parameters is None
+
+
+# ==================================================================================================
+# Tests for Tool
+# ==================================================================================================
+
+class TestTool:
+    """Tests for Tool Pydantic model."""
+    
+    def test_valid_tool(self):
+        """
+        What it does: Verifies creation of valid Tool.
+        Purpose: Ensure model accepts valid tool.
+        """
+        print("Setup: Creating Tool with valid data...")
+        tool = Tool(
+            type="function",
+            function=ToolFunction(
+                name="get_weather",
+                description="Get weather",
+                parameters={}
+            )
+        )
+        
+        print(f"Result: {tool}")
+        print(f"Comparing type: Expected 'function', Got '{tool.type}'")
+        assert tool.type == "function"
+        
+        print(f"Comparing function.name: Expected 'get_weather', Got '{tool.function.name}'")
+        assert tool.function.name == "get_weather"
+    
+    def test_type_defaults_to_function(self):
+        """
+        What it does: Verifies that type defaults to "function".
+        Purpose: Ensure default value is set correctly.
+        """
+        print("Setup: Creating Tool without explicit type...")
+        tool = Tool(function=ToolFunction(name="test"))
+        
+        print(f"Comparing type: Expected 'function', Got '{tool.type}'")
+        assert tool.type == "function"
+    
+    def test_requires_function(self):
+        """
+        What it does: Verifies that function is required.
+        Purpose: Ensure validation fails without function.
+        """
+        print("Setup: Attempting to create Tool without function...")
+        
+        print("Action: Creating model (should raise ValidationError)...")
+        with pytest.raises(ValidationError) as exc_info:
+            Tool(type="function")
+        
+        print(f"ValidationError raised: {exc_info.value}")
+        assert "function" in str(exc_info.value)
+
+
+# ==================================================================================================
+# Tests for ChatCompletionRequest
+# ==================================================================================================
+
+class TestChatCompletionRequest:
+    """Tests for ChatCompletionRequest Pydantic model."""
+    
+    def test_valid_request(self):
+        """
+        What it does: Verifies creation of valid ChatCompletionRequest.
+        Purpose: Ensure model accepts valid request.
+        """
+        print("Setup: Creating ChatCompletionRequest with valid data...")
+        request = ChatCompletionRequest(
+            model="claude-sonnet-4-5",
+            messages=[ChatMessage(role="user", content="Hello")]
+        )
+        
+        print(f"Result: {request}")
+        print(f"Comparing model: Expected 'claude-sonnet-4-5', Got '{request.model}'")
+        assert request.model == "claude-sonnet-4-5"
+        
+        print(f"Comparing messages length: Expected 1, Got {len(request.messages)}")
+        assert len(request.messages) == 1
+        
+        print(f"Comparing stream: Expected False, Got {request.stream}")
+        assert request.stream is False
+    
+    def test_requires_model(self):
+        """
+        What it does: Verifies that model is required.
+        Purpose: Ensure validation fails without model.
+        """
+        print("Setup: Attempting to create ChatCompletionRequest without model...")
+        
+        print("Action: Creating model (should raise ValidationError)...")
+        with pytest.raises(ValidationError) as exc_info:
+            ChatCompletionRequest(messages=[ChatMessage(role="user", content="Hi")])
+        
+        print(f"ValidationError raised: {exc_info.value}")
+        assert "model" in str(exc_info.value)
+    
+    def test_requires_messages(self):
+        """
+        What it does: Verifies that messages is required.
+        Purpose: Ensure validation fails without messages.
+        """
+        print("Setup: Attempting to create ChatCompletionRequest without messages...")
+        
+        print("Action: Creating model (should raise ValidationError)...")
+        with pytest.raises(ValidationError) as exc_info:
+            ChatCompletionRequest(model="claude-sonnet-4-5")
+        
+        print(f"ValidationError raised: {exc_info.value}")
+        assert "messages" in str(exc_info.value)
+    
+    def test_requires_at_least_one_message(self):
+        """
+        What it does: Verifies that at least one message is required.
+        Purpose: Ensure validation fails with empty messages.
+        """
+        print("Setup: Attempting to create ChatCompletionRequest with empty messages...")
+        
+        print("Action: Creating model (should raise ValidationError)...")
+        with pytest.raises(ValidationError) as exc_info:
+            ChatCompletionRequest(model="claude-sonnet-4-5", messages=[])
+        
+        print(f"ValidationError raised: {exc_info.value}")
+    
+    def test_stream_defaults_to_false(self):
+        """
+        What it does: Verifies that stream defaults to False.
+        Purpose: Ensure default value is set correctly.
+        """
+        print("Setup: Creating ChatCompletionRequest without explicit stream...")
+        request = ChatCompletionRequest(
+            model="test",
+            messages=[ChatMessage(role="user", content="Hi")]
+        )
+        
+        print(f"Comparing stream: Expected False, Got {request.stream}")
+        assert request.stream is False
+    
+    def test_accepts_stream_true(self):
+        """
+        What it does: Verifies that stream=True is accepted.
+        Purpose: Ensure streaming requests work.
+        """
+        print("Setup: Creating ChatCompletionRequest with stream=True...")
+        request = ChatCompletionRequest(
+            model="test",
+            messages=[ChatMessage(role="user", content="Hi")],
+            stream=True
+        )
+        
+        print(f"Comparing stream: Expected True, Got {request.stream}")
+        assert request.stream is True
+    
+    def test_accepts_tools(self):
+        """
+        What it does: Verifies that tools are accepted.
+        Purpose: Ensure function calling works.
+        """
+        print("Setup: Creating ChatCompletionRequest with tools...")
+        request = ChatCompletionRequest(
+            model="test",
+            messages=[ChatMessage(role="user", content="Hi")],
+            tools=[Tool(function=ToolFunction(name="test_tool"))]
+        )
+        
+        print(f"Comparing tools: Got {request.tools}")
+        assert request.tools is not None
+        assert len(request.tools) == 1
+    
+    def test_accepts_generation_parameters(self):
+        """
+        What it does: Verifies that generation parameters are accepted.
+        Purpose: Ensure temperature, top_p, max_tokens work.
+        """
+        print("Setup: Creating ChatCompletionRequest with generation params...")
+        request = ChatCompletionRequest(
+            model="test",
+            messages=[ChatMessage(role="user", content="Hi")],
+            temperature=0.7,
+            top_p=0.9,
+            max_tokens=1000
+        )
+        
+        print(f"Comparing temperature: Expected 0.7, Got {request.temperature}")
+        assert request.temperature == 0.7
+        
+        print(f"Comparing top_p: Expected 0.9, Got {request.top_p}")
+        assert request.top_p == 0.9
+        
+        print(f"Comparing max_tokens: Expected 1000, Got {request.max_tokens}")
+        assert request.max_tokens == 1000
+
+
+# ==================================================================================================
+# Tests for ChatCompletionUsage
+# ==================================================================================================
+
+class TestChatCompletionUsage:
+    """Tests for ChatCompletionUsage Pydantic model."""
+    
+    def test_valid_usage(self):
+        """
+        What it does: Verifies creation of valid ChatCompletionUsage.
+        Purpose: Ensure model accepts valid usage data.
+        """
+        print("Setup: Creating ChatCompletionUsage with valid data...")
+        usage = ChatCompletionUsage(
+            prompt_tokens=100,
+            completion_tokens=50,
+            total_tokens=150
+        )
+        
+        print(f"Result: {usage}")
+        print(f"Comparing prompt_tokens: Expected 100, Got {usage.prompt_tokens}")
+        assert usage.prompt_tokens == 100
+        
+        print(f"Comparing completion_tokens: Expected 50, Got {usage.completion_tokens}")
+        assert usage.completion_tokens == 50
+        
+        print(f"Comparing total_tokens: Expected 150, Got {usage.total_tokens}")
+        assert usage.total_tokens == 150
+    
+    def test_defaults_to_zero(self):
+        """
+        What it does: Verifies that all fields default to 0.
+        Purpose: Ensure default values are set correctly.
+        """
+        print("Setup: Creating ChatCompletionUsage without explicit values...")
+        usage = ChatCompletionUsage()
+        
+        print(f"Comparing prompt_tokens: Expected 0, Got {usage.prompt_tokens}")
+        assert usage.prompt_tokens == 0
+        
+        print(f"Comparing completion_tokens: Expected 0, Got {usage.completion_tokens}")
+        assert usage.completion_tokens == 0
+        
+        print(f"Comparing total_tokens: Expected 0, Got {usage.total_tokens}")
+        assert usage.total_tokens == 0
+    
+    def test_credits_used_is_optional(self):
+        """
+        What it does: Verifies that credits_used is optional.
+        Purpose: Ensure Kiro-specific field is optional.
+        """
+        print("Setup: Creating ChatCompletionUsage without credits_used...")
+        usage = ChatCompletionUsage()
+        
+        print(f"Comparing credits_used: Expected None, Got {usage.credits_used}")
+        assert usage.credits_used is None
+
+
+# ==================================================================================================
+# Tests for ChatCompletionChoice
+# ==================================================================================================
+
+class TestChatCompletionChoice:
+    """Tests for ChatCompletionChoice Pydantic model."""
+    
+    def test_valid_choice(self):
+        """
+        What it does: Verifies creation of valid ChatCompletionChoice.
+        Purpose: Ensure model accepts valid choice data.
+        """
+        print("Setup: Creating ChatCompletionChoice with valid data...")
+        choice = ChatCompletionChoice(
+            index=0,
+            message={"role": "assistant", "content": "Hello!"},
+            finish_reason="stop"
+        )
+        
+        print(f"Result: {choice}")
+        print(f"Comparing index: Expected 0, Got {choice.index}")
+        assert choice.index == 0
+        
+        print(f"Comparing message: Got {choice.message}")
+        assert choice.message["role"] == "assistant"
+        
+        print(f"Comparing finish_reason: Expected 'stop', Got '{choice.finish_reason}'")
+        assert choice.finish_reason == "stop"
+    
+    def test_index_defaults_to_zero(self):
+        """
+        What it does: Verifies that index defaults to 0.
+        Purpose: Ensure default value is set correctly.
+        """
+        print("Setup: Creating ChatCompletionChoice without explicit index...")
+        choice = ChatCompletionChoice(message={"role": "assistant", "content": "Hi"})
+        
+        print(f"Comparing index: Expected 0, Got {choice.index}")
+        assert choice.index == 0
+    
+    def test_requires_message(self):
+        """
+        What it does: Verifies that message is required.
+        Purpose: Ensure validation fails without message.
+        """
+        print("Setup: Attempting to create ChatCompletionChoice without message...")
+        
+        print("Action: Creating model (should raise ValidationError)...")
+        with pytest.raises(ValidationError) as exc_info:
+            ChatCompletionChoice(index=0, finish_reason="stop")
+        
+        print(f"ValidationError raised: {exc_info.value}")
+        assert "message" in str(exc_info.value)
+    
+    def test_finish_reason_is_optional(self):
+        """
+        What it does: Verifies that finish_reason is optional.
+        Purpose: Ensure choices without finish_reason work.
+        """
+        print("Setup: Creating ChatCompletionChoice without finish_reason...")
+        choice = ChatCompletionChoice(message={"role": "assistant", "content": "Hi"})
+        
+        print(f"Comparing finish_reason: Expected None, Got {choice.finish_reason}")
+        assert choice.finish_reason is None
+
+
+# ==================================================================================================
+# Tests for ChatCompletionResponse
+# ==================================================================================================
+
+class TestChatCompletionResponse:
+    """Tests for ChatCompletionResponse Pydantic model."""
+    
+    def test_valid_response(self):
+        """
+        What it does: Verifies creation of valid ChatCompletionResponse.
+        Purpose: Ensure model accepts valid response data.
+        """
+        print("Setup: Creating ChatCompletionResponse with valid data...")
+        response = ChatCompletionResponse(
+            id="chatcmpl-123",
+            model="claude-sonnet-4-5",
+            choices=[ChatCompletionChoice(
+                message={"role": "assistant", "content": "Hello!"},
+                finish_reason="stop"
+            )],
+            usage=ChatCompletionUsage(prompt_tokens=10, completion_tokens=5, total_tokens=15)
+        )
+        
+        print(f"Result: {response}")
+        print(f"Comparing id: Expected 'chatcmpl-123', Got '{response.id}'")
+        assert response.id == "chatcmpl-123"
+        
+        print(f"Comparing object: Expected 'chat.completion', Got '{response.object}'")
+        assert response.object == "chat.completion"
+        
+        print(f"Comparing model: Expected 'claude-sonnet-4-5', Got '{response.model}'")
+        assert response.model == "claude-sonnet-4-5"
+        
+        print(f"Comparing choices length: Expected 1, Got {len(response.choices)}")
+        assert len(response.choices) == 1
+    
+    def test_object_defaults_to_chat_completion(self):
+        """
+        What it does: Verifies that object defaults to "chat.completion".
+        Purpose: Ensure default value is set correctly.
+        """
+        print("Setup: Creating ChatCompletionResponse without explicit object...")
+        response = ChatCompletionResponse(
+            id="test",
+            model="test",
+            choices=[ChatCompletionChoice(message={"role": "assistant", "content": "Hi"})],
+            usage=ChatCompletionUsage()
+        )
+        
+        print(f"Comparing object: Expected 'chat.completion', Got '{response.object}'")
+        assert response.object == "chat.completion"
+    
+    def test_created_is_auto_generated(self):
+        """
+        What it does: Verifies that created timestamp is auto-generated.
+        Purpose: Ensure timestamp is set automatically.
+        """
+        print("Setup: Creating ChatCompletionResponse without explicit created...")
+        response = ChatCompletionResponse(
+            id="test",
+            model="test",
+            choices=[ChatCompletionChoice(message={"role": "assistant", "content": "Hi"})],
+            usage=ChatCompletionUsage()
+        )
+        
+        print(f"Comparing created: Got {response.created}")
+        assert response.created > 0
+        assert isinstance(response.created, int)
+    
+    def test_requires_id(self):
+        """
+        What it does: Verifies that id is required.
+        Purpose: Ensure validation fails without id.
+        """
+        print("Setup: Attempting to create ChatCompletionResponse without id...")
+        
+        print("Action: Creating model (should raise ValidationError)...")
+        with pytest.raises(ValidationError) as exc_info:
+            ChatCompletionResponse(
+                model="test",
+                choices=[ChatCompletionChoice(message={"role": "assistant", "content": "Hi"})],
+                usage=ChatCompletionUsage()
+            )
+        
+        print(f"ValidationError raised: {exc_info.value}")
+        assert "id" in str(exc_info.value)
+
+
+# ==================================================================================================
+# Tests for Streaming Models
+# ==================================================================================================
+
+class TestChatCompletionChunkDelta:
+    """Tests for ChatCompletionChunkDelta Pydantic model."""
+    
+    def test_valid_delta_with_content(self):
+        """
+        What it does: Verifies creation of valid delta with content.
+        Purpose: Ensure model accepts content delta.
+        """
+        print("Setup: Creating ChatCompletionChunkDelta with content...")
+        delta = ChatCompletionChunkDelta(content="Hello")
+        
+        print(f"Result: {delta}")
+        print(f"Comparing content: Expected 'Hello', Got '{delta.content}'")
+        assert delta.content == "Hello"
+    
+    def test_valid_delta_with_role(self):
+        """
+        What it does: Verifies creation of valid delta with role.
+        Purpose: Ensure model accepts role delta (first chunk).
+        """
+        print("Setup: Creating ChatCompletionChunkDelta with role...")
+        delta = ChatCompletionChunkDelta(role="assistant")
+        
+        print(f"Result: {delta}")
+        print(f"Comparing role: Expected 'assistant', Got '{delta.role}'")
+        assert delta.role == "assistant"
+    
+    def test_all_fields_optional(self):
+        """
+        What it does: Verifies that all fields are optional.
+        Purpose: Ensure empty delta works.
+        """
+        print("Setup: Creating empty ChatCompletionChunkDelta...")
+        delta = ChatCompletionChunkDelta()
+        
+        print(f"Comparing role: Expected None, Got {delta.role}")
+        assert delta.role is None
+        
+        print(f"Comparing content: Expected None, Got {delta.content}")
+        assert delta.content is None
+        
+        print(f"Comparing tool_calls: Expected None, Got {delta.tool_calls}")
+        assert delta.tool_calls is None
+    
+    def test_accepts_tool_calls(self):
+        """
+        What it does: Verifies that tool_calls is accepted.
+        Purpose: Ensure streaming tool calls work.
+        """
+        print("Setup: Creating ChatCompletionChunkDelta with tool_calls...")
+        delta = ChatCompletionChunkDelta(
+            tool_calls=[{"index": 0, "id": "call_1", "function": {"name": "test"}}]
+        )
+        
+        print(f"Comparing tool_calls: Got {delta.tool_calls}")
+        assert delta.tool_calls is not None
+        assert len(delta.tool_calls) == 1
+
+
+class TestChatCompletionChunkChoice:
+    """Tests for ChatCompletionChunkChoice Pydantic model."""
+    
+    def test_valid_chunk_choice(self):
+        """
+        What it does: Verifies creation of valid chunk choice.
+        Purpose: Ensure model accepts valid chunk choice.
+        """
+        print("Setup: Creating ChatCompletionChunkChoice with valid data...")
+        choice = ChatCompletionChunkChoice(
+            index=0,
+            delta=ChatCompletionChunkDelta(content="Hello")
+        )
+        
+        print(f"Result: {choice}")
+        print(f"Comparing index: Expected 0, Got {choice.index}")
+        assert choice.index == 0
+        
+        print(f"Comparing delta.content: Expected 'Hello', Got '{choice.delta.content}'")
+        assert choice.delta.content == "Hello"
+    
+    def test_index_defaults_to_zero(self):
+        """
+        What it does: Verifies that index defaults to 0.
+        Purpose: Ensure default value is set correctly.
+        """
+        print("Setup: Creating ChatCompletionChunkChoice without explicit index...")
+        choice = ChatCompletionChunkChoice(delta=ChatCompletionChunkDelta())
+        
+        print(f"Comparing index: Expected 0, Got {choice.index}")
+        assert choice.index == 0
+    
+    def test_finish_reason_is_optional(self):
+        """
+        What it does: Verifies that finish_reason is optional.
+        Purpose: Ensure intermediate chunks work.
+        """
+        print("Setup: Creating ChatCompletionChunkChoice without finish_reason...")
+        choice = ChatCompletionChunkChoice(delta=ChatCompletionChunkDelta(content="Hi"))
+        
+        print(f"Comparing finish_reason: Expected None, Got {choice.finish_reason}")
+        assert choice.finish_reason is None
+    
+    def test_accepts_finish_reason(self):
+        """
+        What it does: Verifies that finish_reason is accepted.
+        Purpose: Ensure final chunk works.
+        """
+        print("Setup: Creating ChatCompletionChunkChoice with finish_reason...")
+        choice = ChatCompletionChunkChoice(
+            delta=ChatCompletionChunkDelta(),
+            finish_reason="stop"
+        )
+        
+        print(f"Comparing finish_reason: Expected 'stop', Got '{choice.finish_reason}'")
+        assert choice.finish_reason == "stop"
+
+
+class TestChatCompletionChunk:
+    """Tests for ChatCompletionChunk Pydantic model."""
+    
+    def test_valid_chunk(self):
+        """
+        What it does: Verifies creation of valid chunk.
+        Purpose: Ensure model accepts valid chunk data.
+        """
+        print("Setup: Creating ChatCompletionChunk with valid data...")
+        chunk = ChatCompletionChunk(
+            id="chatcmpl-123",
+            model="claude-sonnet-4-5",
+            choices=[ChatCompletionChunkChoice(
+                delta=ChatCompletionChunkDelta(content="Hello")
+            )]
+        )
+        
+        print(f"Result: {chunk}")
+        print(f"Comparing id: Expected 'chatcmpl-123', Got '{chunk.id}'")
+        assert chunk.id == "chatcmpl-123"
+        
+        print(f"Comparing object: Expected 'chat.completion.chunk', Got '{chunk.object}'")
+        assert chunk.object == "chat.completion.chunk"
+        
+        print(f"Comparing model: Expected 'claude-sonnet-4-5', Got '{chunk.model}'")
+        assert chunk.model == "claude-sonnet-4-5"
+    
+    def test_object_defaults_to_chunk(self):
+        """
+        What it does: Verifies that object defaults to "chat.completion.chunk".
+        Purpose: Ensure default value is set correctly.
+        """
+        print("Setup: Creating ChatCompletionChunk without explicit object...")
+        chunk = ChatCompletionChunk(
+            id="test",
+            model="test",
+            choices=[ChatCompletionChunkChoice(delta=ChatCompletionChunkDelta())]
+        )
+        
+        print(f"Comparing object: Expected 'chat.completion.chunk', Got '{chunk.object}'")
+        assert chunk.object == "chat.completion.chunk"
+    
+    def test_usage_is_optional(self):
+        """
+        What it does: Verifies that usage is optional.
+        Purpose: Ensure intermediate chunks work without usage.
+        """
+        print("Setup: Creating ChatCompletionChunk without usage...")
+        chunk = ChatCompletionChunk(
+            id="test",
+            model="test",
+            choices=[ChatCompletionChunkChoice(delta=ChatCompletionChunkDelta())]
+        )
+        
+        print(f"Comparing usage: Expected None, Got {chunk.usage}")
+        assert chunk.usage is None
+    
+    def test_accepts_usage(self):
+        """
+        What it does: Verifies that usage is accepted.
+        Purpose: Ensure final chunk with usage works.
+        """
+        print("Setup: Creating ChatCompletionChunk with usage...")
+        chunk = ChatCompletionChunk(
+            id="test",
+            model="test",
+            choices=[ChatCompletionChunkChoice(
+                delta=ChatCompletionChunkDelta(),
+                finish_reason="stop"
+            )],
+            usage=ChatCompletionUsage(prompt_tokens=10, completion_tokens=5, total_tokens=15)
+        )
+        
+        print(f"Comparing usage: Got {chunk.usage}")
+        assert chunk.usage is not None
+        assert chunk.usage.total_tokens == 15