mojentic 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

mojentic/llm/gateways/openai_model_registry.py

@@ -35,6 +35,9 @@ class ModelCapabilities:
     max_context_tokens: Optional[int] = None
     max_output_tokens: Optional[int] = None
     supported_temperatures: Optional[List[float]] = None  # None means all temperatures supported
+    supports_chat_api: bool = True
+    supports_completions_api: bool = False
+    supports_responses_api: bool = False
 
     def get_token_limit_param(self) -> str:
         """Get the correct parameter name for token limits based on model type."""
@@ -67,30 +70,34 @@ class OpenAIModelRegistry:
     def _initialize_default_models(self):
         """Initialize the registry with known OpenAI models and their capabilities."""
 
-        # Reasoning Models (o1, o3, o4, gpt-5 series) - Updated 2025-09-28
+        # Reasoning Models (o1, o3, o4, gpt-5 series) - Updated 2026-02-04
         reasoning_models = [
-            "o1", "o1-2024-12-17", "o1-mini", "o1-mini-2024-09-12",
+            "o1", "o1-2024-12-17",
             "o1-pro", "o1-pro-2025-03-19",
             "o3", "o3-2025-04-16", "o3-deep-research", "o3-deep-research-2025-06-26",
             "o3-mini", "o3-mini-2025-01-31", "o3-pro", "o3-pro-2025-06-10",
             "o4-mini", "o4-mini-2025-04-16", "o4-mini-deep-research",
             "o4-mini-deep-research-2025-06-26",
-            "gpt-5", "gpt-5-2025-08-07", "gpt-5-chat-latest", "gpt-5-codex",
-            "gpt-5-mini", "gpt-5-mini-2025-08-07", "gpt-5-nano", "gpt-5-nano-2025-08-07"
+            "gpt-5", "gpt-5-2025-08-07", "gpt-5-codex",
+            "gpt-5-mini", "gpt-5-mini-2025-08-07", "gpt-5-nano", "gpt-5-nano-2025-08-07",
+            "gpt-5-pro", "gpt-5-pro-2025-10-06",
+            "gpt-5.1", "gpt-5.1-2025-11-13", "gpt-5.1-chat-latest",
+            "gpt-5.2", "gpt-5.2-2025-12-11", "gpt-5.2-chat-latest"
         ]
 
         for model in reasoning_models:
             # Deep research models and GPT-5 might have different capabilities
             is_deep_research = "deep-research" in model
             is_gpt5 = "gpt-5" in model
-            is_o1_series = model.startswith("o1")
-            is_o3_series = model.startswith("o3")
-            is_o4_series = model.startswith("o4")
+            is_gpt5_1 = "gpt-5.1" in model
+            is_gpt5_2 = "gpt-5.2" in model
+            is_gpt5_pro = "gpt-5-pro" in model and not is_gpt5_2
             is_mini_or_nano = ("mini" in model or "nano" in model)
+            is_chat_latest = "chat-latest" in model
 
-            # GPT-5 models may support more features than o1/o3/o4
-            supports_tools = is_gpt5  # GPT-5 might support tools
-            supports_streaming = is_gpt5  # GPT-5 might support streaming
+            # ALL reasoning models now support tools and streaming (except gpt-5-pro which is responses-only)
+            supports_tools = not is_gpt5_pro
+            supports_streaming = not is_gpt5_pro
 
             # Set context and output tokens based on model tier
             if is_gpt5:
@@ -104,15 +111,20 @@ class OpenAIModelRegistry:
                 output_tokens = 32768
 
             # Temperature restrictions based on model series
-            if is_gpt5 or is_o1_series or is_o4_series:
-                # GPT-5, o1, and o4 series only support temperature=1.0
-                supported_temps = [1.0]
-            elif is_o3_series:
-                # o3 series doesn't support temperature parameter at all
-                supported_temps = []
-            else:
-                # Other reasoning models support all temperatures
+            # All reasoning models now support only temperature=1.0 (o3 now supports it too)
+            if is_gpt5_1 and not is_chat_latest:
+                # gpt-5.1 and gpt-5.1-2025-11-13 support all temperatures
+                supported_temps = None
+            elif is_gpt5_2 and not is_chat_latest:
+                # gpt-5.2 and gpt-5.2-2025-12-11 support all temperatures
                 supported_temps = None
+            else:
+                # All other reasoning models (including o1, o3, o4, gpt-5, and *-chat-latest) support only temp=1.0
+                supported_temps = [1.0]
+
+            # API endpoint support flags
+            is_responses_only = "pro" in model or "deep-research" in model or model == "gpt-5-codex"
+            is_both_endpoint = model in ("gpt-5.1", "gpt-5.1-2025-11-13")
 
             self._models[model] = ModelCapabilities(
                 model_type=ModelType.REASONING,
@@ -121,11 +133,14 @@ class OpenAIModelRegistry:
                 supports_vision=False,  # Vision support would need to be confirmed for GPT-5
                 max_context_tokens=context_tokens,
                 max_output_tokens=output_tokens,
-                supported_temperatures=supported_temps
+                supported_temperatures=supported_temps,
+                supports_chat_api=not is_responses_only,
+                supports_completions_api=is_both_endpoint,
+                supports_responses_api=is_responses_only
             )
 
-        # Chat Models (GPT-4 and GPT-4.1 series) - Updated 2025-09-28
-        # Note: GPT-5 series moved to reasoning models
+        # Chat Models (GPT-4 and GPT-4.1 series) - Updated 2026-02-04
+        # Note: Most GPT-5 series moved to reasoning models; gpt-5-chat-latest is chat
         gpt4_and_newer_models = [
             "chatgpt-4o-latest",
             "gpt-4", "gpt-4-0125-preview", "gpt-4-0613", "gpt-4-1106-preview",
@@ -133,7 +148,7 @@ class OpenAIModelRegistry:
             "gpt-4.1", "gpt-4.1-2025-04-14", "gpt-4.1-mini", "gpt-4.1-mini-2025-04-14",
             "gpt-4.1-nano", "gpt-4.1-nano-2025-04-14",
             "gpt-4o", "gpt-4o-2024-05-13", "gpt-4o-2024-08-06", "gpt-4o-2024-11-20",
-            "gpt-4o-audio-preview", "gpt-4o-audio-preview-2024-10-01",
+            "gpt-4o-audio-preview",
             "gpt-4o-audio-preview-2024-12-17", "gpt-4o-audio-preview-2025-06-03",
             "gpt-4o-mini", "gpt-4o-mini-2024-07-18",
             "gpt-4o-mini-audio-preview", "gpt-4o-mini-audio-preview-2024-12-17",
@@ -143,18 +158,37 @@ class OpenAIModelRegistry:
             "gpt-4o-realtime-preview", "gpt-4o-realtime-preview-2024-10-01",
             "gpt-4o-realtime-preview-2024-12-17", "gpt-4o-realtime-preview-2025-06-03",
             "gpt-4o-search-preview", "gpt-4o-search-preview-2025-03-11",
-            "gpt-4o-transcribe"
+            "gpt-4o-transcribe",
+            "gpt-5-chat-latest",
+            "gpt-5-search-api", "gpt-5-search-api-2025-10-14"
         ]
 
         for model in gpt4_and_newer_models:
             # Determine capabilities based on model features
-            vision_support = ("gpt-4o" in model or "audio-preview" in model or "realtime" in model)
+            is_chatgpt_latest = model == "chatgpt-4o-latest"
             is_mini_or_nano = ("mini" in model or "nano" in model)
-            is_audio = "audio" in model or "realtime" in model or "transcribe" in model
+            is_audio = "audio" in model or "realtime" in model or "transcribe" in model or "tts" in model
+            is_search = "search" in model
             is_gpt41 = "gpt-4.1" in model
+            is_gpt5_chat = model == "gpt-5-chat-latest"
+            is_gpt5_search = "gpt-5-search-api" in model
+            is_nano_base = model == "gpt-4.1-nano"
+            # Note: Keep vision=True for gpt-4o models (audit probe limitation with 1x1 PNG)
+            # Exclude chatgpt-4o-latest, audio/search/transcribe/tts/realtime variants
+            vision_support = ("gpt-4o" in model and not is_chatgpt_latest and not is_audio and not is_search)
+
+            # Tool support: disabled for audio models, search models, chatgpt-4o-latest, and gpt-4.1-nano
+            supports_tools = not (is_audio or is_search or is_chatgpt_latest or is_nano_base)
+            # Streaming: disabled for audio models only
+            supports_streaming = not is_audio
+            # Temperature restrictions for search models
+            supported_temps = [] if is_search else None
 
             # Set context and output tokens based on model tier
-            if is_gpt41:
+            if is_gpt5_chat or is_gpt5_search:
+                context_tokens = 300000
+                output_tokens = 50000
+            elif is_gpt41:
                 context_tokens = 200000 if not is_mini_or_nano else 128000
                 output_tokens = 32768 if not is_mini_or_nano else 16384
             elif "gpt-4o" in model:
@@ -164,33 +198,42 @@ class OpenAIModelRegistry:
                 context_tokens = 32000
                 output_tokens = 8192
 
+            # API endpoint support flags
+            is_both_endpoint = model in ("gpt-4.1-nano", "gpt-4.1-nano-2025-04-14",
+                                         "gpt-4o-mini", "gpt-4o-mini-2024-07-18")
+
             self._models[model] = ModelCapabilities(
                 model_type=ModelType.CHAT,
-                supports_tools=True,
-                supports_streaming=not is_audio,  # Audio models may not support streaming
+                supports_tools=supports_tools,
+                supports_streaming=supports_streaming,
                 supports_vision=vision_support,
                 max_context_tokens=context_tokens,
-                max_output_tokens=output_tokens
+                max_output_tokens=output_tokens,
+                supported_temperatures=supported_temps,
+                supports_completions_api=is_both_endpoint
             )
 
-        # Chat Models (GPT-3.5 series) - Updated 2025-09-28
+        # Chat Models (GPT-3.5 series) - Updated 2026-02-04
         gpt35_models = [
             "gpt-3.5-turbo", "gpt-3.5-turbo-0125", "gpt-3.5-turbo-1106",
             "gpt-3.5-turbo-16k", "gpt-3.5-turbo-instruct", "gpt-3.5-turbo-instruct-0914"
         ]
 
         for model in gpt35_models:
+            is_instruct = "instruct" in model
             context_tokens = 16385 if "16k" not in model else 16385
             self._models[model] = ModelCapabilities(
                 model_type=ModelType.CHAT,
-                supports_tools="instruct" not in model,  # Instruct models don't support tools
-                supports_streaming="instruct" not in model,  # Instruct models don't support streaming
+                supports_tools=not is_instruct,  # Instruct models don't support tools
+                supports_streaming=not is_instruct,  # Instruct models don't support streaming
                 supports_vision=False,
                 max_context_tokens=context_tokens,
-                max_output_tokens=4096
+                max_output_tokens=4096,
+                supports_chat_api=not is_instruct,
+                supports_completions_api=is_instruct
             )
 
-        # Embedding Models - Updated 2025-09-28
+        # Embedding Models - Updated 2026-02-04
         embedding_models = [
             "text-embedding-3-large", "text-embedding-3-small", "text-embedding-ada-002"
         ]
@@ -200,15 +243,61 @@ class OpenAIModelRegistry:
                 model_type=ModelType.EMBEDDING,
                 supports_tools=False,
                 supports_streaming=False,
-                supports_vision=False
+                supports_vision=False,
+                supports_chat_api=False
             )
 
-        # Pattern mappings for unknown models - Updated 2025-09-28
+        # Legacy & Codex Models - Updated 2026-02-05
+        self._models["babbage-002"] = ModelCapabilities(
+            model_type=ModelType.CHAT,
+            supports_tools=False,
+            supports_streaming=False,
+            supports_vision=False,
+            supports_chat_api=False,
+            supports_completions_api=True
+        )
+
+        self._models["davinci-002"] = ModelCapabilities(
+            model_type=ModelType.CHAT,
+            supports_tools=False,
+            supports_streaming=False,
+            supports_vision=False,
+            supports_chat_api=False,
+            supports_completions_api=True
+        )
+
+        self._models["gpt-5.1-codex-mini"] = ModelCapabilities(
+            model_type=ModelType.REASONING,
+            supports_tools=False,
+            supports_streaming=False,
+            supports_vision=False,
+            max_context_tokens=128000,
+            max_output_tokens=32768,
+            supported_temperatures=[1.0],
+            supports_chat_api=False,
+            supports_completions_api=True
+        )
+
+        self._models["codex-mini-latest"] = ModelCapabilities(
+            model_type=ModelType.REASONING,
+            supports_tools=False,
+            supports_streaming=False,
+            supports_vision=False,
+            max_context_tokens=128000,
+            max_output_tokens=32768,
+            supported_temperatures=[1.0],
+            supports_chat_api=False,
+            supports_responses_api=True
+        )
+
+        # Pattern mappings for unknown models - Updated 2026-02-04
         self._pattern_mappings = {
             "o1": ModelType.REASONING,
             "o3": ModelType.REASONING,
             "o4": ModelType.REASONING,
             "gpt-5": ModelType.REASONING,  # GPT-5 is a reasoning model
+            "gpt-5.1": ModelType.REASONING,
+            "gpt-5.2": ModelType.REASONING,
             "gpt-4": ModelType.CHAT,
             "gpt-4.1": ModelType.CHAT,
             "gpt-3.5": ModelType.CHAT,
@@ -262,28 +351,40 @@ class OpenAIModelRegistry:
                 model_type=ModelType.REASONING,
                 supports_tools=False,
                 supports_streaming=False,
-                supports_vision=False
+                supports_vision=False,
+                supports_chat_api=True,
+                supports_completions_api=False,
+                supports_responses_api=False
             )
         elif model_type == ModelType.CHAT:
             return ModelCapabilities(
                 model_type=ModelType.CHAT,
                 supports_tools=True,
                 supports_streaming=True,
-                supports_vision=False
+                supports_vision=False,
+                supports_chat_api=True,
+                supports_completions_api=False,
+                supports_responses_api=False
             )
         elif model_type == ModelType.EMBEDDING:
             return ModelCapabilities(
                 model_type=ModelType.EMBEDDING,
                 supports_tools=False,
                 supports_streaming=False,
-                supports_vision=False
+                supports_vision=False,
+                supports_chat_api=False,
+                supports_completions_api=False,
+                supports_responses_api=False
             )
         else:  # MODERATION
             return ModelCapabilities(
                 model_type=ModelType.MODERATION,
                 supports_tools=False,
                 supports_streaming=False,
-                supports_vision=False
+                supports_vision=False,
+                supports_chat_api=False,
+                supports_completions_api=False,
+                supports_responses_api=False
             )
 
     def is_reasoning_model(self, model_name: str) -> bool:

mojentic/llm/gateways/openai_model_registry_spec.py

@@ -22,9 +22,10 @@ class DescribeOpenAIModelRegistry:
         registry = OpenAIModelRegistry()
         registered_models = registry.get_registered_models()
 
-        # Check that we have reasoning models
+        # Check that we have reasoning models (o1-mini removed in 2026-02-04 audit)
         assert "o1" in registered_models
-        assert "o1-mini" in registered_models
+        assert "o3" in registered_models
+        assert "gpt-5" in registered_models
 
         # Check that we have chat models
         assert "gpt-4o" in registered_models
@@ -43,15 +44,17 @@ class DescribeOpenAIModelRegistry:
         """
         registry = OpenAIModelRegistry()
 
-        # Test known reasoning models
-        assert registry.is_reasoning_model("o1-preview") is True
-        assert registry.is_reasoning_model("o1-mini") is True
+        # Test known reasoning models (o1-mini removed, o1-preview uses pattern matching)
+        assert registry.is_reasoning_model("o1") is True
         assert registry.is_reasoning_model("o3-mini") is True
+        assert registry.is_reasoning_model("gpt-5") is True
+        assert registry.is_reasoning_model("gpt-5.1") is True
 
         # Test chat models
         assert registry.is_reasoning_model("gpt-4o") is False
         assert registry.is_reasoning_model("gpt-4o-mini") is False
         assert registry.is_reasoning_model("gpt-3.5-turbo") is False
+        assert registry.is_reasoning_model("gpt-5-chat-latest") is False
 
     def should_use_pattern_matching_for_unknown_models(self):
         """
@@ -80,7 +83,7 @@ class DescribeOpenAIModelRegistry:
         registry = OpenAIModelRegistry()
 
         # Reasoning models should use max_completion_tokens
-        o1_capabilities = registry.get_model_capabilities("o1-mini")
+        o1_capabilities = registry.get_model_capabilities("o1")
         assert o1_capabilities.get_token_limit_param() == "max_completion_tokens"
 
         # Chat models should use max_tokens
@@ -178,3 +181,167 @@ class DescribeOpenAIModelRegistry:
         assert ModelType.CHAT.value == "chat"
         assert ModelType.EMBEDDING.value == "embedding"
         assert ModelType.MODERATION.value == "moderation"
+
+    def should_support_tools_and_streaming_for_all_reasoning_models(self):
+        """
+        Given reasoning models as of 2026-02-04 audit
+        When checking their capabilities
+        Then all should support tools and streaming except gpt-5-pro
+        """
+        registry = OpenAIModelRegistry()
+
+        # All o1/o3/o4 models now support tools and streaming
+        o1_caps = registry.get_model_capabilities("o1")
+        assert o1_caps.supports_tools is True
+        assert o1_caps.supports_streaming is True
+
+        o3_caps = registry.get_model_capabilities("o3")
+        assert o3_caps.supports_tools is True
+        assert o3_caps.supports_streaming is True
+
+        o3_mini_caps = registry.get_model_capabilities("o3-mini")
+        assert o3_mini_caps.supports_tools is True
+        assert o3_mini_caps.supports_streaming is True
+
+        # GPT-5 family (except gpt-5-pro) supports tools and streaming
+        gpt5_caps = registry.get_model_capabilities("gpt-5")
+        assert gpt5_caps.supports_tools is True
+        assert gpt5_caps.supports_streaming is True
+
+        # gpt-5-pro is responses-only, no tools/streaming
+        gpt5_pro_caps = registry.get_model_capabilities("gpt-5-pro")
+        assert gpt5_pro_caps.supports_tools is False
+        assert gpt5_pro_caps.supports_streaming is False
+
+    def should_support_temperature_1_0_only_for_most_reasoning_models(self):
+        """
+        Given reasoning models as of 2026-02-04 audit
+        When checking temperature support
+        Then most should support only temperature=1.0, except gpt-5.1/5.2 base models
+        """
+        registry = OpenAIModelRegistry()
+
+        # o1/o3/o4 series support only temperature=1.0
+        o1_caps = registry.get_model_capabilities("o1")
+        assert o1_caps.supported_temperatures == [1.0]
+        assert o1_caps.supports_temperature(1.0) is True
+        assert o1_caps.supports_temperature(0.7) is False
+
+        o3_caps = registry.get_model_capabilities("o3")
+        assert o3_caps.supported_temperatures == [1.0]
+
+        # gpt-5.1 and gpt-5.1-2025-11-13 support all temperatures
+        gpt5_1_caps = registry.get_model_capabilities("gpt-5.1")
+        assert gpt5_1_caps.supported_temperatures is None
+        assert gpt5_1_caps.supports_temperature(0.7) is True
+        assert gpt5_1_caps.supports_temperature(1.0) is True
+
+        # gpt-5.1-chat-latest supports only temperature=1.0
+        gpt5_1_chat_caps = registry.get_model_capabilities("gpt-5.1-chat-latest")
+        assert gpt5_1_chat_caps.supported_temperatures == [1.0]
+
+        # gpt-5.2 and gpt-5.2-2025-12-11 support all temperatures
+        gpt5_2_caps = registry.get_model_capabilities("gpt-5.2")
+        assert gpt5_2_caps.supported_temperatures is None
+
+        # gpt-5.2-chat-latest supports only temperature=1.0
+        gpt5_2_chat_caps = registry.get_model_capabilities("gpt-5.2-chat-latest")
+        assert gpt5_2_chat_caps.supported_temperatures == [1.0]
+
+    def should_disable_tools_for_specific_chat_models(self):
+        """
+        Given chat models as of 2026-02-04 audit
+        When checking tool support
+        Then specific models should have tools disabled
+        """
+        registry = OpenAIModelRegistry()
+
+        # chatgpt-4o-latest does not support tools
+        chatgpt_caps = registry.get_model_capabilities("chatgpt-4o-latest")
+        assert chatgpt_caps.supports_tools is False
+        assert chatgpt_caps.supports_vision is False
+
+        # gpt-4.1-nano does not support tools
+        nano_caps = registry.get_model_capabilities("gpt-4.1-nano")
+        assert nano_caps.supports_tools is False
+
+        # Search models do not support tools and have no temperature support
+        search_caps = registry.get_model_capabilities("gpt-4o-search-preview")
+        assert search_caps.supports_tools is False
+        assert search_caps.supported_temperatures == []
+        assert search_caps.supports_temperature(1.0) is False
+
+        gpt5_search_caps = registry.get_model_capabilities("gpt-5-search-api")
+        assert gpt5_search_caps.supports_tools is False
+        assert gpt5_search_caps.supported_temperatures == []
+
+        # Audio models do not support tools or streaming
+        audio_caps = registry.get_model_capabilities("gpt-4o-audio-preview")
+        assert audio_caps.supports_tools is False
+        assert audio_caps.supports_streaming is False
+
+
+class DescribeAPIEndpointSupport:
+
+    def should_flag_chat_only_model(self):
+        registry = OpenAIModelRegistry()
+        caps = registry.get_model_capabilities("gpt-4")
+        assert caps.supports_chat_api is True
+        assert caps.supports_completions_api is False
+        assert caps.supports_responses_api is False
+
+    def should_flag_both_endpoint_model(self):
+        registry = OpenAIModelRegistry()
+        caps = registry.get_model_capabilities("gpt-4o-mini")
+        assert caps.supports_chat_api is True
+        assert caps.supports_completions_api is True
+        assert caps.supports_responses_api is False
+
+    def should_flag_completions_only_model(self):
+        registry = OpenAIModelRegistry()
+        caps = registry.get_model_capabilities("gpt-3.5-turbo-instruct")
+        assert caps.supports_chat_api is False
+        assert caps.supports_completions_api is True
+        assert caps.supports_responses_api is False
+
+    def should_flag_responses_only_model(self):
+        registry = OpenAIModelRegistry()
+        caps = registry.get_model_capabilities("gpt-5-pro")
+        assert caps.supports_chat_api is False
+        assert caps.supports_completions_api is False
+        assert caps.supports_responses_api is True
+
+    def should_flag_legacy_completions_model(self):
+        registry = OpenAIModelRegistry()
+        caps = registry.get_model_capabilities("babbage-002")
+        assert caps.supports_chat_api is False
+        assert caps.supports_completions_api is True
+        assert caps.supports_responses_api is False
+
+    def should_flag_embedding_model_with_no_endpoints(self):
+        registry = OpenAIModelRegistry()
+        caps = registry.get_model_capabilities("text-embedding-3-large")
+        assert caps.supports_chat_api is False
+        assert caps.supports_completions_api is False
+        assert caps.supports_responses_api is False
+
+    def should_flag_codex_mini_latest_as_responses_only(self):
+        registry = OpenAIModelRegistry()
+        caps = registry.get_model_capabilities("codex-mini-latest")
+        assert caps.supports_chat_api is False
+        assert caps.supports_completions_api is False
+        assert caps.supports_responses_api is True
+
+    def should_flag_gpt51_as_both_chat_and_completions(self):
+        registry = OpenAIModelRegistry()
+        caps = registry.get_model_capabilities("gpt-5.1")
+        assert caps.supports_chat_api is True
+        assert caps.supports_completions_api is True
+        assert caps.supports_responses_api is False
+
+    def should_include_endpoint_flags_in_default_capabilities(self):
+        registry = OpenAIModelRegistry()
+        caps = registry.get_model_capabilities("completely-unknown-model-xyz")
+        assert caps.supports_chat_api is True
+        assert caps.supports_completions_api is False
+        assert caps.supports_responses_api is False

mojentic/llm/gateways/openai_temperature_handling_spec.py

@@ -88,16 +88,16 @@ class DescribeOpenAIGatewayTemperatureHandling:
             call_args = mock_openai_client.chat.completions.create.call_args
             assert call_args[1]['temperature'] == 0.1
 
-        def should_automatically_adjust_unsupported_temperature_for_o1_mini(self, openai_gateway, mock_openai_client):
+        def should_automatically_adjust_unsupported_temperature_for_o1(self, openai_gateway, mock_openai_client):
             """
-            Given an o1-mini model that only supports temperature=1.0
+            Given an o1 model that only supports temperature=1.0
             When calling complete with temperature=0.1 (unsupported)
             Then it should automatically adjust to temperature=1.0
             """
             messages = [LLMMessage(role=MessageRole.User, content="Test message")]
 
             openai_gateway.complete(
-                model="o1-mini",
+                model="o1",
                 messages=messages,
                 temperature=0.1
             )
@@ -124,11 +124,11 @@ class DescribeOpenAIGatewayTemperatureHandling:
             call_args = mock_openai_client.chat.completions.create.call_args
             assert call_args[1]['temperature'] == 1.0
 
-        def should_remove_temperature_parameter_for_o3_mini(self, openai_gateway, mock_openai_client):
+        def should_automatically_adjust_unsupported_temperature_for_o3_mini(self, openai_gateway, mock_openai_client):
             """
-            Given an o3-mini model that doesn't support temperature parameter at all
-            When calling complete with temperature=0.1
-            Then it should remove the temperature parameter entirely
+            Given an o3-mini model that only supports temperature=1.0
+            When calling complete with temperature=0.1 (unsupported)
+            Then it should automatically adjust to temperature=1.0
             """
             messages = [LLMMessage(role=MessageRole.User, content="Test message")]
 
@@ -138,9 +138,9 @@ class DescribeOpenAIGatewayTemperatureHandling:
                 temperature=0.1
             )
 
-            # Verify the API was called without temperature parameter
+            # Verify the API was called with temperature=1.0, not 0.1
             call_args = mock_openai_client.chat.completions.create.call_args
-            assert 'temperature' not in call_args[1]
+            assert call_args[1]['temperature'] == 1.0
 
 
 class DescribeModelCapabilitiesTemperatureRestrictions:
@@ -178,14 +178,14 @@ class DescribeModelCapabilitiesTemperatureRestrictions:
     def should_identify_all_gpt5_variants_temperature_restrictions(self):
         """
         Given the model registry
-        When checking all GPT-5 variant models
-        Then they should all have temperature restrictions to 1.0 only
+        When checking GPT-5 reasoning variant models
+        Then they should have temperature restrictions to 1.0 only
+        Note: gpt-5-chat-latest is a CHAT model and supports all temperatures
         """
         registry = get_model_registry()
-        gpt5_models = [
+        gpt5_reasoning_models = [
             "gpt-5",
             "gpt-5-2025-08-07",
-            "gpt-5-chat-latest",
             "gpt-5-codex",
             "gpt-5-mini",
             "gpt-5-mini-2025-08-07",
@@ -193,7 +193,7 @@ class DescribeModelCapabilitiesTemperatureRestrictions:
             "gpt-5-nano-2025-08-07"
         ]
 
-        for model in gpt5_models:
+        for model in gpt5_reasoning_models:
             capabilities = registry.get_model_capabilities(model)
             assert capabilities.supports_temperature(1.0) is True
             assert capabilities.supports_temperature(0.1) is False
@@ -204,9 +204,10 @@ class DescribeModelCapabilitiesTemperatureRestrictions:
         Given the model registry
         When checking o1 series models
         Then they should have temperature restrictions to 1.0 only
+        Note: o1-mini removed from API as of 2026-02-04 audit
         """
         registry = get_model_registry()
-        o1_models = ["o1", "o1-mini", "o1-pro", "o1-2024-12-17"]
+        o1_models = ["o1", "o1-pro", "o1-2024-12-17", "o1-pro-2025-03-19"]
 
         for model in o1_models:
             capabilities = registry.get_model_capabilities(model)
@@ -214,20 +215,21 @@ class DescribeModelCapabilitiesTemperatureRestrictions:
             assert capabilities.supports_temperature(0.1) is False
             assert capabilities.supported_temperatures == [1.0]
 
-    def should_identify_o3_series_no_temperature_support(self):
+    def should_identify_o3_series_temperature_restrictions(self):
         """
         Given the model registry
         When checking o3 series models
-        Then they should not support temperature parameter at all
+        Then they should now support temperature=1.0 only (as of 2026-02-04 audit)
         """
         registry = get_model_registry()
-        o3_models = ["o3", "o3-mini", "o3-pro", "o3-deep-research"]
+        o3_models = ["o3", "o3-mini", "o3-pro", "o3-deep-research", "o3-2025-04-16",
+                     "o3-mini-2025-01-31", "o3-pro-2025-06-10", "o3-deep-research-2025-06-26"]
 
         for model in o3_models:
             capabilities = registry.get_model_capabilities(model)
-            assert capabilities.supports_temperature(1.0) is False
+            assert capabilities.supports_temperature(1.0) is True
             assert capabilities.supports_temperature(0.1) is False
-            assert capabilities.supported_temperatures == []
+            assert capabilities.supported_temperatures == [1.0]
 
     def should_identify_o4_series_temperature_restrictions(self):
         """