jarvis-ai-assistant 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

jarvis/__init__.py

@@ -1,3 +1,3 @@
 """Jarvis AI Assistant"""
 
-__version__ = "0.1.9" 
+__version__ = "0.1.11" 

jarvis/agent.py

@@ -11,7 +11,7 @@ import os
 from datetime import datetime
 
 class Agent:
-    def __init__(self, model: BaseModel, tool_registry: ToolRegistry, name: str = "Jarvis", is_sub_agent: bool = False):
+    def __init__(self, model: BaseModel, tool_registry: ToolRegistry, name: str = "Jarvis"):
         """Initialize Agent with a model, optional tool registry and name
         
         Args:
@@ -23,29 +23,88 @@ class Agent:
         self.model = model
         self.tool_registry = tool_registry or ToolRegistry(model)
         self.name = name
-        self.is_sub_agent = is_sub_agent
+        self.prompt = ""
+
+
+    @staticmethod
+    def extract_tool_calls(content: str) -> List[Dict]:
+        """从内容中提取工具调用，如果检测到多个工具调用则抛出异常，并返回工具调用之前的内容和工具调用"""
+        # 分割内容为行
+        lines = content.split('\n')
+        tool_call_lines = []
+        in_tool_call = False
+        
+        # 逐行处理
+        for line in lines:
+            if '<START_TOOL_CALL>' in line:
+                in_tool_call = True
+                continue
+            elif '<END_TOOL_CALL>' in line:
+                if in_tool_call and tool_call_lines:
+                    try:
+                        # 直接解析YAML
+                        tool_call_text = '\n'.join(tool_call_lines)
+                        tool_call_data = yaml.safe_load(tool_call_text)
+                        
+                        # 验证必要的字段
+                        if "name" in tool_call_data and "arguments" in tool_call_data:
+                            # 返回工具调用之前的内容和工具调用
+                            return [{
+                                "name": tool_call_data["name"],
+                                "arguments": tool_call_data["arguments"]
+                            }]
+                        else:
+                            PrettyOutput.print("工具调用缺少必要字段", OutputType.ERROR)
+                            raise '工具调用缺少必要字段'
+                    except yaml.YAMLError as e:
+                        PrettyOutput.print(f"YAML解析错误: {str(e)}", OutputType.ERROR)
+                        raise 'YAML解析错误'
+                    except Exception as e:
+                        PrettyOutput.print(f"处理工具调用时发生错误: {str(e)}", OutputType.ERROR)
+                        raise '处理工具调用时发生错误'
+                in_tool_call = False
+                continue
+            
+            if in_tool_call:
+                tool_call_lines.append(line)
+        
+        return []
+
+    def _call_model(self, message: str) -> str:
+        """调用模型获取响应"""
+        try:
+            return self.model.chat(message)
+        except Exception as e:
+            raise Exception(f"{self.name}: 模型调用失败: {str(e)}")
+
+    def run(self, user_input: str, file_list: Optional[List[str]] = None):
+        """处理用户输入并返回响应，返回任务总结报告
+        
+        Args:
+            user_input: 用户输入的任务描述
+            file_list: 可选的文件列表，默认为None
+        
+        Returns:
+            str: 任务总结报告
+        """
+        self.clear_history()
+        
+        if file_list:
+            self.model.upload_files(file_list)
+        
+        # 显示任务开始
+        PrettyOutput.section(f"开始新任务: {self.name}", OutputType.PLANNING)
 
-        # 构建工具说明
         tools_prompt = "可用工具:\n"
         for tool in self.tool_registry.get_all_tools():
             tools_prompt += f"- 名称: {tool['name']}\n"
             tools_prompt += f"  描述: {tool['description']}\n"
             tools_prompt += f"  参数: {tool['parameters']}\n"
 
-        self.messages = [
-            {
-                "role": "system",
-                "content": f"""你是 {name}，一个严格遵循 ReAct 框架进行逐步推理和行动的 AI 助手。
+        self.prompt =f"""你是 {self.name}，一个严格遵循 ReAct 框架进行逐步推理和行动的 AI 助手。
 
 {tools_prompt}
 
-关键规则：
-‼️ 禁止创建虚假对话
-‼️ 禁止假设用户回应
-‼️ 禁止在没有实际用户输入时继续
-‼️ 只回应用户实际说的内容
-‼️ 每个动作后停止并等待
-
 ReAct 框架：
 1. 思考
    - 分析当前情况
@@ -62,7 +121,7 @@ ReAct 框架：
      - 只使用下面列出的工具
      - 每次只执行一个工具
      - 工具由用户手动执行
-     - 必须使用有效的YAML格式：
+     - 必须使用有效合法的YAML格式：
      <START_TOOL_CALL>
      name: tool_name
      arguments:
@@ -103,7 +162,6 @@ arguments:
 ‼️ 工具调用必须是有效的YAML格式
 ‼️ 参数必须正确缩进
 ‼️ 使用YAML块样式(|)表示多行值
-‼️ <END_TOOL_CALL>后的内容将被丢弃
 ‼️ 工具由用户手动执行
 ‼️ 等待用户提供工具执行结果
 ‼️ 不要假设或想象用户回应
@@ -125,174 +183,59 @@ arguments:
 - 不要虚构对话
 - 每个动作后停止
 - 只在有实际用户输入时继续
-"""
-            }
-        ]
 
-    @staticmethod
-    def extract_tool_calls(content: str) -> Tuple[str, List[Dict]]:
-        """从内容中提取工具调用，如果检测到多个工具调用则抛出异常，并返回工具调用之前的内容和工具调用"""
-        # 分割内容为行
-        lines = content.split('\n')
-        tool_call_lines = []
-        content_lines = []  # 存储工具调用之前的内容
-        in_tool_call = False
-        
-        # 逐行处理
-        for line in lines:
-            content_lines.append(line)  # 所有内容都添加到 content_lines
-            
-            if '<START_TOOL_CALL>' in line:
-                in_tool_call = True
-                continue
-            elif '<END_TOOL_CALL>' in line:
-                if in_tool_call and tool_call_lines:
-                    try:
-                        # 直接解析YAML
-                        tool_call_text = '\n'.join(tool_call_lines)
-                        tool_call_data = yaml.safe_load(tool_call_text)
-                        
-                        # 验证必要的字段
-                        if "name" in tool_call_data and "arguments" in tool_call_data:
-                            # 返回工具调用之前的内容和工具调用
-                            return '\n'.join(content_lines), [{
-                                "name": tool_call_data["name"],
-                                "arguments": tool_call_data["arguments"]
-                            }]
-                        else:
-                            PrettyOutput.print("工具调用缺少必要字段", OutputType.ERROR)
-                            raise '工具调用缺少必要字段'
-                    except yaml.YAMLError as e:
-                        PrettyOutput.print(f"YAML解析错误: {str(e)}", OutputType.ERROR)
-                        raise 'YAML解析错误'
-                    except Exception as e:
-                        PrettyOutput.print(f"处理工具调用时发生错误: {str(e)}", OutputType.ERROR)
-                        raise '处理工具调用时发生错误'
-                in_tool_call = False
-                continue
+任务:
+{user_input}
+"""
             
-            if in_tool_call:
-                tool_call_lines.append(line)
-        
-        # 如果没有找到有效的工具调用，返回原始内容
-        return '\n'.join(content_lines), []
-
-    def _call_model(self, messages: List[Dict]) -> Dict:
-        """调用模型获取响应"""
-        try:
-            return self.model.chat(
-                messages=messages,
-            )
-        except Exception as e:
-            raise Exception(f"{self.name}: 模型调用失败: {str(e)}")
-
-    def run(self, user_input: str) -> str:
-        """处理用户输入并返回响应，返回任务总结报告"""
-        self.clear_history()
-        
-        # 显示任务开始
-        PrettyOutput.section(f"开始新任务: {self.name}", OutputType.PLANNING)
-        
-        self.messages.append({
-            "role": "user",
-            "content": user_input
-        })
         
         while True:
             try:
                 # 显示思考状态
                 PrettyOutput.print("分析任务...", OutputType.PROGRESS)
                 
-                current_response = self._call_model(self.messages)
+                current_response = self._call_model(self.prompt)
 
                 try:
                     result = Agent.extract_tool_calls(current_response)
                 except Exception as e:
                     PrettyOutput.print(f"工具调用错误: {str(e)}", OutputType.ERROR)
-                    self.messages.append({
-                        "role": "user",
-                        "content": f"工具调用错误: {str(e)}"
-                    })
+                    self.prompt = f"工具调用错误: {str(e)}"
                     continue
-
-
-                self.messages.append({
-                    "role": "assistant",
-                    "content": result[0]
-                })
-
                 
-                if len(result[1]) > 0:
+                if len(result) > 0:
                     try:
                         # 显示工具调用
                         PrettyOutput.print("执行工具调用...", OutputType.PROGRESS)
-                        tool_result = self.tool_registry.handle_tool_calls(result[1])
+                        tool_result = self.tool_registry.handle_tool_calls(result)
                         PrettyOutput.print(tool_result, OutputType.RESULT)
                     except Exception as e:
                         PrettyOutput.print(str(e), OutputType.ERROR)
                         tool_result = f"Tool call failed: {str(e)}"
 
-                    self.messages.append({
-                        "role": "user",
-                        "content": tool_result
-                    })
+                    self.prompt = tool_result
                     continue
                 
                 # 获取用户输入
                 user_input = get_multiline_input(f"{self.name}: 您可以继续输入，或输入空行结束当前任务")
-                if not user_input:
-                    # 只有子Agent才需要生成任务总结
-                    if self.is_sub_agent:
-                        PrettyOutput.print("生成任务总结...", OutputType.PROGRESS)
-                        
-                        # 生成任务总结
-                        summary_prompt = {
-                            "role": "user",
-                            "content": """任务已完成。请根据之前的分析和执行结果，提供一个简明的任务总结，包括：
-
-1. 关键发现：
-   - 分析过程中的重要发现
-   - 工具执行的关键结果
-   - 发现的重要数据
-
-2. 执行成果：
-   - 任务完成情况
-   - 具体实现结果
-   - 达成的目标
-
-请直接描述事实和实际结果，保持简洁明了。"""
-                        }
-                        
-                        while True:
-                            try:
-                                summary = self._call_model(self.messages + [summary_prompt])
-                                 
-                                # 显示任务总结
-                                PrettyOutput.section("任务总结", OutputType.SUCCESS)
-                                PrettyOutput.print(summary, OutputType.SYSTEM)
-                                PrettyOutput.section("任务完成", OutputType.SUCCESS)
-                                
-                                return summary
-                                
-                            except Exception as e:
-                                PrettyOutput.print(str(e), OutputType.ERROR)
-                    else:
-                        # 顶层Agent直接返回空字符串
-                        PrettyOutput.section("任务完成", OutputType.SUCCESS)
-                        return ""
-                
                 if user_input == "__interrupt__":
                     PrettyOutput.print("任务已取消", OutputType.WARNING)
                     return "Task cancelled by user"
+                if user_input:
+                    self.prompt = user_input
+                    continue
+                
+                if not user_input:
+                        PrettyOutput.section("任务完成", OutputType.SUCCESS)
+                        return 
+                
+
                 
-                self.messages.append({
-                    "role": "user",
-                    "content": user_input
-                })
                 
             except Exception as e:
                 PrettyOutput.print(str(e), OutputType.ERROR)
 
     def clear_history(self):
         """清除对话历史，只保留系统提示"""
-        self.messages = [self.messages[0]] 
+        self.prompt = "" 
+        self.model.reset()

jarvis/main.py

@@ -12,33 +12,9 @@ sys.path.insert(0, str(Path(__file__).parent.parent))
 
 from jarvis.agent import Agent
 from jarvis.tools import ToolRegistry
-from jarvis.models import DDGSModel, OllamaModel, OpenAIModel
+from jarvis.models import KimiModel
 from jarvis.utils import PrettyOutput, OutputType, get_multiline_input, load_env_from_file
-from jarvis.zte_llm import create_zte_llm
 
-# 定义支持的平台和模型
-SUPPORTED_PLATFORMS = {
-    "ollama": {
-        "models": ["qwen2.5:14b", "qwq"],
-        "default": "qwen2.5:14b",
-        "allow_custom": True
-    },
-    "ddgs": {
-        "models": ["gpt-4o-mini", "claude-3-haiku", "llama-3.1-70b", "mixtral-8x7b"],
-        "default": "gpt-4o-mini",
-        "allow_custom": False
-    },
-    "zte": {
-        "models": ["NebulaBiz", "nebulacoder", "NTele-72B"],
-        "default": "NebulaBiz",
-        "allow_custom": False
-    },
-    "openai": {
-        "models": ["deepseek-chat"],
-        "default": "deepseek-chat",
-        "allow_custom": True
-    }
-}
 
 def load_tasks() -> dict:
     """Load tasks from .jarvis file if it exists."""
@@ -96,77 +72,26 @@ def select_task(tasks: dict) -> str:
 
 def main():
     """Main entry point for Jarvis."""
-
-    load_env_from_file()
-
-    parser = argparse.ArgumentParser(description="Jarvis AI Assistant")
-    
-    # 添加平台选择参数
-    parser.add_argument(
-        "--platform",
-        choices=list(SUPPORTED_PLATFORMS.keys()),
-        default=os.getenv("JARVIS_PLATFORM") or "ddgs",
-        help="选择运行平台 (默认: ollama)"
-    )
-    
-    # 添加模型选择参数
-    parser.add_argument(
-        "--model",
-        help="选择模型 (默认: 根据平台自动选择)"
-    )
-    
-    # 添加API基础URL参数
-    parser.add_argument(
-        "--api-base",
-        default=os.getenv("JARVIS_OLLAMA_API_BASE") or "http://localhost:11434",
-        help="Ollama API基础URL (仅用于Ollama平台, 默认: http://localhost:11434)"
-    )
-    
+    # Add argument parser
+    parser = argparse.ArgumentParser(description='Jarvis AI Assistant')
+    parser.add_argument('-f', '--files', nargs='*', help='List of files to process')
     args = parser.parse_args()
 
-    args.model = args.model or os.getenv("JARVIS_MODEL")
+    load_env_from_file()
     
-    # 修改模型验证逻辑
-    if args.model:
-        if (args.model not in SUPPORTED_PLATFORMS[args.platform]["models"] and 
-            not SUPPORTED_PLATFORMS[args.platform]["allow_custom"]):
-            supported_models = ", ".join(SUPPORTED_PLATFORMS[args.platform]["models"])
-            PrettyOutput.print(
-                f"错误: 平台 {args.platform} 不支持模型 {args.model}\n"
-                f"支持的模型: {supported_models}",
-                OutputType.ERROR
-            )
-            return 1
-    else:
-        args.model = SUPPORTED_PLATFORMS[args.platform]["default"]
-
     try:
-        # 根据平台创建相应的模型实例
-        if args.platform == "ollama":
-            model = OllamaModel(
-                model_name=args.model,
-                api_base=args.api_base
-            )
-            platform_name = f"Ollama ({args.model})"
-        elif args.platform == "ddgs":  # ddgs
-            model = DDGSModel(model_name=args.model)
-            platform_name = f"DuckDuckGo Search ({args.model})"
-        elif args.platform == "zte":  # zte
-            model = create_zte_llm(model_name=args.model)
-            platform_name = f"ZTE ({args.model})"
-        elif args.platform == "openai":
-            model = OpenAIModel(
-                model_name=args.model,
-                api_key=os.getenv("OPENAI_API_KEY"),
-                api_base=os.getenv("OPENAI_API_BASE")
-            )
-            platform_name = f"OpenAI ({args.model})"
+        kimi_api_key = os.getenv("KIMI_API_KEY")
+        if not kimi_api_key:
+            PrettyOutput.print("Kimi API key 未设置", OutputType.ERROR)
+            return 1
+        
+        model = KimiModel(kimi_api_key)
 
         tool_registry = ToolRegistry(model)
         agent = Agent(model, tool_registry)
 
         # 欢迎信息
-        PrettyOutput.print(f"Jarvis 已初始化 - {platform_name}", OutputType.SYSTEM)
+        PrettyOutput.print(f"Jarvis 已初始化 - With Kimi", OutputType.SYSTEM)
         
         # 加载预定义任务
         tasks = load_tasks()
@@ -174,7 +99,7 @@ def main():
             selected_task = select_task(tasks)
             if selected_task:
                 PrettyOutput.print(f"\n执行任务: {selected_task}", OutputType.INFO)
-                agent.run(selected_task)
+                agent.run(selected_task, args.files)
                 return 0
         
         # 如果没有选择预定义任务，进入交互模式
@@ -183,7 +108,7 @@ def main():
                 user_input = get_multiline_input("请输入您的任务(输入空行退出):")
                 if not user_input or user_input == "__interrupt__":
                     break
-                agent.run(user_input)
+                agent.run(user_input, args.files)
             except Exception as e:
                 PrettyOutput.print(f"错误: {str(e)}", OutputType.ERROR)
 

jarvis/models/__init__.py

@@ -0,0 +1,11 @@
+from typing import Dict, List, Optional, Tuple
+from duckduckgo_search import DDGS
+import ollama
+import yaml
+import openai
+
+from ..utils import OutputType, PrettyOutput
+from .base import BaseModel
+from .kimi import KimiModel
+
+__all__ = ['BaseModel', 'KimiModel'] 

jarvis/models/base.py

@@ -0,0 +1,19 @@
+from abc import ABC, abstractmethod
+from typing import Dict, List
+
+class BaseModel(ABC):
+    """大语言模型基类"""
+    
+    @abstractmethod
+    def chat(self, message: str) -> str:
+        """执行对话"""
+        pass 
+
+    def upload_files(self, file_list: List[str]) -> List[Dict]:
+        """上传文件"""
+        pass
+
+    def reset(self):
+        """重置模型"""
+        pass
+