fix(converters): handle orphaned tool_results and strip tool content when no tools defined

kiro/converters_anthropic.py

@@ -153,7 +153,6 @@ def extract_tool_results_from_anthropic_content(content: Any) -> List[Dict[str,
                 "tool_use_id": tool_use_id,
                 "content": result_content or "(empty result)"
             })
-            logger.debug(f"Extracted tool result for tool_use_id={tool_use_id}")
     
     return tool_results
 
@@ -201,7 +200,6 @@ def extract_tool_uses_from_anthropic_content(content: Any) -> List[Dict[str, Any
                     "arguments": tool_input if isinstance(tool_input, str) else tool_input
                 }
             })
-            logger.debug(f"Extracted tool use: {tool_name} (id={tool_id})")
     
     return tool_calls
 
@@ -222,6 +220,8 @@ def convert_anthropic_messages(messages: List[AnthropicMessage]) -> List[Unified
         List of messages in unified format
     """
     unified_messages = []
+    total_tool_calls = 0
+    total_tool_results = 0
     
     for msg in messages:
         role = msg.role
@@ -238,13 +238,13 @@ def convert_anthropic_messages(messages: List[AnthropicMessage]) -> List[Unified
             # Assistant messages may contain tool_use blocks
             tool_calls = extract_tool_uses_from_anthropic_content(content)
             if tool_calls:
-                logger.debug(f"Found {len(tool_calls)} tool calls in assistant message")
+                total_tool_calls += len(tool_calls)
         
         elif role == "user":
             # User messages may contain tool_result blocks
             tool_results = extract_tool_results_from_anthropic_content(content)
             if tool_results:
-                logger.debug(f"Found {len(tool_results)} tool results in user message")
+                total_tool_results += len(tool_results)
         
         unified_msg = UnifiedMessage(
             role=role,
@@ -254,6 +254,13 @@ def convert_anthropic_messages(messages: List[AnthropicMessage]) -> List[Unified
         )
         unified_messages.append(unified_msg)
     
+    # Log summary if any tool content was found
+    if total_tool_calls > 0 or total_tool_results > 0:
+        logger.debug(
+            f"Converted {len(messages)} Anthropic messages: "
+            f"{total_tool_calls} tool_calls, {total_tool_results} tool_results"
+        )
+    
     return unified_messages
 
 

kiro/converters_core.py

@@ -492,6 +492,124 @@ def extract_tool_uses_from_message(
 # Message Merging
 # ==================================================================================================
 
+def strip_all_tool_content(messages: List[UnifiedMessage]) -> Tuple[List[UnifiedMessage], bool]:
+    """
+    Strips ALL tool-related content from messages.
+    
+    This is used when no tools are defined in the request. Kiro API rejects
+    requests that have toolResults but no tools defined.
+    
+    Args:
+        messages: List of messages in unified format
+    
+    Returns:
+        Tuple of:
+        - List of messages with all tool content stripped
+        - Boolean indicating whether any tool content was stripped
+    """
+    if not messages:
+        return [], False
+    
+    result = []
+    total_tool_calls_stripped = 0
+    total_tool_results_stripped = 0
+    
+    for msg in messages:
+        # Check if this message has any tool content
+        has_tool_calls = bool(msg.tool_calls)
+        has_tool_results = bool(msg.tool_results)
+        
+        if has_tool_calls or has_tool_results:
+            if has_tool_calls:
+                total_tool_calls_stripped += len(msg.tool_calls)
+            if has_tool_results:
+                total_tool_results_stripped += len(msg.tool_results)
+            
+            # Create a copy of the message without tool content
+            cleaned_msg = UnifiedMessage(
+                role=msg.role,
+                content=msg.content,
+                tool_calls=None,
+                tool_results=None
+            )
+            result.append(cleaned_msg)
+        else:
+            result.append(msg)
+    
+    had_tool_content = total_tool_calls_stripped > 0 or total_tool_results_stripped > 0
+    
+    # Log summary once (DEBUG level - this is normal for clients like Cline/Roo)
+    if had_tool_content:
+        logger.debug(
+            f"Stripped tool content (no tools defined): "
+            f"{total_tool_calls_stripped} tool_calls, {total_tool_results_stripped} tool_results"
+        )
+    
+    return result, had_tool_content
+
+
+def ensure_assistant_before_tool_results(messages: List[UnifiedMessage]) -> Tuple[List[UnifiedMessage], bool]:
+    """
+    Ensures that messages with tool_results have a preceding assistant message with tool_calls.
+    
+    Kiro API requires that when toolResults are present, there must be a preceding
+    assistantResponseMessage with toolUses. Some clients (like Cline/Roo) may send
+    truncated conversations where the assistant message is missing.
+    
+    Since we don't know the original tool name and arguments when the assistant message
+    is missing, we cannot create a valid synthetic assistant message. Instead, we strip
+    the tool_results from such messages to avoid Kiro API rejection.
+    
+    Args:
+        messages: List of messages in unified format
+    
+    Returns:
+        Tuple of:
+        - List of messages with orphaned tool_results stripped
+        - Boolean indicating whether any tool_results were stripped (used to skip thinking tag injection)
+    """
+    if not messages:
+        return [], False
+    
+    result = []
+    stripped_any_tool_results = False
+    
+    for msg in messages:
+        # Check if this message has tool_results
+        if msg.tool_results:
+            # Check if the previous message is an assistant with tool_calls
+            has_preceding_assistant = (
+                result and
+                result[-1].role == "assistant" and
+                result[-1].tool_calls
+            )
+            
+            if not has_preceding_assistant:
+                # We cannot create a valid synthetic assistant message because we don't know
+                # the original tool name and arguments. Kiro API validates tool names.
+                # Strip the tool_results to avoid "Improperly formed request" error.
+                logger.warning(
+                    f"Stripping {len(msg.tool_results)} orphaned tool_results "
+                    f"(no preceding assistant message with tool_calls). "
+                    f"Tool IDs: {[tr.get('tool_use_id', 'unknown') for tr in msg.tool_results]}"
+                )
+                
+                # Create a copy of the message without tool_results
+                cleaned_msg = UnifiedMessage(
+                    role=msg.role,
+                    content=msg.content,
+                    tool_calls=msg.tool_calls,
+                    tool_results=None  # Strip orphaned tool_results
+                )
+                result.append(cleaned_msg)
+                stripped_any_tool_results = True
+                continue
+        
+        result.append(msg)
+    
+    return result, stripped_any_tool_results
+
+
 def merge_adjacent_messages(messages: List[UnifiedMessage]) -> List[UnifiedMessage]:
     """
     Merges adjacent messages with the same role.
@@ -655,8 +773,19 @@ def build_kiro_payload(
     if thinking_system_addition:
         full_system_prompt = full_system_prompt + thinking_system_addition if full_system_prompt else thinking_system_addition.strip()
     
+    # If no tools are defined, strip ALL tool-related content from messages
+    # Kiro API rejects requests with toolResults but no tools
+    if not tools:
+        messages_without_tools, had_tool_content = strip_all_tool_content(messages)
+        messages_with_assistants = messages_without_tools
+        stripped_tool_results = had_tool_content
+    else:
+        # Ensure assistant messages exist before tool_results (Kiro API requirement)
+        # Also returns flag if any tool_results were stripped (to skip thinking tag injection)
+        messages_with_assistants, stripped_tool_results = ensure_assistant_before_tool_results(messages)
+    
     # Merge adjacent messages with the same role
-    merged_messages = merge_adjacent_messages(messages)
+    merged_messages = merge_adjacent_messages(messages_with_assistants)
     
     if not merged_messages:
         raise ValueError("No messages to send")
@@ -716,12 +845,8 @@ def build_kiro_payload(
             user_input_context["toolResults"] = tool_results
     
     # Inject thinking tags if enabled (only for the current/last user message)
-    # Skip injection when toolResults are present - Kiro API rejects this combination
-    has_tool_results = "toolResults" in user_input_context
-    if inject_thinking and current_message.role == "user" and not has_tool_results:
+    if inject_thinking and current_message.role == "user":
         current_content = inject_thinking_tags(current_content)
-    elif has_tool_results:
-        logger.debug("Skipping thinking tag injection: toolResults present in current message")
     
     # Build userInputMessage
     user_input_message = {

kiro/converters_openai.py

@@ -130,6 +130,8 @@ def convert_openai_messages_to_unified(messages: List[ChatMessage]) -> Tuple[str
     # Process tool messages - convert to user messages with tool_results
     processed = []
     pending_tool_results = []
+    total_tool_calls = 0
+    total_tool_results = 0
     
     for msg in non_system_messages:
         if msg.role == "tool":
@@ -140,7 +142,7 @@ def convert_openai_messages_to_unified(messages: List[ChatMessage]) -> Tuple[str
                 "content": extract_text_content(msg.content) or "(empty result)"
             }
             pending_tool_results.append(tool_result)
-            logger.debug(f"Collected tool result for tool_call_id={msg.tool_call_id}")
+            total_tool_results += 1
         else:
             # If there are accumulated tool results, create user message with them
             if pending_tool_results:
@@ -151,7 +153,6 @@ def convert_openai_messages_to_unified(messages: List[ChatMessage]) -> Tuple[str
                 )
                 processed.append(unified_msg)
                 pending_tool_results.clear()
-                logger.debug(f"Created user message with {len(unified_msg.tool_results)} tool results")
             
             # Convert regular message
             tool_calls = None
@@ -159,8 +160,12 @@ def convert_openai_messages_to_unified(messages: List[ChatMessage]) -> Tuple[str
             
             if msg.role == "assistant":
                 tool_calls = _extract_tool_calls_from_openai(msg) or None
+                if tool_calls:
+                    total_tool_calls += len(tool_calls)
             elif msg.role == "user":
                 tool_results = _extract_tool_results_from_openai(msg.content) or None
+                if tool_results:
+                    total_tool_results += len(tool_results)
             
             unified_msg = UnifiedMessage(
                 role=msg.role,
@@ -178,7 +183,13 @@ def convert_openai_messages_to_unified(messages: List[ChatMessage]) -> Tuple[str
             tool_results=pending_tool_results.copy()
         )
         processed.append(unified_msg)
-        logger.debug(f"Created final user message with {len(pending_tool_results)} tool results")
+    
+    # Log summary if any tool content was found
+    if total_tool_calls > 0 or total_tool_results > 0:
+        logger.debug(
+            f"Converted {len(messages)} OpenAI messages: "
+            f"{total_tool_calls} tool_calls, {total_tool_results} tool_results"
+        )
     
     return system_prompt, processed
 

kiro/routes_anthropic.py

@@ -47,7 +47,6 @@ from kiro.converters_anthropic import anthropic_to_kiro
 from kiro.streaming_anthropic import (
     stream_kiro_to_anthropic,
     collect_anthropic_response,
-    stream_with_first_token_retry_anthropic,
 )
 from kiro.http_client import KiroHttpClient
 from kiro.utils import generate_conversation_id
@@ -142,10 +141,7 @@ async def messages(
     Raises:
         HTTPException: On validation or API errors
     """
-    logger.info(
-        f"Request to /v1/messages (model={request_data.model}, "
-        f"stream={request_data.stream}, max_tokens={request_data.max_tokens})"
-    )
+    logger.info(f"Request to /v1/messages (model={request_data.model}, stream={request_data.stream})")
     
     if anthropic_version:
         logger.debug(f"Anthropic-Version header: {anthropic_version}")
@@ -212,29 +208,70 @@ async def messages(
     tools_for_tokenizer = [tool.model_dump() for tool in request_data.tools] if request_data.tools else None
     
     try:
-        if request_data.stream:
-            # Streaming mode with first token retry
-            # Request is made inside retry loop, not here
-            async def make_request():
-                """Create new request to Kiro API."""
-                return await http_client.request_with_retry(
-                    "POST",
-                    url,
-                    kiro_payload,
-                    stream=True
-                )
+        # Make request to Kiro API (for both streaming and non-streaming modes)
+        # Important: we wait for Kiro response BEFORE returning StreamingResponse,
+        # so that we can return proper HTTP error codes if Kiro fails
+        response = await http_client.request_with_retry(
+            "POST",
+            url,
+            kiro_payload,
+            stream=True
+        )
+        
+        if response.status_code != 200:
+            try:
+                error_content = await response.aread()
+            except Exception:
+                error_content = b"Unknown error"
+            
+            await http_client.close()
+            error_text = error_content.decode('utf-8', errors='replace')
+            logger.error(f"Error from Kiro API: {response.status_code} - {error_text}")
+            
+            # Try to parse JSON response from Kiro to extract error message
+            error_message = error_text
+            try:
+                error_json = json.loads(error_text)
+                if "message" in error_json:
+                    error_message = error_json["message"]
+                    if "reason" in error_json:
+                        error_message = f"{error_message} (reason: {error_json['reason']})"
+            except (json.JSONDecodeError, KeyError):
+                pass
+            
+            # Log access log for error (before flush, so it gets into app_logs)
+            logger.warning(
+                f"HTTP {response.status_code} - POST /v1/messages - {error_message[:100]}"
+            )
+            
+            # Flush debug logs on error
+            if debug_logger:
+                debug_logger.flush_on_error(response.status_code, error_message)
             
+            # Return error in Anthropic format
+            return JSONResponse(
+                status_code=response.status_code,
+                content={
+                    "type": "error",
+                    "error": {
+                        "type": "api_error",
+                        "message": error_message
+                    }
+                }
+            )
+        
+        if request_data.stream:
+            # Streaming mode - Kiro already returned 200, now stream the response
             async def stream_wrapper():
                 streaming_error = None
                 client_disconnected = False
                 try:
-                    async for chunk in stream_with_first_token_retry_anthropic(
-                        make_request=make_request,
-                        model=request_data.model,
-                        model_cache=model_cache,
-                        auth_manager=auth_manager,
-                        request_messages=messages_for_tokenizer,
-                        request_tools=tools_for_tokenizer
+                    async for chunk in stream_kiro_to_anthropic(
+                        response,
+                        request_data.model,
+                        model_cache,
+                        auth_manager,
+                        request_messages=messages_for_tokenizer
                     ):
                         yield chunk
                 except GeneratorExit:
@@ -242,13 +279,12 @@ async def messages(
                     logger.debug("Client disconnected during streaming (GeneratorExit in routes)")
                 except Exception as e:
                     streaming_error = e
-                    # Send error event
+                    # Send error event to client, then gracefully end the stream
                     try:
                         error_event = f'event: error\ndata: {json.dumps({"type": "error", "error": {"type": "api_error", "message": str(e)}})}\n\n'
                         yield error_event
                     except Exception:
                         pass
-                    raise
                 finally:
                     await http_client.close()
                     if streaming_error:
@@ -276,56 +312,7 @@ async def messages(
             )
         
         else:
-            # Non-streaming mode - make request here
-            response = await http_client.request_with_retry(
-                "POST",
-                url,
-                kiro_payload,
-                stream=True
-            )
-            
-            if response.status_code != 200:
-                try:
-                    error_content = await response.aread()
-                except Exception:
-                    error_content = b"Unknown error"
-                
-                await http_client.close()
-                error_text = error_content.decode('utf-8', errors='replace')
-                logger.error(f"Error from Kiro API: {response.status_code} - {error_text}")
-                
-                # Try to parse JSON response from Kiro
-                error_message = error_text
-                try:
-                    error_json = json.loads(error_text)
-                    if "message" in error_json:
-                        error_message = error_json["message"]
-                        if "reason" in error_json:
-                            error_message = f"{error_message} (reason: {error_json['reason']})"
-                except (json.JSONDecodeError, KeyError):
-                    pass
-                
-                # Log access log for error
-                logger.warning(
-                    f"HTTP {response.status_code} - POST /v1/messages - {error_message[:100]}"
-                )
-                
-                # Flush debug logs on error
-                if debug_logger:
-                    debug_logger.flush_on_error(response.status_code, error_message)
-                
-                # Return error in Anthropic format
-                return JSONResponse(
-                    status_code=response.status_code,
-                    content={
-                        "type": "error",
-                        "error": {
-                            "type": "api_error",
-                            "message": error_message
-                        }
-                    }
-                )
-            
+            # Non-streaming mode - collect entire response
             anthropic_response = await collect_anthropic_response(
                 response,
                 request_data.model,

kiro/streaming_core.py

@@ -468,9 +468,10 @@ async def stream_with_first_token_retry(
             
         except Exception as e:
             # Other errors - no retry, propagate
-            # Use repr() to avoid loguru interpreting curly braces in error message as format placeholders
-            error_msg = repr(str(e))
-            logger.error(f"Unexpected error during streaming: {error_msg}", exc_info=True)
+            # Use positional argument to avoid loguru interpreting curly braces in error message as format placeholders
+            # f-string with repr() doesn't work because loguru still sees {type} inside the string
+            error_msg = str(e) if str(e) else "(empty message)"
+            logger.error("Unexpected error during streaming: {}", error_msg, exc_info=True)
             if response:
                 try:
                     await response.aclose()

tests/README.md

@@ -865,6 +865,54 @@ Unit tests for **Anthropic Messages API → Kiro** converters. **45 tests.**
   - **What it does**: Verifies conversion of other types to string
   - **Purpose**: Ensure numbers and other types are converted
 
+#### `TestExtractSystemPrompt`
+
+Tests for extract_system_prompt function (Support System commit - prompt caching support).
+
+- **`test_extracts_from_string()`**:
+  - **What it does**: Verifies extraction from simple string
+  - **Purpose**: Ensure string system prompt is returned as-is
+
+- **`test_extracts_from_list_with_text_blocks()`**:
+  - **What it does**: Verifies extraction from list of content blocks
+  - **Purpose**: Ensure Anthropic prompt caching format is handled
+
+- **`test_extracts_from_list_with_cache_control()`**:
+  - **What it does**: Verifies extraction ignores cache_control field
+  - **Purpose**: Ensure cache_control is stripped (not supported by Kiro)
+
+- **`test_extracts_from_pydantic_system_content_blocks()`**:
+  - **What it does**: Verifies extraction from Pydantic SystemContentBlock objects
+  - **Purpose**: Ensure Pydantic models are handled correctly
+
+- **`test_handles_none()`**:
+  - **What it does**: Verifies None handling
+  - **Purpose**: Ensure None returns empty string
+
+- **`test_handles_empty_list()`**:
+  - **What it does**: Verifies empty list handling
+  - **Purpose**: Ensure empty list returns empty string
+
+- **`test_handles_mixed_content_blocks()`**:
+  - **What it does**: Verifies handling of list with non-text blocks
+  - **Purpose**: Ensure only text blocks are extracted
+
+- **`test_converts_other_types_to_string()`**:
+  - **What it does**: Verifies conversion of other types to string
+  - **Purpose**: Ensure numbers and other types are converted
+
+- **`test_handles_single_text_block()`**:
+  - **What it does**: Verifies extraction from single text block in list
+  - **Purpose**: Ensure single block list works correctly
+
+- **`test_handles_empty_text_in_block()`**:
+  - **What it does**: Verifies handling of empty text in content block
+  - **Purpose**: Ensure empty text doesn't cause errors
+
+- **`test_handles_missing_text_key()`**:
+  - **What it does**: Verifies handling of content block without text key
+  - **Purpose**: Ensure missing text key doesn't cause errors
+
 #### `TestExtractToolResultsFromAnthropicContent`
 
 - **`test_extracts_tool_result_from_dict()`**:
@@ -1021,9 +1069,9 @@ Main entry point tests for anthropic_to_kiro function.
   - **What it does**: Verifies that thinking tags are injected when enabled
   - **Purpose**: Ensure fake reasoning feature works with Anthropic API
 
-- **`test_skips_thinking_tags_when_tool_results_present()`**:
-  - **What it does**: Verifies that thinking tags are skipped when tool results are present
-  - **Purpose**: Ensure Kiro API compatibility (rejects thinking tags with tool results)
+- **`test_injects_thinking_tags_even_when_tool_results_present()`**:
+  - **What it does**: Verifies that thinking tags ARE injected even when tool results are present
+  - **Purpose**: Extended thinking should work in all scenarios including tool use flows
 
 ---
 
@@ -1171,6 +1219,54 @@ Tests for sanitize_json_schema function that cleans JSON Schema from fields not
   - **What it does**: Verifies extraction of multiple tool results
   - **Purpose**: Ensure all tool_result elements are extracted
 
+#### `TestConvertToolResultsToKiroFormat`
+
+Tests for convert_tool_results_to_kiro_format function that converts unified tool results format (snake_case) to Kiro API format (camelCase). This is a critical function for fixing the 400 "Improperly formed request" bug.
+
+- **`test_converts_single_tool_result()`**:
+  - **What it does**: Verifies conversion of a single tool result
+  - **Purpose**: Ensure basic conversion from unified to Kiro format works
+
+- **`test_converts_multiple_tool_results()`**:
+  - **What it does**: Verifies conversion of multiple tool results
+  - **Purpose**: Ensure all tool results are converted correctly
+
+- **`test_returns_empty_list_for_empty_input()`**:
+  - **What it does**: Verifies empty list handling
+  - **Purpose**: Ensure empty input returns empty output
+
+- **`test_replaces_empty_content_with_placeholder()`**:
+  - **What it does**: Verifies empty content is replaced with placeholder
+  - **Purpose**: Ensure Kiro API receives non-empty content (required by API)
+
+- **`test_replaces_none_content_with_placeholder()`**:
+  - **What it does**: Verifies None content is replaced with placeholder
+  - **Purpose**: Ensure Kiro API receives non-empty content when content is None
+
+- **`test_handles_missing_content_key()`**:
+  - **What it does**: Verifies handling of missing content key
+  - **Purpose**: Ensure function doesn't crash when content key is missing
+
+- **`test_handles_missing_tool_use_id()`**:
+  - **What it does**: Verifies handling of missing tool_use_id
+  - **Purpose**: Ensure function returns empty string for missing tool_use_id
+
+- **`test_extracts_text_from_list_content()`**:
+  - **What it does**: Verifies extraction of text from list content
+  - **Purpose**: Ensure multimodal content format is handled correctly
+
+- **`test_preserves_long_content()`**:
+  - **What it does**: Verifies long content is preserved
+  - **Purpose**: Ensure large tool results are not truncated
+
+- **`test_all_results_have_success_status()`**:
+  - **What it does**: Verifies all results have status="success"
+  - **Purpose**: Ensure Kiro API receives correct status field
+
+- **`test_handles_unicode_content()`**:
+  - **What it does**: Verifies Unicode content is preserved
+  - **Purpose**: Ensure non-ASCII characters are handled correctly
+
 #### `TestExtractToolUses`
 
 - **`test_extracts_from_tool_calls_field()`**:
@@ -1443,9 +1539,9 @@ Unit tests for **OpenAI Chat API → Kiro** converters. **47 tests.**
   - **What it does**: Verifies including tools in userInputMessageContext
   - **Purpose**: Ensure tools are converted and included
 
-- **`test_skips_thinking_tags_when_tool_results_present()`**:
-  - **What it does**: Verifies thinking tags are NOT injected when toolResults are present
-  - **Purpose**: Fix GitHub issue #20 - OpenCode compaction returns 400 error
+- **`test_injects_thinking_tags_even_when_tool_results_present()`**:
+  - **What it does**: Verifies thinking tags ARE injected even when toolResults are present
+  - **Purpose**: Extended thinking should work in all scenarios including tool use flows
 
 - **`test_injects_thinking_tags_when_no_tool_results()`**:
   - **What it does**: Verifies thinking tags ARE injected for normal user messages

tests/unit/test_converters_anthropic.py

@@ -17,6 +17,7 @@ from unittest.mock import patch, MagicMock
 
 from kiro.converters_anthropic import (
     convert_anthropic_content_to_text,
+    extract_system_prompt,
     extract_tool_results_from_anthropic_content,
     extract_tool_uses_from_anthropic_content,
     convert_anthropic_messages,
@@ -31,6 +32,7 @@ from kiro.models_anthropic import (
     TextContentBlock,
     ToolUseContentBlock,
     ToolResultContentBlock,
+    SystemContentBlock,
 )
 
 
@@ -149,6 +151,183 @@ class TestConvertAnthropicContentToText:
         assert result == "42"
 
 
+# ==================================================================================================
+# Tests for extract_system_prompt
+# ==================================================================================================
+
+class TestExtractSystemPrompt:
+    """Tests for extract_system_prompt function (Support System commit)."""
+    
+    def test_extracts_from_string(self):
+        """
+        What it does: Verifies extraction from simple string.
+        Purpose: Ensure string system prompt is returned as-is.
+        """
+        print("Setup: Simple string system prompt...")
+        system = "You are a helpful assistant."
+        
+        print("Action: Extracting system prompt...")
+        result = extract_system_prompt(system)
+        
+        print(f"Comparing result: Expected 'You are a helpful assistant.', Got '{result}'")
+        assert result == "You are a helpful assistant."
+    
+    def test_extracts_from_list_with_text_blocks(self):
+        """
+        What it does: Verifies extraction from list of content blocks.
+        Purpose: Ensure Anthropic prompt caching format is handled.
+        """
+        print("Setup: List with text content blocks (prompt caching format)...")
+        system = [
+            {"type": "text", "text": "You are helpful."},
+            {"type": "text", "text": "Be concise."}
+        ]
+        
+        print("Action: Extracting system prompt...")
+        result = extract_system_prompt(system)
+        
+        print(f"Comparing result: Expected 'You are helpful.\\nBe concise.', Got '{result}'")
+        assert result == "You are helpful.\nBe concise."
+    
+    def test_extracts_from_list_with_cache_control(self):
+        """
+        What it does: Verifies extraction ignores cache_control field.
+        Purpose: Ensure cache_control is stripped (not supported by Kiro).
+        """
+        print("Setup: List with cache_control (prompt caching format)...")
+        system = [
+            {
+                "type": "text",
+                "text": "You are a helpful assistant.",
+                "cache_control": {"type": "ephemeral"}
+            }
+        ]
+        
+        print("Action: Extracting system prompt...")
+        result = extract_system_prompt(system)
+        
+        print(f"Comparing result: Expected 'You are a helpful assistant.', Got '{result}'")
+        assert result == "You are a helpful assistant."
+    
+    def test_extracts_from_pydantic_system_content_blocks(self):
+        """
+        What it does: Verifies extraction from Pydantic SystemContentBlock objects.
+        Purpose: Ensure Pydantic models are handled correctly.
+        """
+        print("Setup: List with Pydantic SystemContentBlock objects...")
+        system = [
+            SystemContentBlock(type="text", text="Part 1"),
+            SystemContentBlock(type="text", text="Part 2")
+        ]
+        
+        print("Action: Extracting system prompt...")
+        result = extract_system_prompt(system)
+        
+        print(f"Comparing result: Expected 'Part 1\\nPart 2', Got '{result}'")
+        assert result == "Part 1\nPart 2"
+    
+    def test_handles_none(self):
+        """
+        What it does: Verifies None handling.
+        Purpose: Ensure None returns empty string.
+        """
+        print("Setup: None system prompt...")
+        
+        print("Action: Extracting system prompt...")
+        result = extract_system_prompt(None)
+        
+        print(f"Comparing result: Expected '', Got '{result}'")
+        assert result == ""
+    
+    def test_handles_empty_list(self):
+        """
+        What it does: Verifies empty list handling.
+        Purpose: Ensure empty list returns empty string.
+        """
+        print("Setup: Empty list...")
+        system = []
+        
+        print("Action: Extracting system prompt...")
+        result = extract_system_prompt(system)
+        
+        print(f"Comparing result: Expected '', Got '{result}'")
+        assert result == ""
+    
+    def test_handles_mixed_content_blocks(self):
+        """
+        What it does: Verifies handling of list with non-text blocks.
+        Purpose: Ensure only text blocks are extracted.
+        """
+        print("Setup: List with mixed content blocks...")
+        system = [
+            {"type": "text", "text": "Hello"},
+            {"type": "image", "source": {"type": "base64", "data": "..."}},
+            {"type": "text", "text": "World"}
+        ]
+        
+        print("Action: Extracting system prompt...")
+        result = extract_system_prompt(system)
+        
+        print(f"Comparing result: Expected 'Hello\\nWorld', Got '{result}'")
+        assert result == "Hello\nWorld"
+    
+    def test_converts_other_types_to_string(self):
+        """
+        What it does: Verifies conversion of other types to string.
+        Purpose: Ensure numbers and other types are converted.
+        """
+        print("Setup: Number as system prompt...")
+        system = 42
+        
+        print("Action: Extracting system prompt...")
+        result = extract_system_prompt(system)
+        
+        print(f"Comparing result: Expected '42', Got '{result}'")
+        assert result == "42"
+    
+    def test_handles_single_text_block(self):
+        """
+        What it does: Verifies extraction from single text block in list.
+        Purpose: Ensure single block list works correctly.
+        """
+        print("Setup: Single text block in list...")
+        system = [{"type": "text", "text": "Single block"}]
+        
+        print("Action: Extracting system prompt...")
+        result = extract_system_prompt(system)
+        
+        print(f"Comparing result: Expected 'Single block', Got '{result}'")
+        assert result == "Single block"
+    
+    def test_handles_empty_text_in_block(self):
+        """
+        What it does: Verifies handling of empty text in content block.
+        Purpose: Ensure empty text doesn't cause errors.
+        """
+        print("Setup: Content block with empty text...")
+        system = [{"type": "text", "text": ""}]
+        
+        print("Action: Extracting system prompt...")
+        result = extract_system_prompt(system)
+        
+        print(f"Comparing result: Expected '', Got '{result}'")
+        assert result == ""
+    
+    def test_handles_missing_text_key(self):
+        """
+        What it does: Verifies handling of content block without text key.
+        Purpose: Ensure missing text key doesn't cause errors.
+        """
+        print("Setup: Content block without text key...")
+        system = [{"type": "text"}]
+        
+        print("Action: Extracting system prompt...")
+        result = extract_system_prompt(system)
+        
+        print(f"Comparing result: Expected '', Got '{result}'")
+        assert result == ""
+
+
 # ==================================================================================================
 # Tests for extract_tool_results_from_anthropic_content
 # ==================================================================================================
@@ -857,7 +1036,15 @@ class TestAnthropicToKiro:
                     ]
                 )
             ],
-            max_tokens=1024
+            max_tokens=1024,
+            # Tools must be defined for tool_results to be preserved
+            tools=[
+                AnthropicTool(
+                    name="get_weather",
+                    description="Get weather for a location",
+                    input_schema={"type": "object", "properties": {"location": {"type": "string"}}}
+                )
+            ]
         )
         
         print("Action: Converting to Kiro payload...")
@@ -926,14 +1113,10 @@ class TestAnthropicToKiro:
         assert "<thinking_mode>enabled</thinking_mode>" in current_content
         assert "What is 2+2?" in current_content
     
-    def test_skips_thinking_tags_when_tool_results_present(self):
+    def test_injects_thinking_tags_even_when_tool_results_present(self):
         """
-        What it does: Verifies that thinking tags are skipped when tool results are present.
-        Purpose: Ensure Kiro API compatibility (rejects thinking tags with tool results).
-        
-        Note: The system prompt addition contains `<thinking_mode>` as documentation text
-        (in backticks), but the actual thinking tags injection is skipped. We check that
-        the content doesn't START with the thinking tags prefix.
+        What it does: Verifies that thinking tags ARE injected even when tool results are present.
+        Purpose: Extended thinking should work in all scenarios including tool use flows.
         """
         print("Setup: Request with tool results and fake reasoning enabled...")
         request = AnthropicMessagesRequest(
@@ -946,7 +1129,15 @@ class TestAnthropicToKiro:
                     ]
                 )
             ],
-            max_tokens=1024
+            max_tokens=1024,
+            # Tools must be defined for tool_results to be preserved
+            tools=[
+                AnthropicTool(
+                    name="test_tool",
+                    description="A test tool",
+                    input_schema={"type": "object", "properties": {}}
+                )
+            ]
         )
         
         print("Action: Converting to Kiro payload...")
@@ -959,14 +1150,10 @@ class TestAnthropicToKiro:
         current_content = result["conversationState"]["currentMessage"]["userInputMessage"]["content"]
         print(f"Current content (first 100 chars): {current_content[:100]}...")
         
-        print("Checking that content does NOT start with thinking tags prefix...")
-        # The actual thinking tags prefix starts with "<thinking_mode>enabled"
-        # The system prompt addition contains this text in backticks as documentation
-        # We check that the content doesn't start with the actual tag (not in backticks)
-        assert not current_content.startswith("<thinking_mode>enabled</thinking_mode>"), \
-            "Content should not start with thinking tags when tool results are present"
-        
-        print("Checking that <max_thinking_length> tag is NOT present...")
-        # This tag is only present in the actual injection, not in documentation
-        assert "<max_thinking_length>4000</max_thinking_length>" not in current_content, \
-            "max_thinking_length tag should not be present when tool results are present"
+        print("Checking that thinking tags ARE present...")
+        assert "<thinking_mode>enabled</thinking_mode>" in current_content, \
+            "thinking tags SHOULD be injected even with tool results"
+        
+        print("Checking that <max_thinking_length> tag IS present...")
+        assert "<max_thinking_length>4000</max_thinking_length>" in current_content, \
+            "max_thinking_length tag SHOULD be present even with tool results"

tests/unit/test_converters_core.py

@@ -17,6 +17,7 @@ from unittest.mock import patch
 from kiro.converters_core import (
     extract_text_content,
     merge_adjacent_messages,
+    ensure_assistant_before_tool_results,
     build_kiro_history,
     process_tools_with_long_descriptions,
     inject_thinking_tags,
@@ -24,6 +25,7 @@ from kiro.converters_core import (
     extract_tool_uses_from_message,
     sanitize_json_schema,
     convert_tools_to_kiro_format,
+    convert_tool_results_to_kiro_format,
     UnifiedMessage,
     UnifiedTool,
 )
@@ -393,6 +395,352 @@ class TestMergeAdjacentMessages:
         assert len(result[0].tool_results) == 2
 
 
+# ==================================================================================================
+# Tests for ensure_assistant_before_tool_results
+# ==================================================================================================
+
+class TestEnsureAssistantBeforeToolResults:
+    """
+    Tests for ensure_assistant_before_tool_results function.
+    
+    This function handles the case when clients (like Cline/Roo) send truncated
+    conversations with tool_results but without the preceding assistant message
+    that contains the tool_calls. Since we don't know the original tool name,
+    we strip the orphaned tool_results to avoid Kiro API rejection.
+    """
+    
+    def test_returns_empty_list_for_empty_input(self):
+        """
+        What it does: Verifies empty list handling.
+        Purpose: Ensure empty input returns empty output.
+        """
+        print("Setup: Empty list...")
+        
+        print("Action: Processing messages...")
+        result, stripped = ensure_assistant_before_tool_results([])
+        
+        print(f"Comparing result: Expected [], Got {result}")
+        assert result == []
+        assert stripped is False
+    
+    def test_preserves_messages_without_tool_results(self):
+        """
+        What it does: Verifies messages without tool_results are unchanged.
+        Purpose: Ensure regular messages pass through unmodified.
+        """
+        print("Setup: Messages without tool_results...")
+        messages = [
+            UnifiedMessage(role="user", content="Hello"),
+            UnifiedMessage(role="assistant", content="Hi there"),
+            UnifiedMessage(role="user", content="How are you?")
+        ]
+        
+        print("Action: Processing messages...")
+        result, stripped = ensure_assistant_before_tool_results(messages)
+        
+        print(f"Comparing length: Expected 3, Got {len(result)}")
+        assert len(result) == 3
+        assert result[0].content == "Hello"
+        assert result[1].content == "Hi there"
+        assert result[2].content == "How are you?"
+        assert stripped is False
+    
+    def test_preserves_tool_results_with_preceding_assistant(self):
+        """
+        What it does: Verifies tool_results are preserved when assistant with tool_calls precedes.
+        Purpose: Ensure valid tool_results are not stripped.
+        """
+        print("Setup: Valid conversation with assistant tool_calls followed by user tool_results...")
+        messages = [
+            UnifiedMessage(role="user", content="Call a tool"),
+            UnifiedMessage(
+                role="assistant",
+                content="",
+                tool_calls=[{
+                    "id": "call_123",
+                    "type": "function",
+                    "function": {"name": "get_weather", "arguments": '{"location": "Moscow"}'}
+                }]
+            ),
+            UnifiedMessage(
+                role="user",
+                content="",
+                tool_results=[{
+                    "type": "tool_result",
+                    "tool_use_id": "call_123",
+                    "content": "Weather is sunny"
+                }]
+            )
+        ]
+        
+        print("Action: Processing messages...")
+        result, stripped = ensure_assistant_before_tool_results(messages)
+        
+        print(f"Result: {result}")
+        print(f"Comparing length: Expected 3, Got {len(result)}")
+        assert len(result) == 3
+        
+        print("Checking that tool_results are preserved...")
+        assert result[2].tool_results is not None
+        assert len(result[2].tool_results) == 1
+        assert result[2].tool_results[0]["tool_use_id"] == "call_123"
+        assert stripped is False
+    
+    def test_strips_orphaned_tool_results_at_start(self):
+        """
+        What it does: Verifies orphaned tool_results at the start are stripped.
+        Purpose: Ensure tool_results without preceding assistant are removed.
+        
+        This is the critical bug fix test - when a client sends a truncated
+        conversation starting with tool_results, they should be stripped.
+        """
+        print("Setup: Conversation starting with orphaned tool_results...")
+        messages = [
+            UnifiedMessage(
+                role="user",
+                content="",
+                tool_results=[{
+                    "type": "tool_result",
+                    "tool_use_id": "call_orphan",
+                    "content": "Orphaned result"
+                }]
+            ),
+            UnifiedMessage(role="user", content="Continue the conversation")
+        ]
+        
+        print("Action: Processing messages...")
+        result, stripped = ensure_assistant_before_tool_results(messages)
+        
+        print(f"Result: {result}")
+        print(f"Comparing length: Expected 2, Got {len(result)}")
+        assert len(result) == 2
+        
+        print("Checking that orphaned tool_results are stripped...")
+        assert result[0].tool_results is None
+        assert result[0].content == ""  # Content preserved
+        assert result[1].content == "Continue the conversation"
+        assert stripped is True
+    
+    def test_strips_tool_results_after_assistant_without_tool_calls(self):
+        """
+        What it does: Verifies tool_results are stripped when preceding assistant has no tool_calls.
+        Purpose: Ensure tool_results require assistant with tool_calls, not just any assistant.
+        """
+        print("Setup: Assistant without tool_calls followed by user with tool_results...")
+        messages = [
+            UnifiedMessage(role="user", content="Hello"),
+            UnifiedMessage(role="assistant", content="Let me think...", tool_calls=None),
+            UnifiedMessage(
+                role="user",
+                content="",
+                tool_results=[{
+                    "type": "tool_result",
+                    "tool_use_id": "call_123",
+                    "content": "Result"
+                }]
+            )
+        ]
+        
+        print("Action: Processing messages...")
+        result, stripped = ensure_assistant_before_tool_results(messages)
+        
+        print(f"Result: {result}")
+        print("Checking that tool_results are stripped...")
+        assert result[2].tool_results is None
+        assert stripped is True
+    
+    def test_strips_tool_results_after_user_message(self):
+        """
+        What it does: Verifies tool_results are stripped when preceded by user message.
+        Purpose: Ensure tool_results require assistant, not user.
+        """
+        print("Setup: User message followed by user with tool_results...")
+        messages = [
+            UnifiedMessage(role="user", content="First message"),
+            UnifiedMessage(
+                role="user",
+                content="",
+                tool_results=[{
+                    "type": "tool_result",
+                    "tool_use_id": "call_123",
+                    "content": "Result"
+                }]
+            )
+        ]
+        
+        print("Action: Processing messages...")
+        result, stripped = ensure_assistant_before_tool_results(messages)
+        
+        print(f"Result: {result}")
+        print("Checking that tool_results are stripped...")
+        assert result[1].tool_results is None
+        assert stripped is True
+    
+    def test_preserves_content_when_stripping_tool_results(self):
+        """
+        What it does: Verifies message content is preserved when tool_results are stripped.
+        Purpose: Ensure only tool_results are removed, not the entire message.
+        """
+        print("Setup: Message with both content and orphaned tool_results...")
+        messages = [
+            UnifiedMessage(
+                role="user",
+                content="Here is some context",
+                tool_results=[{
+                    "type": "tool_result",
+                    "tool_use_id": "call_123",
+                    "content": "Result"
+                }]
+            )
+        ]
+        
+        print("Action: Processing messages...")
+        result, stripped = ensure_assistant_before_tool_results(messages)
+        
+        print(f"Result: {result}")
+        print("Checking that content is preserved...")
+        assert result[0].content == "Here is some context"
+        assert result[0].tool_results is None
+        assert stripped is True
+    
+    def test_preserves_tool_calls_when_stripping_tool_results(self):
+        """
+        What it does: Verifies tool_calls are preserved when tool_results are stripped.
+        Purpose: Ensure only tool_results are removed, tool_calls stay.
+        """
+        print("Setup: Message with tool_calls and orphaned tool_results...")
+        messages = [
+            UnifiedMessage(
+                role="assistant",
+                content="",
+                tool_calls=[{
+                    "id": "call_new",
+                    "type": "function",
+                    "function": {"name": "new_tool", "arguments": "{}"}
+                }],
+                tool_results=[{  # This shouldn't happen but let's test it
+                    "type": "tool_result",
+                    "tool_use_id": "call_old",
+                    "content": "Old result"
+                }]
+            )
+        ]
+        
+        print("Action: Processing messages...")
+        result, stripped = ensure_assistant_before_tool_results(messages)
+        
+        print(f"Result: {result}")
+        print("Checking that tool_calls are preserved...")
+        assert result[0].tool_calls is not None
+        assert len(result[0].tool_calls) == 1
+        assert result[0].tool_results is None
+        assert stripped is True
+    
+    def test_handles_multiple_orphaned_tool_results(self):
+        """
+        What it does: Verifies multiple orphaned tool_results are all stripped.
+        Purpose: Ensure all tool_results in the list are removed.
+        """
+        print("Setup: Message with multiple orphaned tool_results...")
+        messages = [
+            UnifiedMessage(
+                role="user",
+                content="",
+                tool_results=[
+                    {"type": "tool_result", "tool_use_id": "call_1", "content": "Result 1"},
+                    {"type": "tool_result", "tool_use_id": "call_2", "content": "Result 2"},
+                    {"type": "tool_result", "tool_use_id": "call_3", "content": "Result 3"}
+                ]
+            )
+        ]
+        
+        print("Action: Processing messages...")
+        result, stripped = ensure_assistant_before_tool_results(messages)
+        
+        print(f"Result: {result}")
+        print("Checking that all tool_results are stripped...")
+        assert result[0].tool_results is None
+        assert stripped is True
+    
+    def test_mixed_valid_and_orphaned_tool_results(self):
+        """
+        What it does: Verifies correct handling of mixed valid and orphaned tool_results.
+        Purpose: Ensure valid tool_results are preserved while orphaned are stripped.
+        """
+        print("Setup: Mixed conversation with valid and orphaned tool_results...")
+        messages = [
+            # Orphaned tool_results at start
+            UnifiedMessage(
+                role="user",
+                content="",
+                tool_results=[{
+                    "type": "tool_result",
+                    "tool_use_id": "call_orphan",
+                    "content": "Orphaned"
+                }]
+            ),
+            # Valid assistant with tool_calls
+            UnifiedMessage(
+                role="assistant",
+                content="",
+                tool_calls=[{
+                    "id": "call_valid",
+                    "type": "function",
+                    "function": {"name": "valid_tool", "arguments": "{}"}
+                }]
+            ),
+            # Valid tool_results
+            UnifiedMessage(
+                role="user",
+                content="",
+                tool_results=[{
+                    "type": "tool_result",
+                    "tool_use_id": "call_valid",
+                    "content": "Valid result"
+                }]
+            )
+        ]
+        
+        print("Action: Processing messages...")
+        result, stripped = ensure_assistant_before_tool_results(messages)
+        
+        print(f"Result: {result}")
+        print("Checking orphaned tool_results are stripped...")
+        assert result[0].tool_results is None
+        
+        print("Checking valid tool_results are preserved...")
+        assert result[2].tool_results is not None
+        assert result[2].tool_results[0]["tool_use_id"] == "call_valid"
+        assert stripped is True  # Because orphaned ones were stripped
+    
+    def test_single_message_with_tool_results(self):
+        """
+        What it does: Verifies handling of single message with tool_results.
+        Purpose: Ensure single orphaned message is handled correctly.
+        """
+        print("Setup: Single message with tool_results...")
+        messages = [
+            UnifiedMessage(
+                role="user",
+                content="",
+                tool_results=[{
+                    "type": "tool_result",
+                    "tool_use_id": "call_123",
+                    "content": "Result"
+                }]
+            )
+        ]
+        
+        print("Action: Processing messages...")
+        result, stripped = ensure_assistant_before_tool_results(messages)
+        
+        print(f"Result: {result}")
+        print("Checking that tool_results are stripped...")
+        assert len(result) == 1
+        assert result[0].tool_results is None
+        assert stripped is True
+
+
 # ==================================================================================================
 # Tests for sanitize_json_schema
 # ==================================================================================================
@@ -686,6 +1034,243 @@ class TestExtractToolResults:
         assert result[1]["toolUseId"] == "call_2"
 
 
+# ==================================================================================================
+# Tests for convert_tool_results_to_kiro_format
+# ==================================================================================================
+
+class TestConvertToolResultsToKiroFormat:
+    """
+    Tests for convert_tool_results_to_kiro_format function.
+    
+    This function converts unified tool results format (snake_case) to Kiro API format (camelCase).
+    
+    Unified format: {"type": "tool_result", "tool_use_id": "...", "content": "..."}
+    Kiro format: {"content": [{"text": "..."}], "status": "success", "toolUseId": "..."}
+    
+    This is a critical function for fixing the 400 "Improperly formed request" bug
+    where tool_results were sent in unified format instead of Kiro format.
+    """
+    
+    def test_converts_single_tool_result(self):
+        """
+        What it does: Verifies conversion of a single tool result.
+        Purpose: Ensure basic conversion from unified to Kiro format works.
+        """
+        print("Setup: Single tool result in unified format...")
+        tool_results = [
+            {"type": "tool_result", "tool_use_id": "call_123", "content": "Result text"}
+        ]
+        
+        print("Action: Converting to Kiro format...")
+        result = convert_tool_results_to_kiro_format(tool_results)
+        
+        print(f"Result: {result}")
+        print("Checking structure...")
+        assert len(result) == 1
+        
+        print("Checking toolUseId (camelCase)...")
+        assert result[0]["toolUseId"] == "call_123"
+        
+        print("Checking status...")
+        assert result[0]["status"] == "success"
+        
+        print("Checking content structure...")
+        assert "content" in result[0]
+        assert isinstance(result[0]["content"], list)
+        assert len(result[0]["content"]) == 1
+        assert result[0]["content"][0]["text"] == "Result text"
+    
+    def test_converts_multiple_tool_results(self):
+        """
+        What it does: Verifies conversion of multiple tool results.
+        Purpose: Ensure all tool results are converted correctly.
+        """
+        print("Setup: Multiple tool results...")
+        tool_results = [
+            {"type": "tool_result", "tool_use_id": "call_1", "content": "Result 1"},
+            {"type": "tool_result", "tool_use_id": "call_2", "content": "Result 2"},
+            {"type": "tool_result", "tool_use_id": "call_3", "content": "Result 3"}
+        ]
+        
+        print("Action: Converting to Kiro format...")
+        result = convert_tool_results_to_kiro_format(tool_results)
+        
+        print(f"Result: {result}")
+        print(f"Comparing count: Expected 3, Got {len(result)}")
+        assert len(result) == 3
+        
+        print("Checking all toolUseIds...")
+        assert result[0]["toolUseId"] == "call_1"
+        assert result[1]["toolUseId"] == "call_2"
+        assert result[2]["toolUseId"] == "call_3"
+        
+        print("Checking all contents...")
+        assert result[0]["content"][0]["text"] == "Result 1"
+        assert result[1]["content"][0]["text"] == "Result 2"
+        assert result[2]["content"][0]["text"] == "Result 3"
+    
+    def test_returns_empty_list_for_empty_input(self):
+        """
+        What it does: Verifies empty list handling.
+        Purpose: Ensure empty input returns empty output.
+        """
+        print("Setup: Empty list...")
+        
+        print("Action: Converting to Kiro format...")
+        result = convert_tool_results_to_kiro_format([])
+        
+        print(f"Comparing result: Expected [], Got {result}")
+        assert result == []
+    
+    def test_replaces_empty_content_with_placeholder(self):
+        """
+        What it does: Verifies empty content is replaced with placeholder.
+        Purpose: Ensure Kiro API receives non-empty content (required by API).
+        """
+        print("Setup: Tool result with empty content...")
+        tool_results = [
+            {"type": "tool_result", "tool_use_id": "call_123", "content": ""}
+        ]
+        
+        print("Action: Converting to Kiro format...")
+        result = convert_tool_results_to_kiro_format(tool_results)
+        
+        print(f"Result: {result}")
+        print("Checking that empty content is replaced with placeholder...")
+        assert result[0]["content"][0]["text"] == "(empty result)"
+    
+    def test_replaces_none_content_with_placeholder(self):
+        """
+        What it does: Verifies None content is replaced with placeholder.
+        Purpose: Ensure Kiro API receives non-empty content when content is None.
+        """
+        print("Setup: Tool result with None content...")
+        tool_results = [
+            {"type": "tool_result", "tool_use_id": "call_123", "content": None}
+        ]
+        
+        print("Action: Converting to Kiro format...")
+        result = convert_tool_results_to_kiro_format(tool_results)
+        
+        print(f"Result: {result}")
+        print("Checking that None content is replaced with placeholder...")
+        assert result[0]["content"][0]["text"] == "(empty result)"
+    
+    def test_handles_missing_content_key(self):
+        """
+        What it does: Verifies handling of missing content key.
+        Purpose: Ensure function doesn't crash when content key is missing.
+        """
+        print("Setup: Tool result without content key...")
+        tool_results = [
+            {"type": "tool_result", "tool_use_id": "call_123"}
+        ]
+        
+        print("Action: Converting to Kiro format...")
+        result = convert_tool_results_to_kiro_format(tool_results)
+        
+        print(f"Result: {result}")
+        print("Checking that missing content is replaced with placeholder...")
+        assert result[0]["content"][0]["text"] == "(empty result)"
+    
+    def test_handles_missing_tool_use_id(self):
+        """
+        What it does: Verifies handling of missing tool_use_id.
+        Purpose: Ensure function returns empty string for missing tool_use_id.
+        """
+        print("Setup: Tool result without tool_use_id...")
+        tool_results = [
+            {"type": "tool_result", "content": "Result text"}
+        ]
+        
+        print("Action: Converting to Kiro format...")
+        result = convert_tool_results_to_kiro_format(tool_results)
+        
+        print(f"Result: {result}")
+        print("Checking that missing tool_use_id becomes empty string...")
+        assert result[0]["toolUseId"] == ""
+        assert result[0]["content"][0]["text"] == "Result text"
+    
+    def test_extracts_text_from_list_content(self):
+        """
+        What it does: Verifies extraction of text from list content.
+        Purpose: Ensure multimodal content format is handled correctly.
+        """
+        print("Setup: Tool result with list content...")
+        tool_results = [
+            {
+                "type": "tool_result",
+                "tool_use_id": "call_123",
+                "content": [
+                    {"type": "text", "text": "Part 1"},
+                    {"type": "text", "text": " Part 2"}
+                ]
+            }
+        ]
+        
+        print("Action: Converting to Kiro format...")
+        result = convert_tool_results_to_kiro_format(tool_results)
+        
+        print(f"Result: {result}")
+        print("Checking that list content is extracted correctly...")
+        assert result[0]["content"][0]["text"] == "Part 1 Part 2"
+    
+    def test_preserves_long_content(self):
+        """
+        What it does: Verifies long content is preserved.
+        Purpose: Ensure large tool results are not truncated.
+        """
+        print("Setup: Tool result with long content...")
+        long_content = "A" * 10000
+        tool_results = [
+            {"type": "tool_result", "tool_use_id": "call_123", "content": long_content}
+        ]
+        
+        print("Action: Converting to Kiro format...")
+        result = convert_tool_results_to_kiro_format(tool_results)
+        
+        print(f"Result content length: {len(result[0]['content'][0]['text'])}")
+        print("Checking that long content is preserved...")
+        assert result[0]["content"][0]["text"] == long_content
+        assert len(result[0]["content"][0]["text"]) == 10000
+    
+    def test_all_results_have_success_status(self):
+        """
+        What it does: Verifies all results have status="success".
+        Purpose: Ensure Kiro API receives correct status field.
+        """
+        print("Setup: Multiple tool results...")
+        tool_results = [
+            {"type": "tool_result", "tool_use_id": "call_1", "content": "Result 1"},
+            {"type": "tool_result", "tool_use_id": "call_2", "content": "Result 2"}
+        ]
+        
+        print("Action: Converting to Kiro format...")
+        result = convert_tool_results_to_kiro_format(tool_results)
+        
+        print("Checking all statuses...")
+        for i, r in enumerate(result):
+            print(f"Result {i}: status = {r['status']}")
+            assert r["status"] == "success"
+    
+    def test_handles_unicode_content(self):
+        """
+        What it does: Verifies Unicode content is preserved.
+        Purpose: Ensure non-ASCII characters are handled correctly.
+        """
+        print("Setup: Tool result with Unicode content...")
+        tool_results = [
+            {"type": "tool_result", "tool_use_id": "call_123", "content": "Привет мир! 你好世界! 🎉"}
+        ]
+        
+        print("Action: Converting to Kiro format...")
+        result = convert_tool_results_to_kiro_format(tool_results)
+        
+        print(f"Result: {result}")
+        print("Checking that Unicode content is preserved...")
+        assert result[0]["content"][0]["text"] == "Привет мир! 你好世界! 🎉"
+
+
 # ==================================================================================================
 # Tests for extract_tool_uses_from_message
 # ==================================================================================================

tests/unit/test_converters_openai.py

@@ -463,10 +463,10 @@ class TestBuildKiroPayload:
         assert len(context["tools"]) == 1
         assert context["tools"][0]["toolSpecification"]["name"] == "get_weather"
     
-    def test_skips_thinking_tags_when_tool_results_present(self):
+    def test_injects_thinking_tags_even_when_tool_results_present(self):
         """
-        What it does: Verifies thinking tags are NOT injected when toolResults are present.
-        Purpose: Fix GitHub issue #20 - OpenCode compaction returns 400 error.
+        What it does: Verifies thinking tags ARE injected even when toolResults are present.
+        Purpose: Extended thinking should work in all scenarios including tool use flows.
         """
         print("Setup: Request where last message is a tool result...")
         request = ChatCompletionRequest(
@@ -483,6 +483,17 @@ class TestBuildKiroPayload:
                     }]
                 ),
                 ChatMessage(role="tool", content="Command output here", tool_call_id="tool_1"),
+            ],
+            # Tools must be defined for tool_results to be preserved
+            tools=[
+                Tool(
+                    type="function",
+                    function=ToolFunction(
+                        name="bash",
+                        description="Run a bash command",
+                        parameters={"type": "object", "properties": {}}
+                    )
+                )
             ]
         )
         
@@ -499,8 +510,8 @@ class TestBuildKiroPayload:
         print(f"Has toolResults: {'toolResults' in context}")
         
         assert "toolResults" in context, "toolResults should be present"
-        assert "<thinking_mode>" not in content, "thinking tags should NOT be injected when toolResults present"
-        assert content == "Continue", "Content should be 'Continue' (no thinking tags)"
+        assert "<thinking_mode>enabled</thinking_mode>" in content, "thinking tags SHOULD be injected even with toolResults"
+        assert "<max_thinking_length>4000</max_thinking_length>" in content, "max_thinking_length should be present"
     
     def test_injects_thinking_tags_when_no_tool_results(self):
         """
@@ -846,7 +857,7 @@ class TestBuildKiroPayloadToolCallsIntegration:
         """
         What it does: Verifies full scenario with multiple assistant tool_calls and their results.
         Purpose: Ensure all toolUses and toolResults are correctly linked in Kiro payload.
-        
+
         This is an integration test for a Codex CLI bug where multiple assistant
         messages with tool_calls were sent in a row, followed by tool results.
         """
@@ -878,6 +889,17 @@ class TestBuildKiroPayloadToolCallsIntegration:
                 # Results of both tool_calls
                 ChatMessage(role="tool", content="file1.txt\nfile2.txt", tool_call_id="tooluse_first"),
                 ChatMessage(role="tool", content="/home/user", tool_call_id="tooluse_second")
+            ],
+            # Tools must be defined for tool_results to be preserved
+            tools=[
+                Tool(
+                    type="function",
+                    function=ToolFunction(
+                        name="shell",
+                        description="Run a shell command",
+                        parameters={"type": "object", "properties": {"command": {"type": "array"}}}
+                    )
+                )
             ]
         )
         

tests/unit/test_routes_anthropic.py

@@ -720,7 +720,12 @@ class TestMessagesOptionalParams:
             yield 'event: message_start\ndata: {"type":"message_start"}\n\n'
             yield 'event: message_stop\ndata: {"type":"message_stop"}\n\n'
         
-        with patch('kiro.routes_anthropic.stream_with_first_token_retry_anthropic', mock_stream):
+        # Create mock response for HTTP client
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        
+        with patch('kiro.routes_anthropic.stream_kiro_to_anthropic', mock_stream), \
+             patch('kiro.http_client.KiroHttpClient.request_with_retry', return_value=mock_response):
             response = test_client.post(
                 "/v1/messages",
                 headers={"x-api-key": valid_proxy_api_key},