auto-coder 0.1.353__py3-none-any.whl → 0.1.354__py3-none-any.whl

autocoder/common/rulefiles/autocoderrules_utils.py

@@ -0,0 +1,173 @@
+import os
+from pathlib import Path
+from threading import Lock
+import threading
+from typing import Dict, List, Optional
+from loguru import logger
+
+# 尝试导入 FileMonitor
+try:
+    from autocoder.common.file_monitor.monitor import FileMonitor, Change
+except ImportError:
+    # 如果导入失败，提供一个空的实现
+    logger.warning("警告: 无法导入 FileMonitor，规则文件变更监控将不可用")
+    FileMonitor = None
+    Change = None
+
+
+class AutocoderRulesManager:
+    """
+    管理和监控 autocoderrules 目录中的规则文件。
+    
+    实现单例模式，确保全局只有一个规则管理实例。
+    支持监控规则文件变化，当规则文件变化时自动重新加载。
+    """
+    _instance = None
+    _lock = Lock()
+
+    def __new__(cls, project_root: Optional[str] = None):
+        if not cls._instance:
+            with cls._lock:
+                if not cls._instance:
+                    cls._instance = super(AutocoderRulesManager, cls).__new__(cls)
+                    cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self, project_root: Optional[str] = None):
+        if self._initialized:
+            return
+        self._initialized = True
+        
+        self._rules: Dict[str, str] = {}  # 存储规则文件内容: {file_path: content}
+        self._rules_dir: Optional[str] = None  # 当前使用的规则目录
+        self._file_monitor = None  # FileMonitor 实例
+        self._monitored_dirs: List[str] = []  # 被监控的目录列表
+        self._project_root = project_root if project_root is not None else os.getcwd()  # 项目根目录
+        
+        # 加载规则
+        self._load_rules()
+        # 设置文件监控
+        self._setup_file_monitor()
+
+    def _load_rules(self):
+        """
+        按优先级顺序加载规则文件。
+        优先级顺序：
+        1. .autocoderrules/
+        2. .auto-coder/.autocoderrules/
+        3. .auto-coder/autocoderrules/
+        """
+        self._rules = {}
+        project_root = self._project_root
+        
+        # 按优先级顺序定义可能的规则目录
+        rules_dirs = [
+            os.path.join(project_root, ".autocoderrules"),
+            os.path.join(project_root, ".auto-coder", ".autocoderrules"),
+            os.path.join(project_root, ".auto-coder", "autocoderrules")
+        ]
+        
+        # 按优先级查找第一个存在的目录
+        found_dir = None
+        for rules_dir in rules_dirs:
+            if os.path.isdir(rules_dir):
+                found_dir = rules_dir
+                break
+        
+        if not found_dir:
+            logger.info("未找到规则目录")
+            return
+        
+        self._rules_dir = found_dir
+        logger.info(f"使用规则目录: {self._rules_dir}")
+        
+        # 加载目录中的所有 .md 文件
+        try:
+            for fname in os.listdir(self._rules_dir):
+                if fname.endswith(".md"):
+                    fpath = os.path.join(self._rules_dir, fname)
+                    try:
+                        with open(fpath, "r", encoding="utf-8") as f:
+                            content = f.read()
+                            self._rules[fpath] = content
+                            logger.info(f"已加载规则文件: {fpath}")
+                    except Exception as e:
+                        logger.info(f"加载规则文件 {fpath} 时出错: {e}")
+                        continue
+        except Exception as e:
+            logger.info(f"读取规则目录 {self._rules_dir} 时出错: {e}")
+
+    def _setup_file_monitor(self):
+        """设置文件监控，当规则文件或目录变化时重新加载规则"""
+        if FileMonitor is None or not self._rules_dir:
+            return
+        
+        try:
+            # 获取项目根目录
+            project_root = self._project_root
+            
+            # 创建 FileMonitor 实例
+            self._file_monitor = FileMonitor(root_dir=project_root)
+            
+            # 监控所有可能的规则目录
+            self._monitored_dirs = [
+                os.path.join(project_root, ".autocoderrules"),
+                os.path.join(project_root, ".auto-coder", ".autocoderrules"),
+                os.path.join(project_root, ".auto-coder", "autocoderrules")
+            ]
+            
+            # 注册目录监控
+            for dir_path in self._monitored_dirs:
+                # 创建目录（如果不存在）
+                os.makedirs(dir_path, exist_ok=True)
+                # 注册监控
+                self._file_monitor.register(dir_path, self._on_rules_changed)
+                logger.info(f"已注册规则目录监控: {dir_path}")
+            
+            # 启动监控
+            if not self._file_monitor.is_running():
+                self._file_monitor.start()
+                logger.info("规则文件监控已启动")
+                
+        except Exception as e:
+            logger.warning(f"设置规则文件监控时出错: {e}")
+
+    def _on_rules_changed(self, change_type: Change, changed_path: str):
+        """当规则文件或目录发生变化时的回调函数"""
+        # 检查变化是否与规则相关
+        is_rule_related = False
+        
+        # 检查是否是 .md 文件
+        if changed_path.endswith(".md"):
+            # 检查文件是否在监控的目录中
+            for dir_path in self._monitored_dirs:
+                if os.path.abspath(changed_path).startswith(os.path.abspath(dir_path)):
+                    is_rule_related = True
+                    break
+        else:
+            # 检查是否是监控的目录本身
+            for dir_path in self._monitored_dirs:
+                if os.path.abspath(changed_path) == os.path.abspath(dir_path):
+                    is_rule_related = True
+                    break
+        
+        if is_rule_related:
+            logger.info(f"检测到规则相关变化 ({change_type.name}): {changed_path}")
+            # 重新加载规则
+            self._load_rules()
+            logger.info("已重新加载规则")
+
+    def get_rules(self) -> Dict[str, str]:
+        """获取所有规则文件内容"""
+        return self._rules.copy()
+
+
+# 对外提供单例
+_rules_manager = None
+
+def get_rules(project_root: Optional[str] = None) -> Dict[str, str]:
+    """获取所有规则文件内容，可指定项目根目录"""
+    global _rules_manager
+    if _rules_manager is None:
+        _rules_manager = AutocoderRulesManager(project_root=project_root)
+    return _rules_manager.get_rules()

autocoder/common/save_formatted_log.py

@@ -0,0 +1,54 @@
+import os
+import json
+import uuid
+from datetime import datetime
+
+def save_formatted_log(project_root, json_text, suffix):
+    """
+    Save a JSON log as a formatted markdown file under project_root/.cache/logs.
+    Filename: <YYYYmmdd_HHMMSS>_<uuid>_<suffix>.md
+    Args:
+        project_root (str): The root directory of the project.
+        json_text (str): The JSON string to be formatted and saved.
+        suffix (str): The suffix for the filename.
+    """
+    # Parse JSON
+    try:
+        data = json.loads(json_text)
+    except Exception as e:
+        raise ValueError(f"Invalid JSON provided: {e}")
+
+    # Format as markdown with recursive depth
+    def to_markdown(obj, level=1):
+        lines = []
+        if isinstance(obj, dict):
+            for key, value in obj.items():
+                lines.append(f"{'#' * (level + 1)} {key}\n")
+                lines.extend(to_markdown(value, level + 1))
+        elif isinstance(obj, list):
+            for idx, item in enumerate(obj, 1):
+                lines.append(f"{'#' * (level + 1)} Item {idx}\n")
+                lines.extend(to_markdown(item, level + 1))
+        else:
+            lines.append(str(obj) + "\n")
+        return lines
+
+    md_lines = ["# Log Entry\n"]
+    md_lines.extend(to_markdown(data, 1))
+    md_content = "\n".join(md_lines)
+
+    # Prepare directory
+    logs_dir = os.path.join(project_root, ".cache", "logs")
+    os.makedirs(logs_dir, exist_ok=True)
+
+    # Prepare filename
+    now = datetime.now().strftime("%Y%m%d_%H%M%S")
+    unique_id = str(uuid.uuid4())
+    filename = f"{now}_{unique_id}_{suffix}.md"
+    filepath = os.path.join(logs_dir, filename)
+
+    # Save file
+    with open(filepath, "w", encoding="utf-8") as f:
+        f.write(md_content)
+
+    return filepath

autocoder/common/v2/agent/agentic_edit.py

@@ -1,6 +1,3 @@
-from autocoder.common.v2.agent.agentic_edit_conversation import AgenticConversation
-from enum import Enum
-from enum import Enum
 import json
 import os
 import time
@@ -55,7 +52,7 @@ from autocoder.common.v2.agent.agentic_edit_tools import (  # Import specific re
     AttemptCompletionToolResolver, PlanModeRespondToolResolver, UseMcpToolResolver,
     ListPackageInfoToolResolver
 )
-
+from autocoder.common.rulefiles.autocoderrules_utils import get_rules
 from autocoder.common.v2.agent.agentic_edit_types import (AgenticEditRequest, ToolResult,
                                                           MemoryConfig, CommandConfig, BaseTool,
                                                           ExecuteCommandTool, ReadFileTool,
@@ -119,12 +116,7 @@ class AgenticEdit:
         self.memory_config = memory_config
         self.command_config = command_config  # Note: command_config might be unused now
         self.project_type_analyzer = ProjectTypeAnalyzer(
-            args=args, llm=self.llm)
-
-        self.conversation_manager = AgenticConversation(
-            args, self.conversation_history, conversation_name=conversation_name)
-        # 当前不开启历史记录，所以清空
-        self.conversation_manager.clear_history()
+            args=args, llm=self.llm)        
 
         self.shadow_manager = ShadowManager(
             args.source_dir, args.event_file, args.ignore_clean_shadows)
@@ -687,21 +679,8 @@ class AgenticEdit:
         {% endif %}
         """
         import os
-        extra_docs = {}
-        rules_dir = os.path.join(self.args.source_dir,
-                                 ".auto-coder", "autocoderrules")
-        if os.path.isdir(rules_dir):
-            for fname in os.listdir(rules_dir):
-                if fname.endswith(".md"):
-                    fpath = os.path.join(rules_dir, fname)
-                    try:
-                        with open(fpath, "r", encoding="utf-8") as f:
-                            content = f.read()
-                            key = fpath
-                            extra_docs[key] = content
-                    except Exception:
-                        continue
-
+        extra_docs = get_rules()
+        
         env_info = detect_env()
         shell_type = "bash"
         if shells.is_running_in_cmd():
@@ -793,12 +772,10 @@ Below are some files the user is focused on, and the content is up to date. Thes
             "role":"assistant","content":"Ok"
         })
         
-        logger.info("Adding conversation history")
-        conversations.extend(self.conversation_manager.get_history())        
+        logger.info("Adding conversation history")        
         conversations.append({
             "role": "user", "content": request.user_input
-        })
-        self.conversation_manager.add_user_message(request.user_input)
+        })        
         
         logger.info(
             f"Initial conversation history size: {len(conversations)}")
@@ -856,9 +833,7 @@ Below are some files the user is focused on, and the content is up to date. Thes
                     conversations.append({
                         "role": "assistant",
                         "content": assistant_buffer + tool_xml
-                    })
-                    self.conversation_manager.add_assistant_message(
-                        assistant_buffer + tool_xml)
+                    })                    
                     assistant_buffer = ""  # Reset buffer after tool call
 
                     yield event  # Yield the ToolCallEvent for display
@@ -941,7 +916,6 @@ Below are some files the user is focused on, and the content is up to date. Thes
                         "role": "user",  # Simulating the user providing the tool result
                         "content": error_xml
                     })
-                    self.conversation_manager.add_user_message(error_xml)
                     logger.info(
                         f"Added tool result to conversations for tool {type(tool_obj).__name__}")
                     logger.info(f"Breaking LLM cycle after executing tool: {tool_name}")
@@ -968,12 +942,9 @@ Below are some files the user is focused on, and the content is up to date. Thes
                         logger.info("Adding new assistant message")
                         conversations.append(
                             {"role": "assistant", "content": assistant_buffer})
-                        self.conversation_manager.add_assistant_message(
-                            assistant_buffer)
                     elif last_message["role"] == "assistant":
                         logger.info("Appending to existing assistant message")
                         last_message["content"] += assistant_buffer
-                        self.conversation_manager.append_to_last_message(assistant_buffer)                        
                 # If the loop ends without AttemptCompletion, it means the LLM finished talking
                 # without signaling completion. We might just stop or yield a final message.
                 # Let's assume it stops here.

autocoder/common/v2/agent/agentic_edit_tools/list_files_tool_resolver.py

@@ -6,7 +6,7 @@ from loguru import logger
 import typing
 from autocoder.common import AutoCoderArgs
 
-from autocoder.ignorefiles.ignore_file_utils import should_ignore
+from autocoder.common.ignorefiles.ignore_file_utils import should_ignore
 
 if typing.TYPE_CHECKING:
     from autocoder.common.v2.agent.agentic_edit import AgenticEdit

autocoder/common/v2/agent/agentic_edit_tools/search_files_tool_resolver.py

@@ -1,4 +1,3 @@
-
 import os
 import re
 import glob
@@ -9,7 +8,7 @@ from loguru import logger
 from autocoder.common import AutoCoderArgs
 import typing
 
-from autocoder.ignorefiles.ignore_file_utils import should_ignore
+from autocoder.common.ignorefiles.ignore_file_utils import should_ignore
 
 if typing.TYPE_CHECKING:
     from autocoder.common.v2.agent.agentic_edit import AgenticEdit  
@@ -33,14 +32,13 @@ class SearchFilesToolResolver(BaseToolResolver):
         if not absolute_search_path.startswith(absolute_source_dir):
             return ToolResult(success=False, message=f"Error: Access denied. Attempted to search outside the project directory: {search_path_str}")
 
-        # Determine search base directory: prefer shadow if exists
-        search_base_path = absolute_search_path
+        # Check if shadow directory exists
         shadow_exists = False
+        shadow_dir_path = None
         if self.shadow_manager:
             try:
                 shadow_dir_path = self.shadow_manager.to_shadow_path(absolute_search_path)
                 if os.path.exists(shadow_dir_path) and os.path.isdir(shadow_dir_path):
-                    search_base_path = shadow_dir_path
                     shadow_exists = True
             except Exception as e:
                 logger.warning(f"Error checking shadow path for {absolute_search_path}: {e}")
@@ -50,51 +48,83 @@ class SearchFilesToolResolver(BaseToolResolver):
             return ToolResult(success=False, message=f"Error: Search path not found: {search_path_str}")
         if os.path.exists(absolute_search_path) and not os.path.isdir(absolute_search_path):
             return ToolResult(success=False, message=f"Error: Search path is not a directory: {search_path_str}")
-        if shadow_exists and not os.path.isdir(search_base_path):
-            return ToolResult(success=False, message=f"Error: Shadow search path is not a directory: {search_base_path}")
+        if shadow_exists and not os.path.isdir(shadow_dir_path):
+            return ToolResult(success=False, message=f"Error: Shadow search path is not a directory: {shadow_dir_path}")
 
-        results = []
         try:
             compiled_regex = re.compile(regex_pattern)
-            search_glob_pattern = os.path.join(search_base_path, "**", file_pattern)
-
-            logger.info(f"Searching for regex '{regex_pattern}' in files matching '{file_pattern}' under '{search_base_path}' (shadow: {shadow_exists}) with ignore rules applied.")
-
-            for filepath in glob.glob(search_glob_pattern, recursive=True):
-                abs_path = os.path.abspath(filepath)
-                if should_ignore(abs_path):
-                    continue
+            
+            # Helper function to search in a directory
+            def search_in_dir(base_dir, is_shadow=False):
+                search_results = []
+                search_glob_pattern = os.path.join(base_dir, "**", file_pattern)
+                
+                logger.info(f"Searching for regex '{regex_pattern}' in files matching '{file_pattern}' under '{base_dir}' (shadow: {is_shadow}) with ignore rules applied.")
+                
+                for filepath in glob.glob(search_glob_pattern, recursive=True):
+                    abs_path = os.path.abspath(filepath)
+                    if should_ignore(abs_path):
+                        continue
 
-                if os.path.isfile(filepath):
-                    try:
-                        with open(filepath, 'r', encoding='utf-8', errors='replace') as f:
-                            lines = f.readlines()
-                        for i, line in enumerate(lines):
-                            if compiled_regex.search(line):
-                                context_start = max(0, i - 2)
-                                context_end = min(len(lines), i + 3)
-                                context = "".join([f"{j+1}: {lines[j]}" for j in range(context_start, context_end)])
-                                if shadow_exists and self.shadow_manager:
-                                    try:
-                                        abs_project_path = self.shadow_manager.from_shadow_path(filepath)
-                                        relative_path = os.path.relpath(abs_project_path, source_dir)
-                                    except Exception:
+                    if os.path.isfile(filepath):
+                        try:
+                            with open(filepath, 'r', encoding='utf-8', errors='replace') as f:
+                                lines = f.readlines()
+                            for i, line in enumerate(lines):
+                                if compiled_regex.search(line):
+                                    context_start = max(0, i - 2)
+                                    context_end = min(len(lines), i + 3)
+                                    context = "".join([f"{j+1}: {lines[j]}" for j in range(context_start, context_end)])
+                                    
+                                    if is_shadow and self.shadow_manager:
+                                        try:
+                                            abs_project_path = self.shadow_manager.from_shadow_path(filepath)
+                                            relative_path = os.path.relpath(abs_project_path, source_dir)
+                                        except Exception:
+                                            relative_path = os.path.relpath(filepath, source_dir)
+                                    else:
                                         relative_path = os.path.relpath(filepath, source_dir)
-                                else:
-                                    relative_path = os.path.relpath(filepath, source_dir)
-                                results.append({
-                                    "path": relative_path,
-                                    "line_number": i + 1,
-                                    "match_line": line.strip(),
-                                    "context": context.strip()
-                                })
-                    except Exception as e:
-                        logger.warning(f"Could not read or process file {filepath}: {e}")
-                        continue
+                                    
+                                    search_results.append({
+                                        "path": relative_path,
+                                        "line_number": i + 1,
+                                        "match_line": line.strip(),
+                                        "context": context.strip()
+                                    })
+                        except Exception as e:
+                            logger.warning(f"Could not read or process file {filepath}: {e}")
+                            continue
+                
+                return search_results
+            
+            # Search in both directories and merge results
+            shadow_results = []
+            source_results = []
+            
+            if shadow_exists:
+                shadow_results = search_in_dir(shadow_dir_path, is_shadow=True)
+            
+            if os.path.exists(absolute_search_path) and os.path.isdir(absolute_search_path):
+                source_results = search_in_dir(absolute_search_path, is_shadow=False)
+            
+            # Merge results, prioritizing shadow results
+            # Create a dictionary for quick lookup
+            results_dict = {}
+            for result in source_results:
+                key = (result["path"], result["line_number"])
+                results_dict[key] = result
+            
+            # Override with shadow results
+            for result in shadow_results:
+                key = (result["path"], result["line_number"])
+                results_dict[key] = result
+            
+            # Convert back to list
+            merged_results = list(results_dict.values())
 
-            message = f"Search completed. Found {len(results)} matches."
+            message = f"Search completed. Found {len(merged_results)} matches."
             logger.info(message)
-            return ToolResult(success=True, message=message, content=results)
+            return ToolResult(success=True, message=message, content=merged_results)
 
         except re.error as e:
             logger.error(f"Invalid regex pattern '{regex_pattern}': {e}")

autocoder/common/v2/code_editblock_manager.py

@@ -396,24 +396,36 @@ class CodeEditBlockManager:
         def _format_blocks(merge: MergeCodeWithoutEffect) -> Tuple[str, str]:
             unmerged_formatted_text = ""
             for file_path, head, update in merge.failed_blocks:
-                unmerged_formatted_text += "```lang\n"
-                unmerged_formatted_text += f"##File: {file_path}\n"
-                unmerged_formatted_text += "<<<<<<< SEARCH\n"
+                unmerged_formatted_text += "```lang"
+                unmerged_formatted_text += "\n"
+                unmerged_formatted_text += f"##File: {file_path}"
+                unmerged_formatted_text += "\n"
+                unmerged_formatted_text += "<<<<<<< SEARCH"
+                unmerged_formatted_text += "\n"
                 unmerged_formatted_text += head
-                unmerged_formatted_text += "=======\n"
+                unmerged_formatted_text += "\n"
+                unmerged_formatted_text += "======="
+                unmerged_formatted_text += "\n"
                 unmerged_formatted_text += update
-                unmerged_formatted_text += ">>>>>>> REPLACE\n"
+                unmerged_formatted_text += "\n"
+                unmerged_formatted_text += ">>>>>>> REPLACE"
+                unmerged_formatted_text += "\n"
                 unmerged_formatted_text += "```"
                 unmerged_formatted_text += "\n"
 
             merged_formatted_text = ""
             if merge.merged_blocks:
                 for file_path, head, update in merge.merged_blocks:
-                    merged_formatted_text += "```lang\n"
-                    merged_formatted_text += f"##File: {file_path}\n"
+                    merged_formatted_text += "```lang"
+                    merged_formatted_text += "\n"
+                    merged_formatted_text += f"##File: {file_path}"
+                    merged_formatted_text += "\n"
                     merged_formatted_text += head
-                    merged_formatted_text += "=======\n"
+                    merged_formatted_text += "\n"
+                    merged_formatted_text += "======="
+                    merged_formatted_text += "\n"
                     merged_formatted_text += update
+                    merged_formatted_text += "\n"
                     merged_formatted_text += "```"
                     merged_formatted_text += "\n"
 

autocoder/index/index.py

@@ -462,7 +462,7 @@ class IndexManager:
     def filter_exclude_files(self, file_path, exclude_patterns):
         # 增加 ignore_file_utils 的过滤
         try:
-            from src.autocoder.ignorefiles import ignore_file_utils
+            from autocoder.common.ignorefiles import ignore_file_utils
             if ignore_file_utils.should_ignore(file_path):
                 return True
         except Exception:

autocoder/models.py

@@ -60,22 +60,35 @@ default_models_list = [
         "max_output_tokens": 8096
     },    
     {
-        "name": "openrouter/quasar-alpha",
+        "name": "openai/gpt-4.1-mini",
         "description": "",
-        "model_name": "openrouter/quasar-alpha",
+        "model_name": "openai/gpt-4.1-mini",
         "model_type": "saas/openai",
         "base_url": "https://openrouter.ai/api/v1",
         "api_key_path": "",
         "is_reasoning": False,
-        "input_price": 0.0,
-        "output_price": 0.0,
+        "input_price": 2.8,
+        "output_price": 11.2,
         "average_speed": 0.0,
-        "max_output_tokens": 8096*2
+        "max_output_tokens": 8096*3
     },
     {
-        "name": "openrouter/optimus-alpha",
+        "name": "openai/gpt-4.1",
         "description": "",
-        "model_name": "openrouter/optimus-alpha",
+        "model_name": "openai/gpt-4.1",
+        "model_type": "saas/openai",
+        "base_url": "https://openrouter.ai/api/v1",
+        "api_key_path": "",
+        "is_reasoning": False,
+        "input_price": 14.0,
+        "output_price": 42.0,
+        "average_speed": 0.0,
+        "max_output_tokens": 8096*3
+    },   
+    {
+        "name": "openai/gpt-4.1-nano",
+        "description": "",
+        "model_name": "openai/gpt-4.1-nano",
         "model_type": "saas/openai",
         "base_url": "https://openrouter.ai/api/v1",
         "api_key_path": "",
@@ -83,8 +96,8 @@ default_models_list = [
         "input_price": 0.0,
         "output_price": 0.0,
         "average_speed": 0.0,
-        "max_output_tokens": 8096*2
-    },     
+        "max_output_tokens": 8096*3
+    },  
     {
         "name": "openrouter/google/gemini-2.5-pro-preview-03-25",
         "description": "",

autocoder/rag/api_server.py

@@ -187,9 +187,16 @@ async def serve_static_file(full_path: str, request: Request):
         # 直接使用规范化的路径
         file_path = os.path.join("/", os.path.normpath(unquote(full_path)))
         
+        # 获取允许的静态文件目录
+        allowed_static_abs = request.app.state.allowed_static_abs
+        logger.info(f"==allowed_static_abs==: {allowed_static_abs}")
+        
+        if file_path.startswith(("/_images","_images")):            
+            file_path = os.path.join(allowed_static_abs, file_path)  
+
         # 检查文件是否存在
         if not os.path.exists(file_path):
-            raise FileNotFoundError(f"File not found: {file_path}")
+            raise FileNotFoundError(f"File not found: {file_path}")          
         
         # 如果启用了Nginx X-Accel-Redirect，使用X-Accel特性
         if hasattr(request.app.state, "enable_nginx_x_accel") and request.app.state.enable_nginx_x_accel:
@@ -273,6 +280,9 @@ def serve(llm:ByzerLLM, args: ServerArgs):
     allowed_static_abs = os.path.abspath(allowed_static_dir)
     logger.info(f"Static files root directory: {allowed_static_abs}")
     
+    # 将允许的静态文件目录存储到应用状态中
+    router_app.state.allowed_static_abs = allowed_static_abs
+    
     router_app.add_middleware(
         CORSMiddleware,
         allow_origins=args.allowed_origins,
@@ -309,9 +319,11 @@ def serve(llm:ByzerLLM, args: ServerArgs):
                 
                 # Check if path is in allowed directory
                 abs_path = os.path.abspath(os.path.join("/", normalized_path))
+                if abs_path.startswith("/_images"):
+                    return await call_next(request)
                 
                 # 使用预先计算好的allowed_static_abs
-                is_allowed = abs_path.startswith(allowed_static_abs)
+                is_allowed = abs_path.startswith(request.app.state.allowed_static_abs)
                 
                 if not is_allowed:
                     logger.warning(f"Unauthorized path access: {abs_path}")