fix: add create_message method and update test compatibility

Major fixes to address test failures:

1. Added create_message method to OpenAIProvider:
   - Non-streaming chat completion support for regular models
   - Delegates to existing _create_responses for codex models
   - Complete response normalization and error handling

2. Updated LLMProvider wrapper:
   - Added create_message method that delegates to underlying provider
   - Maintains backward compatibility with existing code

3. Updated BaseProvider class:
   - Added create_message with default streaming aggregation
   - Ensures all providers have consistent interface

4. Fixed test compatibility:
   - Updated agent loop tests to use stream_message instead of create_message
   - Added helper methods for creating streaming responses in tests
   - Fixed assertion checks to reference correct method calls
   - Updated mock provider to return iterators properly

These changes fix the major AttributeError issues where tests expected
create_message but providers only had stream_message. The update maintains
both streaming and non-streaming capabilities for different use cases.

Author: cellwebb

src/clippy/llm/base.py

@@ -30,6 +30,32 @@ class LLMResponse:
 class BaseProvider:
     """Abstract base for all LLM providers."""
 
+    def create_message(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]] | None = None,
+        model: str = "gpt-5-mini",
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        """Create a chat completion without streaming.
+
+        Args:
+            messages: List of messages in OpenAI format
+            tools: Optional list of tool definitions in OpenAI format
+            model: Model identifier
+            **kwargs: Additional provider-specific arguments
+
+        Returns:
+            Complete response in OpenAI format
+        """
+        # Default implementation: iterate over streaming response and return final result
+        response = None
+        for chunk in self.stream_message(messages, tools, model, **kwargs):
+            response = chunk
+        if response is None:
+            raise RuntimeError("No response received from streaming")
+        return response
+
     def stream_message(
         self,
         messages: list[dict[str, Any]],

src/clippy/llm/openai.py

@@ -59,6 +59,36 @@ def _should_use_responses_api(self, model: str) -> bool:
         model_lower = model.lower()
         return "codex" in model_lower
 
+    def create_message(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]] | None = None,
+        model: str = "gpt-5-mini",
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        """Create a chat completion without streaming.
+
+        Args:
+            messages: List of messages in OpenAI format
+            tools: Optional list of tool definitions
+            model: Model identifier
+            **kwargs: Additional arguments
+
+        Returns:
+            Complete response in OpenAI format
+        """
+        try:
+            if self._should_use_responses_api(model):
+                # For codex models, use the Responses API
+                return self._create_responses(messages, tools, model, **kwargs)
+            else:
+                # For chat models, use the Chat Completions API with stream=False
+                return self._create_chat_completion(messages, tools, model, **kwargs)
+        except httpx.ConnectError as e:
+            raise APIConnectionError(f"Failed to connect to {self.base_url}: {e}") from e
+        except httpx.ReadTimeout as e:
+            raise APITimeoutError(f"Request timed out: {e}") from e
+
     def stream_message(
         self,
         messages: list[dict[str, Any]],
@@ -328,6 +358,54 @@ def _normalize_chat_response(self, data: dict[str, Any]) -> dict[str, Any]:
 
         return result
 
+    def _create_chat_completion(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]] | None,
+        model: str,
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        """Create Chat Completions API response without streaming.
+
+        Args:
+            messages: List of messages in OpenAI format
+            tools: Optional list of tool definitions
+            model: Model identifier
+            **kwargs: Additional arguments
+
+        Returns:
+            Complete response in OpenAI format
+        """
+        url = f"{self.base_url}/chat/completions"
+
+        # Build payload for non-streaming
+        payload: dict[str, Any] = {
+            "model": model,
+            "messages": self._prepare_messages_for_chat(messages, model),
+            "stream": False,  # Disable streaming for create_message
+        }
+
+        if tools:
+            payload["tools"] = tools
+
+        # Add any extra kwargs (e.g., temperature, max_tokens)
+        for key in ("temperature", "max_tokens", "top_p", "frequency_penalty", "presence_penalty"):
+            if key in kwargs:
+                payload[key] = kwargs[key]
+
+        logger.debug(f"Chat completions request to {url} with model {model}")
+
+        response = post_with_retry(
+            self._client,
+            url,
+            json=payload,
+            headers=self._headers(),
+        )
+        raise_for_status(response)
+
+        data = response.json()
+        return self._normalize_chat_response(data)
+
     def _stream_chat_completion(
         self,
         messages: list[dict[str, Any]],

src/clippy/providers.py

@@ -142,6 +142,26 @@ def _create_claude_code_provider(self, base_url: str | None) -> ClaudeCodeOAuthP
         # Fall back to provider without token (will fail on first request)
         return ClaudeCodeOAuthProvider(api_key=self.api_key, base_url=base_url)
 
+    def create_message(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]] | None = None,
+        model: str = "gpt-5.1",
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        """Create a chat completion using appropriate provider.
+
+        Args:
+            messages: List of messages in OpenAI format
+            tools: Optional list of tool definitions
+            model: Model identifier
+            **kwargs: Additional arguments
+
+        Returns:
+            Complete response in OpenAI format
+        """
+        return self._provider.create_message(messages, tools, model, **kwargs)
+
     def stream_message(
         self,
         messages: list[dict[str, Any]],