test(zen): align provider tests with API

tests/test_zen_provider.py

@@ -288,57 +288,52 @@ class TestZenAPIMocking:
         mock_response.usage.prompt_tokens = 10
         mock_response.usage.completion_tokens = 20
 
-        with patch.object(provider.client.chat.completions, "create", return_value=mock_response):
+        with patch.object(provider.client.chat.completions, "create", return_value=mock_response) as create_mock:
-            # Test the completion method - this will initialize the client
+            response = provider.generate_content(
-            response = provider.complete(
+                prompt="Hello",
-                model="claude-sonnet-4-5", messages=[{"role": "user", "content": "Hello"}], temperature=0.7
+                model_name="claude-sonnet-4-5",
+                temperature=0.7,
             )
 
             assert response.content == "Mocked response from Zen"
+            call_kwargs = create_mock.call_args.kwargs
+            assert call_kwargs["model"] == "claude-sonnet-4-5"
+            assert call_kwargs["messages"] == [{"role": "user", "content": "Hello"}]
+            assert call_kwargs["temperature"] == 0.7
+            assert call_kwargs["stream"] is False
 
-    def test_streaming_completion_mock(self):
+    def test_generate_content_resolves_aliases(self):
-        """Test streaming completion with mocked API."""
+        """Test generate_content resolves Zen aliases before calling the API."""
         provider = ZenProvider(api_key="test-key")
 
-        # Mock streaming response
+        mock_response = Mock()
-        mock_chunk1 = Mock()
+        mock_response.output_text = "Alias response"
-        mock_chunk1.choices = [Mock()]
+        mock_response.model = "gpt-5.1-codex"
-        mock_chunk1.choices[0].delta.content = "Hello"
+        mock_response.id = "resp_123"
-        mock_chunk1.choices[0].finish_reason = None
+        mock_response.created_at = 1234567890
+        mock_response.usage = Mock()
+        mock_response.usage.prompt_tokens = 11
+        mock_response.usage.completion_tokens = 7
+        mock_response.usage.total_tokens = 18
 
-        mock_chunk2 = Mock()
+        with patch.object(provider.client.responses, "create", return_value=mock_response) as create_mock:
-        mock_chunk2.choices = [Mock()]
+            response = provider.generate_content(
-        mock_chunk2.choices[0].delta.content = " world!"
+                prompt="Say hello",
-        mock_chunk2.choices[0].finish_reason = "stop"
+                model_name="zen-codex",
-
-        mock_stream = [mock_chunk1, mock_chunk2]
-
-        # Access client to initialize it first
-        _ = provider.client
-        with patch.object(provider.client.chat.completions, "create", return_value=mock_stream):
-            # Test streaming completion
-            stream = provider.complete_stream(
-                model="gpt-5.1-codex",
-                messages=[{"role": "user", "content": "Say hello"}],
             )
 
-            chunks = list(stream)
+            assert response.content == "Alias response"
-            assert len(chunks) == 2
+            call_kwargs = create_mock.call_args.kwargs
-            assert chunks[0].content == "Hello"
+            assert call_kwargs["model"] == "gpt-5.1-codex"
-            assert chunks[1].content == " world!"
+            assert call_kwargs["input"] == [{"role": "user", "content": [{"type": "input_text", "text": "Say hello"}]}]
 
     def test_api_error_handling(self):
         """Test error handling for API failures."""
         provider = ZenProvider(api_key="test-key")
 
-        # Mock API error
+        with patch.object(provider.client.chat.completions, "create", side_effect=RuntimeError("Mock API error")):
-        from openai import APIError
+            with pytest.raises(RuntimeError, match="OpenCode Zen API error for model claude-sonnet-4-5"):
-
+                provider.generate_content(prompt="Test", model_name="claude-sonnet-4-5")
-        api_error = APIError("Mock API error", request=Mock(), body="error details")
-
-        with patch.object(provider._client.chat.completions, "create", side_effect=api_error):
-            with pytest.raises(APIError):
-                provider.complete(model="claude-sonnet-4-5", messages=[{"role": "user", "content": "Test"}])
 
     def test_invalid_model_error(self):
         """Test error handling for invalid models."""
@@ -351,11 +346,6 @@ class TestZenAPIMocking:
         """Test handling of authentication errors."""
         provider = ZenProvider(api_key="invalid-key")
 
-        # Mock authentication error
+        with patch.object(provider.client.chat.completions, "create", side_effect=RuntimeError("auth failed")):
-        from openai import AuthenticationError
+            with pytest.raises(RuntimeError, match="OpenCode Zen API error for model claude-sonnet-4-5"):
-
+                provider.generate_content(prompt="Test", model_name="claude-sonnet-4-5")
-        auth_error = AuthenticationError("Invalid API key", request=Mock(), body="auth failed")
-
-        with patch.object(provider._client.chat.completions, "create", side_effect=auth_error):
-            with pytest.raises(AuthenticationError):
-                provider.complete(model="claude-sonnet-4-5", messages=[{"role": "user", "content": "Test"}])