feat(openai): support Cursor flat format, inverted model names, and improve tool_results handling (#49)

CONTRIBUTORS.md

@@ -9,5 +9,5 @@ Thank you to all the contributors who have helped improve this project!
 - [@JoeGrimes123](https://github.com/JoeGrimes123) — Suggesting the fake reasoning approach (#11)
 - [@kilhyeonjun](https://github.com/kilhyeonjun) — SQLite credentials reload for containers (#22), thinking tags fix for toolResults (#23)
 - [@cniu6](https://github.com/cniu6) — Image content block support inspiration (#26)
-- [@somehow-paul](https://github.com/somehow-paul) — Enterprise Kiro IDE support (#45, #48)
+- [@somehow-paul](https://github.com/somehow-paul) — Enterprise Kiro IDE support (#45, #48), Cursor IDE compatibility design (#49)
 - [@bhaskoro-muthohar](https://github.com/bhaskoro-muthohar) — Root cause analysis and solution for MCP tool results bug (#46, #50)

kiro/converters_core.py

@@ -886,7 +886,7 @@ def strip_all_tool_content(messages: List[UnifiedMessage]) -> Tuple[List[Unified
     
     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)
+    # Log summary once (DEBUG level - this is normal for clients like Cline/Roo/Cursor)
     if had_tool_content:
         logger.debug(
             f"Converted tool content to text (no tools defined): "
@@ -901,26 +901,27 @@ def ensure_assistant_before_tool_results(messages: List[UnifiedMessage]) -> Tupl
     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
+    assistantResponseMessage with toolUses. Some clients (like Cline/Roo/Cursor) 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.
+    is missing, we cannot create a valid synthetic assistant message. Instead, we convert
+    the tool_results to text representation and append to the message content, preserving
+    the context for the model while avoiding 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)
+        - List of messages with orphaned tool_results converted to text
+        - Boolean indicating whether any tool_results were converted (used to skip thinking tag injection)
     """
     if not messages:
         return [], False
     
     result = []
-    stripped_any_tool_results = False
+    converted_any_tool_results = False
     
     for msg in messages:
         # Check if this message has tool_results
@@ -935,27 +936,40 @@ def ensure_assistant_before_tool_results(messages: List[UnifiedMessage]) -> Tupl
             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 "
+                # Convert tool_results to text to preserve context for the model.
+                logger.debug(
+                    f"Converting {len(msg.tool_results)} orphaned tool_results to text "
                     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
+                # Convert tool_results to text representation
+                tool_results_text = tool_results_to_text(msg.tool_results)
+                
+                # Append to existing content
+                original_content = extract_text_content(msg.content) or ""
+                if original_content and tool_results_text:
+                    new_content = f"{original_content}\n\n{tool_results_text}"
+                elif tool_results_text:
+                    new_content = tool_results_text
+                else:
+                    new_content = original_content
+                
+                # Create a copy of the message with tool_results converted to text
                 cleaned_msg = UnifiedMessage(
                     role=msg.role,
-                    content=msg.content,
+                    content=new_content,
                     tool_calls=msg.tool_calls,
-                    tool_results=None  # Strip orphaned tool_results
+                    tool_results=None,  # Remove orphaned tool_results (now in text)
+                    images=msg.images
                 )
                 result.append(cleaned_msg)
-                stripped_any_tool_results = True
+                converted_any_tool_results = True
                 continue
         
         result.append(msg)
     
-    return result, stripped_any_tool_results
+    return result, converted_any_tool_results
 
 
 def merge_adjacent_messages(messages: List[UnifiedMessage]) -> List[UnifiedMessage]:
@@ -1179,11 +1193,11 @@ def build_kiro_payload(
     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
+        converted_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)
+        # Also returns flag if any tool_results were converted (to skip thinking tag injection)
+        messages_with_assistants, converted_tool_results = ensure_assistant_before_tool_results(messages)
     
     # Merge adjacent messages with the same role
     merged_messages = merge_adjacent_messages(messages_with_assistants)

kiro/converters_openai.py

@@ -207,6 +207,10 @@ def convert_openai_tools_to_unified(tools: Optional[List[Tool]]) -> Optional[Lis
     """
     Converts OpenAI tools to unified format.
     
+    Supports two formats:
+    1. Standard OpenAI format: {"type": "function", "function": {"name": "...", ...}}
+    2. Flat format (Cursor-style): {"name": "...", "description": "...", "input_schema": {...}}
+    
     Args:
         tools: List of OpenAI Tool objects
     
@@ -221,11 +225,24 @@ def convert_openai_tools_to_unified(tools: Optional[List[Tool]]) -> Optional[Lis
         if tool.type != "function":
             continue
         
-        unified_tools.append(UnifiedTool(
-            name=tool.function.name,
-            description=tool.function.description,
-            input_schema=tool.function.parameters
-        ))
+        # Standard OpenAI format (function field) takes priority
+        if tool.function is not None:
+            unified_tools.append(UnifiedTool(
+                name=tool.function.name,
+                description=tool.function.description,
+                input_schema=tool.function.parameters
+            ))
+        # Flat format compatibility (Cursor-style)
+        elif tool.name is not None:
+            unified_tools.append(UnifiedTool(
+                name=tool.name,
+                description=tool.description,
+                input_schema=tool.input_schema
+            ))
+        # Skip invalid tools
+        else:
+            logger.warning(f"Skipping invalid tool: no function or name field found")
+            continue
     
     return unified_tools if unified_tools else None
 

kiro/model_resolver.py

@@ -71,6 +71,7 @@ def normalize_model_name(name: str) -> str:
     4. claude-sonnet-4-20250514 → claude-sonnet-4 (strip date, no minor)
     5. claude-3-7-sonnet → claude-3.7-sonnet (legacy format normalization)
     6. claude-3-7-sonnet-20250219 → claude-3.7-sonnet (legacy + strip date)
+    7. claude-4.5-opus-high → claude-opus-4.5 (inverted format with suffix)
     
     Args:
         name: External model name from client
@@ -93,6 +94,10 @@ def normalize_model_name(name: str) -> str:
         'claude-3.7-sonnet'
         >>> normalize_model_name("claude-3-7-sonnet-20250219")
         'claude-3.7-sonnet'
+        >>> normalize_model_name("claude-4.5-opus-high")
+        'claude-opus-4.5'
+        >>> normalize_model_name("claude-4.5-sonnet-low")
+        'claude-sonnet-4.5'
         >>> normalize_model_name("auto")
         'auto'
     """
@@ -140,6 +145,19 @@ def normalize_model_name(name: str) -> str:
     if match:
         return match.group(1)
     
+    # Pattern 5: Inverted format with suffix - claude-{major}.{minor}-{family}-{suffix}
+    # Matches: claude-4.5-opus-high, claude-4.5-sonnet-low, claude-4.5-opus-high-thinking
+    # Convert to: claude-{family}-{major}.{minor}
+    # Groups: (4), (5), (opus), any suffix
+    # NOTE: This pattern REQUIRES a suffix to avoid matching already-normalized formats like claude-3.7-sonnet
+    inverted_with_suffix_pattern = r'^claude-(\d+)\.(\d+)-(haiku|sonnet|opus)-(.+)$'
+    match = re.match(inverted_with_suffix_pattern, name_lower)
+    if match:
+        major = match.group(1)   # 4
+        minor = match.group(2)   # 5
+        family = match.group(3)  # opus
+        return f"claude-{family}-{major}.{minor}"  # claude-opus-4.5
+    
     # No transformation needed - return as-is (preserving original case for passthrough)
     return name
 

kiro/models_openai.py

@@ -102,12 +102,27 @@ class Tool(BaseModel):
     """
     Tool in OpenAI format.
     
+    Supports two formats:
+    1. Standard OpenAI format: {"type": "function", "function": {...}}
+    2. Flat format (Cursor-style): {"name": "...", "description": "...", "input_schema": {...}}
+    
     Attributes:
         type: Tool type (usually "function")
-        function: Function description
+        function: Function description (standard format)
+        name: Function name (flat format)
+        description: Function description (flat format)
+        input_schema: Function parameters (flat format)
     """
+    # Standard OpenAI format fields
     type: str = "function"
-    function: ToolFunction
+    function: Optional[ToolFunction] = None
+    
+    # Flat format fields (Cursor-style)
+    name: Optional[str] = None
+    description: Optional[str] = None
+    input_schema: Optional[Dict[str, Any]] = None
+    
+    model_config = {"extra": "allow"}
 
 
 class ChatCompletionRequest(BaseModel):

tests/unit/test_converters_core.py

@@ -1273,7 +1273,7 @@ class TestEnsureAssistantBeforeToolResults:
     """
     Tests for ensure_assistant_before_tool_results function.
     
-    This function handles the case when clients (like Cline/Roo) send truncated
+    This function handles the case when clients (like Cline/Roo/Cursor) 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.
@@ -1358,11 +1358,11 @@ class TestEnsureAssistantBeforeToolResults:
     
     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.
+        What it does: Verifies orphaned tool_results at the start are converted to text.
+        Purpose: Ensure tool_results without preceding assistant are converted to text representation.
         
         This is the critical bug fix test - when a client sends a truncated
-        conversation starting with tool_results, they should be stripped.
+        conversation starting with tool_results, they should be converted to text.
         """
         print("Setup: Conversation starting with orphaned tool_results...")
         messages = [
@@ -1379,21 +1379,26 @@ class TestEnsureAssistantBeforeToolResults:
         ]
         
         print("Action: Processing messages...")
-        result, stripped = ensure_assistant_before_tool_results(messages)
+        result, converted = 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...")
+        print("Checking that orphaned tool_results are converted to text...")
         assert result[0].tool_results is None
-        assert result[0].content == ""  # Content preserved
+        
+        print("Checking that content now contains the tool result as text...")
+        print(f"Content: '{result[0].content}'")
+        assert "[Tool Result (call_orphan)]" in result[0].content
+        assert "Orphaned result" in result[0].content
+        
         assert result[1].content == "Continue the conversation"
-        assert stripped is True
+        assert converted is True
     
-    def test_strips_tool_results_after_assistant_without_tool_calls(self):
+    def test_converts_tool_results_after_assistant_without_tool_calls(self):
         """
-        What it does: Verifies tool_results are stripped when preceding assistant has no tool_calls.
+        What it does: Verifies tool_results are converted 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...")
@@ -1412,16 +1417,21 @@ class TestEnsureAssistantBeforeToolResults:
         ]
         
         print("Action: Processing messages...")
-        result, stripped = ensure_assistant_before_tool_results(messages)
+        result, converted = ensure_assistant_before_tool_results(messages)
         
         print(f"Result: {result}")
-        print("Checking that tool_results are stripped...")
+        print("Checking that tool_results are converted to text...")
         assert result[2].tool_results is None
-        assert stripped is True
+        
+        print(f"Content after conversion: '{result[2].content}'")
+        assert "[Tool Result (call_123)]" in result[2].content
+        assert "Result" in result[2].content
+        
+        assert converted is True
     
-    def test_strips_tool_results_after_user_message(self):
+    def test_converts_tool_results_after_user_message(self):
         """
-        What it does: Verifies tool_results are stripped when preceded by user message.
+        What it does: Verifies tool_results are converted when preceded by user message.
         Purpose: Ensure tool_results require assistant, not user.
         """
         print("Setup: User message followed by user with tool_results...")
@@ -1439,17 +1449,22 @@ class TestEnsureAssistantBeforeToolResults:
         ]
         
         print("Action: Processing messages...")
-        result, stripped = ensure_assistant_before_tool_results(messages)
+        result, converted = ensure_assistant_before_tool_results(messages)
         
         print(f"Result: {result}")
-        print("Checking that tool_results are stripped...")
+        print("Checking that tool_results are converted to text...")
         assert result[1].tool_results is None
-        assert stripped is True
+        
+        print(f"Content after conversion: '{result[1].content}'")
+        assert "[Tool Result (call_123)]" in result[1].content
+        assert "Result" in result[1].content
+        
+        assert converted is True
     
-    def test_preserves_content_when_stripping_tool_results(self):
+    def test_preserves_content_when_converting_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.
+        What it does: Verifies message content is preserved and tool_results are appended as text.
+        Purpose: Ensure original content is kept and tool_results are converted to text representation.
         """
         print("Setup: Message with both content and orphaned tool_results...")
         messages = [
@@ -1465,18 +1480,27 @@ class TestEnsureAssistantBeforeToolResults:
         ]
         
         print("Action: Processing messages...")
-        result, stripped = ensure_assistant_before_tool_results(messages)
+        result, converted = ensure_assistant_before_tool_results(messages)
         
         print(f"Result: {result}")
-        print("Checking that content is preserved...")
-        assert result[0].content == "Here is some context"
+        print(f"Content after conversion: '{result[0].content}'")
+        
+        print("Checking that original content is preserved...")
+        assert "Here is some context" in result[0].content
+        
+        print("Checking that tool_results are converted to text and appended...")
+        assert "[Tool Result (call_123)]" in result[0].content
+        assert "Result" in result[0].content
+        
+        print("Checking that tool_results field is removed...")
         assert result[0].tool_results is None
-        assert stripped is True
+        
+        assert converted is True
     
-    def test_preserves_tool_calls_when_stripping_tool_results(self):
+    def test_preserves_tool_calls_when_converting_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.
+        What it does: Verifies tool_calls are preserved when tool_results are converted.
+        Purpose: Ensure only tool_results are converted, tool_calls stay.
         """
         print("Setup: Message with tool_calls and orphaned tool_results...")
         messages = [
@@ -1497,19 +1521,24 @@ class TestEnsureAssistantBeforeToolResults:
         ]
         
         print("Action: Processing messages...")
-        result, stripped = ensure_assistant_before_tool_results(messages)
+        result, converted = 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
+        
+        print("Checking that tool_results are converted to text...")
         assert result[0].tool_results is None
-        assert stripped is True
+        assert "[Tool Result (call_old)]" in result[0].content
+        assert "Old result" in result[0].content
+        
+        assert converted 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.
+        What it does: Verifies multiple orphaned tool_results are all converted.
+        Purpose: Ensure all tool_results in the list are converted to text.
         """
         print("Setup: Message with multiple orphaned tool_results...")
         messages = [
@@ -1525,12 +1554,215 @@ class TestEnsureAssistantBeforeToolResults:
         ]
         
         print("Action: Processing messages...")
-        result, stripped = ensure_assistant_before_tool_results(messages)
+        result, converted = ensure_assistant_before_tool_results(messages)
         
         print(f"Result: {result}")
-        print("Checking that all tool_results are stripped...")
+        print(f"Content after conversion: '{result[0].content}'")
+        
+        print("Checking that all tool_results are converted to text...")
         assert result[0].tool_results is None
-        assert stripped is True
+        assert "[Tool Result (call_1)]" in result[0].content
+        assert "Result 1" in result[0].content
+        assert "[Tool Result (call_2)]" in result[0].content
+        assert "Result 2" in result[0].content
+        assert "[Tool Result (call_3)]" in result[0].content
+        assert "Result 3" in result[0].content
+        
+        assert converted is True
+    
+    # ==================================================================================
+    # New tests for tool_results conversion (PR #49)
+    # ==================================================================================
+    
+    def test_conversion_preserves_images(self):
+        """
+        What it does: Verifies that images field is preserved when converting tool_results.
+        Purpose: Ensure images=msg.images is set correctly in converted message.
+        """
+        print("Setup: Message with images and orphaned tool_results...")
+        messages = [
+            UnifiedMessage(
+                role="user",
+                content="Here's an image and tool result",
+                images=[{"media_type": "image/jpeg", "data": "image_data"}],
+                tool_results=[{
+                    "type": "tool_result",
+                    "tool_use_id": "call_123",
+                    "content": "Tool output"
+                }]
+            )
+        ]
+        
+        print("Action: Processing messages...")
+        result, converted = ensure_assistant_before_tool_results(messages)
+        
+        print(f"Result: {result}")
+        print("Checking that images are preserved...")
+        assert result[0].images is not None
+        assert len(result[0].images) == 1
+        assert result[0].images[0]["media_type"] == "image/jpeg"
+        
+        print("Checking that tool_results are converted...")
+        assert result[0].tool_results is None
+        assert "[Tool Result" in result[0].content
+        
+        assert converted is True
+    
+    def test_conversion_appends_to_existing_content(self):
+        """
+        What it does: Verifies tool_results are appended with double newline.
+        Purpose: Ensure formatting: "original\\n\\n[Tool Result]\\ndata".
+        """
+        print("Setup: Message with content and orphaned tool_results...")
+        messages = [
+            UnifiedMessage(
+                role="user",
+                content="Original content here",
+                tool_results=[{
+                    "type": "tool_result",
+                    "tool_use_id": "call_abc",
+                    "content": "Tool data"
+                }]
+            )
+        ]
+        
+        print("Action: Processing messages...")
+        result, converted = ensure_assistant_before_tool_results(messages)
+        
+        print(f"Result content: '{result[0].content}'")
+        
+        print("Checking formatting...")
+        assert "Original content here" in result[0].content
+        assert "[Tool Result (call_abc)]" in result[0].content
+        assert "Tool data" in result[0].content
+        
+        # Check double newline separator
+        assert "\n\n" in result[0].content
+        
+        assert converted is True
+    
+    def test_conversion_handles_empty_original_content(self):
+        """
+        What it does: Verifies conversion works when original content is empty.
+        Purpose: Ensure that only tool_results text is used when content is empty.
+        """
+        print("Setup: Message with empty content and orphaned tool_results...")
+        messages = [
+            UnifiedMessage(
+                role="user",
+                content="",
+                tool_results=[{
+                    "type": "tool_result",
+                    "tool_use_id": "call_xyz",
+                    "content": "Only tool result"
+                }]
+            )
+        ]
+        
+        print("Action: Processing messages...")
+        result, converted = ensure_assistant_before_tool_results(messages)
+        
+        print(f"Result content: '{result[0].content}'")
+        
+        print("Checking that only tool result text is present...")
+        assert "[Tool Result (call_xyz)]" in result[0].content
+        assert "Only tool result" in result[0].content
+        
+        # Should not have leading/trailing whitespace from empty original content
+        assert result[0].content.strip() == result[0].content
+        
+        assert converted is True
+    
+    def test_conversion_returns_correct_flag(self):
+        """
+        What it does: Verifies that converted_any_tool_results flag is returned correctly.
+        Purpose: Ensure return value accurately reflects whether conversion happened.
+        """
+        print("Setup: Two scenarios - with and without orphaned tool_results...")
+        
+        # Scenario 1: With orphaned tool_results (should return True)
+        messages_with_orphaned = [
+            UnifiedMessage(
+                role="user",
+                content="Test",
+                tool_results=[{"type": "tool_result", "tool_use_id": "call_1", "content": "Result"}]
+            )
+        ]
+        
+        print("Action: Processing messages with orphaned tool_results...")
+        result1, converted1 = ensure_assistant_before_tool_results(messages_with_orphaned)
+        
+        print(f"Comparing converted flag: Expected True, Got {converted1}")
+        assert converted1 is True
+        
+        # Scenario 2: Without orphaned tool_results (should return False)
+        messages_without_orphaned = [
+            UnifiedMessage(role="user", content="Hello"),
+            UnifiedMessage(
+                role="assistant",
+                content="",
+                tool_calls=[{"id": "call_1", "type": "function", "function": {"name": "tool", "arguments": "{}"}}]
+            ),
+            UnifiedMessage(
+                role="user",
+                content="",
+                tool_results=[{"type": "tool_result", "tool_use_id": "call_1", "content": "Result"}]
+            )
+        ]
+        
+        print("Action: Processing messages without orphaned tool_results...")
+        result2, converted2 = ensure_assistant_before_tool_results(messages_without_orphaned)
+        
+        print(f"Comparing converted flag: Expected False, Got {converted2}")
+        assert converted2 is False
+    
+    def test_normal_tool_results_unchanged(self):
+        """
+        What it does: Verifies that normal (non-orphaned) tool_results are NOT converted.
+        Purpose: CRITICAL - ensure 99% of cases (normal tool use) have zero change.
+        
+        This is the most important backward compatibility test. Normal tool_results
+        (with preceding assistant message with tool_calls) should pass through unchanged.
+        """
+        print("Setup: Normal conversation with valid tool_results...")
+        messages = [
+            UnifiedMessage(role="user", content="Call a tool"),
+            UnifiedMessage(
+                role="assistant",
+                content="",
+                tool_calls=[{
+                    "id": "call_valid",
+                    "type": "function",
+                    "function": {"name": "test_tool", "arguments": "{}"}
+                }]
+            ),
+            UnifiedMessage(
+                role="user",
+                content="",
+                tool_results=[{
+                    "type": "tool_result",
+                    "tool_use_id": "call_valid",
+                    "content": "Tool executed successfully"
+                }]
+            )
+        ]
+        
+        print("Action: Processing messages...")
+        result, converted = ensure_assistant_before_tool_results(messages)
+        
+        print(f"Result: {result}")
+        print(f"Comparing converted flag: Expected False, Got {converted}")
+        assert converted is False  # No conversion happened
+        
+        print("Checking that tool_results are preserved (NOT converted)...")
+        assert result[2].tool_results is not None  # Still has tool_results
+        assert len(result[2].tool_results) == 1
+        assert result[2].tool_results[0]["tool_use_id"] == "call_valid"
+        assert result[2].tool_results[0]["content"] == "Tool executed successfully"
+        
+        print("Checking that content is NOT modified...")
+        assert result[2].content == ""  # Original empty content preserved
+        assert "[Tool Result" not in result[2].content  # NOT converted to text
     
     def test_mixed_valid_and_orphaned_tool_results(self):
         """
@@ -3261,7 +3493,7 @@ class TestStripAllToolContent:
     from messages. It is used when no tools are defined in the request, because
     Kiro API rejects requests that have toolResults but no tools defined.
     
-    This is a critical function for handling clients like Cline/Roo that may
+    This is a critical function for handling clients like Cline/Roo/Cursor that may
     send tool-related content even when tools are not available.
     """
     

tests/unit/test_converters_openai.py

@@ -459,6 +459,205 @@ class TestConvertOpenAIToolsToUnified:
         assert result[0].name == "tool1"
         assert result[1].name == "tool2"
         assert result[2].name == "tool3"
+    
+    # ==================================================================================
+    # Cursor IDE Flat Tool Format Tests (PR #49)
+    # ==================================================================================
+    
+    def test_converts_flat_format_tool(self):
+        """
+        What it does: Verifies conversion of flat format tool (Cursor-style).
+        Purpose: Ensure Cursor IDE flat format is supported.
+        
+        Cursor IDE sends tools in flat format:
+        {"type": "function", "name": "...", "description": "...", "input_schema": {...}}
+        instead of standard OpenAI nested format.
+        """
+        print("Setup: Flat format tool (Cursor-style)...")
+        tools = [Tool(
+            type="function",
+            name="cursor_tool",
+            description="A tool from Cursor IDE",
+            input_schema={"type": "object", "properties": {"param": {"type": "string"}}}
+        )]
+        
+        print("Action: Converting tools...")
+        result = convert_openai_tools_to_unified(tools)
+        
+        print(f"Result: {result}")
+        print(f"Comparing count: Expected 1, Got {len(result) if result else 0}")
+        assert result is not None
+        assert len(result) == 1
+        
+        print(f"Comparing name: Expected 'cursor_tool', Got '{result[0].name}'")
+        assert result[0].name == "cursor_tool"
+        
+        print(f"Comparing description: Expected 'A tool from Cursor IDE', Got '{result[0].description}'")
+        assert result[0].description == "A tool from Cursor IDE"
+        
+        print(f"Comparing input_schema: Got {result[0].input_schema}")
+        assert result[0].input_schema == {"type": "object", "properties": {"param": {"type": "string"}}}
+    
+    def test_converts_mixed_format_tools(self):
+        """
+        What it does: Verifies conversion of mixed format tools.
+        Purpose: Ensure both standard and flat format can coexist in same request.
+        
+        This simulates a scenario where some tools are in standard OpenAI format
+        and some are in Cursor flat format (though unlikely in practice).
+        """
+        print("Setup: Mixed format tools...")
+        tools = [
+            # Standard OpenAI format
+            Tool(
+                type="function",
+                function=ToolFunction(
+                    name="standard_tool",
+                    description="Standard format",
+                    parameters={"type": "object"}
+                )
+            ),
+            # Cursor flat format
+            Tool(
+                type="function",
+                name="flat_tool",
+                description="Flat format",
+                input_schema={"type": "object"}
+            )
+        ]
+        
+        print("Action: Converting tools...")
+        result = convert_openai_tools_to_unified(tools)
+        
+        print(f"Result: {result}")
+        print(f"Comparing count: Expected 2, Got {len(result)}")
+        assert len(result) == 2
+        
+        print("Checking standard format tool...")
+        assert result[0].name == "standard_tool"
+        assert result[0].description == "Standard format"
+        
+        print("Checking flat format tool...")
+        assert result[1].name == "flat_tool"
+        assert result[1].description == "Flat format"
+    
+    def test_standard_format_takes_priority(self):
+        """
+        What it does: Verifies that standard format takes priority over flat format.
+        Purpose: Ensure function field is used when both formats are present (edge case).
+        
+        This is an edge case where a tool has BOTH function and name fields.
+        The standard format (function) should take priority.
+        """
+        print("Setup: Tool with BOTH formats (edge case)...")
+        tools = [Tool(
+            type="function",
+            # Standard format
+            function=ToolFunction(
+                name="standard_name",
+                description="Standard description",
+                parameters={"type": "object", "properties": {"a": {"type": "string"}}}
+            ),
+            # Flat format (should be ignored)
+            name="flat_name",
+            description="Flat description",
+            input_schema={"type": "object", "properties": {"b": {"type": "string"}}}
+        )]
+        
+        print("Action: Converting tools...")
+        result = convert_openai_tools_to_unified(tools)
+        
+        print(f"Result: {result}")
+        assert len(result) == 1
+        
+        print("Checking that standard format was used (not flat)...")
+        print(f"Comparing name: Expected 'standard_name', Got '{result[0].name}'")
+        assert result[0].name == "standard_name"
+        
+        print(f"Comparing description: Expected 'Standard description', Got '{result[0].description}'")
+        assert result[0].description == "Standard description"
+        
+        print(f"Comparing input_schema: Got {result[0].input_schema}")
+        assert result[0].input_schema == {"type": "object", "properties": {"a": {"type": "string"}}}
+    
+    def test_skips_invalid_tools(self):
+        """
+        What it does: Verifies that tools without function OR name are skipped.
+        Purpose: Ensure invalid tools don't crash the conversion.
+        
+        This tests the error handling when a tool has neither function nor name field.
+        """
+        print("Setup: Invalid tool (no function, no name)...")
+        tools = [
+            # Valid tool
+            Tool(
+                type="function",
+                function=ToolFunction(name="valid_tool", description="Valid")
+            ),
+            # Invalid tool (neither function nor name)
+            Tool(type="function"),
+            # Another valid tool
+            Tool(
+                type="function",
+                name="another_valid",
+                description="Also valid",
+                input_schema={}
+            )
+        ]
+        
+        print("Action: Converting tools...")
+        result = convert_openai_tools_to_unified(tools)
+        
+        print(f"Result: {result}")
+        print(f"Comparing count: Expected 2 (invalid skipped), Got {len(result)}")
+        assert len(result) == 2
+        
+        print("Checking that only valid tools were converted...")
+        assert result[0].name == "valid_tool"
+        assert result[1].name == "another_valid"
+    
+    def test_backward_compat_standard_openai_tools(self):
+        """
+        What it does: Verifies that standard OpenAI format is not broken.
+        Purpose: Regression test for existing clients (non-Cursor).
+        
+        This is a critical backward compatibility test. After adding support for
+        Cursor's flat format, we must ensure standard OpenAI format still works.
+        """
+        print("Setup: Standard OpenAI tools (regression test)...")
+        tools = [
+            Tool(
+                type="function",
+                function=ToolFunction(
+                    name="get_weather",
+                    description="Get weather for a location",
+                    parameters={
+                        "type": "object",
+                        "properties": {
+                            "location": {"type": "string", "description": "City name"}
+                        },
+                        "required": ["location"]
+                    }
+                )
+            )
+        ]
+        
+        print("Action: Converting tools...")
+        result = convert_openai_tools_to_unified(tools)
+        
+        print(f"Result: {result}")
+        assert result is not None
+        assert len(result) == 1
+        
+        print(f"Comparing name: Expected 'get_weather', Got '{result[0].name}'")
+        assert result[0].name == "get_weather"
+        
+        print(f"Comparing description: Expected 'Get weather for a location', Got '{result[0].description}'")
+        assert result[0].description == "Get weather for a location"
+        
+        print(f"Comparing input_schema: Got {result[0].input_schema}")
+        assert result[0].input_schema["required"] == ["location"]
+        assert result[0].input_schema["properties"]["location"]["type"] == "string"
 
 
 # ==================================================================================================

tests/unit/test_model_resolver.py

@@ -243,6 +243,99 @@ class TestNormalizeModelName:
         print(f"Comparing result: Expected 'claude-3.0-opus', Got '{result}'")
         assert result == "claude-3.0-opus"
     
+    # === Inverted format with suffix (Pattern 5 - Cursor IDE) ===
+    
+    def test_inverted_format_with_high_suffix(self):
+        """
+        What it does: claude-4.5-opus-high → claude-opus-4.5
+        Goal: Check inverted format normalization with 'high' suffix (Cursor IDE).
+        
+        Cursor IDE sends model names in inverted format with priority suffix.
+        This is Pattern 5 from PR #49.
+        """
+        print("Action: Normalizing 'claude-4.5-opus-high'...")
+        result = normalize_model_name("claude-4.5-opus-high")
+        
+        print(f"Comparing result: Expected 'claude-opus-4.5', Got '{result}'")
+        assert result == "claude-opus-4.5"
+    
+    def test_inverted_format_with_low_suffix(self):
+        """
+        What it does: claude-4.5-sonnet-low → claude-sonnet-4.5
+        Goal: Check inverted format normalization with 'low' suffix (Cursor IDE).
+        """
+        print("Action: Normalizing 'claude-4.5-sonnet-low'...")
+        result = normalize_model_name("claude-4.5-sonnet-low")
+        
+        print(f"Comparing result: Expected 'claude-sonnet-4.5', Got '{result}'")
+        assert result == "claude-sonnet-4.5"
+    
+    def test_inverted_format_with_thinking_suffix(self):
+        """
+        What it does: claude-4.5-opus-high-thinking → claude-opus-4.5
+        Goal: Check inverted format with compound suffix (high-thinking).
+        
+        The pattern strips ALL suffixes after the family name.
+        """
+        print("Action: Normalizing 'claude-4.5-opus-high-thinking'...")
+        result = normalize_model_name("claude-4.5-opus-high-thinking")
+        
+        print(f"Comparing result: Expected 'claude-opus-4.5', Got '{result}'")
+        assert result == "claude-opus-4.5"
+    
+    def test_inverted_format_all_families(self):
+        """
+        What it does: Verifies inverted format works for all families.
+        Goal: Check haiku, sonnet, opus all work with inverted format.
+        """
+        print("Action: Normalizing inverted format for all families...")
+        
+        print("  Testing haiku...")
+        result_haiku = normalize_model_name("claude-4.5-haiku-high")
+        print(f"  Comparing: Expected 'claude-haiku-4.5', Got '{result_haiku}'")
+        assert result_haiku == "claude-haiku-4.5"
+        
+        print("  Testing sonnet...")
+        result_sonnet = normalize_model_name("claude-4.5-sonnet-low")
+        print(f"  Comparing: Expected 'claude-sonnet-4.5', Got '{result_sonnet}'")
+        assert result_sonnet == "claude-sonnet-4.5"
+        
+        print("  Testing opus...")
+        result_opus = normalize_model_name("claude-4.5-opus-high")
+        print(f"  Comparing: Expected 'claude-opus-4.5', Got '{result_opus}'")
+        assert result_opus == "claude-opus-4.5"
+    
+    def test_inverted_format_requires_suffix(self):
+        """
+        What it does: Verifies that suffix is required (doesn't match claude-3.7-sonnet).
+        Goal: CRITICAL - ensure Pattern 5 doesn't break already-normalized formats.
+        
+        This is the most important test for Pattern 5. The regex MUST require a suffix
+        to avoid matching already-normalized formats like claude-3.7-sonnet.
+        """
+        print("Action: Normalizing 'claude-3.7-sonnet' (should NOT match Pattern 5)...")
+        result = normalize_model_name("claude-3.7-sonnet")
+        
+        print(f"Comparing result: Expected 'claude-3.7-sonnet' (unchanged), Got '{result}'")
+        assert result == "claude-3.7-sonnet"
+        
+        print("Action: Normalizing 'claude-4.5-sonnet' (should NOT match Pattern 5)...")
+        result2 = normalize_model_name("claude-4.5-sonnet")
+        
+        print(f"Comparing result: Expected 'claude-4.5-sonnet' (unchanged), Got '{result2}'")
+        assert result2 == "claude-4.5-sonnet"
+    
+    def test_inverted_format_case_insensitive(self):
+        """
+        What it does: CLAUDE-4.5-OPUS-HIGH → claude-opus-4.5
+        Goal: Check case insensitivity for inverted format.
+        """
+        print("Action: Normalizing 'CLAUDE-4.5-OPUS-HIGH'...")
+        result = normalize_model_name("CLAUDE-4.5-OPUS-HIGH")
+        
+        print(f"Comparing result: Expected 'claude-opus-4.5', Got '{result}'")
+        assert result == "claude-opus-4.5"
+    
     # === Already normalized (passthrough) ===
     
     def test_passthrough_already_normalized_haiku(self):

tests/unit/test_models_openai.py

@@ -465,19 +465,46 @@ class TestTool:
         print(f"Comparing type: Expected 'function', Got '{tool.type}'")
         assert tool.type == "function"
     
-    def test_requires_function(self):
+    def test_function_is_optional_for_flat_format(self):
         """
-        What it does: Verifies that function is required.
-        Purpose: Ensure validation fails without function.
+        What it does: Verifies that function is optional (for flat format compatibility).
+        Purpose: Ensure flat format (Cursor-style) is supported without function field.
         """
-        print("Setup: Attempting to create Tool without function...")
+        print("Setup: Creating Tool with flat format (name, description, input_schema)...")
+        tool = Tool(
+            type="function",
+            name="test_tool",
+            description="A test tool",
+            input_schema={"type": "object", "properties": {}}
+        )
         
-        print("Action: Creating model (should raise ValidationError)...")
-        with pytest.raises(ValidationError) as exc_info:
-            Tool(type="function")
+        print(f"Result: {tool}")
+        print(f"Comparing name: Expected 'test_tool', Got '{tool.name}'")
+        assert tool.name == "test_tool"
         
-        print(f"ValidationError raised: {exc_info.value}")
-        assert "function" in str(exc_info.value)
+        print(f"Comparing function: Expected None, Got {tool.function}")
+        assert tool.function is None
+        
+        print(f"Comparing description: Expected 'A test tool', Got '{tool.description}'")
+        assert tool.description == "A test tool"
+    
+    def test_standard_format_still_works(self):
+        """
+        What it does: Verifies that standard OpenAI format still works.
+        Purpose: Ensure backward compatibility with standard format.
+        """
+        print("Setup: Creating Tool with standard OpenAI format (function field)...")
+        tool = Tool(
+            type="function",
+            function=ToolFunction(name="standard_tool", description="Standard")
+        )
+        
+        print(f"Result: {tool}")
+        print(f"Comparing function.name: Expected 'standard_tool', Got '{tool.function.name}'")
+        assert tool.function.name == "standard_tool"
+        
+        print(f"Comparing name: Expected None, Got {tool.name}")
+        assert tool.name is None
 
 
 # ==================================================================================================