jarvis-ai-assistant 0.1.6__tar.gz → 0.1.8__tar.gz

{jarvis_ai_assistant-0.1.6 → jarvis_ai_assistant-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jarvis-ai-assistant
-Version: 0.1.6
+Version: 0.1.8
 Summary: Jarvis: An AI assistant that uses tools to interact with the system
 Home-page: https://github.com/skyfireitdiy/Jarvis
 Author: skyfire
@@ -22,6 +22,7 @@ Requires-Dist: duckduckgo-search>=3.0.0
 Requires-Dist: pyyaml>=5.1
 Requires-Dist: ollama>=0.1.6
 Requires-Dist: colorama>=0.4.6
+Requires-Dist: openai>=1.2.0
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: black; extra == "dev"

{jarvis_ai_assistant-0.1.6 → jarvis_ai_assistant-0.1.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "jarvis-ai-assistant"
-version = "0.1.6"
+version = "0.1.8"
 description = "Jarvis: An AI assistant that uses tools to interact with the system"
 readme = "README.md"
 authors = [{ name = "Your Name", email = "your.email@example.com" }]
@@ -26,6 +26,7 @@ dependencies = [
     "pyyaml>=5.1",
     "ollama>=0.1.6",
     "colorama>=0.4.6",
+    "openai>=1.2.0",
 ]
 requires-python = ">=3.8"
 

{jarvis_ai_assistant-0.1.6 → jarvis_ai_assistant-0.1.8}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="jarvis-ai-assistant",
-    version="0.1.6",
+    version="0.1.8",
     author="skyfire",
     author_email="skyfireitdiy@hotmail.com",
     description="An AI assistant that uses various tools to interact with the system",
@@ -19,6 +19,7 @@ setup(
         "pyyaml>=5.1",
         "ollama>=0.1.6",
         "colorama>=0.4.6",
+        "openai>=1.2.0",
     ],
     entry_points={
         "console_scripts": [

{jarvis_ai_assistant-0.1.6 → jarvis_ai_assistant-0.1.8}/src/jarvis/__init__.py

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

jarvis_ai_assistant-0.1.8/src/jarvis/agent.py

@@ -0,0 +1,298 @@
+import json
+import subprocess
+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
+import re
+import os
+from datetime import datetime
+
+class Agent:
+    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 = "可用工具:\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 助手。
+
+{tools_prompt}
+
+关键规则：
+‼️ 禁止创建虚假对话
+‼️ 禁止假设用户回应
+‼️ 禁止在没有实际用户输入时继续
+‼️ 只回应用户实际说的内容
+‼️ 每个动作后停止并等待
+
+ReAct 框架：
+1. 思考
+   - 分析当前情况
+   - 考虑可用工具
+   - 规划下一步行动
+   - 仅基于事实
+   - 不做用户回应的假设
+   - 不想象对话内容
+
+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>
+
+[如果需要更多信息：]
+我需要了解更多关于[具体细节]的信息。请提供[需要的信息]。
+
+严格规则：
+‼️ 只使用下面列出的工具
+‼️ 工具调用是可选的 - 需要时询问用户
+‼️ 每次只能调用一个工具
+‼️ 工具调用必须是有效的YAML格式
+‼️ 参数必须正确缩进
+‼️ 使用YAML块样式(|)表示多行值
+‼️ <END_TOOL_CALL>后的内容将被丢弃
+‼️ 工具由用户手动执行
+‼️ 等待用户提供工具执行结果
+‼️ 不要假设或想象用户回应
+‼️ 没有用户输入时不要继续对话
+‼️ 不要创建虚假对话
+‼️ 每个动作后停止
+‼️ 不要假设结果
+‼️ 不要假设行动
+
+注意事项：
+- 先思考再行动
+- 需要时询问用户
+- 只使用列出的工具
+- 一次一个工具
+- 严格遵循YAML格式
+- 等待用户回应
+- 工具结果来自用户
+- 不要假设回应
+- 不要虚构对话
+- 每个动作后停止
+- 只在有实际用户输入时继续
+"""
+            }
+        ]
+
+    @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,
+            )
+        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)
+
+                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
+
+
+                self.messages.append({
+                    "role": "assistant",
+                    "content": result[0]
+                })
+
+                
+                if len(result[1]) > 0:
+                    try:
+                        # 显示工具调用
+                        PrettyOutput.print("执行工具调用...", OutputType.PROGRESS)
+                        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": "user",
+                        "content": 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"
+                
+                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]] 

{jarvis_ai_assistant-0.1.6 → jarvis_ai_assistant-0.1.8}/src/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_ai_assistant-0.1.8/src/jarvis/models.py

@@ -0,0 +1,122 @@
+import re
+import time
+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
+
+class BaseModel(ABC):
+    """大语言模型基类"""
+    
+    @abstractmethod
+    def chat(self, messages: List[Dict]) -> str:
+        """执行对话"""
+        pass
+
+
+class DDGSModel(BaseModel):
+    def __init__(self, model_name: str = "gpt-4o-mini"):
+        """
+        [1]: gpt-4o-mini
+        [2]: claude-3-haiku
+        [3]: llama-3.1-70b
+        [4]: mixtral-8x7b
+        """
+        self.model_name = model_name
+
+    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]) -> str:
+        ddgs = DDGS()
+        prompt = self.__make_prompt(messages)
+        content = ddgs.chat(prompt)
+        PrettyOutput.print(content, OutputType.SYSTEM)
+        return content
+
+
+class OllamaModel(BaseModel):
+    """Ollama模型实现"""
+    
+    def __init__(self, model_name: str = "qwen2.5:14b", api_base: str = "http://localhost:11434"):
+        self.model_name = model_name
+        self.api_base = api_base
+        self.client = ollama.Client(host=api_base)
+
+    def chat(self, messages: List[Dict]) -> str:
+        """调用Ollama API获取响应"""
+        try:
+            # 使用流式调用
+            stream = self.client.chat(
+                model=self.model_name,
+                messages=messages,
+                stream=True
+            )
+
+            # 收集完整响应
+            content_parts = []
+            for chunk in stream:
+                if chunk.message.content:
+                    content_parts.append(chunk.message.content)
+                    # 实时打印内容
+                    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()
+            
+            # 合并完整内容
+            return "".join(content_parts)
+            
+        except Exception as e:
+            raise Exception(f"OpenAI API调用失败: {str(e)}") 

{jarvis_ai_assistant-0.1.6 → jarvis_ai_assistant-0.1.8}/src/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',
 ] 

{jarvis_ai_assistant-0.1.6 → jarvis_ai_assistant-0.1.8}/src/jarvis/tools/base.py

@@ -13,12 +13,9 @@ class Tool:
     def to_dict(self) -> Dict:
         """转换为Ollama工具格式"""
         return {
-            "type": "function",
-            "function": {
-                "name": self.name,
-                "description": self.description,
-                "parameters": self.parameters
-            }
+            "name": self.name,
+            "description": self.description,
+            "parameters": json.dumps(self.parameters)
         }
 
     def execute(self, arguments: Dict) -> Dict[str, Any]:
@@ -38,14 +35,13 @@ class ToolRegistry:
         from .file_ops import FileOperationTool
         from .webpage import WebpageTool
         from .sub_agent import SubAgentTool
-        from .user_input import UserInputTool
 
         tools = [
-            SearchTool(),
+            SearchTool(self.model),
             ShellTool(),
             FileOperationTool(),
             WebpageTool(),
-            UserInputTool(),
+            SubAgentTool(self.model)
         ]
 
         for tool in tools:
@@ -56,14 +52,6 @@ class ToolRegistry:
                 func=tool.execute
             )
 
-        sub_agent_tool = SubAgentTool(self.model)
-        self.register_tool(
-            name=sub_agent_tool.name,
-            description=sub_agent_tool.description,
-            parameters=sub_agent_tool.parameters,
-            func=sub_agent_tool.execute
-        )
-
     def register_tool(self, name: str, description: str, parameters: Dict, func: Callable):
         """注册新工具"""
         self.tools[name] = Tool(name, description, parameters, func)
@@ -90,8 +78,8 @@ class ToolRegistry:
             
         # 只处理第一个工具调用
         tool_call = tool_calls[0]
-        name = tool_call["function"]["name"]
-        args = tool_call["function"]["arguments"]
+        name = tool_call["name"]
+        args = tool_call["arguments"]
         
         if isinstance(args, str):
             try:
@@ -121,6 +109,7 @@ class ToolRegistry:
             if stderr:
                 output_parts.append(f"错误:\n{stderr}")
             output = "\n\n".join(output_parts)
+            output = "没有输出和错误" if not output else output
             PrettyOutput.section("执行成功", OutputType.SUCCESS)
         else:
             error_msg = result["error"]

{jarvis_ai_assistant-0.1.6 → jarvis_ai_assistant-0.1.8}/src/jarvis/tools/file_ops.py

@@ -5,7 +5,7 @@ from ..utils import PrettyOutput, OutputType
 
 class FileOperationTool:
     name = "file_operation"
-    description = "Execute file operations (read/write/append/exists)"
+    description = "文件操作 (read/write/append/exists)"
     parameters = {
         "type": "object",
         "properties": {