게이트웨이 openai provider 경로를 정식 소스로 복원

apps/api/engine_gateway/test_provider_registry.py

@@ -1,7 +1,7 @@
 import json
 import unittest
 from datetime import datetime, timezone
-from unittest.mock import AsyncMock, patch
+from unittest.mock import AsyncMock, Mock, patch
 
 from app.contracts.engine_gateway import EngineMessage, GenerateRequest
 from engine_gateway import provider_registry
@@ -221,6 +221,137 @@ class ProviderRegistryTest(unittest.IsolatedAsyncioTestCase):
         self.assertEqual(result.models, [])
         self.assertIn("ANTHROPIC_API_KEY", result.detail)
 
+    async def test_openai_catalog_intersects_live_models_with_explicit_allowlist(self):
+        response = Mock()
+        response.raise_for_status.return_value = None
+        response.json.return_value = {
+            "data": [
+                {"id": "gpt-5.6-sol"},
+                {"id": "gpt-5.6-terra"},
+                {"id": "gpt-4.1"},
+                {"id": "gpt-4o-mini-tts"},
+            ]
+        }
+        client = AsyncMock()
+        client.__aenter__.return_value = client
+        client.__aexit__.return_value = False
+        client.get.return_value = response
+        with (
+            patch.dict(
+                provider_registry.os.environ,
+                {
+                    "OPENAI_API_KEY": "test-openai-key",
+                    "OPENAI_ENGINE_MODEL": "gpt-5.6-terra",
+                    "OPENAI_ENGINE_MODELS": "gpt-5.6-terra,gpt-4.1",
+                },
+                clear=True,
+            ),
+            patch.object(
+                provider_registry.httpx,
+                "AsyncClient",
+                return_value=client,
+            ),
+        ):
+            result = await provider_registry.discover_capabilities(
+                "openai", force=True
+            )
+
+        self.assertTrue(result.available)
+        self.assertEqual(result.source, "live_api")
+        self.assertEqual(result.default_model, "gpt-5.6-terra")
+        self.assertEqual(
+            [model.id for model in result.models],
+            ["gpt-5.6-terra", "gpt-4.1"],
+        )
+        self.assertEqual(result.models[0].reasoning_efforts, ["low", "medium", "high"])
+        self.assertEqual(result.models[1].reasoning_efforts, [])
+        request = client.get.await_args
+        self.assertEqual(request.args[0], f"{provider_registry.OPENAI_API_BASE}/models")
+        self.assertEqual(
+            request.kwargs["headers"]["Authorization"],
+            "Bearer test-openai-key",
+        )
+
+    async def test_openai_generation_uses_responses_api_without_temperature_for_reasoning(self):
+        capabilities = provider_registry.EngineCapabilitiesResponse(
+            provider="openai",
+            available=True,
+            source="live_api",
+            models=[
+                provider_registry.EngineModelOption(
+                    id="gpt-5.6-terra",
+                    label="gpt-5.6-terra",
+                    reasoning_efforts=["low", "medium", "high"],
+                    default_reasoning_effort="medium",
+                    is_default=True,
+                )
+            ],
+            default_model="gpt-5.6-terra",
+            default_reasoning_effort="medium",
+            fetched_at=1,
+        )
+        response = Mock()
+        response.raise_for_status.return_value = None
+        response.json.return_value = {
+            "model": "gpt-5.6-terra",
+            "output": [
+                {
+                    "type": "message",
+                    "content": [{"type": "output_text", "text": "OK"}],
+                }
+            ],
+            "usage": {
+                "input_tokens": 12,
+                "output_tokens": 2,
+                "input_tokens_details": {"cached_tokens": 3},
+            },
+        }
+        client = AsyncMock()
+        client.__aenter__.return_value = client
+        client.__aexit__.return_value = False
+        client.post.return_value = response
+        request = GenerateRequest(
+            provider="openai",
+            model="gpt-5.6-terra",
+            reasoning_effort="medium",
+            messages=[EngineMessage(role="user", content="hello")],
+        )
+        with (
+            patch.dict(
+                provider_registry.os.environ,
+                {"OPENAI_API_KEY": "test-openai-key"},
+                clear=True,
+            ),
+            patch.object(
+                provider_registry,
+                "discover_capabilities",
+                AsyncMock(return_value=capabilities),
+            ),
+            patch.object(
+                provider_registry.httpx,
+                "AsyncClient",
+                return_value=client,
+            ),
+        ):
+            result = await provider_registry.generate_with_provider(
+                request,
+                system_prompt="system",
+                user_payload="current turn",
+            )
+
+        self.assertEqual(result.text, "OK")
+        self.assertEqual(result.provider, "openai")
+        self.assertEqual(result.tokens_in, 12)
+        self.assertEqual(result.tokens_out, 2)
+        call = client.post.await_args
+        self.assertEqual(call.args[0], f"{provider_registry.OPENAI_API_BASE}/responses")
+        payload = call.kwargs["json"]
+        self.assertEqual(payload["model"], "gpt-5.6-terra")
+        self.assertEqual(payload["instructions"], "system")
+        self.assertEqual(payload["input"], [{"role": "user", "content": "current turn"}])
+        self.assertIs(payload["store"], False)
+        self.assertEqual(payload["reasoning"], {"effort": "medium"})
+
     async def test_codex_generation_uses_model_and_reasoning_from_selection(self):
         capabilities = provider_registry.EngineCapabilitiesResponse(
             provider="codex_cli",