auto-coder 1.0.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

autocoder/utils/llms.py

@@ -1,32 +1,75 @@
 import byzerllm
-from typing import Union,Optional
+from typing import Union, Optional, List
 
-def get_llm_names(llm: Union[byzerllm.ByzerLLM, byzerllm.SimpleByzerLLM,str],target_model_type:Optional[str]=None):
-   if target_model_type is None:
-      if isinstance(llm,list):
-         return [_llm.default_model_name for _llm in llm]
-      return [llm.default_model_name for llm in [llm] if llm.default_model_name]
-   
-   llms = llm.get_sub_client(target_model_type) 
+# Import the new LLM module
+from autocoder.common.llms import LLMManager
+
+# Global LLM manager instance
+_llm_manager = None
+
+def _get_llm_manager() -> LLMManager:
+    """Get or create the global LLM manager instance"""
+    global _llm_manager
+    if _llm_manager is None:
+        _llm_manager = LLMManager()
+    return _llm_manager
+
+def get_llm_names(llm: Union[byzerllm.ByzerLLM, byzerllm.SimpleByzerLLM, str, List], 
+                  target_model_type: Optional[str] = None) -> List[str]:
+    """
+    Get LLM model names from various input types
+    
+    Args:
+        llm: LLM instance, model name string, or list of LLMs
+        target_model_type: Optional target model type filter
+        
+    Returns:
+        List of model names
+    """
+    if target_model_type is None:
+        if isinstance(llm, list):
+            return [_llm.default_model_name for _llm in llm if hasattr(_llm, 'default_model_name') and _llm.default_model_name]
+        elif isinstance(llm, str):
+            return llm.split(",") if llm else []
+        elif hasattr(llm, 'default_model_name') and llm.default_model_name:
+            return [llm.default_model_name]
+        else:
+            return []
    
-   if llms is None:
-      if isinstance(llm,list):
-         return [_llm.default_model_name for _llm in llm]
-      return [llm.default_model_name for llm in [llm] if llm.default_model_name]
-   elif isinstance(llms, list):
-       return [llm.default_model_name for llm in llms if llm.default_model_name]
-   elif isinstance(llms,str) and llms:
-      return llms.split(",")      
-   else:
-      return [llm.default_model_name for llm in [llms] if llm.default_model_name]
+    # Handle target_model_type case
+    if not isinstance(llm, (str, list)) and hasattr(llm, 'get_sub_client'):
+        llms = llm.get_sub_client(target_model_type)
+        
+        if llms is None:
+            if isinstance(llm, list):
+                return [_llm.default_model_name for _llm in llm if hasattr(_llm, 'default_model_name') and _llm.default_model_name]
+            elif hasattr(llm, 'default_model_name') and llm.default_model_name:
+                return [llm.default_model_name]
+            else:
+                return []
+        elif isinstance(llms, list):
+            return [_llm.default_model_name for _llm in llms if hasattr(_llm, 'default_model_name') and _llm.default_model_name]
+        elif isinstance(llms, str) and llms:
+            return llms.split(",")
+        elif hasattr(llms, 'default_model_name') and llms.default_model_name:
+            return [llms.default_model_name]
+        else:
+            return []
+    
+    return []
 
-def get_model_info(model_names: str, product_mode: str):    
-    from autocoder import models as models_module
-    def get_model_by_name(model_name: str):
-        try:
-            return models_module.get_model_by_name(model_name)
-        except Exception as e:
-            return None
+def get_model_info(model_names: str, product_mode: str):
+    """
+    Get model information using the new LLM module
+    
+    Args:
+        model_names: Comma-separated model names or single model name
+        product_mode: Product mode ("pro" or "lite")
+        
+    Returns:
+        Model info dictionary or None
+    """
+    manager = _get_llm_manager()
     
     if product_mode == "pro":
         return None
@@ -34,62 +77,27 @@ def get_model_info(model_names: str, product_mode: str):
     if product_mode == "lite":
         if "," in model_names:
             # Multiple code models specified
-            model_names = model_names.split(",")
-            for _, model_name in enumerate(model_names):
-                return get_model_by_name(model_name)
+            names = model_names.split(",")
+            for model_name in names:
+                model_name = model_name.strip()
+                model_info = manager.get_model_info(model_name, product_mode)
+                if model_info:
+                    return model_info
+            return None
         else:
             # Single code model
-            return get_model_by_name(model_names)
+            return manager.get_model_info(model_names.strip(), product_mode)
 
 def get_single_llm(model_names: str, product_mode: str):
-    from autocoder import models as models_module
-    if product_mode == "pro":
-        if "," in model_names:
-            # Multiple code models specified
-            model_names = model_names.split(",")
-            for _, model_name in enumerate(model_names):
-                return byzerllm.ByzerLLM.from_default_model(model_name)
-        else:
-            # Single code model
-            return byzerllm.ByzerLLM.from_default_model(model_names)
-
-    if product_mode == "lite":
-        if "," in model_names:
-            # Multiple code models specified
-            model_names = model_names.split(",")            
-            for _, model_name in enumerate(model_names):
-                model_name = model_name.strip()
-                model_info = models_module.get_model_by_name(model_name)
-                target_llm = byzerllm.SimpleByzerLLM(default_model_name=model_name)
-                target_llm.deploy(
-                    model_path="",
-                    pretrained_model_type=model_info["model_type"],
-                    udf_name=model_name,
-                    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)
-                    }
-                )
-                return target_llm
-            
-        else:
-            # Single code model
-            model_info = models_module.get_model_by_name(model_names)
-            model_name = model_names
-            target_llm = byzerllm.SimpleByzerLLM(default_model_name=model_name)
-            target_llm.deploy(
-                model_path="",
-                pretrained_model_type=model_info["model_type"],
-                udf_name=model_name,
-                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)
-                }
-            )
-            return target_llm
+    """
+    Get a single LLM instance using the new LLM module
+    
+    Args:
+        model_names: Comma-separated model names or single model name
+        product_mode: Product mode ("pro" or "lite")
+        
+    Returns:
+        LLM instance or None
+    """
+    manager = _get_llm_manager()
+    return manager.get_single_llm(model_names, product_mode)

autocoder/utils/math_utils.py

@@ -0,0 +1,101 @@
+"""
+简单的数学工具函数模块
+
+提供基础的数学计算功能，包括：
+- 计算两个数字的和
+- 计算数字的平方
+- 判断是否为偶数
+- 计算阶乘
+"""
+
+from typing import Union
+
+
+def add_numbers(a: Union[int, float], b: Union[int, float]) -> Union[int, float]:
+    """
+    计算两个数字的和
+    
+    Args:
+        a: 第一个数字
+        b: 第二个数字
+        
+    Returns:
+        两个数字的和
+        
+    Examples:
+        >>> add_numbers(2, 3)
+        5
+        >>> add_numbers(2.5, 3.7)
+        6.2
+    """
+    return a + b
+
+
+def square(x: Union[int, float]) -> Union[int, float]:
+    """
+    计算数字的平方
+    
+    Args:
+        x: 要计算平方的数字
+        
+    Returns:
+        x 的平方值
+        
+    Examples:
+        >>> square(4)
+        16
+        >>> square(2.5)
+        6.25
+    """
+    return x * x
+
+
+def is_even(n: int) -> bool:
+    """
+    判断一个整数是否为偶数
+    
+    Args:
+        n: 要判断的整数
+        
+    Returns:
+        如果是偶数返回 True，否则返回 False
+        
+    Examples:
+        >>> is_even(4)
+        True
+        >>> is_even(5)
+        False
+    """
+    return n % 2 == 0
+
+
+def factorial(n: int) -> int:
+    """
+    计算正整数的阶乘
+    
+    Args:
+        n: 要计算阶乘的正整数
+        
+    Returns:
+        n 的阶乘值
+        
+    Raises:
+        ValueError: 当 n 为负数时抛出异常
+        
+    Examples:
+        >>> factorial(5)
+        120
+        >>> factorial(0)
+        1
+    """
+    if n < 0:
+        raise ValueError("阶乘只能计算非负整数")
+    
+    if n == 0 or n == 1:
+        return 1
+    
+    result = 1
+    for i in range(2, n + 1):
+        result *= i
+    
+    return result

autocoder/utils/model_provider_selector.py

@@ -7,7 +7,7 @@ from autocoder.common.printer import Printer
 import re
 from pydantic import BaseModel
 
-from autocoder.models import process_api_key_path
+from autocoder.common.llms import LLMManager
 
 class ProviderInfo(BaseModel):
     name: str
@@ -97,6 +97,7 @@ class ModelProviderSelector:
     def __init__(self):
         self.printer = Printer()
         self.console = Console()
+        self.llm_manager = LLMManager()
 
     def to_models_json(self, provider_info: ProviderInfo) -> List[Dict[str, Any]]:
         """
@@ -124,7 +125,9 @@ class ModelProviderSelector:
                 "is_reasoning": True,
                 "input_price": provider_info.r1_input_price,
                 "output_price": provider_info.r1_output_price,
-                "average_speed": 0.0
+                "average_speed": 0.0,
+                "context_window": 32768,
+                "max_output_tokens": 8096
             })
             
         # Add V3 model (for coding)
@@ -140,7 +143,9 @@ class ModelProviderSelector:
                 "is_reasoning": False,
                 "input_price": provider_info.v3_input_price,
                 "output_price": provider_info.v3_output_price,
-                "average_speed": 0.0
+                "average_speed": 0.0,
+                "context_window": 32768,
+                "max_output_tokens": 8096
             })
             
         return models
@@ -174,6 +179,9 @@ class ModelProviderSelector:
                 provider_info = provider
                 break
         
+        if provider_info is None:
+            return None
+        
         # if result == "volcano":
         #     # Get R1 endpoint
         #     r1_endpoint = input_dialog(
@@ -214,6 +222,10 @@ class ModelProviderSelector:
             
         provider_info.api_key = api_key
         
+        # 使用新的 LLMManager 添加模型
+        models_to_add = self.to_models_json(provider_info)
+        self.llm_manager.add_models(models_to_add)  # type: ignore
+        
         self.printer.print_panel(
             self.printer.get_message_from_key("model_provider_selected"),
             text_options={"justify": "left"},
@@ -223,4 +235,4 @@ class ModelProviderSelector:
             }
         )
         
-        return provider_info
+        return provider_info.dict()

autocoder/utils/operate_config_api.py

@@ -3,6 +3,7 @@ import os
 import uuid
 import byzerllm
 from autocoder.common import AutoCoderArgs
+from autocoder.common.autocoderargs_parser import AutoCoderArgsParser
 from typing import List, Optional
 import yaml
 from autocoder.auto_coder import AutoCoderArgs, load_include_files, Template
@@ -58,14 +59,41 @@ def get_llm_friendly_package_docs(memory,
 
 
 def convert_config_value(key, value):
+    # 定义需要使用 token 解析的字段
+    token_fields = {
+        'conversation_prune_safe_zone_tokens',
+        'context_prune_safe_zone_tokens',
+        'context_prune_sliding_window_size',
+        'context_prune_sliding_window_overlap',
+        'rag_params_max_tokens',
+        'rag_context_window_limit',
+        'rag_duckdb_vector_dim',
+        'rag_duckdb_query_top_k',
+        'rag_emb_dim',
+        'rag_emb_text_size',
+        'hybrid_index_max_output_tokens',
+        'data_cells_max_num',
+    }
+    
     field_info = AutoCoderArgs.model_fields.get(key)
     if field_info:
-        if value.lower() in ["true", "false"]:
+        # 对于需要 token 解析的字段，使用 AutoCoderArgsParser
+        if key in token_fields:
+            try:
+                parser = AutoCoderArgsParser()
+                return parser.parse_token_field(key, value)
+            except Exception as e:
+                print(f"Warning: Failed to parse token field '{key}' with value '{value}': {e}")
+                # 如果解析失败，fallback 到原有逻辑
+                pass
+        
+        # 原有的类型转换逻辑
+        if isinstance(value, str) and value.lower() in ["true", "false"]:
             return value.lower() == "true"
-        elif "int" in str(field_info.annotation):
-            return int(value)
         elif "float" in str(field_info.annotation):
-            return float(value)
+            return float(value)    
+        elif "int" in str(field_info.annotation):
+            return int(value)        
         else:
             return value
     else:
@@ -90,7 +118,7 @@ def get_llm(memory, model:Optional[str]=None):
                 "skip_build_index": conf.get("skip_build_index", "true") == "true",
                 "skip_confirm": conf.get("skip_confirm", "true") == "true",
                 "silence": conf.get("silence", "true") == "true",
-                "include_project_structure": conf.get("include_project_structure", "true")
+                "include_project_structure": conf.get("include_project_structure", "false")
                 == "true",
             }
             for key, value in conf.items():

autocoder/utils/thread_utils.py

@@ -1,5 +1,5 @@
 from functools import wraps
-from typing import Any, Optional, Dict, Callable
+from typing import Any, Optional, Dict, Callable, List
 import threading
 import time
 from autocoder.common.global_cancel import global_cancel, CancelRequestedException
@@ -36,7 +36,7 @@ def run_in_raw_thread(token: Optional[str] = None, context: Optional[Dict[str, A
         def wrapper(*args, **kwargs):
             # Store thread results
             result = []
-            exception_raised = [None]  # 存储工作线程中的异常            
+            exception_raised: List[Optional[Exception]] = [None]  # 存储工作线程中的异常
             thread_terminated = threading.Event()  # 用于标记线程是否已终止
             
             def worker():

autocoder/version.py

@@ -1,2 +1,4 @@
-__version__ = "1.0.0"
-
+# This file is auto-generated by Hatchling. As such, do not:
+#   - modify
+#   - track in version control e.g. be sure to add to .gitignore
+__version__ = '2.0.0'

autocoder/workflow_agents/__init__.py

@@ -0,0 +1,84 @@
+"""
+Workflow Agents - 子代理编排系统
+
+提供基于 YAML 配置的多子代理编排功能，支持：
+- DAG 拓扑顺序执行
+- 条件判断（正则/JSONPath）
+- 输出映射与跨步骤数据传递
+- 会话共享策略
+- 基于 SdkRunner/TerminalRunner 的代理执行
+"""
+
+from autocoder.workflow_agents.types import (
+    WorkflowSpec,
+    GlobalsConfig,
+    ConversationConfig,
+    AttemptConfig,
+    AgentSpec,
+    StepSpec,
+    WhenConfig,
+    OutputConfig,
+    StepResult,
+    StepStatus,
+    WorkflowResult,
+)
+from autocoder.workflow_agents.agent import WorkflowSubAgent
+from autocoder.workflow_agents.executor import SubagentWorkflowExecutor
+from autocoder.workflow_agents.loader import load_workflow_from_yaml
+from autocoder.workflow_agents.runner import (
+    run_workflow_from_yaml,
+    print_workflow_result,
+    list_available_workflows,
+)
+from autocoder.workflow_agents.workflow_manager import WorkflowManager
+from autocoder.workflow_agents.exceptions import (
+    WorkflowError,
+    WorkflowValidationError,
+    WorkflowFileNotFoundError,
+    WorkflowParseError,
+    WorkflowStepError,
+    WorkflowDependencyError,
+    WorkflowAgentNotFoundError,
+    WorkflowTemplateError,
+    WorkflowAgentDefinitionError,
+    WorkflowConversationError,
+    WorkflowConditionError,
+    WorkflowOutputExtractionError,
+)
+
+__all__ = [
+    # 类型定义
+    "WorkflowSpec",
+    "GlobalsConfig",
+    "ConversationConfig",
+    "AttemptConfig",
+    "AgentSpec",
+    "StepSpec",
+    "WhenConfig",
+    "OutputConfig",
+    "StepResult",
+    "StepStatus",
+    "WorkflowResult",
+    # 核心类
+    "WorkflowSubAgent",
+    "SubagentWorkflowExecutor",
+    "WorkflowManager",
+    # 加载器和运行器
+    "load_workflow_from_yaml",
+    "run_workflow_from_yaml",
+    "print_workflow_result",
+    "list_available_workflows",
+    # 异常类
+    "WorkflowError",
+    "WorkflowValidationError",
+    "WorkflowFileNotFoundError",
+    "WorkflowParseError",
+    "WorkflowStepError",
+    "WorkflowDependencyError",
+    "WorkflowAgentNotFoundError",
+    "WorkflowTemplateError",
+    "WorkflowAgentDefinitionError",
+    "WorkflowConversationError",
+    "WorkflowConditionError",
+    "WorkflowOutputExtractionError",
+]

autocoder/workflow_agents/agent.py

@@ -0,0 +1,143 @@
+"""
+Workflow Sub-Agent 实现
+
+提供基于 SdkRunner 和 TerminalRunner 的子代理执行能力。
+"""
+
+from typing import Optional, Union, Any
+from copy import deepcopy
+from loguru import logger
+
+from autocoder.common.v2.agent.agentic_edit import AgenticEditRequest
+from autocoder.common.v2.agent.agentic_edit_types import (
+    AgenticEditConversationConfig,
+    CompletionEvent,
+    AttemptCompletionTool,
+)
+from autocoder.common.v2.agent.runner import SdkRunner, TerminalRunner
+from autocoder.common import AutoCoderArgs
+from autocoder.inner.agentic import RunAgentic
+
+
+class WorkflowSubAgent:
+    """
+    Workflow 子代理
+
+    每个子代理对应一个特定的 agent 配置，支持使用 SdkRunner 或 TerminalRunner 执行用户输入。
+    """
+
+    def __init__(
+        self,
+        agent_id: str,
+        model: Optional[str],
+        system_prompt: Optional[str],
+        retry: int,
+        timeout_sec: int,
+        runner_type: str = "sdk",
+        include_rules: bool = False,
+    ) -> None:
+        """
+        初始化子代理
+
+        Args:
+            agent_id: 代理 ID
+            model: 模型名称（可选，使用全局默认）
+            system_prompt: 系统提示词
+            retry: 重试次数
+            timeout_sec: 超时时间（秒）
+            runner_type: 运行器类型（sdk | terminal）
+            include_rules: 是否包含规则上下文
+        """
+        self.agent_id = agent_id
+        self.model = model
+        self.system_prompt = system_prompt
+        self.retry = retry
+        self.timeout_sec = timeout_sec
+        self.runner_type = runner_type
+        self.include_rules = include_rules
+
+    def run(
+        self,
+        user_input: str,
+        conversation_config: Optional[AgenticEditConversationConfig],
+        args: AutoCoderArgs,
+        llm: Any,
+        cancel_token: Optional[str] = None,
+    ) -> Optional[AttemptCompletionTool]:
+        """
+        运行子代理
+
+        Args:
+            user_input: 用户输入
+            conversation_config: 会话配置
+            args: AutoCoderArgs 配置
+            llm: LLM 实例
+            cancel_token: 取消令牌，用于支持任务取消
+
+        Returns:
+            AttemptCompletionTool 对象（两种 Runner 返回统一接口）
+            如果失败则返回 None
+        """
+        try:
+            # 深拷贝 args 避免修改原始对象
+            agent_args = deepcopy(args)
+
+            # 配置模型
+            if self.model:
+                agent_args.code_model = self.model
+                agent_args.model = self.model
+
+            # 配置 include_rules
+            if hasattr(agent_args, "skip_build_index"):
+                # 如果 include_rules 为 True，需要确保不跳过索引构建
+                if self.include_rules:
+                    agent_args.skip_build_index = False
+                    agent_args.skip_filter_index = False
+                    logger.debug(
+                        f"代理 {self.agent_id} 启用规则上下文，skip_build_index=False"
+                    )
+                else:
+                    # 保持默认行为
+                    pass
+
+            # 根据 runner_type 选择不同的 runner
+            if self.runner_type == "terminal":                                
+                # 使用 TerminalRunner
+                runner = TerminalRunner(
+                    llm=llm,
+                    args=agent_args,
+                    conversation_config=conversation_config,
+                    cancel_token=cancel_token,
+                    system_prompt=self.system_prompt,
+                )
+
+                # TerminalRunner.run() 直接返回 attempt_result 字符串
+                attempt_result = runner.run(AgenticEditRequest(user_input=user_input))
+
+                # 为了统一接口，将字符串包装为 AttemptCompletionTool 对象
+                return AttemptCompletionTool(result=attempt_result, command=None)
+
+            else:
+                # 使用 SdkRunner（默认）
+                runner = SdkRunner(
+                    llm=llm,
+                    args=agent_args,
+                    conversation_config=conversation_config,
+                    cancel_token=cancel_token,
+                    system_prompt=self.system_prompt,
+                )
+
+                # 执行并监听事件
+                attempt_completion = None
+                events = runner.run(AgenticEditRequest(user_input=user_input))
+
+                for event in events:
+                    if isinstance(event, CompletionEvent):
+                        attempt_completion = event.completion
+                        break
+
+                return attempt_completion
+
+        except Exception as e:
+            logger.error(f"WorkflowSubAgent {self.agent_id} 运行失败: {str(e)}")
+            return None