newcode 0.2.6__tar.gz → 0.2.9__tar.gz

{newcode-0.2.6 → newcode-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: newcode
-Version: 0.2.6
+Version: 0.2.9
 Summary: AI-powered code generation agent platform
 Project-URL: repository, https://github.com/janfeddersen-wq/new_code
 Project-URL: HomePage, https://github.com/janfeddersen-wq/new_code
@@ -17,7 +17,6 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Code Generators
 Requires-Python: <3.14,>=3.11
 Requires-Dist: anthropic==0.79.0
-Requires-Dist: dbos>=2.11.0
 Requires-Dist: fastapi>=0.109.0
 Requires-Dist: httpx[http2]>=0.24.1
 Requires-Dist: json-repair>=0.46.2

{newcode-0.2.6 → newcode-0.2.9}/newcode/agents/base_agent.py

@@ -27,7 +27,6 @@ from typing import (
 import mcp
 import pydantic
 import pydantic_ai.models
-from dbos import DBOS, SetWorkflowID
 from pydantic_ai import Agent as PydanticAgent
 from pydantic_ai import (
     BinaryContent,
@@ -37,7 +36,6 @@ from pydantic_ai import (
     UsageLimitExceeded,
     UsageLimits,
 )
-from pydantic_ai.durable_exec.dbos import DBOSAgent
 from pydantic_ai.messages import (
     ModelMessage,
     ModelRequest,
@@ -67,7 +65,6 @@ from newcode.config import (
     get_global_model_name,
     get_message_limit,
     get_protected_token_count,
-    get_use_dbos,
     get_value,
 )
 from newcode.error_logging import log_error
@@ -1319,6 +1316,12 @@ class BaseAgent(ABC):
         """Force-reload the pydantic-ai Agent based on current config and model."""
         from newcode.tools import register_tools_for_agent
 
+        # Invalidate the project-local rules cache so a fresh read from the
+        # current working directory is performed on the next load_agent_rules()
+        # call.  This is critical for /cd: the user may have switched to a
+        # different project that has its own AGENT.md (or none at all).
+        self._agent_rules = None
+
         if message_group is None:
             message_group = str(uuid.uuid4())
 
@@ -1417,64 +1420,25 @@ class BaseAgent(ABC):
             )
 
         self._last_model_name = resolved_model_name
-        # expose for run_with_mcp
-        # Wrap it with DBOS, but handle MCP servers separately to avoid serialization issues
         global _reload_count
         _reload_count += 1
-        if get_use_dbos():
-            # Don't pass MCP servers to the agent constructor when using DBOS
-            # This prevents the "cannot pickle async_generator object" error
-            # MCP servers will be handled separately in run_with_mcp
-            agent_without_mcp = PydanticAgent(
-                model=model,
-                instructions=instructions,
-                output_type=str,
-                retries=10,
-                toolsets=[],  # Don't include MCP servers here
-                history_processors=[self.message_history_accumulator],
-                model_settings=model_settings,
-            )
-
-            # Register regular tools (non-MCP) on the new agent
-            agent_tools = self.get_available_tools()
-            register_tools_for_agent(
-                agent_without_mcp, agent_tools, model_name=resolved_model_name
-            )
-
-            # Wrap with DBOS - pass event_stream_handler at construction time
-            # so DBOSModel gets the handler for streaming output
-            dbos_agent = DBOSAgent(
-                agent_without_mcp,
-                name=f"{self.name}-{_reload_count}",
-                event_stream_handler=event_stream_handler,
-            )
-            self.pydantic_agent = dbos_agent
-            self._code_generation_agent = dbos_agent
 
-            # Store filtered MCP servers separately for runtime use
-            self._mcp_servers = filtered_mcp_servers
-        else:
-            # Normal path without DBOS - include filtered MCP servers in the agent
-            # Re-create agent with filtered MCP servers
-            p_agent = PydanticAgent(
-                model=model,
-                instructions=instructions,
-                output_type=str,
-                retries=10,
-                toolsets=filtered_mcp_servers,
-                history_processors=[self.message_history_accumulator],
-                model_settings=model_settings,
-            )
-            # Register regular tools on the agent
-            agent_tools = self.get_available_tools()
-            register_tools_for_agent(
-                p_agent, agent_tools, model_name=resolved_model_name
-            )
+        p_agent = PydanticAgent(
+            model=model,
+            instructions=instructions,
+            output_type=str,
+            retries=10,
+            toolsets=filtered_mcp_servers,
+            history_processors=[self.message_history_accumulator],
+            model_settings=model_settings,
+        )
+        # Register regular tools on the agent
+        agent_tools = self.get_available_tools()
+        register_tools_for_agent(p_agent, agent_tools, model_name=resolved_model_name)
 
-            self.pydantic_agent = p_agent
-            self._code_generation_agent = p_agent
-            self._mcp_servers = filtered_mcp_servers
-            self._mcp_servers = mcp_servers
+        self.pydantic_agent = p_agent
+        self._code_generation_agent = p_agent
+        self._mcp_servers = filtered_mcp_servers
         return self._code_generation_agent
 
     def _create_agent_with_output_type(self, output_type: Type[Any]) -> PydanticAgent:
@@ -1488,7 +1452,7 @@ class BaseAgent(ABC):
             output_type: The Pydantic model or type for structured output.
 
         Returns:
-            A configured PydanticAgent (or DBOSAgent wrapper) with the custom output_type.
+            A configured PydanticAgent with the custom output_type.
         """
         from newcode.model_utils import prepare_prompt_for_model
         from newcode.tools import register_tools_for_agent
@@ -1515,45 +1479,21 @@ class BaseAgent(ABC):
         global _reload_count
         _reload_count += 1
 
-        if get_use_dbos():
-            temp_agent = PydanticAgent(
-                model=model,
-                instructions=instructions,
-                output_type=output_type,
-                retries=10,
-                toolsets=[],
-                history_processors=[self.message_history_accumulator],
-                model_settings=model_settings,
-            )
-            agent_tools = self.get_available_tools()
-            register_tools_for_agent(
-                temp_agent, agent_tools, model_name=resolved_model_name
-            )
-            # Pass event_stream_handler at construction time for streaming output
-            dbos_agent = DBOSAgent(
-                temp_agent,
-                name=f"{self.name}-structured-{_reload_count}",
-                event_stream_handler=event_stream_handler,
-            )
-            return dbos_agent
-        else:
-            temp_agent = PydanticAgent(
-                model=model,
-                instructions=instructions,
-                output_type=output_type,
-                retries=10,
-                toolsets=mcp_servers,
-                history_processors=[self.message_history_accumulator],
-                model_settings=model_settings,
-            )
-            agent_tools = self.get_available_tools()
-            register_tools_for_agent(
-                temp_agent, agent_tools, model_name=resolved_model_name
-            )
-            return temp_agent
+        temp_agent = PydanticAgent(
+            model=model,
+            instructions=instructions,
+            output_type=output_type,
+            retries=10,
+            toolsets=mcp_servers,
+            history_processors=[self.message_history_accumulator],
+            model_settings=model_settings,
+        )
+        agent_tools = self.get_available_tools()
+        register_tools_for_agent(
+            temp_agent, agent_tools, model_name=resolved_model_name
+        )
+        return temp_agent
 
-    # It's okay to decorate it with DBOS.step even if not using DBOS; the decorator is a no-op in that case.
-    @DBOS.step()
     def message_history_accumulator(self, ctx: RunContext, messages: List[Any]):
         _message_history = self.get_message_history()
 
@@ -1908,51 +1848,14 @@ class BaseAgent(ABC):
 
                     usage_limits = UsageLimits(request_limit=get_message_limit())
 
-                    # Handle MCP servers - add them temporarily when using DBOS
-                    if (
-                        get_use_dbos()
-                        and hasattr(self, "_mcp_servers")
-                        and self._mcp_servers
-                    ):
-                        # Temporarily add MCP servers to the DBOS agent using internal _toolsets
-                        original_toolsets = pydantic_agent._toolsets
-                        pydantic_agent._toolsets = original_toolsets + self._mcp_servers
-                        pydantic_agent._toolsets = original_toolsets + self._mcp_servers
-
-                        try:
-                            # Set the workflow ID for DBOS context so DBOS and the agent ID match
-                            with SetWorkflowID(group_id):
-                                result_ = await pydantic_agent.run(
-                                    prompt_payload,
-                                    message_history=self.get_message_history(),
-                                    usage_limits=usage_limits,
-                                    event_stream_handler=event_stream_handler,
-                                    **kwargs,
-                                )
-                                return result_
-                        finally:
-                            # Always restore original toolsets
-                            pydantic_agent._toolsets = original_toolsets
-                    elif get_use_dbos():
-                        with SetWorkflowID(group_id):
-                            result_ = await pydantic_agent.run(
-                                prompt_payload,
-                                message_history=self.get_message_history(),
-                                usage_limits=usage_limits,
-                                event_stream_handler=event_stream_handler,
-                                **kwargs,
-                            )
-                            return result_
-                    else:
-                        # Non-DBOS path (MCP servers are already included)
-                        result_ = await pydantic_agent.run(
-                            prompt_payload,
-                            message_history=self.get_message_history(),
-                            usage_limits=usage_limits,
-                            event_stream_handler=event_stream_handler,
-                            **kwargs,
-                        )
-                        return result_
+                    result_ = await pydantic_agent.run(
+                        prompt_payload,
+                        message_history=self.get_message_history(),
+                        usage_limits=usage_limits,
+                        event_stream_handler=event_stream_handler,
+                        **kwargs,
+                    )
+                    return result_
                 except* UsageLimitExceeded as ule:
                     emit_info(f"Usage limit exceeded: {str(ule)}", group_id=group_id)
                     emit_info(
@@ -1968,12 +1871,8 @@ class BaseAgent(ABC):
                     )
                 except* asyncio.exceptions.CancelledError:
                     emit_info("Cancelled")
-                    if get_use_dbos():
-                        await DBOS.cancel_workflow_async(group_id)
                 except* InterruptedError as ie:
                     emit_info(f"Interrupted: {str(ie)}")
-                    if get_use_dbos():
-                        await DBOS.cancel_workflow_async(group_id)
                 except* Exception as other_error:
 
                     def contains_cloudflare_auth_error(exc: Exception) -> bool:

{newcode-0.2.6 → newcode-0.2.9}/newcode/claude_cache_client.py

@@ -371,7 +371,7 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
                 is_auth_error = response.status_code in (401, 403)
 
                 if response.status_code == 400:
-                    is_auth_error = self._is_cloudflare_html_error(response)
+                    is_auth_error = await self._is_cloudflare_html_error(response)
                     if is_auth_error:
                         logger.info(
                             "Detected Cloudflare 400 error (expired token), attempting token refresh"
@@ -531,7 +531,7 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
             headers["Authorization"] = bearer_value
 
     @staticmethod
-    def _is_cloudflare_html_error(response: httpx.Response) -> bool:
+    async def _is_cloudflare_html_error(response: httpx.Response) -> bool:
         """Check if this is a Cloudflare HTML error response.
 
         Cloudflare often returns HTML error pages with status 400 when
@@ -546,10 +546,20 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
         """
         try:
             body = None
-            # Try reading the body from _content first (already consumed)
+
+            # For async httpx, read the body if content is not available yet.
+            if not hasattr(response, "_content") or not response._content:
+                try:
+                    await response.aread()
+                except Exception as read_exc:
+                    logger.debug("Failed to read response body: %s", read_exc)
+                    return False
+
+            # Prefer raw _content if present (already consumed responses).
             if hasattr(response, "_content") and response._content:
                 body = response._content.decode("utf-8", errors="ignore")
             else:
+                # Fallback to text property.
                 try:
                     body = response.text
                 except Exception:

{newcode-0.2.6 → newcode-0.2.9}/newcode/cli_runner.py

@@ -12,10 +12,8 @@ import argparse
 import asyncio
 import os
 import sys
-import time
 from pathlib import Path
 
-from dbos import DBOS, DBOSConfig
 from rich.console import Console
 
 from newcode import __version__, callbacks, plugins
@@ -25,10 +23,8 @@ from newcode.command_line.clipboard import get_clipboard_manager
 from newcode.config import (
     AUTOSAVE_DIR,
     COMMAND_HISTORY_FILE,
-    DBOS_DATABASE_URL,
     ensure_config_exists,
     finalize_autosave_session,
-    get_use_dbos,
     initialize_command_history_file,
     save_command_to_history,
 )
@@ -271,33 +267,6 @@ async def main():
 
     await callbacks.on_startup()
 
-    # Initialize DBOS if not disabled
-    if get_use_dbos():
-        # Append a Unix timestamp in ms to the version for uniqueness
-        dbos_app_version = os.environ.get(
-            "DBOS_APP_VERSION", f"{current_version}-{int(time.time() * 1000)}"
-        )
-        dbos_config: DBOSConfig = {
-            "name": "dbos-code-agent",
-            "system_database_url": DBOS_DATABASE_URL,
-            "run_admin_server": False,
-            "conductor_key": os.environ.get(
-                "DBOS_CONDUCTOR_KEY"
-            ),  # Optional, if set in env, connect to conductor
-            "log_level": os.environ.get(
-                "DBOS_LOG_LEVEL", "ERROR"
-            ),  # Default to ERROR level to suppress verbose logs
-            "application_version": dbos_app_version,  # Match DBOS app version
-        }
-        try:
-            DBOS(config=dbos_config)
-            DBOS.launch()
-        except Exception as e:
-            emit_error(f"Error initializing DBOS: {e}")
-            sys.exit(1)
-    else:
-        pass
-
     global shutdown_flag
     shutdown_flag = False
     try:
@@ -322,8 +291,6 @@ async def main():
         if bus_renderer:
             bus_renderer.stop()
         await callbacks.on_shutdown()
-        if get_use_dbos():
-            DBOS.destroy()
 
 
 async def interactive_mode(message_renderer, initial_command: str = None) -> None:
@@ -981,8 +948,6 @@ def main_entry():
         asyncio.run(main())
     except KeyboardInterrupt:
         # Normal exit via Ctrl+C – not a crash, so just clean up quietly
-        if get_use_dbos():
-            DBOS.destroy()
         return 0
     finally:
         # Reset terminal on Unix-like systems (not Windows)

{newcode-0.2.6 → newcode-0.2.9}/newcode/command_line/config_commands.py

@@ -42,7 +42,6 @@ def handle_show_command(command: str) -> bool:
         get_protected_token_count,
         get_resume_message_count,
         get_temperature,
-        get_use_dbos,
         get_yolo_mode,
     )
     from newcode.keymap import (
@@ -69,7 +68,6 @@ def handle_show_command(command: str) -> bool:
 [bold]default_agent:[/bold]        [cyan]{default_agent}[/cyan]
 [bold]model:[/bold]                 [green]{model}[/green]
 [bold]YOLO_MODE:[/bold]             {"[red]ON[/red]" if yolo_mode else "[yellow]off[/yellow]"}
-[bold]DBOS:[/bold]                  {"[green]enabled[/green]" if get_use_dbos() else "[yellow]disabled[/yellow]"} (toggle: /set enable_dbos true|false)
 [bold]auto_save_session:[/bold]     {"[green]enabled[/green]" if auto_save else "[yellow]disabled[/yellow]"}
 [bold]protected_tokens:[/bold]      [cyan]{protected_tokens:,}[/cyan] recent tokens preserved
 [bold]compaction_threshold:[/bold]     [cyan]{compaction_threshold:.1%}[/cyan] context usage triggers compaction
@@ -211,14 +209,6 @@ def handle_set_command(command: str) -> bool:
         )
         return True
     if key:
-        # Check if we're toggling DBOS enablement
-        if key == "enable_dbos":
-            emit_info(
-                Text.from_markup(
-                    "[yellow]⚠️ DBOS configuration changed. Please restart the application for this change to take effect.[/yellow]"
-                )
-            )
-
         # Validate cancel_agent_key before setting
         if key == "cancel_agent_key":
             from newcode.keymap import VALID_CANCEL_KEYS

{newcode-0.2.6 → newcode-0.2.9}/newcode/command_line/core_commands.py

@@ -55,7 +55,7 @@ def handle_cd_command(command: str) -> bool:
     # Use shlex.split to handle quoted paths properly
     import shlex
 
-    from newcode.messaging import emit_error, emit_info, emit_success
+    from newcode.messaging import emit_error, emit_info, emit_success, emit_warning
 
     try:
         tokens = shlex.split(command)
@@ -77,6 +77,20 @@ def handle_cd_command(command: str) -> bool:
         if os.path.isdir(target):
             os.chdir(target)
             emit_success(f"Changed directory to: {target}")
+            # Reload the agent so the system prompt and project-local
+            # AGENT.md rules reflect the new working directory.  Without
+            # this, the LLM keeps receiving stale path information for the
+            # remainder of the session (the PydanticAgent instructions are
+            # baked in at construction time and never refreshed otherwise).
+            try:
+                from newcode.agents import get_current_agent
+
+                get_current_agent().reload_code_generation_agent()
+            except Exception as e:
+                emit_warning(
+                    f"Directory changed, but agent reload failed: {e}. "
+                    "You may need to run /agent or /model to force a refresh."
+                )
         else:
             emit_error(f"Not a directory: {dirname}")
         return True

{newcode-0.2.6 → newcode-0.2.9}/newcode/config.py

@@ -49,7 +49,6 @@ EXTRA_MODELS_FILE = os.path.join(DATA_DIR, "extra_models.json")
 AGENTS_DIR = os.path.join(DATA_DIR, "agents")
 SKILLS_DIR = os.path.join(DATA_DIR, "skills")
 CONTEXTS_DIR = os.path.join(DATA_DIR, "contexts")
-_DEFAULT_SQLITE_FILE = os.path.join(DATA_DIR, "dbos_store.sqlite")
 
 # OAuth plugin model files (XDG_DATA_HOME)
 GEMINI_MODELS_FILE = os.path.join(DATA_DIR, "gemini_models.json")
@@ -62,19 +61,6 @@ AUTOSAVE_DIR = os.path.join(CACHE_DIR, "autosaves")
 
 # State files (XDG_STATE_HOME)
 COMMAND_HISTORY_FILE = os.path.join(STATE_DIR, "command_history.txt")
-DBOS_DATABASE_URL = os.environ.get(
-    "DBOS_SYSTEM_DATABASE_URL", f"sqlite:///{_DEFAULT_SQLITE_FILE}"
-)
-# DBOS enable switch is controlled solely via puppy.cfg using key 'enable_dbos'.
-# Default: True (DBOS enabled) unless explicitly disabled.
-
-
-def get_use_dbos() -> bool:
-    """Return True if DBOS should be used based on 'enable_dbos' (default True)."""
-    cfg_val = get_value("enable_dbos")
-    if cfg_val is None:
-        return True
-    return str(cfg_val).strip().lower() in {"1", "true", "yes", "on"}
 
 
 def get_subagent_verbose() -> bool:
@@ -288,8 +274,6 @@ def get_config_keys():
         "frontend_emitter_max_recent_events",
         "frontend_emitter_queue_size",
     ]
-    # Add DBOS control key
-    default_keys.append("enable_dbos")
     # Add pack agents control key
     default_keys.append("enable_pack_agents")
     # Add universal constructor control key
@@ -1193,11 +1177,6 @@ def set_http2(enabled: bool) -> None:
     set_config_value("http2", "true" if enabled else "false")
 
 
-def set_enable_dbos(enabled: bool) -> None:
-    """Enable DBOS via config (true enables, default false)."""
-    set_config_value("enable_dbos", "true" if enabled else "false")
-
-
 def get_message_limit(default: int = 1000) -> int:
     """
     Returns the user-configured message/request limit for the agent.

{newcode-0.2.6 → newcode-0.2.9}/newcode/hook_engine/executor.py

@@ -193,7 +193,7 @@ def _substitute_variables(
     result = command
     for var, value in substitutions.items():
         result = result.replace(f"${{{var}}}", str(value))
-        result = re.sub(rf"\${re.escape(var)}(?=\W|$)", str(value), result)
+        result = re.sub(rf"\${re.escape(var)}(?=\W|$)", lambda m: str(value), result)
     return result
 
 

{newcode-0.2.6 → newcode-0.2.9}/newcode/models.json

@@ -9,9 +9,9 @@
     "context_length": 200000,
     "supported_settings": ["temperature", "seed", "top_p"]
   },
-  "synthetic-MiniMax-M2.1": {
+  "synthetic-MiniMax-M2.5": {
     "type": "custom_openai",
-    "name": "hf:MiniMaxAI/MiniMax-M2.1",
+    "name": "hf:MiniMaxAI/MiniMax-M2.5",
     "custom_endpoint": {
       "url": "https://api.synthetic.new/openai/v1/",
       "api_key": "$SYN_API_KEY"
@@ -19,9 +19,9 @@
     "context_length": 195000,
     "supported_settings": ["temperature", "seed", "top_p"]
   },
-  "synthetic-Kimi-K2-Thinking": {
+  "synthetic-qwen3.5-397b": {
     "type": "custom_openai",
-    "name": "hf:moonshotai/Kimi-K2-Thinking",
+    "name": "hf:Qwen/Qwen3.5-397B-A17B",
     "custom_endpoint": {
       "url": "https://api.synthetic.new/openai/v1/",
       "api_key": "$SYN_API_KEY"

{newcode-0.2.6 → newcode-0.2.9}/newcode/plugins/chatgpt_oauth/oauth_flow.py

@@ -318,9 +318,10 @@ def run_oauth_flow() -> None:
 
     if api_key:
         emit_info("Registering ChatGPT Codex models…")
-        from .utils import DEFAULT_CODEX_MODELS
+        from .utils import fetch_chatgpt_models
 
-        models = DEFAULT_CODEX_MODELS
+        account_id = tokens.get("account_id", "")
+        models = fetch_chatgpt_models(api_key, account_id)
         if models:
             if add_models_to_extra_config(models):
                 emit_success(

{newcode-0.2.6 → newcode-0.2.9}/newcode/plugins/chatgpt_oauth/test_plugin.py

@@ -251,6 +251,10 @@ def test_fetch_chatgpt_models(mock_get):
 
     models = utils.fetch_chatgpt_models("test_access_token", "test_account_id")
     assert models is not None
+    # Required models always injected
+    assert "gpt-5.4" in models
+    assert "gpt-5.3-instant" in models
+    # API-returned models present too
     assert "gpt-4o" in models
     assert "gpt-3.5-turbo" in models
     assert "o1-preview" in models
@@ -267,7 +271,9 @@ def test_fetch_chatgpt_models_fallback(mock_get):
 
     models = utils.fetch_chatgpt_models("test_access_token", "test_account_id")
     assert models is not None
-    # Should return default models
+    # Should return default models (including new required ones)
+    assert "gpt-5.4" in models
+    assert "gpt-5.3-instant" in models
     assert "gpt-5.3-codex-spark" in models
     assert "gpt-5.3-codex" in models
     assert "gpt-5.2-codex" in models

{newcode-0.2.6 → newcode-0.2.9}/newcode/plugins/chatgpt_oauth/utils.py

@@ -344,19 +344,43 @@ def exchange_code_for_tokens(
 # These are the known models that work with ChatGPT OAuth tokens
 # Based on codex-rs CLI and shell-scripts/codex-call.sh
 DEFAULT_CODEX_MODELS = [
+    "gpt-5.4",
+    "gpt-5.3-instant",
     "gpt-5.3-codex-spark",
     "gpt-5.3-codex",
     "gpt-5.2-codex",
     "gpt-5.2",
 ]
 
+# Models that MUST always be registered, even if the /models endpoint
+# doesn't return them (e.g. newly launched, not yet in the API catalogue).
+# These are merged into whatever the endpoint returns.
+REQUIRED_CODEX_MODELS = [
+    "gpt-5.4",
+    "gpt-5.3-instant",
+    "gpt-5.3-codex",
+]
+
 # Per-model context length overrides (tokens).
 # Models not listed here use CHATGPT_OAUTH_CONFIG["default_context_length"] (272,000).
 CODEX_MODEL_CONTEXT_LENGTHS = {
     "gpt-5.3-codex-spark": 131000,
+    "gpt-5.3-instant": 192000,
 }
 
 
+def _ensure_required_models(models: List[str]) -> List[str]:
+    """Merge REQUIRED_CODEX_MODELS into the given list, preserving order.
+
+    Any required model not already present is prepended so it appears first.
+    """
+    existing = set(models)
+    missing = [m for m in REQUIRED_CODEX_MODELS if m not in existing]
+    if missing:
+        logger.info("Injecting required models not returned by API: %s", missing)
+    return missing + models
+
+
 def fetch_chatgpt_models(access_token: str, account_id: str) -> Optional[List[str]]:
     """Fetch available models from ChatGPT Codex API.
 
@@ -419,7 +443,7 @@ def fetch_chatgpt_models(access_token: str, account_id: str) -> Optional[List[st
                         if model_id:
                             models.append(model_id)
                     if models:
-                        return models
+                        return _ensure_required_models(models)
             except (json.JSONDecodeError, ValueError) as exc:
                 logger.warning("Failed to parse models response: %s", exc)