newcode 0.2.5__tar.gz → 0.2.8__tar.gz

{newcode-0.2.5 → newcode-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: newcode
-Version: 0.2.5
+Version: 0.2.8
 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
@@ -57,7 +57,7 @@ NewCode is designed for practical software workflows in the terminal: inspect fi
 - Built-in agent system with a default coding agent and optional specialist workflows
 - MCP (Model Context Protocol) integration and server management
 - Interactive command-driven UX for model, agent, and settings management
-- Session autosave/restore and scheduler utilities
+- Session autosave/restore utilities
 - Plugin/callback extensibility hooks
 
 ## Quick start
@@ -94,7 +94,6 @@ On first run, NewCode starts onboarding to help configure API keys and defaults.
 /config         # Show current configuration
 /model          # Select or switch model
 /agent          # Select or switch agent
-/scheduler      # Manage scheduled tasks
 /colors         # Customize terminal UI colors
 /api            # Manage built-in API server (start|stop|status)
 ```

{newcode-0.2.5 → newcode-0.2.8}/README.md

@@ -15,7 +15,7 @@ NewCode is designed for practical software workflows in the terminal: inspect fi
 - Built-in agent system with a default coding agent and optional specialist workflows
 - MCP (Model Context Protocol) integration and server management
 - Interactive command-driven UX for model, agent, and settings management
-- Session autosave/restore and scheduler utilities
+- Session autosave/restore utilities
 - Plugin/callback extensibility hooks
 
 ## Quick start
@@ -52,7 +52,6 @@ On first run, NewCode starts onboarding to help configure API keys and defaults.
 /config         # Show current configuration
 /model          # Select or switch model
 /agent          # Select or switch agent
-/scheduler      # Manage scheduled tasks
 /colors         # Customize terminal UI colors
 /api            # Manage built-in API server (start|stop|status)
 ```

{newcode-0.2.5 → newcode-0.2.8}/newcode/agents/base_agent.py

@@ -71,6 +71,7 @@ from newcode.config import (
     get_value,
 )
 from newcode.error_logging import log_error
+from newcode.image_utils import constrain_image_dimensions
 from newcode.keymap import cancel_agent_uses_signal, get_cancel_agent_char_code
 from newcode.mcp_ import get_mcp_manager
 from newcode.messaging import (
@@ -95,6 +96,20 @@ _delayed_compaction_requested = False
 _reload_count = 0
 
 
+def _is_cloudflare_auth_error(exc: Exception) -> bool:
+    """Detect Cloudflare 400 auth failures from exception text."""
+    message = str(exc)
+    if not message:
+        return False
+
+    message_lower = message.lower()
+    return (
+        "cloudflare" in message_lower
+        and "400" in message_lower
+        and "bad request" in message_lower
+    )
+
+
 def _log_error_to_file(exc: Exception) -> Optional[str]:
     """Log detailed error information to ~/.newcode/error_logs/log_{timestamp}.txt.
 
@@ -1304,6 +1319,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())
 
@@ -1836,7 +1857,25 @@ class BaseAgent(ABC):
         # Build combined prompt payload when attachments are provided.
         attachment_parts: List[Any] = []
         if attachments:
-            attachment_parts.extend(list(attachments))
+            # Constrain image dimensions for API compliance (Claude max 2000px for many-image requests)
+            constrained = []
+            for att in attachments:
+                if (
+                    isinstance(att, BinaryContent)
+                    and hasattr(att, "media_type")
+                    and hasattr(att, "data")
+                ):
+                    media_type = getattr(att, "media_type", "") or ""
+                    if media_type.startswith("image/"):
+                        new_data = constrain_image_dimensions(
+                            att.data, media_type=media_type
+                        )
+                        if new_data is not att.data:
+                            att = BinaryContent(data=new_data, media_type=media_type)
+                    constrained.append(att)
+                else:
+                    constrained.append(att)
+            attachment_parts.extend(constrained)
         if link_attachments:
             attachment_parts.extend(list(link_attachments))
 
@@ -1849,41 +1888,58 @@ class BaseAgent(ABC):
             prompt_payload = prompt
 
         async def run_agent_task():
-            try:
-                self.set_message_history(
-                    self.prune_interrupted_tool_calls(self.get_message_history())
-                )
+            _cloudflare_retry_attempted = False
 
-                # DELAYED COMPACTION: Check if we should attempt delayed compaction
-                if self.should_attempt_delayed_compaction():
-                    emit_info(
-                        "🔄 Attempting delayed compaction (tool calls completed)",
-                        message_group="token_context_status",
+            while True:
+                _retry_after_cloudflare_refresh = False
+                try:
+                    self.set_message_history(
+                        self.prune_interrupted_tool_calls(self.get_message_history())
                     )
-                    current_messages = self.get_message_history()
-                    compacted_messages, _ = self.compact_messages(current_messages)
-                    if compacted_messages != current_messages:
-                        self.set_message_history(compacted_messages)
+
+                    # DELAYED COMPACTION: Check if we should attempt delayed compaction
+                    if self.should_attempt_delayed_compaction():
                         emit_info(
-                            "✅ Delayed compaction completed successfully",
+                            "🔄 Attempting delayed compaction (tool calls completed)",
                             message_group="token_context_status",
                         )
+                        current_messages = self.get_message_history()
+                        compacted_messages, _ = self.compact_messages(current_messages)
+                        if compacted_messages != current_messages:
+                            self.set_message_history(compacted_messages)
+                            emit_info(
+                                "✅ Delayed compaction completed successfully",
+                                message_group="token_context_status",
+                            )
 
-                usage_limits = UsageLimits(request_limit=get_message_limit())
+                    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
+                    # 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
+                        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,
@@ -1893,11 +1949,8 @@ class BaseAgent(ABC):
                                 **kwargs,
                             )
                             return result_
-                    finally:
-                        # Always restore original toolsets
-                        pydantic_agent._toolsets = original_toolsets
-                elif get_use_dbos():
-                    with SetWorkflowID(group_id):
+                    else:
+                        # Non-DBOS path (MCP servers are already included)
                         result_ = await pydantic_agent.run(
                             prompt_payload,
                             message_history=self.get_message_history(),
@@ -1906,74 +1959,111 @@ class BaseAgent(ABC):
                             **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,
+                except* UsageLimitExceeded as ule:
+                    emit_info(f"Usage limit exceeded: {str(ule)}", group_id=group_id)
+                    emit_info(
+                        "The agent has reached its usage limit. You can ask it to continue by saying 'please continue' or similar.",
+                        group_id=group_id,
                     )
-                    return result_
-            except* UsageLimitExceeded as ule:
-                emit_info(f"Usage limit exceeded: {str(ule)}", group_id=group_id)
-                emit_info(
-                    "The agent has reached its usage limit. You can ask it to continue by saying 'please continue' or similar.",
-                    group_id=group_id,
-                )
-            except* mcp.shared.exceptions.McpError as mcp_error:
-                emit_info(f"MCP server error: {str(mcp_error)}", group_id=group_id)
-                emit_info(f"{str(mcp_error)}", group_id=group_id)
-                emit_info(
-                    "Try disabling any malfunctioning MCP servers", group_id=group_id
-                )
-            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:
-                # Filter out CancelledError and UsageLimitExceeded from the exception group - let it propagate
-                remaining_exceptions = []
-
-                def collect_non_cancelled_exceptions(exc):
-                    if isinstance(exc, ExceptionGroup):
-                        for sub_exc in exc.exceptions:
-                            collect_non_cancelled_exceptions(sub_exc)
-                    elif not isinstance(
-                        exc, (asyncio.CancelledError, UsageLimitExceeded)
+                except* mcp.shared.exceptions.McpError as mcp_error:
+                    emit_info(f"MCP server error: {str(mcp_error)}", group_id=group_id)
+                    emit_info(f"{str(mcp_error)}", group_id=group_id)
+                    emit_info(
+                        "Try disabling any malfunctioning MCP servers",
+                        group_id=group_id,
+                    )
+                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:
+                        if isinstance(exc, ExceptionGroup):
+                            return any(
+                                contains_cloudflare_auth_error(sub_exc)
+                                for sub_exc in exc.exceptions
+                            )
+                        return _is_cloudflare_auth_error(exc)
+
+                    if (
+                        not _cloudflare_retry_attempted
+                        and contains_cloudflare_auth_error(other_error)
                     ):
-                        remaining_exceptions.append(exc)
-                        emit_info(f"Unexpected error: {str(exc)}", group_id=group_id)
-                        emit_info(f"{str(exc.args)}", group_id=group_id)
-                        # Log to file for debugging
-                        log_error(
-                            exc,
-                            context=f"Agent run (group_id={group_id})",
-                            include_traceback=True,
+                        _cloudflare_retry_attempted = True
+                        emit_info(
+                            "Detected Cloudflare 400 error (likely expired token), attempting refresh...",
+                            group_id=group_id,
                         )
+                        refreshed_token = None
+                        try:
+                            from newcode.plugins.claude_code_oauth.utils import (
+                                refresh_access_token,
+                            )
+
+                            refreshed_token = refresh_access_token(force=True)
+                        except Exception as refresh_error:
+                            emit_info(
+                                f"Token refresh failed: {str(refresh_error)}",
+                                group_id=group_id,
+                            )
+
+                        if refreshed_token:
+                            emit_info(
+                                "Token refresh successful, retrying request...",
+                                group_id=group_id,
+                            )
+                            _retry_after_cloudflare_refresh = True
+
+                    if not _retry_after_cloudflare_refresh:
+                        # Filter out CancelledError and UsageLimitExceeded from the exception group - let it propagate
+                        remaining_exceptions = []
+
+                        def collect_non_cancelled_exceptions(exc):
+                            if isinstance(exc, ExceptionGroup):
+                                for sub_exc in exc.exceptions:
+                                    collect_non_cancelled_exceptions(sub_exc)
+                            elif not isinstance(
+                                exc, (asyncio.CancelledError, UsageLimitExceeded)
+                            ):
+                                remaining_exceptions.append(exc)
+                                emit_info(
+                                    f"Unexpected error: {str(exc)}", group_id=group_id
+                                )
+                                emit_info(f"{str(exc.args)}", group_id=group_id)
+                                # Log to file for debugging
+                                log_error(
+                                    exc,
+                                    context=f"Agent run (group_id={group_id})",
+                                    include_traceback=True,
+                                )
 
-                collect_non_cancelled_exceptions(other_error)
+                        collect_non_cancelled_exceptions(other_error)
 
-                # If there are CancelledError exceptions in the group, re-raise them
-                cancelled_exceptions = []
+                        # If there are CancelledError exceptions in the group, re-raise them
+                        cancelled_exceptions = []
 
-                def collect_cancelled_exceptions(exc):
-                    if isinstance(exc, ExceptionGroup):
-                        for sub_exc in exc.exceptions:
-                            collect_cancelled_exceptions(sub_exc)
-                    elif isinstance(exc, asyncio.CancelledError):
-                        cancelled_exceptions.append(exc)
+                        def collect_cancelled_exceptions(exc):
+                            if isinstance(exc, ExceptionGroup):
+                                for sub_exc in exc.exceptions:
+                                    collect_cancelled_exceptions(sub_exc)
+                            elif isinstance(exc, asyncio.CancelledError):
+                                cancelled_exceptions.append(exc)
 
-                collect_cancelled_exceptions(other_error)
-            finally:
-                self.set_message_history(
-                    self.prune_interrupted_tool_calls(self.get_message_history())
-                )
+                        collect_cancelled_exceptions(other_error)
+                finally:
+                    self.set_message_history(
+                        self.prune_interrupted_tool_calls(self.get_message_history())
+                    )
+
+                if _retry_after_cloudflare_refresh:
+                    continue
+
+                break
 
         # Create the task FIRST
         agent_task = asyncio.create_task(run_agent_task())

{newcode-0.2.5 → newcode-0.2.8}/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.5 → newcode-0.2.8}/newcode/command_line/attachments.py

@@ -11,6 +11,8 @@ from typing import Iterable, List, Sequence
 
 from pydantic_ai import BinaryContent, DocumentUrl, ImageUrl
 
+from newcode.image_utils import constrain_image_dimensions
+
 SUPPORTED_INLINE_SCHEMES = {"http", "https"}
 
 # Maximum path length to consider - conservative limit to avoid OS errors
@@ -341,6 +343,8 @@ def parse_prompt_attachments(prompt: str) -> ProcessedPrompt:
         except AttachmentParsingError:
             # Silently ignore unreadable attachments to reduce prompt noise
             continue
+        # Constrain image dimensions for API compliance (Claude max 2000px for many-image requests)
+        data = constrain_image_dimensions(data, media_type=media_type)
         attachments.append(
             PromptAttachment(
                 placeholder=detection.placeholder,

{newcode-0.2.5 → newcode-0.2.8}/newcode/command_line/clipboard.py

@@ -16,6 +16,8 @@ import threading
 import time
 from typing import Optional
 
+from newcode.image_utils import constrain_image_dimensions
+
 # Try to import PIL - it's optional but needed for clipboard image support
 try:
     from PIL import Image, ImageGrab
@@ -42,7 +44,7 @@ logger = logging.getLogger(__name__)
 
 # Constants
 MAX_IMAGE_SIZE_BYTES = 10 * 1024 * 1024  # 10MB
-MAX_IMAGE_DIMENSION = 4096  # Max width/height for resize
+MAX_IMAGE_DIMENSION = 1920  # Max width/height for resize
 MAX_PENDING_IMAGES = (
     10  # SEC-CLIP-001: Limit pending images to prevent memory exhaustion
 )
@@ -317,6 +319,7 @@ def get_clipboard_image() -> Optional[bytes]:
                     )
                     return None
 
+        image_bytes = constrain_image_dimensions(image_bytes)
         return image_bytes
 
     # Windows/macOS path - use PIL
@@ -356,6 +359,7 @@ def get_clipboard_image() -> Optional[bytes]:
         image_bytes = buffer.getvalue()
 
         logger.info(f"Clipboard image size: {len(image_bytes) / 1024:.1f}KB")
+        image_bytes = constrain_image_dimensions(image_bytes)
         return image_bytes
 
     except Exception as e:

{newcode-0.2.5 → newcode-0.2.8}/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.5 → newcode-0.2.8}/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.8/newcode/image_utils.py

@@ -0,0 +1,85 @@
+"""Image processing utilities for API compliance.
+
+Ensures images sent to LLM APIs respect dimension limits.
+The Claude API enforces a 2000px max dimension for many-image requests.
+We use 1920px as default to provide a safety margin.
+"""
+
+import io
+import logging
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+# Claude API max dimension for many-image requests is 2000px.
+# Use 1920 for safety margin.
+MAX_IMAGE_DIMENSION = 1920
+
+try:
+    from PIL import Image
+
+    PIL_AVAILABLE = True
+except ImportError:
+    PIL_AVAILABLE = False
+    Image = None  # type: ignore[misc, assignment]
+
+
+def constrain_image_dimensions(
+    image_bytes: bytes,
+    max_dim: int = MAX_IMAGE_DIMENSION,
+    media_type: Optional[str] = None,
+) -> bytes:
+    """Resize image if any dimension exceeds max_dim, preserving aspect ratio.
+
+    Args:
+        image_bytes: Raw image bytes (PNG, JPEG, etc.).
+        max_dim: Maximum allowed width or height in pixels.
+        media_type: Optional MIME type hint. If provided and not an image
+                    type, returns bytes unchanged.
+
+    Returns:
+        Original bytes if within limits or PIL unavailable, resized PNG bytes otherwise.
+    """
+    # Skip non-image content
+    if media_type and not media_type.startswith("image/"):
+        return image_bytes
+
+    if not PIL_AVAILABLE or Image is None:
+        logger.debug("PIL not available, skipping image dimension check")
+        return image_bytes
+
+    if not image_bytes:
+        return image_bytes
+
+    try:
+        img = Image.open(io.BytesIO(image_bytes))
+        width, height = img.size
+
+        if width <= max_dim and height <= max_dim:
+            return image_bytes
+
+        # Calculate scale factor based on the larger dimension
+        scale = max_dim / max(width, height)
+        new_width = int(width * scale)
+        new_height = int(height * scale)
+
+        # Ensure minimum dimensions
+        new_width = max(new_width, 1)
+        new_height = max(new_height, 1)
+
+        resized = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+
+        # Save as PNG to preserve quality
+        output = io.BytesIO()
+        resized.save(output, format="PNG", optimize=True)
+        output.seek(0)
+
+        logger.info(
+            f"Constrained image dimensions from {width}x{height} "
+            f"to {new_width}x{new_height} (max_dim={max_dim})"
+        )
+        return output.read()
+
+    except Exception as e:
+        logger.warning(f"Failed to constrain image dimensions: {e}")
+        return image_bytes

{newcode-0.2.5 → newcode-0.2.8}/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.5 → newcode-0.2.8}/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(