jarvis-ai-assistant 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

jarvis/__init__.py

@@ -1,3 +1,3 @@
 """Jarvis AI Assistant"""
 
-__version__ = "0.1.6" 
+__version__ = "0.1.8" 

jarvis/agent.py

@@ -1,6 +1,8 @@
 import json
 import subprocess
-from typing import Dict, Any, List, Optional
+from typing import Dict, Any, List, Optional, Tuple
+
+import yaml
 from .tools import ToolRegistry
 from .utils import PrettyOutput, OutputType, get_multiline_input
 from .models import BaseModel
@@ -9,86 +11,177 @@ import os
 from datetime import datetime
 
 class Agent:
-    def __init__(self, model: BaseModel, tool_registry: ToolRegistry, name: str = "Jarvis"):
-        """Initialize Agent with a model, optional tool registry and name"""
+    def __init__(self, model: BaseModel, tool_registry: ToolRegistry, name: str = "Jarvis", is_sub_agent: bool = False):
+        """Initialize Agent with a model, optional tool registry and name
+        
+        Args:
+            model: 语言模型实例
+            tool_registry: 工具注册表实例
+            name: Agent名称，默认为"Jarvis"
+            is_sub_agent: 是否为子Agent，默认为False
+        """
         self.model = model
         self.tool_registry = tool_registry or ToolRegistry(model)
         self.name = name
+        self.is_sub_agent = is_sub_agent
 
         # 构建工具说明
-        tools_prompt = "Available Tools:\n"
+        tools_prompt = "可用工具:\n"
         for tool in self.tool_registry.get_all_tools():
-            tools_prompt += f"- Tool: {tool['function']['name']}\n"
-            tools_prompt += f"  Description: {tool['function']['description']}\n"
-            tools_prompt += f"  Arguments: {tool['function']['parameters']}\n"
+            tools_prompt += f"- 名称: {tool['name']}\n"
+            tools_prompt += f"  描述: {tool['description']}\n"
+            tools_prompt += f"  参数: {tool['parameters']}\n"
 
         self.messages = [
             {
                 "role": "system",
-                "content": f"""You are {name}, an AI assistant that follows the ReAct (Reasoning + Acting) framework to solve tasks step by step.
+                "content": f"""你是 {name}，一个严格遵循 ReAct 框架进行逐步推理和行动的 AI 助手。
+
+{tools_prompt}
+
+关键规则：
+‼️ 禁止创建虚假对话
+‼️ 禁止假设用户回应
+‼️ 禁止在没有实际用户输入时继续
+‼️ 只回应用户实际说的内容
+‼️ 每个动作后停止并等待
 
-FRAMEWORK:
-1. Thought: Analyze the current situation and plan the next step
-2. Action: Execute ONE specific tool call
-3. Observation: Review the result
-4. Next: Plan the next step or conclude
+ReAct 框架：
+1. 思考
+   - 分析当前情况
+   - 考虑可用工具
+   - 规划下一步行动
+   - 仅基于事实
+   - 不做用户回应的假设
+   - 不想象对话内容
 
-FORMAT:
-Thought: I need to [reasoning about the current situation]...
-Action: I will use [tool] to [purpose]...
+2. 行动（可选）
+   - 不是每次回应都需要调用工具
+   - 如果需要更多信息，直接询问用户
+   - 使用工具时：
+     - 只使用下面列出的工具
+     - 每次只执行一个工具
+     - 工具由用户手动执行
+     - 必须使用有效的YAML格式：
+     <START_TOOL_CALL>
+     name: tool_name
+     arguments:
+         param1: value1       # 所有参数必须正确缩进
+         param2: |           # 使用YAML块样式表示多行字符串
+             line1
+             line2
+     <END_TOOL_CALL>
+
+3. 观察
+   - 等待工具执行结果或用户回应
+   - 工具执行结果由用户提供
+   - 不要假设或想象回应
+   - 不要创建虚假对话
+   - 停止并等待实际输入
+
+回应格式：
+思考：我分析当前情况[具体情况]... 基于[事实]，我需要[目标]...
+
+[如果需要使用工具：]
+行动：我将使用[工具]来[具体目的]...
 <START_TOOL_CALL>
 name: tool_name
 arguments:
     param1: value1
+    param2: |
+        multiline
+        value
 <END_TOOL_CALL>
 
-After receiving result:
-Observation: The tool returned [analyze result]...
-Next: Based on this, I will [next step]...
-
-CORE RULES:
-1. ONE Action Per Response
-   - Only ONE tool call per response
-   - Additional tool calls will be ignored
-   - Complete current step before next
-
-2. Clear Reasoning
-   - Explain your thought process
-   - Justify tool selection
-   - Analyze results thoroughly
-
-Examples:
-✓ Good Response:
-Thought: I need to check the content of utils.py first to understand its structure.
-Action: I will read the file content.
-<START_TOOL_CALL>
-name: file_operation
-arguments:
-    operation: read
-    filepath: src/utils.py
-<END_TOOL_CALL>
-
-✗ Bad Response:
-Thought: Let's analyze the code.
-Action: I'll read and check everything.
-[Multiple or vague tool calls...]
+[如果需要更多信息：]
+我需要了解更多关于[具体细节]的信息。请提供[需要的信息]。
 
-Remember:
-- Always start with "Thought:"
-- Use exactly ONE tool per response
-- Wait for results before next step
-- Clearly explain your reasoning
+严格规则：
+‼️ 只使用下面列出的工具
+‼️ 工具调用是可选的 - 需要时询问用户
+‼️ 每次只能调用一个工具
+‼️ 工具调用必须是有效的YAML格式
+‼️ 参数必须正确缩进
+‼️ 使用YAML块样式(|)表示多行值
+‼️ <END_TOOL_CALL>后的内容将被丢弃
+‼️ 工具由用户手动执行
+‼️ 等待用户提供工具执行结果
+‼️ 不要假设或想象用户回应
+‼️ 没有用户输入时不要继续对话
+‼️ 不要创建虚假对话
+‼️ 每个动作后停止
+‼️ 不要假设结果
+‼️ 不要假设行动
 
-{tools_prompt}"""
+注意事项：
+- 先思考再行动
+- 需要时询问用户
+- 只使用列出的工具
+- 一次一个工具
+- 严格遵循YAML格式
+- 等待用户回应
+- 工具结果来自用户
+- 不要假设回应
+- 不要虚构对话
+- 每个动作后停止
+- 只在有实际用户输入时继续
+"""
             }
         ]
 
-    def _call_model(self, messages: List[Dict], use_tools: bool = True) -> Dict:
+    @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
+            
+            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,
-                tools=self.tool_registry.get_all_tools() if use_tools else []
             )
         except Exception as e:
             raise Exception(f"{self.name}: 模型调用失败: {str(e)}")
@@ -109,33 +202,38 @@ Remember:
             try:
                 # 显示思考状态
                 PrettyOutput.print("分析任务...", OutputType.PROGRESS)
-                response = self._call_model(self.messages)
-                current_response = response
+                
+                current_response = self._call_model(self.messages)
+
+                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)}"
+                    })
+                    continue
 
-                # 流式输出已经在model中处理，这里添加换行
-                PrettyOutput.print_stream_end()
 
                 self.messages.append({
                     "role": "assistant",
-                    "content": response["message"].get("content", ""),
-                    "tool_calls": current_response["message"]["tool_calls"]
+                    "content": result[0]
                 })
+
                 
-                if len(current_response["message"]["tool_calls"]) > 0:
-                    if current_response["message"].get("content"):
-                        PrettyOutput.print(current_response["message"]["content"], OutputType.SYSTEM)
-                        
+                if len(result[1]) > 0:
                     try:
                         # 显示工具调用
                         PrettyOutput.print("执行工具调用...", OutputType.PROGRESS)
-                        tool_result = self.tool_registry.handle_tool_calls(current_response["message"]["tool_calls"])
+                        tool_result = self.tool_registry.handle_tool_calls(result[1])
                         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": "tool",
+                        "role": "user",
                         "content": tool_result
                     })
                     continue
@@ -143,40 +241,45 @@ Remember:
                 # 获取用户输入
                 user_input = get_multiline_input(f"{self.name}: 您可以继续输入，或输入空行结束当前任务")
                 if not user_input:
-                    PrettyOutput.print("生成任务总结...", OutputType.PROGRESS)
-                    
-                    # 生成任务总结
-                    summary_prompt = {
-                        "role": "user",
-                        "content": """The task has been completed. Based on the previous analysis and execution results, provide a task summary including:
-
-1. Key Information:
-   - Essential findings from analysis
-   - Important results from tool executions
-   - Critical data discovered
-
-2. Task Results:
-   - Final outcome
-   - Actual achievements
-   - Concrete results
-
-Focus only on facts and actual results. Be direct and concise."""
-                    }
-                    
-                    while True:
-                        try:
-                            summary_response = self._call_model(self.messages + [summary_prompt], use_tools=False)
-                            summary = summary_response["message"].get("content", "")
-                            
-                            # 显示任务总结
-                            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)
+                    # 只有子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)

jarvis/main.py

@@ -12,7 +12,7 @@ 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
+from jarvis.models import DDGSModel, OllamaModel, OpenAIModel
 from jarvis.utils import PrettyOutput, OutputType, get_multiline_input, load_env_from_file
 from jarvis.zte_llm import create_zte_llm
 
@@ -20,15 +20,23 @@ from jarvis.zte_llm import create_zte_llm
 SUPPORTED_PLATFORMS = {
     "ollama": {
         "models": ["qwen2.5:14b", "qwq"],
-        "default": "qwen2.5:14b"
+        "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"
+        "default": "gpt-4o-mini",
+        "allow_custom": False
     },
     "zte": {
         "models": ["NebulaBiz", "nebulacoder", "NTele-72B"],
-        "default": "NebulaBiz"
+        "default": "NebulaBiz",
+        "allow_custom": False
+    },
+    "openai": {
+        "models": ["deepseek-chat"],
+        "default": "deepseek-chat",
+        "allow_custom": True
     }
 }
 
@@ -118,9 +126,10 @@ def main():
 
     args.model = args.model or os.getenv("JARVIS_MODEL")
     
-    # 验证并设置默认模型
+    # 修改模型验证逻辑
     if args.model:
-        if args.model not in SUPPORTED_PLATFORMS[args.platform]["models"]:
+        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"
@@ -145,6 +154,13 @@ def main():
         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})"
 
         tool_registry = ToolRegistry(model)
         agent = Agent(model, tool_registry)

jarvis/models.py

@@ -1,10 +1,11 @@
 import re
 import time
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Tuple
 from duckduckgo_search import DDGS
 import ollama
 from abc import ABC, abstractmethod
 import yaml
+import openai
 
 from .utils import OutputType, PrettyOutput
 
@@ -12,53 +13,10 @@ class BaseModel(ABC):
     """大语言模型基类"""
     
     @abstractmethod
-    def chat(self, messages: List[Dict], tools: Optional[List[Dict]] = None) -> Dict:
+    def chat(self, messages: List[Dict]) -> str:
         """执行对话"""
         pass
 
-    @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 not line:
-                continue
-                
-            if line == '<START_TOOL_CALL>':
-                tool_call_lines = []
-                in_tool_call = True
-                continue
-            elif line == '<END_TOOL_CALL>':
-                if in_tool_call and tool_call_lines:
-                    try:
-                        # 解析工具调用内容
-                        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 [{
-                                "function": {
-                                    "name": tool_call_data["name"],
-                                    "arguments": tool_call_data["arguments"]
-                                }
-                            }]
-                    except yaml.YAMLError:
-                        pass  # 跳过无效的YAML
-                    except Exception:
-                        pass  # 跳过其他错误
-                in_tool_call = False
-            elif in_tool_call:
-                tool_call_lines.append(line)
-        
-        return []  # 如果没有找到有效的工具调用，返回空列表
-
 
 class DDGSModel(BaseModel):
     def __init__(self, model_name: str = "gpt-4o-mini"):
@@ -70,24 +28,18 @@ class DDGSModel(BaseModel):
         """
         self.model_name = model_name
 
-    def __make_prompt(self, messages: List[Dict], tools: Optional[List[Dict]] = None) -> str:
+    def __make_prompt(self, messages: List[Dict]) -> str:
         prompt = ""
         for message in messages:
             prompt += f"[{message['role']}]: {message['content']}\n"
         return prompt
 
-    def chat(self, messages: List[Dict], tools: Optional[List[Dict]] = None) -> Dict:
+    def chat(self, messages: List[Dict]) -> str:
         ddgs = DDGS()
-        prompt = self.__make_prompt(messages, tools)
+        prompt = self.__make_prompt(messages)
         content = ddgs.chat(prompt)
-        PrettyOutput.print_stream(content, OutputType.SYSTEM)
-        tool_calls = BaseModel.extract_tool_calls(content)
-        return {
-            "message": {
-                "content": content,
-                "tool_calls": tool_calls
-            }
-        }
+        PrettyOutput.print(content, OutputType.SYSTEM)
+        return content
 
 
 class OllamaModel(BaseModel):
@@ -98,7 +50,7 @@ class OllamaModel(BaseModel):
         self.api_base = api_base
         self.client = ollama.Client(host=api_base)
 
-    def chat(self, messages: List[Dict], tools: Optional[List[Dict]] = None) -> Dict:
+    def chat(self, messages: List[Dict]) -> str:
         """调用Ollama API获取响应"""
         try:
             # 使用流式调用
@@ -116,15 +68,55 @@ class OllamaModel(BaseModel):
                     # 实时打印内容
                     PrettyOutput.print_stream(chunk.message.content, OutputType.SYSTEM)
 
+            PrettyOutput.print_stream_end()
+
+            # 合并完整内容
+            return "".join(content_parts)
+            
+        except Exception as e:
+            raise Exception(f"Ollama API调用失败: {str(e)}") 
+
+
+class OpenAIModel(BaseModel):
+    """OpenAI模型实现"""
+    
+    def __init__(self, model_name: str = "deepseek-chat", api_key: Optional[str] = None, api_base: Optional[str] = None):
+        """
+        初始化OpenAI模型
+        Args:
+            model_name: 模型名称，默认为 deepseek-chat
+            api_key: OpenAI API密钥
+            api_base: 可选的API基础URL，用于自定义端点
+        """
+        self.model_name = model_name
+        if api_key:
+            openai.api_key = api_key
+        if api_base:
+            openai.base_url = api_base
+        
+    def chat(self, messages: List[Dict]) -> str:
+        """调用OpenAI API获取响应"""
+        try:
+            # 使用流式调用
+            stream = openai.chat.completions.create(
+                model=self.model_name,
+                messages=messages,
+                stream=True
+            )
+            
+            # 收集完整响应
+            content_parts = []
+            for chunk in stream:
+                if chunk.choices[0].delta.content:
+                    content = chunk.choices[0].delta.content
+                    content_parts.append(content)
+                    # 实时打印内容
+                    PrettyOutput.print_stream(content, OutputType.SYSTEM)
+                    
+            PrettyOutput.print_stream_end()
+            
             # 合并完整内容
-            content = "".join(content_parts)
-            tool_calls = BaseModel.extract_tool_calls(content)
+            return "".join(content_parts)
             
-            return {
-                "message": {
-                    "content": content,
-                    "tool_calls": tool_calls
-                }
-            }
         except Exception as e:
-            raise Exception(f"Ollama API调用失败: {str(e)}") 
+            raise Exception(f"OpenAI API调用失败: {str(e)}") 

jarvis/tools/__init__.py

@@ -3,7 +3,6 @@ from .file_ops import FileOperationTool
 from .search import SearchTool
 from .shell import ShellTool
 from .webpage import WebpageTool
-from .user_input import UserInputTool
 
 __all__ = [
     'Tool',
@@ -12,5 +11,4 @@ __all__ = [
     'SearchTool',
     'ShellTool',
     'WebpageTool',
-    'UserInputTool',
 ]