auto-coder 0.1.374__py3-none-any.whl → 0.1.376__py3-none-any.whl

autocoder/agent/base_agentic/tools/search_files_tool_resolver.py

@@ -1,7 +1,7 @@
 import os
 import re
 import glob
-from typing import Dict, Any, Optional, List
+from typing import Dict, Any, Optional, List, Union
 from autocoder.agent.base_agentic.tools.base_tool_resolver import BaseToolResolver
 from autocoder.agent.base_agentic.types import SearchFilesTool, ToolResult  # Import ToolResult from types
 from loguru import logger
@@ -20,14 +20,54 @@ class SearchFilesToolResolver(BaseToolResolver):
         self.tool: SearchFilesTool = tool
         self.shadow_manager = self.agent.shadow_manager if self.agent else None
 
-    def resolve(self) -> ToolResult:
-        search_path_str = self.tool.path
-        regex_pattern = self.tool.regex
-        file_pattern = self.tool.file_pattern or "*"
-        source_dir = self.args.source_dir or "."
-        absolute_source_dir = os.path.abspath(source_dir)
-        absolute_search_path = os.path.abspath(os.path.join(source_dir, search_path_str))
+    def search_in_dir(self, base_dir: str, regex_pattern: str, file_pattern: str, source_dir: str, is_shadow: bool = False, compiled_regex: Optional[re.Pattern] = None) -> List[Dict[str, Any]]:
+        """Helper function to search in a directory"""
+        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.")
+        
+        if compiled_regex is None:
+            compiled_regex = re.compile(regex_pattern)
+            
+        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 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)
+                            
+                            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
+
+    def search_files_with_shadow(self, search_path_str: str, regex_pattern: str, file_pattern: str, source_dir: str, absolute_source_dir: str, absolute_search_path: str) -> Union[ToolResult, List[Dict[str, Any]]]:
+        """Search files using shadow manager for path translation"""
         # Security check
         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}")
@@ -54,58 +94,15 @@ class SearchFilesToolResolver(BaseToolResolver):
         try:
             compiled_regex = re.compile(regex_pattern)
             
-            # 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 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)
-                                    
-                                    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)
+                shadow_results = self.search_in_dir(shadow_dir_path, regex_pattern, file_pattern, source_dir, is_shadow=True, compiled_regex=compiled_regex)
             
             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)
+                source_results = self.search_in_dir(absolute_search_path, regex_pattern, file_pattern, source_dir, is_shadow=False, compiled_regex=compiled_regex)
             
             # Merge results, prioritizing shadow results
             # Create a dictionary for quick lookup
@@ -122,9 +119,34 @@ class SearchFilesToolResolver(BaseToolResolver):
             # Convert back to list
             merged_results = list(results_dict.values())
 
-            message = f"Search completed. Found {len(merged_results)} matches."
-            logger.info(message)
-            return ToolResult(success=True, message=message, content=merged_results)
+            return merged_results
+
+        except re.error as e:
+            logger.error(f"Invalid regex pattern '{regex_pattern}': {e}")
+            return ToolResult(success=False, message=f"Invalid regex pattern: {e}")
+        except Exception as e:
+            logger.error(f"Error during file search: {str(e)}")
+            return ToolResult(success=False, message=f"An unexpected error occurred during search: {str(e)}")
+    
+    def search_files_normal(self, search_path_str: str, regex_pattern: str, file_pattern: str, source_dir: str, absolute_source_dir: str, absolute_search_path: str) -> Union[ToolResult, List[Dict[str, Any]]]:
+        """Search files directly without using shadow manager"""
+        # Security check
+        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}")
+
+        # Validate that the directory exists
+        if not os.path.exists(absolute_search_path):
+            return ToolResult(success=False, message=f"Error: Search path not found: {search_path_str}")
+        if not os.path.isdir(absolute_search_path):
+            return ToolResult(success=False, message=f"Error: Search path is not a directory: {search_path_str}")
+
+        try:
+            compiled_regex = re.compile(regex_pattern)
+            
+            # Search in the directory
+            search_results = self.search_in_dir(absolute_search_path, regex_pattern, file_pattern, source_dir, is_shadow=False, compiled_regex=compiled_regex)
+            
+            return search_results
 
         except re.error as e:
             logger.error(f"Invalid regex pattern '{regex_pattern}': {e}")
@@ -132,3 +154,26 @@ class SearchFilesToolResolver(BaseToolResolver):
         except Exception as e:
             logger.error(f"Error during file search: {str(e)}")
             return ToolResult(success=False, message=f"An unexpected error occurred during search: {str(e)}")
+
+    def resolve(self) -> ToolResult:
+        """Resolve the search files tool by calling the appropriate implementation"""
+        search_path_str = self.tool.path
+        regex_pattern = self.tool.regex
+        file_pattern = self.tool.file_pattern or "*"
+        source_dir = self.args.source_dir or "."
+        absolute_source_dir = os.path.abspath(source_dir)
+        absolute_search_path = os.path.abspath(os.path.join(source_dir, search_path_str))
+
+        # Choose the appropriate implementation based on whether shadow_manager is available
+        if self.shadow_manager:
+            result = self.search_files_with_shadow(search_path_str, regex_pattern, file_pattern, source_dir, absolute_source_dir, absolute_search_path)
+        else:
+            result = self.search_files_normal(search_path_str, regex_pattern, file_pattern, source_dir, absolute_source_dir, absolute_search_path)
+
+        # Handle the case where the implementation returns a list instead of a ToolResult
+        if isinstance(result, list):
+            message = f"Search completed. Found {len(result)} matches."
+            logger.info(message)
+            return ToolResult(success=True, message=message, content=result)
+        else:
+            return result

autocoder/agent/base_agentic/tools/talk_to_group_tool_resolver.py

@@ -2,10 +2,15 @@ from typing import Optional, Dict, Any
 import os
 from loguru import logger
 from datetime import datetime
+import typing
 
 from ..types import TalkToGroupTool, ToolResult
 from ..tools.base_tool_resolver import BaseToolResolver
 from ..agent_hub import AgentHub, Group
+from autocoder.common import AutoCoderArgs
+
+if typing.TYPE_CHECKING:
+    from ..base_agent import BaseAgent
 
 
 class TalkToGroupToolResolver(BaseToolResolver):

autocoder/agent/base_agentic/tools/talk_to_tool_resolver.py

@@ -2,10 +2,15 @@ from typing import Optional, Dict, Any
 import os
 from loguru import logger
 from datetime import datetime
+import typing
 
 from ..types import TalkToTool, ToolResult
 from ..tools.base_tool_resolver import BaseToolResolver
 from ..agent_hub import AgentHub
+from autocoder.common import AutoCoderArgs
+
+if typing.TYPE_CHECKING:
+    from ..base_agent import BaseAgent
 
 
 class TalkToToolResolver(BaseToolResolver):

autocoder/agent/base_agentic/tools/write_to_file_tool_resolver.py

@@ -1,9 +1,12 @@
 import os
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional,List
 from autocoder.agent.base_agentic.types import WriteToFileTool, ToolResult  # Import ToolResult from types
 from autocoder.agent.base_agentic.tools.base_tool_resolver import BaseToolResolver
 from loguru import logger
 from autocoder.common import AutoCoderArgs
+from autocoder.common.file_checkpoint.models import FileChange as CheckpointFileChange
+from autocoder.common.file_checkpoint.manager import FileChangeManager as CheckpointFileChangeManager
+from autocoder.linters.models import IssueSeverity, FileLintResult
 import typing
 
 if typing.TYPE_CHECKING:
@@ -13,9 +16,148 @@ class WriteToFileToolResolver(BaseToolResolver):
     def __init__(self, agent: Optional['BaseAgent'], tool: WriteToFileTool, args: AutoCoderArgs):
         super().__init__(agent, tool, args)
         self.tool: WriteToFileTool = tool  # For type hinting
+        self.args = args
         self.shadow_manager = self.agent.shadow_manager if self.agent else None
+        self.shadow_linter = self.agent.shadow_linter if self.agent else None
+        
+    def _filter_lint_issues(self, lint_result:FileLintResult, levels: List[IssueSeverity] = [IssueSeverity.ERROR, IssueSeverity.WARNING]):
+        """
+        过滤 lint 结果，只保留指定级别的问题
+        
+        参数:
+            lint_result: 单个文件的 lint 结果对象
+            levels: 要保留的问题级别列表，默认保留 ERROR 和 WARNING 级别
+            
+        返回:
+            过滤后的 lint 结果对象（原对象的副本）
+        """
+        if not lint_result or not lint_result.issues:
+            return lint_result
+            
+        # 创建一个新的 issues 列表，只包含指定级别的问题
+        filtered_issues = []
+        for issue in lint_result.issues:
+            if issue.severity in levels:
+                filtered_issues.append(issue)
+                
+        # 更新 lint_result 的副本
+        filtered_result = lint_result
+        filtered_result.issues = filtered_issues
+        
+        # 更新计数
+        filtered_result.error_count = sum(1 for issue in filtered_issues if issue.severity == IssueSeverity.ERROR)
+        filtered_result.warning_count = sum(1 for issue in filtered_issues if issue.severity == IssueSeverity.WARNING)
+        filtered_result.info_count = sum(1 for issue in filtered_issues if issue.severity == IssueSeverity.INFO)
+        
+        return filtered_result
+        
+    def _format_lint_issues(self, lint_result:FileLintResult):
+        """
+        将 lint 结果格式化为可读的文本格式
+        
+        参数:
+            lint_result: 单个文件的 lint 结果对象
+            
+        返回:
+            str: 格式化的问题描述
+        """
+        formatted_issues = []
+        
+        for issue in lint_result.issues:
+            severity = "错误" if issue.severity.value == 3 else "警告" if issue.severity.value == 2 else "信息"
+            line_info = f"第{issue.position.line}行"
+            if issue.position.column:
+                line_info += f", 第{issue.position.column}列"
+            
+            formatted_issues.append(
+                f"  - [{severity}] {line_info}: {issue.message} (规则: {issue.code})"
+            )
+        
+        return "\n".join(formatted_issues)
+    
+
+    def write_file_normal(self, file_path: str, content: str, source_dir: str, abs_project_dir: str, abs_file_path: str) -> ToolResult:
+        """Write file directly without using shadow manager"""
+        try:
+            os.makedirs(os.path.dirname(abs_file_path), exist_ok=True)            
+
+            if self.agent:
+                rel_path = os.path.relpath(abs_file_path, abs_project_dir)
+                self.agent.record_file_change(rel_path, "added", diff=None, content=content)
+
+            if self.agent and self.agent.checkpoint_manager:
+                changes = {
+                    file_path: CheckpointFileChange(
+                        file_path=file_path,
+                        content=content,
+                        is_deletion=False,
+                        is_new=True
+                    )
+                }
+                change_group_id = self.args.event_file
+                                                              
+                self.agent.checkpoint_manager.apply_changes_with_conversation(
+                            changes=changes,
+                            conversations=self.agent.current_conversations,
+                            change_group_id=change_group_id,
+                            metadata={"event_file": self.args.event_file}
+                        )                    
+            else:
+                with open(abs_file_path, 'w', encoding='utf-8') as f:
+                    f.write(content)
+            logger.info(f"Successfully wrote to file: {file_path}")    
+            
+            # 新增：执行代码质量检查
+            lint_results = None
+            lint_message = ""
+            formatted_issues = ""
+            has_lint_issues = False
+            
+            # 检查是否启用了Lint功能
+            enable_lint = self.args.enable_auto_fix_lint
+            
+            if enable_lint:
+                try:                    
+                    if self.agent.linter:
+                        lint_results = self.agent.linter.lint_file(file_path)
+                        if lint_results and lint_results.issues:
+                            # 过滤 lint 结果，只保留 ERROR 和 WARNING 级别的问题
+                            filtered_results = self._filter_lint_issues(lint_results)
+                            if filtered_results.issues:
+                                has_lint_issues = True
+                                # 格式化 lint 问题
+                                formatted_issues = self._format_lint_issues(filtered_results)
+                                lint_message = f"\n\n代码质量检查发现 {len(filtered_results.issues)} 个问题"
+                except Exception as e:
+                    logger.error(f"Lint 检查失败: {str(e)}")
+                    lint_message = "\n\n尝试进行代码质量检查时出错。"
+            else:
+                logger.info("代码质量检查已禁用")
+            
+            # 构建包含 lint 结果的返回消息
+            message = f"{file_path}"
+                        
+            
+            # 附加 lint 结果到返回内容
+            result_content = {
+                "content": content,
+            }
+            
+            # 只有在启用Lint时才添加Lint结果
+            if enable_lint:
+                message = message + "\n" + lint_message
+                result_content["lint_results"] = {
+                    "has_issues": has_lint_issues,
+                    "issues": formatted_issues if has_lint_issues else None
+                }
+            
+            return ToolResult(success=True, message=message, content=result_content)
+        except Exception as e:
+            logger.error(f"Error writing to file '{file_path}': {str(e)}")
+            return ToolResult(success=False, message=f"An error occurred while writing to the file: {str(e)}")
 
     def resolve(self) -> ToolResult:
+        """Resolve the write file tool by calling the appropriate implementation"""
         file_path = self.tool.path
         content = self.tool.content
         source_dir = self.args.source_dir or "."
@@ -25,34 +167,5 @@ class WriteToFileToolResolver(BaseToolResolver):
         # Security check: ensure the path is within the source directory
         if not abs_file_path.startswith(abs_project_dir):
             return ToolResult(success=False, message=f"Error: Access denied. Attempted to write file outside the project directory: {file_path}")
-
-        try:
-            if self.shadow_manager:
-                shadow_path = self.shadow_manager.to_shadow_path(abs_file_path)
-                # Ensure shadow directory exists
-                os.makedirs(os.path.dirname(shadow_path), exist_ok=True)
-                with open(shadow_path, 'w', encoding='utf-8') as f:
-                    f.write(content)
-                logger.info(f"[Shadow] Successfully wrote shadow file: {shadow_path}")
-
-                # 回调AgenticEdit，记录变更
-                if self.agent:
-                    rel_path = os.path.relpath(abs_file_path, abs_project_dir)
-                    self.agent.record_file_change(rel_path, "added", diff=None, content=content)
-
-                return ToolResult(success=True, message=f"Successfully wrote to file (shadow): {file_path}", content=content)
-            else:
-                # No shadow manager fallback to original file
-                os.makedirs(os.path.dirname(abs_file_path), exist_ok=True)
-                with open(abs_file_path, 'w', encoding='utf-8') as f:
-                    f.write(content)
-                logger.info(f"Successfully wrote to file: {file_path}")
-
-                if self.agent:
-                    rel_path = os.path.relpath(abs_file_path, abs_project_dir)
-                    self.agent.record_file_change(rel_path, "added", diff=None, content=content)
-
-                return ToolResult(success=True, message=f"Successfully wrote to file: {file_path}", content=content)
-        except Exception as e:
-            logger.error(f"Error writing to file '{file_path}': {str(e)}")
-            return ToolResult(success=False, message=f"An error occurred while writing to the file: {str(e)}")
+                
+        return self.write_file_normal(file_path, content, source_dir, abs_project_dir, abs_file_path)

autocoder/auto_coder_rag.py

@@ -6,6 +6,8 @@ from typing import Optional, List
 import byzerllm
 from autocoder.rag.api_server import serve, ServerArgs
 from autocoder.rag.rag_entry import RAGFactory
+from autocoder.rag.agentic_rag import AgenticRAG
+from autocoder.rag.long_context_rag import LongContextRAG
 from autocoder.rag.llm_wrapper import LLWrapper
 from autocoder.common import AutoCoderArgs
 from autocoder.lang import lang_desc
@@ -32,6 +34,7 @@ from autocoder.rag.utils import process_file_local
 import pkg_resources
 from autocoder.rag.token_counter import TokenCounter
 from autocoder.rag.types import RAGServiceInfo
+from autocoder.version import __version__
 
 if platform.system() == "Windows":
     from colorama import init
@@ -167,6 +170,17 @@ def initialize_system(args):
 
 
 def main(input_args: Optional[List[str]] = None):
+    print(
+        f"""
+    \033[1;32m
+      _     _     __  __       _   _    _  _____ _____     _______   ____      _    ____ 
+     | |   | |   |  \/  |     | \ | |  / \|_   _|_ _\ \   / / ____| |  _ \    / \  / ___|
+     | |   | |   | |\/| |_____|  \| | / _ \ | |  | | \ \ / /|  _|   | |_) |  / _ \| |  _ 
+     | |___| |___| |  | |_____| |\  |/ ___ \| |  | |  \ V / | |___  |  _ <  / ___ \ |_| |
+     |_____|_____|_|  |_|     |_| \_/_/   \_\_| |___|  \_/  |_____| |_| \_\/_/   \_\____|
+                                                                            v{__version__}
+    \033[0m"""
+    )
 
     try:
         tokenizer_path = pkg_resources.resource_filename(
@@ -301,6 +315,7 @@ def main(input_args: Optional[List[str]] = None):
         help="Document directory path, also used as the root directory for serving static files"
     )
     serve_parser.add_argument("--enable_local_image_host", action="store_true", help=" enable local image host for local Chat app")
+    serve_parser.add_argument("--agentic", action="store_true", help="使用 AgenticRAG 而不是 LongContextRAG")
     serve_parser.add_argument("--tokenizer_path", default=tokenizer_path, help="")
     serve_parser.add_argument(
         "--collections", default="", help="Collection name for indexing"
@@ -432,6 +447,18 @@ def main(input_args: Optional[List[str]] = None):
         help="The model used for embedding documents",
     )
 
+    serve_parser.add_argument(
+        "--agentic_model",
+        default="",
+        help="The model used for agentic operations",
+    )
+
+    serve_parser.add_argument(
+        "--context_prune_model",
+        default="",
+        help="The model used for context pruning",
+    )
+
     # Benchmark command
     benchmark_parser = subparsers.add_parser(
         "benchmark", help="Benchmark LLM client performance"
@@ -622,6 +649,18 @@ def main(input_args: Optional[List[str]] = None):
                 emb_model.skip_nontext_check = True
                 llm.setup_sub_client("emb_model", emb_model)
 
+            if args.agentic_model:
+                agentic_model = byzerllm.ByzerLLM()
+                agentic_model.setup_default_model_name(args.agentic_model)
+                agentic_model.skip_nontext_check = True
+                llm.setup_sub_client("agentic_model", agentic_model)
+
+            if args.context_prune_model:
+                context_prune_model = byzerllm.ByzerLLM()
+                context_prune_model.setup_default_model_name(args.context_prune_model)
+                context_prune_model.skip_nontext_check = True
+                llm.setup_sub_client("context_prune_model", context_prune_model)
+
             # 当启用hybrid_index时,检查必要的组件
             if auto_coder_args.enable_hybrid_index:
                 if not args.emb_model and not llm.is_model_exist("emb"):
@@ -698,7 +737,7 @@ def main(input_args: Optional[List[str]] = None):
                         "saas.max_output_tokens": model_info.get("max_output_tokens", 8096)
                     }
                 )
-                llm.setup_sub_client("qa_model", qa_model)
+                llm.setup_sub_client("qa_model", qa_model)                
 
             if args.emb_model:
                 model_info = models_module.get_model_by_name(args.emb_model)
@@ -717,22 +756,52 @@ def main(input_args: Optional[List[str]] = None):
                 )
                 llm.setup_sub_client("emb_model", emb_model)
 
+            if args.agentic_model:
+                model_info = models_module.get_model_by_name(args.agentic_model)
+                agentic_model = byzerllm.SimpleByzerLLM(default_model_name=args.agentic_model)
+                agentic_model.deploy(
+                    model_path="",
+                    pretrained_model_type=model_info["model_type"],
+                    udf_name=args.agentic_model,
+                    infer_params={
+                        "saas.base_url": model_info["base_url"],
+                        "saas.api_key": model_info["api_key"],
+                        "saas.model": model_info["model_name"],
+                        "saas.is_reasoning": model_info["is_reasoning"],
+                        "saas.max_output_tokens": model_info.get("max_output_tokens", 8096)
+                    }
+                )
+                llm.setup_sub_client("agentic_model", agentic_model)
+
+            if args.context_prune_model:
+                model_info = models_module.get_model_by_name(args.context_prune_model)
+                context_prune_model = byzerllm.SimpleByzerLLM(default_model_name=args.context_prune_model)
+                context_prune_model.deploy(
+                    model_path="",
+                    pretrained_model_type=model_info["model_type"],
+                    udf_name=args.context_prune_model,
+                    infer_params={
+                        "saas.base_url": model_info["base_url"],
+                        "saas.api_key": model_info["api_key"],
+                        "saas.model": model_info["model_name"],
+                        "saas.is_reasoning": model_info["is_reasoning"],
+                        "saas.max_output_tokens": model_info.get("max_output_tokens", 8096)
+                    }
+                )
+                llm.setup_sub_client("context_prune_model", context_prune_model)
+
             if args.enable_hybrid_index:
                 if not args.emb_model:
                     raise Exception("When enable_hybrid_index is true, an 'emb' model must be specified")                
 
-        if server_args.doc_dir:
-            auto_coder_args.rag_type = "simple"
+        if server_args.doc_dir:            
             auto_coder_args.rag_build_name = generate_unique_name_from_path(server_args.doc_dir)
-            rag = RAGFactory.get_rag(
-                llm=llm,
-                args=auto_coder_args,
-                path=server_args.doc_dir,
-                tokenizer_path=server_args.tokenizer_path,
-            )
+            if args.agentic:
+                rag = AgenticRAG(llm=llm, args=auto_coder_args, path=server_args.doc_dir, tokenizer_path=server_args.tokenizer_path)
+            else:
+                rag = LongContextRAG(llm=llm, args=auto_coder_args, path=server_args.doc_dir, tokenizer_path=server_args.tokenizer_path)
         else:
-            auto_coder_args.rag_build_name = generate_unique_name_from_path("")
-            rag = RAGFactory.get_rag(llm=llm, args=auto_coder_args, path="")
+            raise Exception("doc_dir is required")
 
         llm_wrapper = LLWrapper(llm=llm, rag=rag)
         # Save service info    

autocoder/models.py

@@ -165,8 +165,8 @@ def load_models() -> List[Dict]:
         if model.get("api_key_path",""):           
             api_key_file = os.path.join(api_key_dir, model["api_key_path"])
             if os.path.exists(api_key_file):
-                with open(api_key_file, "r",encoding="utf-8") as f:
-                    model["api_key"] = f.read()                   
+                with open(api_key_file, "r", encoding="utf-8") as f:
+                    model["api_key"] = f.read().strip()
     return target_models
 
 def save_models(models: List[Dict]) -> None: