bone-agent 1.3.2 → 1.4.0

package/src/core/agentic.py

@@ -2,7 +2,6 @@
 
 import json
 import logging
-import time
 from pathlib import Path
 from typing import Optional
 
@@ -47,6 +46,7 @@ from core.tool_feedback import (
     display_tool_feedback,
 )
 from ui.sub_agent_panel import SubAgentPanel
+from tools.helpers.path_resolver import extract_boundary_path, is_boundary_error, set_full_filesystem_access
 
 
 def _handle_empty_response(empty_response_count, console):
@@ -88,7 +88,6 @@ def _handle_tool_limit_reached(chat_manager, console):
             response,
             model_name=provider_cfg.get("model", ""),
         )
-
     try:
         final_message = response["choices"][0]["message"]
     except (KeyError, IndexError):
@@ -106,8 +105,6 @@ def _handle_tool_limit_reached(chat_manager, console):
     console.print("[red]Error: model returned empty response after tool limit reached.[/red]")
     return False
 
-
-
 class AgenticOrchestrator:
     """Orchestrates the agentic tool-calling loop.
 
@@ -172,78 +169,42 @@ class AgenticOrchestrator:
         # Check if we're in a parallel context with suppressed console
         return self._parallel_context.get('console', self.console)
 
-    def _is_memory_file(self, path: str) -> bool:
-        """Check if path targets a memory file (auto-approved).
+    def _get_effective_tools(self, allowed_tools=None, allow_active_plugins=False):
+        """Return tool schemas allowed for the current run."""
+        from tools.helpers.base import ToolRegistry
 
-        Auto-approve scope (restricted to known memory paths):
-        - {repo_root}/.bone/agents.md — project memory
-        - ~/.bone/user_memory.md — global user memory
-        - Any file under {repo_root}/.bone/ — project memory directory
+        tools = TOOLS()
+        if allowed_tools is None:
+            return tools
 
-        Args:
-            path: File path from tool arguments.
+        effective_names = set(allowed_tools)
+        if allow_active_plugins:
+            effective_names.update(ToolRegistry.active_plugin_names())
 
-        Returns:
-            True if the file should be auto-approved as a memory file.
-        """
-        p = Path(path).resolve()
-        repo_root = Path(self.repo_root).resolve()
-        # Known memory paths
-        if p == Path.home() / ".bone" / "user_memory.md":
-            return True
-        # Any file under {repo_root}/.bone/ (future memory files)
-        bone_dir = repo_root / ".bone"
-        if p.is_relative_to(bone_dir):
-            return True
-        return False
+        if not effective_names:
+            return []
 
-    def _execute_memory_edit(self, arguments) -> bool:
-        """Apply a memory file edit synchronously with one retry on failure.
+        return [tool for tool in tools if tool["function"]["name"] in effective_names]
 
-        Args:
-            arguments: Tool arguments dict (path, search, replace, etc.)
-        """
-        from tools.edit import _execute_edit_file
-
-        kwargs = dict(
-            path=arguments.get("path"),
-            search=arguments.get("search"),
-            replace=arguments.get("replace"),
-            repo_root=self.repo_root,
-            console=None,  # silent — no output in chat
-            gitignore_spec=self.gitignore_spec,
-            context_lines=arguments.get("context_lines", 3),
-            vault_root=vault_root_str(),
-        )
-        try:
-            _execute_edit_file(**kwargs)
-            return True
-        except Exception as e:
-            logger.warning("Memory edit failed (retrying in 0.5s): %s", e)
-            time.sleep(0.5)
-            try:
-                _execute_edit_file(**kwargs)
-                logger.info("Memory edit retry succeeded after initial failure.")
-                return True
-            except Exception as e2:
-                logger.error("Memory edit failed after retry: %s", e2)
-                return False
-
-    def run(self, user_input, thinking_indicator=None, allowed_tools=None):
+    def run(self, user_input, thinking_indicator=None, allowed_tools=None, allow_active_plugins=False):
         """Main orchestration loop.
 
         Args:
             user_input: User's input message
             thinking_indicator: Optional ThinkingIndicator instance
             allowed_tools: Optional list of allowed tool names (for research)
+            allow_active_plugins: Whether to include active plugin tools in restricted runs
         """
+        self._current_allowed_tools = allowed_tools
+        self._current_allow_active_plugins = allow_active_plugins
+
         # Append user message
         self.chat_manager.messages.append({"role": "user", "content": user_input})
 
         # Log user message
         self.chat_manager.log_message({"role": "user", "content": user_input})
 
-        from tools.base import ToolRegistry
+        from tools.helpers.base import ToolRegistry
 
         while True:
             # Decrement plugin TTLs after previous iteration's tool execution.
@@ -253,7 +214,10 @@ class AgenticOrchestrator:
                 self.console.print(f"[dim]Plugins evicted (TTL expired): {evicted}[/dim]")
 
             # Get response from LLM
-            response = self._get_llm_response(allowed_tools=allowed_tools)
+            response = self._get_llm_response(
+                allowed_tools=allowed_tools,
+                allow_active_plugins=allow_active_plugins,
+            )
             if response is None:
                 return
 
@@ -267,11 +231,16 @@ class AgenticOrchestrator:
                 if self._handle_final_response(response, thinking_indicator):
                     return
             else:
-                should_exit = self._handle_tool_calls(response, thinking_indicator, allowed_tools)
+                should_exit = self._handle_tool_calls(
+                    response,
+                    thinking_indicator,
+                    allowed_tools,
+                    allow_active_plugins=allow_active_plugins,
+                )
                 if should_exit:
                     return
 
-    def _get_llm_response(self, allowed_tools=None):
+    def _get_llm_response(self, allowed_tools=None, allow_active_plugins=False):
         """Get next LLM response with tool definitions.
 
         Includes automatic retry with live countdown for timeout/connection errors.
@@ -279,6 +248,7 @@ class AgenticOrchestrator:
 
         Args:
             allowed_tools: Optional list of allowed tool names (overrides mode-based filtering)
+            allow_active_plugins: Whether to include active plugin tools in restricted runs
 
         Returns:
             Response dict from LLM, or None if error occurred
@@ -287,19 +257,17 @@ class AgenticOrchestrator:
         self.chat_manager.ensure_context_fits(console=self.console)
 
         # Use allowed_tools if provided, otherwise use mode-based filtering
-        if allowed_tools is not None:
-            # Validate that allowed_tools is not empty
-            if not allowed_tools:
-                self.console.print("[red]Error: allowed_tools is empty[/red]")
-                return None
-            # TOOLS is a function, call it to get the list
-            tools = [tool for tool in TOOLS() if tool["function"]["name"] in allowed_tools]
-            # Log filtered tools for debugging
-            if self.debug_mode:
-                tool_names = [t["function"]["name"] for t in tools]
-                self.console.print(f"[dim]Available tools: {tool_names}[/dim]")
-        else:
-            tools = TOOLS()
+        if allowed_tools is not None and not allowed_tools and not allow_active_plugins:
+            self.console.print("[red]Error: allowed_tools is empty[/red]")
+            return None
+
+        tools = self._get_effective_tools(
+            allowed_tools=allowed_tools,
+            allow_active_plugins=allow_active_plugins,
+        )
+        if allowed_tools is not None and self.debug_mode:
+            tool_names = [t["function"]["name"] for t in tools]
+            self.console.print(f"[dim]Available tools: {tool_names}[/dim]")
 
         # Retry loop for timeout/connection errors
         last_error = None
@@ -320,7 +288,21 @@ class AgenticOrchestrator:
                     continue
                 else:
                     # Non-retryable error or final attempt exhausted
+                    detail_lines = []
+                    for key, value in getattr(e, "details", {}).items():
+                        value_str = str(value)
+                        if "\n" in value_str or key == "original_error":
+                            detail_lines.append(f"{key}: {value_str}")
+                    detailed_error = str(e)
+                    if detail_lines:
+                        detailed_error += "\n\n" + "\n\n".join(detail_lines)
+
+                    if self.is_sub_agent:
+                        raise LLMError(detailed_error, details=getattr(e, "details", {}))
+
                     self.console.print(f"[red]LLM Error: {e}[/red]")
+                    if detail_lines:
+                        self.console.print(f"[dim]{detail_lines[0]}[/dim]", markup=False)
                     return None
 
             # Successful response — parse and return
@@ -382,8 +364,11 @@ class AgenticOrchestrator:
             # NEW: Compact tool results after final answer (per-message compaction)
             self.chat_manager.compact_tool_results(skip_token_update=True)
 
-            # Update context tokens with current mode's tools
-            tools_for_mode = TOOLS()
+            # Update context tokens with current run's effective tools
+            tools_for_mode = self._get_effective_tools(
+                allowed_tools=getattr(self, "_current_allowed_tools", None),
+                allow_active_plugins=getattr(self, "_current_allow_active_plugins", False),
+            )
             self.chat_manager._update_context_tokens(tools_for_mode)
 
             self.console.print()
@@ -395,13 +380,14 @@ class AgenticOrchestrator:
         )
         return not should_continue
 
-    def _handle_tool_calls(self, response, thinking_indicator, allowed_tools=None):
+    def _handle_tool_calls(self, response, thinking_indicator, allowed_tools=None, allow_active_plugins=False):
         """Process tool calls and display accompanying content.
 
         Args:
             response: Full message dict from LLM (includes content and tool_calls)
             thinking_indicator: Optional ThinkingIndicator instance
             allowed_tools: Optional list of allowed tool names
+            allow_active_plugins: Whether to allow active plugin tools in restricted runs
 
         Returns:
             True if should exit the orchestration loop
@@ -415,6 +401,8 @@ class AgenticOrchestrator:
         # This must happen BEFORE filtering so the LLM sees its original intent
         content = (response.get("content") or "").strip()
         assistant_msg = {"role": "assistant", "tool_calls": tool_calls}
+        if response.get("_responses_output"):
+            assistant_msg["_responses_output"] = response["_responses_output"]
         if content:
             assistant_msg["content"] = content
         self.chat_manager.messages.append(assistant_msg)
@@ -425,7 +413,7 @@ class AgenticOrchestrator:
         # This silently removes unknown tools or tools not in the allowed whitelist
         # to prevent error messages from reaching the user while allowing the agent
         # to continue with alternative tools.
-        from tools.base import ToolRegistry
+        from tools.helpers.base import ToolRegistry
 
         filtered_calls = []
         filtered_tool_ids = []  # Track filtered tool IDs to provide feedback
@@ -442,10 +430,14 @@ class AgenticOrchestrator:
                 filtered_tool_ids.append(tool_call.get("id"))
                 continue
 
-            # Check if tool is in allowed_tools whitelist (if provided)
-            # Plugin-tier tools bypass the whitelist — they are already vetted
-            # by the manifest and activated on-demand via search_plugins.
-            if allowed_tools and function_name not in allowed_tools and not ToolRegistry.is_plugin_active(function_name):
+            # Check if tool is in the effective allowlist for this run.
+            effective_allowed_tools = None
+            if allowed_tools is not None:
+                effective_allowed_tools = set(allowed_tools)
+                if allow_active_plugins:
+                    effective_allowed_tools.update(ToolRegistry.active_plugin_names())
+
+            if effective_allowed_tools is not None and function_name not in effective_allowed_tools:
                 # Silent fail - skip this tool
                 if self.debug_mode:
                     self.console.print(f"[dim]Silently filtered non-allowed tool: {function_name}[/dim]")
@@ -600,8 +592,11 @@ class AgenticOrchestrator:
         # Compact completed tool blocks once after all tools complete
         self.chat_manager.compact_tool_results(skip_token_update=True)
 
-        # Update context tokens with current mode's tools
-        tools_for_mode = TOOLS()
+        # Update context tokens with current run's effective tools
+        tools_for_mode = self._get_effective_tools(
+            allowed_tools=getattr(self, "_current_allowed_tools", None),
+            allow_active_plugins=getattr(self, "_current_allow_active_plugins", False),
+        )
         self.chat_manager._update_context_tokens(tools_for_mode)
 
         # Pre-send guard: ensure context fits before next LLM call
@@ -621,7 +616,7 @@ class AgenticOrchestrator:
         """
         if not tool_calls:
             return False
-        from tools.parallel_executor import ParallelToolExecutor, ToolCall
+        from tools.helpers.parallel_executor import ParallelToolExecutor, ToolCall
 
         # Suppress console output in handlers during parallel execution
         # We'll display results ourselves in order below
@@ -841,8 +836,11 @@ class AgenticOrchestrator:
             # after all parallel results are appended (safe — only compacts completed blocks)
             self.chat_manager.compact_tool_results(skip_token_update=True)
 
-            # Update context tokens with current mode's tools
-            tools_for_mode = TOOLS()
+            # Update context tokens with current run's effective tools
+            tools_for_mode = self._get_effective_tools(
+                allowed_tools=getattr(self, "_current_allowed_tools", None),
+                allow_active_plugins=getattr(self, "_current_allow_active_plugins", False),
+            )
             self.chat_manager._update_context_tokens(tools_for_mode)
 
             # Pre-send guard: ensure context fits before next LLM call
@@ -853,6 +851,38 @@ class AgenticOrchestrator:
             # Restore console output
             self._parallel_context['console'] = self.console
 
+    def _boundary_prompt(self, path_str):
+        """Prompt the user to grant filesystem access for a path outside boundaries.
+
+        Called after a tool returns a boundary error. If the user grants access,
+        the caller retries the tool with the boundary lifted.
+
+        Args:
+            path_str: The path that triggered the boundary violation.
+
+        Returns:
+            True if user granted access, False if denied.
+        """
+        if self.is_sub_agent:
+            return False
+
+        console = self._get_console()
+        if console is None:
+            return False
+
+        from ui.tool_confirmation import ToolConfirmationPanel
+        panel = ToolConfirmationPanel(
+            'Grant filesystem access',
+            reason=f'Agent requested access outside project boundary: {path_str}',
+            is_edit_tool=False
+        )
+        action, _ = panel.run()
+
+        if action == "accept":
+            console.print("[yellow]Full filesystem access granted[/yellow]\n")
+            return True
+        return False
+
     def _process_single_tool_call(self, tool_call, thinking_indicator):
         """Process a single tool call.
 
@@ -884,7 +914,7 @@ class AgenticOrchestrator:
             panel_to_use = SubAgentPanel(query, self.console)
 
         # Execute via tool registry
-        from tools.base import ToolRegistry, build_context
+        from tools.helpers.base import ToolRegistry, build_context
 
         tool = ToolRegistry.get(function_name)
         if tool:
@@ -908,26 +938,12 @@ class AgenticOrchestrator:
 
                 # Check if tool requires approval
                 if tool.requires_approval:
-                    # For edit_file: check memory file auto-approve first
+                    # For edit_file: validate path then request approval
                     if function_name == "edit_file":
                         edit_path = arguments.get("path", "")
                         if not edit_path:
                             return False, "Error: path is required for edit_file."
 
-                        # Memory file: auto-approve, fire-and-forget
-                        if self._is_memory_file(edit_path):
-                            # Generate preview to validate the edit (reuses existing logic)
-                            result = tool.execute(arguments, context)
-                            preview, is_valid = resolve_edit_preview(result)
-                            if is_valid:
-                                ok = self._execute_memory_edit(arguments)
-                                if self.debug_mode:
-                                    console = self._get_console()
-                                    if console:
-                                        console.print(f"[dim]Memory edit auto-approved: {edit_path}[/dim]")
-                                return False, "Memory saved." if ok else f"Memory edit failed: {edit_path}"
-                            return False, str(result)
-
                         # Normal edit: generate preview and request approval
                         result = tool.execute(arguments, context)
 
@@ -988,6 +1004,20 @@ class AgenticOrchestrator:
                     if policy == TERMINAL_YIELD and thinking_indicator:
                         thinking_indicator.resume()
 
+                # Boundary escalation: if the tool result is a path boundary
+                # violation, prompt the user to grant session-wide access.
+                result_str = str(result)
+                if is_boundary_error(result_str):
+                    path_arg = arguments.get("path", arguments.get("path_str", ""))
+                    if not path_arg:
+                        path_arg = extract_boundary_path(result_str)
+                    granted = self._boundary_prompt(path_arg)
+                    if granted:
+                        set_full_filesystem_access(True)
+                        # Retry with the boundary now lifted
+                        result = tool.execute(arguments, context)
+                        result_str = str(result)
+
                 # Display result for registry tools
                 # Skip display for tools that take over the terminal (they handle their own display)
                 if policy != TERMINAL_YIELD:
@@ -1020,7 +1050,7 @@ class AgenticOrchestrator:
                             # Then display feedback
                             display_tool_feedback(label, result, console, indent=self.is_sub_agent, panel_updater=self.panel_updater)
 
-                return False, str(result)
+                return False, result_str
             except Exception as e:
                 # If thinking_indicator was paused (TERMINAL_YIELD) and tool
                 # raised, resume it so the spinner reappears for the next iteration
@@ -1053,5 +1083,3 @@ def agentic_answer(chat_manager, user_input, console, repo_root, rg_exe_path, de
         debug_mode=debug_mode,
     )
     orchestrator.run(user_input, thinking_indicator)
-
-

package/src/core/chat_manager.py

@@ -9,12 +9,14 @@ import requests
 from typing import Optional, IO
 
 from llm.client import LLMClient
-from llm.config import get_providers, get_provider_config, reload_config
+from llm.config import get_providers, get_provider_config, get_provider_display_name, reload_config
 from llm.prompts import build_system_prompt
+from core.skills import render_active_skills_section
 from pathlib import Path
 from llm.token_tracker import TokenTracker
 from utils.settings import server_settings, context_settings
 from utils.logger import MarkdownConversationLogger
+from utils.user_message_logger import UserMessageLogger
 from utils.result_parsers import extract_exit_code, extract_metadata_from_result
 
 # Token counting constants
@@ -44,6 +46,10 @@ class ChatManager:
         self.task_list = []
         self.task_list_title = None
 
+        # In-session active skill tracking. These skills are rendered into the
+        # system prompt for the current chat.
+        self.loaded_skills = set()
+
         # .gitignore filtering state
         self._gitignore_spec = None
         self._gitignore_mtime = None
@@ -62,6 +68,9 @@ class ChatManager:
                 conversations_dir=context_settings.conversations_dir
             )
 
+        # User message logging (always on, for dream memory system)
+        self.user_message_logger = UserMessageLogger()
+
         # Compaction lock: prevents compaction during active tool execution
         # Set by agentic.py before executing tools, cleared after all results appended
         self._compaction_locked = False
@@ -90,6 +99,9 @@ class ChatManager:
         if self.markdown_logger:
             self.markdown_logger.start_session()
 
+        # Active skills are scoped to the current message history/session.
+        self.loaded_skills = set()
+
         # Start with system prompt only
         self.messages = [{"role": "system", "content": self._build_system_prompt()}]
 
@@ -119,20 +131,38 @@ class ChatManager:
         self._update_context_tokens()
         self.context_token_estimate = self.token_tracker.current_context_tokens
 
-    def _build_system_prompt(self) -> str:
-        """Build system prompt."""
-        return build_system_prompt()
+    def _build_system_prompt(self, variant: str | None = None) -> str:
+        """Build system prompt.
+
+        Args:
+            variant: Prompt variant name (e.g. 'main', 'micro').
+                     If None, reads from prompt_settings.
+        """
+        if variant is None:
+            from utils.settings import prompt_settings
+            variant = prompt_settings.variant
+        active_skills_section = render_active_skills_section(self.loaded_skills)
+        return build_system_prompt(variant, active_skills_section=active_skills_section)
+
+    def update_system_prompt(self, variant: str | None = None):
+        """Rebuild system prompt in-place (e.g. after hotswap or session reset).
 
-    def update_system_prompt(self):
-        """Rebuild system prompt (e.g. after session reset)."""
+        Args:
+            variant: Prompt variant to use. If None, keeps current variant.
+                     Updates token_tracker.current_variant.
+        """
         if not self.messages:
             raise RuntimeError("Cannot update system prompt: messages array is empty")
 
         if self.messages[0]["role"] != "system":
             raise RuntimeError(f"Cannot update system prompt: messages[0] has role '{self.messages[0]['role']}', expected 'system'")
 
-        # Update the system message with current mode
-        self.messages[0]["content"] = self._build_system_prompt()
+        if variant is None:
+            from utils.settings import prompt_settings
+            variant = prompt_settings.variant
+
+        self.messages[0]["content"] = self._build_system_prompt(variant)
+        self.token_tracker.current_variant = variant
         self._update_context_tokens()
 
     def _load_agents_md(self) -> tuple[str, str]:
@@ -1305,7 +1335,8 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
         """
         providers = get_providers()
         if provider_name not in providers:
-            return f"Invalid provider. Use /provider to list. Available: {', '.join(providers)}"
+            available = ', '.join(get_provider_display_name(provider) for provider in providers)
+            return f"Invalid provider. Use /provider to list. Available: {available}"
 
         previous_provider = self.client.provider
 
@@ -1321,10 +1352,13 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
                     # Failed to start server - revert
                     self.client.switch_provider(previous_provider)
                     self._init_messages(reset_costs=True)
-                    return f"Failed to start local server. Reverted to {previous_provider} provider."
+                    previous_label = get_provider_display_name(previous_provider)
+                    return f"Failed to start local server. Reverted to {previous_label} provider."
                 self.server_process = server
-                return f"Switched to {provider_name} provider (server ready)."
-            return f"Switched to {provider_name} provider."
+                provider_label = get_provider_display_name(provider_name)
+                return f"Switched to {provider_label} provider (server ready)."
+            provider_label = get_provider_display_name(provider_name)
+            return f"Switched to {provider_label} provider."
         return "Provider switch failed."
 
     def reload_config(self):
@@ -1376,6 +1410,10 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
             server_path,
             "-m", model_path,
             "-ngl", str(server_settings.ngl_layers),
+            "--threads", str(server_settings.threads),
+            "--batch-size", str(server_settings.batch_size),
+            "--ubatch-size", str(server_settings.ubatch_size),
+            "--flash-attn" if server_settings.flash_attn else "--no-flash-attn",
             "--split-mode", "none",
             "--ctx-size", str(server_settings.ctx_size),
             "--n-predict", str(server_settings.n_predict),
@@ -1383,6 +1421,7 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
             "--host", host,
             "--port", str(port),
             "--jinja",
+            "--reasoning", "off",
         ]
 
         # Restrict to RTX 5070 Ti only (GPU 0)
@@ -1459,6 +1498,15 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
         if self.markdown_logger:
             self.markdown_logger.log_message(message)
 
+        # Log user messages to JSONL for dream memory processing (only if memory enabled)
+        if message.get("role") == "user" and message.get("content"):
+            from llm.config import MEMORY_SETTINGS
+            if MEMORY_SETTINGS.get("enabled", True):
+                self.user_message_logger.log_user_message(
+                    message["content"],
+                    project_dir=Path.cwd().resolve(),
+                )
+
     def sync_log(self):
         """Rewrite the entire conversation log to match current message state.
 

package/src/core/config_manager.py

@@ -36,12 +36,16 @@ class ConfigManager:
             with open(self.config_path, 'r', encoding='utf-8-sig') as f:
                 self._cached_data = yaml.safe_load(f) or {}
 
-            # Migrate: rename old provider IDs -> bone (provider ID rename)
+            # Migrate legacy provider IDs to current names.
             old_provider = self._cached_data.get('LAST_PROVIDER')
             if old_provider in ('vmcode_proxy', 'vmcode_free', 'vmcode'):
                 logger.info("Migrating provider name '%s' -> 'bone'", old_provider)
                 self._cached_data['LAST_PROVIDER'] = 'bone'
                 self.save(self._cached_data, create_backup=True)
+            elif old_provider == 'codex_plan':
+                logger.info("Migrating provider name '%s' -> 'codex'", old_provider)
+                self._cached_data['LAST_PROVIDER'] = 'codex'
+                self.save(self._cached_data, create_backup=True)
 
             return self._cached_data
         except yaml.YAMLError as e:
@@ -114,11 +118,14 @@ class ConfigManager:
         if model is None:
             provider_model_map = {
                 'bone': 'BONE_PROXY_MODEL',
+                'codex': 'CODEX_PLAN_MODEL',
                 'openrouter': 'OPENROUTER_MODEL',
                 'glm': 'GLM_MODEL',
+                'glm_plan': 'GLM_PLAN_MODEL',
                 'openai': 'OPENAI_MODEL',
                 'gemini': 'GEMINI_MODEL',
                 'minimax': 'MINIMAX_MODEL',
+                'minimax_plan': 'MINIMAX_PLAN_MODEL',
                 'anthropic': 'ANTHROPIC_MODEL',
                 'kimi': 'KIMI_MODEL'
             }
@@ -142,11 +149,14 @@ class ConfigManager:
         provider_keys = {
             'local': 'LOCAL_MODEL_PATH',
             'bone': 'BONE_PROXY_MODEL',
+            'codex': 'CODEX_PLAN_MODEL',
             'openrouter': 'OPENROUTER_MODEL',
             'glm': 'GLM_MODEL',
+            'glm_plan': 'GLM_PLAN_MODEL',
             'openai': 'OPENAI_MODEL',
             'gemini': 'GEMINI_MODEL',
             'minimax': 'MINIMAX_MODEL',
+            'minimax_plan': 'MINIMAX_PLAN_MODEL',
             'anthropic': 'ANTHROPIC_MODEL',
             'kimi': 'KIMI_MODEL'
         }
@@ -171,10 +181,13 @@ class ConfigManager:
         provider_keys = {
             'openrouter': 'OPENROUTER_API_KEY',
             'bone': 'BONE_PROXY_API_KEY',
+            'codex': 'CODEX_PLAN_API_KEY',
             'glm': 'GLM_API_KEY',
+            'glm_plan': 'GLM_PLAN_API_KEY',
             'openai': 'OPENAI_API_KEY',
             'gemini': 'GEMINI_API_KEY',
             'minimax': 'MINIMAX_API_KEY',
+            'minimax_plan': 'MINIMAX_PLAN_API_KEY',
             'anthropic': 'ANTHROPIC_API_KEY',
             'kimi': 'KIMI_API_KEY'
         }