auto-coder 0.1.267__py3-none-any.whl → 0.1.269__py3-none-any.whl

autocoder/common/conversation_pruner.py

@@ -3,8 +3,9 @@ import json
 from pydantic import BaseModel
 import byzerllm
 from autocoder.common.printer import Printer
-from autocoder.utils.llms import count_tokens
+from autocoder.rag.token_counter import count_tokens
 from loguru import logger
+from autocoder.common import AutoCoderArgs
 
 class PruneStrategy(BaseModel):
     name: str
@@ -12,25 +13,25 @@ class PruneStrategy(BaseModel):
     config: Dict[str, Any] = {"safe_zone_tokens": 0, "group_size": 4}
 
 class ConversationPruner:
-    def __init__(self, llm: Union[byzerllm.ByzerLLM, byzerllm.SimpleByzerLLM], 
-                 safe_zone_tokens: int = 500, group_size: int = 4):
+    def __init__(self, args: AutoCoderArgs, llm: Union[byzerllm.ByzerLLM, byzerllm.SimpleByzerLLM]):
+        self.args = args
         self.llm = llm
         self.printer = Printer()
         self.strategies = {
             "summarize": PruneStrategy(
                 name="summarize",
                 description="对早期对话进行分组摘要，保留关键信息",
-                config={"safe_zone_tokens": safe_zone_tokens, "group_size": group_size}
+                config={"safe_zone_tokens": self.args.conversation_prune_safe_zone_tokens, "group_size": self.args.conversation_prune_group_size}
             ),
             "truncate": PruneStrategy(
                 name="truncate",
                 description="分组截断最早的部分对话",
-                config={"safe_zone_tokens": safe_zone_tokens, "group_size": group_size}
+                config={"safe_zone_tokens": self.args.conversation_prune_safe_zone_tokens, "group_size": self.args.conversation_prune_group_size}
             ),
             "hybrid": PruneStrategy(
                 name="hybrid",
                 description="先尝试分组摘要，如果仍超限则分组截断",
-                config={"safe_zone_tokens": safe_zone_tokens, "group_size": group_size}
+                config={"safe_zone_tokens": self.args.conversation_prune_safe_zone_tokens, "group_size": self.args.conversation_prune_group_size}
             )
         }
 
@@ -57,7 +58,7 @@ class ConversationPruner:
         if strategy.name == "summarize":
             return self._summarize_prune(conversations, strategy.config)
         elif strategy.name == "truncate":
-            return self._truncate_prune.with_llm(self.llm).run(conversations)
+            return self._truncate_prune(conversations)
         elif strategy.name == "hybrid":
             pruned = self._summarize_prune(conversations, strategy.config)
             if count_tokens(json.dumps(pruned, ensure_ascii=False)) > self.args.conversation_prune_safe_zone_tokens:
@@ -80,8 +81,8 @@ class ConversationPruner:
                 break
                 
             # 找到要处理的对话组
-            early_conversations = processed_conversations[:-group_size]
-            recent_conversations = processed_conversations[-group_size:]
+            early_conversations = processed_conversations[:group_size]
+            recent_conversations = processed_conversations[group_size:]
             
             if not early_conversations:
                 break
@@ -90,7 +91,7 @@ class ConversationPruner:
             group_summary = self._generate_summary.with_llm(self.llm).run(early_conversations[-group_size:])
             
             # 更新对话历史
-            processed_conversations = early_conversations[:-group_size] + [
+            processed_conversations =  [
                 {"role": "user", "content": f"历史对话摘要：\n{group_summary}"},
                 {"role": "assistant", "content": f"收到"}
             ] + recent_conversations

autocoder/index/entry.py

@@ -58,8 +58,12 @@ def build_index_and_filter_files(
             return file_path.strip()[2:]
         return file_path
 
+    # 文件路径 -> TargetFile 
     final_files: Dict[str, TargetFile] = {}
 
+    # 文件路径 -> 文件在文件列表中的位置（越前面表示越相关）
+    file_positions:Dict[str,int] = {}
+
     # Phase 1: Process REST/RAG/Search sources
     printer = Printer()
     printer.print_in_terminal("phase1_processing_sources")
@@ -102,25 +106,20 @@ def build_index_and_filter_files(
                     })
                 )
             )
-
+        
+        
         if not args.skip_filter_index and args.index_filter_model:
             model_name = getattr(index_manager.index_filter_llm, 'default_model_name', None)
             if not model_name:
                 model_name = "unknown(without default model name)"    
             printer.print_in_terminal("quick_filter_start", style="blue", model_name=model_name)
             quick_filter = QuickFilter(index_manager,stats,sources)        
-            quick_filter_result = quick_filter.filter(index_manager.read_index(),args.query)
-            # if quick_filter_result.has_error:                
-            #     raise KeyboardInterrupt(printer.get_message_from_key_with_format("quick_filter_failed",error=quick_filter_result.error_message))
-
-            # Merge quick filter results into final_files
-            if args.context_prune:
-                context_pruner = PruneContext(max_tokens=args.conversation_prune_safe_zone_tokens, args=args, llm=llm)
-                pruned_files = context_pruner.handle_overflow(quick_filter_result.files, [{"role":"user","content":args.query}], args.context_prune_strategy)
-                for source_file in pruned_files:
-                    final_files[source_file.module_name] = quick_filter_result.files[source_file.module_name]
-            else:
-                final_files.update(quick_filter_result.files)                                     
+            quick_filter_result = quick_filter.filter(index_manager.read_index(),args.query)            
+            
+            final_files.update(quick_filter_result.files)
+            
+            if quick_filter_result.file_positions:
+                file_positions.update(quick_filter_result.file_positions)
         
         if not args.skip_filter_index and not args.index_filter_model:
             model_name = getattr(index_manager.llm, 'default_model_name', None)
@@ -261,32 +260,53 @@ def build_index_and_filter_files(
         for file in final_filenames:
             print(f"{file} - {final_files[file].reason}")
 
-    source_code = ""  
+    # source_code = ""  
     source_code_list = SourceCodeList(sources=[])
     depulicated_sources = set()
-
+    
+    ## 先去重
+    temp_sources = []
     for file in sources:
         if file.module_name in final_filenames:
             if file.module_name in depulicated_sources:
                 continue
             depulicated_sources.add(file.module_name)
-            source_code += f"##File: {file.module_name}\n"
-            source_code += f"{file.source_code}\n\n"
-            source_code_list.sources.append(file)
+            # source_code += f"##File: {file.module_name}\n"
+            # source_code += f"{file.source_code}\n\n"
+            temp_sources.append(file)
+
+    ## 开启了裁剪，则需要做裁剪，不过目前只针对 quick filter 生效
+    if args.context_prune:
+        context_pruner = PruneContext(max_tokens=args.conversation_prune_safe_zone_tokens, args=args, llm=llm)
+        # 如果 file_positions 不为空，则通过 file_positions 来获取文件
+        if file_positions:
+            ## 拿到位置列表，然后根据位置排序 得到 [(pos,file_path)]
+            ## 将 [(pos,file_path)] 转换为 [file_path]
+            ## 通过 [file_path] 顺序调整 temp_sources 的顺序             
+            ## MARK 
+             # 将 file_positions 转换为 [(pos, file_path)] 的列表
+            position_file_pairs = [(pos, file_path) for file_path, pos in file_positions.items()]
+            # 按位置排序
+            position_file_pairs.sort(key=lambda x: x[0])
+            # 提取排序后的文件路径列表
+            sorted_file_paths = [file_path for _, file_path in position_file_pairs]
+            # 根据 sorted_file_paths 重新排序 temp_sources
+            temp_sources.sort(key=lambda x: sorted_file_paths.index(x.module_name) if x.module_name in sorted_file_paths else len(sorted_file_paths))           
+        pruned_files = context_pruner.handle_overflow([source.module_name for source in temp_sources], [{"role":"user","content":args.query}], args.context_prune_strategy)
+        source_code_list.sources = pruned_files
+
     if args.request_id and not args.skip_events:
         queue_communicate.send_event(
             request_id=args.request_id,
             event=CommunicateEvent(
                 event_type=CommunicateEventType.CODE_INDEX_FILTER_FILE_SELECTED.value,
                 data=json.dumps([
-                    (file["file_path"], file.reason)
-                    for file in final_files.values()
-                    if file.file_path in depulicated_sources
+                    (file.module_name, "") for file in source_code_list.sources
                 ])
             )
         )        
 
-    stats["final_files"] = len(depulicated_sources)
+    stats["final_files"] = len(source_code_list.sources)
     phase_end = time.monotonic()
     stats["timings"]["prepare_output"] = phase_end - phase_start
 

autocoder/index/index.py

@@ -12,6 +12,7 @@ from autocoder.index.symbols_utils import (
 from autocoder.privacy.model_filter import ModelPathFilter
 from concurrent.futures import ThreadPoolExecutor, as_completed
 import threading
+import re
 
 import byzerllm
 import hashlib
@@ -27,6 +28,8 @@ from autocoder.index.types import (
 from autocoder.common.global_cancel import global_cancel
 from autocoder.utils.llms import get_llm_names
 from autocoder.rag.token_counter import count_tokens
+
+
 class IndexManager:
     def __init__(
         self, llm: byzerllm.ByzerLLM, sources: List[SourceCode], args: AutoCoderArgs
@@ -52,12 +55,14 @@ class IndexManager:
             self.index_filter_llm = llm
 
         self.llm = llm
-        
+
         # Initialize model filters
         if self.index_llm:
-            self.index_model_filter = ModelPathFilter.from_model_object(self.index_llm, args)
+            self.index_model_filter = ModelPathFilter.from_model_object(
+                self.index_llm, args)
         if self.index_filter_llm:
-            self.index_filter_model_filter = ModelPathFilter.from_model_object(self.index_filter_llm, args)
+            self.index_filter_model_filter = ModelPathFilter.from_model_object(
+                self.index_filter_llm, args)
         self.args = args
         self.max_input_length = (
             args.index_model_max_input_length or args.model_max_input_length
@@ -68,7 +73,6 @@ class IndexManager:
         if not os.path.exists(self.index_dir):
             os.makedirs(self.index_dir)
 
-    
     @byzerllm.prompt()
     def verify_file_relevance(self, file_content: str, query: str) -> str:
         """
@@ -201,12 +205,12 @@ class IndexManager:
         if current_chunk:
             chunks.append("\n".join(current_chunk))
         return chunks
-    
+
     def should_skip(self, file_path: str):
         ext = os.path.splitext(file_path)[1].lower()
         if ext in [".md", ".html", ".txt", ".doc", ".pdf"]:
             return True
-            
+
         # Check model filter restrictions
         if self.index_model_filter and not self.index_model_filter.is_accessible(file_path):
             self.printer.print_in_terminal(
@@ -216,10 +220,10 @@ class IndexManager:
                 model_name=",".join(get_llm_names(self.index_llm))
             )
             return True
-            
+
         return False
 
-    def build_index_for_single_source(self, source: SourceCode):   
+    def build_index_for_single_source(self, source: SourceCode):
         if global_cancel.requested:
             return None
 
@@ -251,13 +255,13 @@ class IndexManager:
 
             start_time = time.monotonic()
             source_code = source.source_code
-            
+
             # 统计token和成本
             total_input_tokens = 0
             total_output_tokens = 0
             total_input_cost = 0.0
             total_output_cost = 0.0
-            
+
             if count_tokens(source.source_code) > self.args.conversation_prune_safe_zone_tokens:
                 self.printer.print_in_terminal(
                     "index_file_too_large",
@@ -276,34 +280,40 @@ class IndexManager:
                         self.index_llm).with_meta(meta_holder).run(source.module_name, chunk)
                     time.sleep(self.anti_quota_limit)
                     symbols.append(chunk_symbols)
-                    
+
                     if meta_holder.get_meta():
                         meta_dict = meta_holder.get_meta()
-                        total_input_tokens += meta_dict.get("input_tokens_count", 0)
-                        total_output_tokens += meta_dict.get("generated_tokens_count", 0)
-                        
+                        total_input_tokens += meta_dict.get(
+                            "input_tokens_count", 0)
+                        total_output_tokens += meta_dict.get(
+                            "generated_tokens_count", 0)
+
                 symbols = "\n".join(symbols)
             else:
                 meta_holder = byzerllm.MetaHolder()
                 symbols = self.get_all_file_symbols.with_llm(
                     self.index_llm).with_meta(meta_holder).run(source.module_name, source_code)
                 time.sleep(self.anti_quota_limit)
-                
+
                 if meta_holder.get_meta():
                     meta_dict = meta_holder.get_meta()
-                    total_input_tokens += meta_dict.get("input_tokens_count", 0)
-                    total_output_tokens += meta_dict.get("generated_tokens_count", 0)
-            
+                    total_input_tokens += meta_dict.get(
+                        "input_tokens_count", 0)
+                    total_output_tokens += meta_dict.get(
+                        "generated_tokens_count", 0)
+
             # 计算总成本
             for name in model_names:
                 info = model_info_map.get(name, {})
-                total_input_cost += (total_input_tokens * info.get("input_price", 0.0)) / 1000000
-                total_output_cost += (total_output_tokens * info.get("output_price", 0.0)) / 1000000
-            
+                total_input_cost += (total_input_tokens *
+                                     info.get("input_price", 0.0)) / 1000000
+                total_output_cost += (total_output_tokens *
+                                      info.get("output_price", 0.0)) / 1000000
+
             # 四舍五入到4位小数
             total_input_cost = round(total_input_cost, 4)
             total_output_cost = round(total_output_cost, 4)
-            
+
             self.printer.print_in_terminal(
                 "index_update_success",
                 style="green",
@@ -340,9 +350,44 @@ class IndexManager:
             "generated_tokens_cost": total_output_cost
         }
 
+    def parse_exclude_files(self, exclude_files):
+        if not exclude_files:
+            return []
+
+        if isinstance(exclude_files, str):
+            exclude_files = [exclude_files]
+
+        exclude_patterns = []
+        for pattern in exclude_files:
+            if pattern.startswith("regex://"):
+                pattern = pattern[8:]
+                exclude_patterns.append(re.compile(pattern))
+            elif pattern.startswith("human://"):
+                pattern = pattern[8:]
+                v = (
+                    self.generate_regex_pattern.with_llm(self.llm)
+                    .with_extractor(self.extract_regex_pattern)
+                    .run(desc=pattern)
+                )
+                if not v:
+                    raise ValueError(
+                        "Fail to generate regex pattern, try again.")
+                exclude_patterns.append(re.compile(v))
+            else:
+                raise ValueError(
+                    "Invalid exclude_files format. Expected 'regex://<pattern>' or 'human://<description>' "
+                )
+        return exclude_patterns
+
+    def filter_exclude_files(self, file_path, exclude_patterns):
+        for pattern in exclude_patterns:
+            if pattern.search(file_path):
+                return True
+        return False
+
     def build_index(self):
         if os.path.exists(self.index_file):
-            with open(self.index_file, "r",encoding="utf-8") as file:
+            with open(self.index_file, "r", encoding="utf-8") as file:
                 index_data = json.load(file)
         else:
             index_data = {}
@@ -351,14 +396,27 @@ class IndexManager:
         keys_to_remove = []
         for file_path in index_data:
             if not os.path.exists(file_path):
-                keys_to_remove.append(file_path)                
-        
+                keys_to_remove.append(file_path)
+
+        # 删除被排除的文件
+        try:
+            exclude_patterns = self.parse_exclude_files(self.args.exclude_files)
+            for file_path in index_data:
+                if self.filter_exclude_files(file_path, exclude_patterns):
+                    keys_to_remove.append(file_path)
+        except Exception as e:
+            self.printer.print_in_terminal(
+                "index_exclude_files_error",
+                style="red",
+                error=str(e)
+            )
+
         # 删除无效条目并记录日志
         for key in set(keys_to_remove):
             if key in index_data:
                 del index_data[key]
                 self.printer.print_in_terminal(
-                    "index_file_removed", 
+                    "index_file_removed",
                     style="yellow",
                     file_path=key
                 )
@@ -388,7 +446,7 @@ class IndexManager:
                     for line in v:
                         new_v.append(line[line.find(":"):])
                     source_code = "\n".join(new_v)
-                
+
                 md5 = hashlib.md5(source_code.encode("utf-8")).hexdigest()
                 if (
                     source.module_name not in index_data
@@ -397,7 +455,8 @@ class IndexManager:
                     wait_to_build_files.append(source)
 
             # Remove duplicates based on module_name
-            wait_to_build_files = list({source.module_name: source for source in wait_to_build_files}.values())
+            wait_to_build_files = list(
+                {source.module_name: source for source in wait_to_build_files}.values())
 
             counter = 0
             num_files = len(wait_to_build_files)
@@ -433,16 +492,17 @@ class IndexManager:
                     index_data[module_name] = result
                     updated_sources.append(module_name)
                     if len(updated_sources) > 5:
-                        with open(self.index_file, "w",encoding="utf-8") as file:
-                            json.dump(index_data, file, ensure_ascii=False, indent=2)
+                        with open(self.index_file, "w", encoding="utf-8") as file:
+                            json.dump(index_data, file,
+                                      ensure_ascii=False, indent=2)
                         updated_sources = []
-        
+
         # 如果 updated_sources 或 keys_to_remove 有值，则保存索引文件
         if updated_sources or keys_to_remove:
-            with open(self.index_file, "w",encoding="utf-8") as file:
+            with open(self.index_file, "w", encoding="utf-8") as file:
                 json.dump(index_data, file, ensure_ascii=False, indent=2)
 
-            print("")    
+            print("")
             self.printer.print_in_terminal(
                 "index_file_saved",
                 style="green",
@@ -461,14 +521,14 @@ class IndexManager:
         if not os.path.exists(self.index_file):
             return []
 
-        with open(self.index_file, "r",encoding="utf-8") as file:
+        with open(self.index_file, "r", encoding="utf-8") as file:
             return file.read()
 
     def read_index(self) -> List[IndexItem]:
         if not os.path.exists(self.index_file):
             return []
 
-        with open(self.index_file, "r",encoding="utf-8") as file:
+        with open(self.index_file, "r", encoding="utf-8") as file:
             index_data = json.load(file)
 
         index_items = []
@@ -572,7 +632,7 @@ class IndexManager:
             {file.file_path: file for file in all_results}.values())
         return FileList(file_list=all_results)
 
-    def _query_index_with_thread(self, query, func):        
+    def _query_index_with_thread(self, query, func):
         all_results = []
         lock = threading.Lock()
         completed_threads = 0
@@ -582,7 +642,7 @@ class IndexManager:
             nonlocal completed_threads
             result = self._get_target_files_by_query.with_llm(
                 self.llm).with_return_type(FileList).run(chunk, query)
-            
+
             if result is not None:
                 with lock:
                     all_results.extend(result.file_list)
@@ -708,4 +768,3 @@ class IndexManager:
 
         请确保结果的准确性和完整性，包括所有可能相关的文件。
         """
-

autocoder/utils/auto_project_type.py

@@ -0,0 +1,120 @@
+import os
+import json
+from collections import defaultdict
+from typing import Dict, List, Set, Tuple
+from pathlib import Path
+from loguru import logger
+import byzerllm
+from autocoder.common import AutoCoderArgs
+from autocoder.common.printer import Printer
+from typing import Union
+import pydantic
+from autocoder.common.result_manager import ResultManager
+
+class ExtensionClassifyResult(pydantic.BaseModel):
+    code: List[str] = []
+    config: List[str] = []
+    data: List[str] = []
+    document: List[str] = []
+    other: List[str] = []
+    framework: List[str] = []
+    
+class ProjectTypeAnalyzer:
+    def __init__(self, args: AutoCoderArgs, llm: Union[byzerllm.ByzerLLM, byzerllm.SimpleByzerLLM]):
+        self.args = args
+        self.llm = llm
+        self.printer = Printer()
+        self.default_exclude_dirs = [
+            ".git", ".svn", ".hg", "build", "dist", "__pycache__", 
+            "node_modules", ".auto-coder", ".vscode", ".idea", "venv",
+            ".next", ".nuxt", ".svelte-kit", "out", "cache", "logs",
+            "temp", "tmp", "coverage", ".DS_Store", "public", "static"
+        ]
+        self.extension_counts = defaultdict(int)
+        self.stats_file = Path(args.source_dir) / ".auto-coder" / "project_type_stats.json"
+        self.result_manager = ResultManager()
+
+    def traverse_project(self) -> None:
+        """遍历项目目录，统计文件后缀"""
+        for root, dirs, files in os.walk(self.args.source_dir):
+            # 过滤掉默认排除的目录
+            dirs[:] = [d for d in dirs if d not in self.default_exclude_dirs]
+            
+            for file in files:
+                _, ext = os.path.splitext(file)
+                if ext:  # 只统计有后缀的文件
+                    self.extension_counts[ext.lower()] += 1
+
+    def count_extensions(self) -> Dict[str, int]:
+        """返回文件后缀统计结果"""
+        return dict(sorted(self.extension_counts.items(), key=lambda x: x[1], reverse=True))
+
+    @byzerllm.prompt()
+    def classify_extensions(self, extensions: str) -> str:
+        """
+        根据文件后缀列表，将后缀分类为代码、配置、数据、文档等类型。
+
+        文件后缀列表：
+        {{ extensions }}
+
+        请返回如下JSON格式：
+        {
+            "code": ["后缀1", "后缀2"],
+            "config": ["后缀3", "后缀4"],
+            "data": ["后缀5", "后缀6"],
+            "document": ["后缀7", "后缀8"],
+            "other": ["后缀9", "后缀10"],
+            "framework": ["后缀11", "后缀12"]
+        }
+        """
+        return {
+            "extensions": extensions
+        }
+
+    def save_stats(self) -> None:
+        """保存统计结果到文件"""
+        stats = {
+            "extension_counts": self.extension_counts,
+            "project_type": self.detect_project_type()
+        }
+        
+        # 确保目录存在
+        self.stats_file.parent.mkdir(parents=True, exist_ok=True)
+        
+        with open(self.stats_file, "w", encoding="utf-8") as f:
+            json.dump(stats, f, indent=2)
+        
+        self.printer.print_in_terminal("stats_saved", path=str(self.stats_file))
+
+    def load_stats(self) -> Dict[str, any]:
+        """从文件加载统计结果"""
+        if not self.stats_file.exists():
+            self.printer.print_in_terminal("stats_not_found", path=str(self.stats_file))
+            return {}
+            
+        with open(self.stats_file, "r", encoding="utf-8") as f:
+            return json.load(f)
+
+    def detect_project_type(self) -> str:
+        """根据后缀统计结果推断项目类型"""
+        # 获取统计结果
+        ext_counts = self.count_extensions()        
+        # 将后缀分类
+        classification = self.classify_extensions.with_llm(self.llm).with_return_type(ExtensionClassifyResult).run(json.dumps(ext_counts,ensure_ascii=False))        
+        return ",".join(classification.code)
+
+    def analyze(self) -> Dict[str, any]:
+        """执行完整的项目类型分析流程"""
+        # 遍历项目目录
+        self.traverse_project()
+        
+        # 检测项目类型
+        project_type = self.detect_project_type()  
+
+        self.result_manager.add_result(content=project_type, meta={
+                    "action": "get_project_type",
+                    "input": {
+                       
+                    }
+                })      
+        return project_type

autocoder/utils/model_provider_selector.py

@@ -25,8 +25,8 @@ PROVIDER_INFO_LIST = [
     ProviderInfo(
         name="volcano",
         endpoint="https://ark.cn-beijing.volces.com/api/v3",   
-        r1_model="",
-        v3_model="",
+        r1_model="deepseek-r1-250120",
+        v3_model="deepseek-v3-241226",
         api_key="",
         r1_input_price=2.0,
         r1_output_price=8.0,
@@ -162,32 +162,32 @@ class ModelProviderSelector:
                 provider_info = provider
                 break
         
-        if result == "volcano":
-            # Get R1 endpoint
-            r1_endpoint = input_dialog(
-                title=self.printer.get_message_from_key("model_provider_api_key_title"),
-                text=self.printer.get_message_from_key("model_provider_volcano_r1_text"),
-                validator=VolcanoEndpointValidator(),
-                style=dialog_style
-            ).run()
+        # if result == "volcano":
+        #     # Get R1 endpoint
+        #     r1_endpoint = input_dialog(
+        #         title=self.printer.get_message_from_key("model_provider_api_key_title"),
+        #         text=self.printer.get_message_from_key("model_provider_volcano_r1_text"),
+        #         validator=VolcanoEndpointValidator(),
+        #         style=dialog_style
+        #     ).run()
             
-            if r1_endpoint is None:
-                return None
+        #     if r1_endpoint is None:
+        #         return None
             
-            provider_info.r1_model = r1_endpoint
+        #     provider_info.r1_model = r1_endpoint
             
-            # Get V3 endpoint
-            v3_endpoint = input_dialog(
-                title=self.printer.get_message_from_key("model_provider_api_key_title"),
-                text=self.printer.get_message_from_key("model_provider_volcano_v3_text"),
-                validator=VolcanoEndpointValidator(),
-                style=dialog_style
-            ).run()
+        #     # Get V3 endpoint
+        #     v3_endpoint = input_dialog(
+        #         title=self.printer.get_message_from_key("model_provider_api_key_title"),
+        #         text=self.printer.get_message_from_key("model_provider_volcano_v3_text"),
+        #         validator=VolcanoEndpointValidator(),
+        #         style=dialog_style
+        #     ).run()
             
-            if v3_endpoint is None:
-                return None
+        #     if v3_endpoint is None:
+        #         return None
                 
-            provider_info.v3_model = v3_endpoint
+        #     provider_info.v3_model = v3_endpoint
         
         # Get API key for all providers
         api_key = input_dialog(

autocoder/version.py

@@ -1 +1 @@
-__version__ = "0.1.267"
+__version__ = "0.1.269"