jarvis-ai-assistant 0.1.10__tar.gz → 0.1.11__tar.gz

{jarvis_ai_assistant-0.1.10 → jarvis_ai_assistant-0.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jarvis-ai-assistant
-Version: 0.1.10
+Version: 0.1.11
 Summary: Jarvis: An AI assistant that uses tools to interact with the system
 Home-page: https://github.com/skyfireitdiy/Jarvis
 Author: skyfire

{jarvis_ai_assistant-0.1.10 → jarvis_ai_assistant-0.1.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "jarvis-ai-assistant"
-version = "0.1.10"
+version = "0.1.11"
 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" }]

{jarvis_ai_assistant-0.1.10 → jarvis_ai_assistant-0.1.11}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="jarvis-ai-assistant",
-    version="0.1.10",
+    version="0.1.11",
     author="skyfire",
     author_email="skyfireitdiy@hotmail.com",
     description="An AI assistant that uses various tools to interact with the system",

{jarvis_ai_assistant-0.1.10 → jarvis_ai_assistant-0.1.11}/src/jarvis/__init__.py

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

{jarvis_ai_assistant-0.1.10 → jarvis_ai_assistant-0.1.11}/src/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,8 +23,7 @@ class Agent:
         self.model = model
         self.tool_registry = tool_registry or ToolRegistry(model)
         self.name = name
-        self.is_sub_agent = is_sub_agent
-        self.messages = []
+        self.prompt = ""
 
 
     @staticmethod
@@ -71,19 +70,28 @@ class Agent:
         
         return []
 
-    def _call_model(self, messages: List[Dict]) -> Dict:
+    def _call_model(self, message: str) -> str:
         """调用模型获取响应"""
         try:
-            return self.model.chat(
-                messages=messages,
-            )
+            return self.model.chat(message)
         except Exception as e:
             raise Exception(f"{self.name}: 模型调用失败: {str(e)}")
 
-    def run(self, user_input: str) -> str:
-        """处理用户输入并返回响应，返回任务总结报告"""
+    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)
 
@@ -93,20 +101,10 @@ class Agent:
             tools_prompt += f"  描述: {tool['description']}\n"
             tools_prompt += f"  参数: {tool['parameters']}\n"
 
-        self.messages = [
-            {
-                "role": "user",
-                "content": f"""你是 {self.name}，一个严格遵循 ReAct 框架进行逐步推理和行动的 AI 助手。
+        self.prompt =f"""你是 {self.name}，一个严格遵循 ReAct 框架进行逐步推理和行动的 AI 助手。
 
 {tools_prompt}
 
-关键规则：
-‼️ 禁止创建虚假对话
-‼️ 禁止假设用户回应
-‼️ 禁止在没有实际用户输入时继续
-‼️ 只回应用户实际说的内容
-‼️ 每个动作后停止并等待
-
 ReAct 框架：
 1. 思考
    - 分析当前情况
@@ -123,7 +121,7 @@ ReAct 框架：
      - 只使用下面列出的工具
      - 每次只执行一个工具
      - 工具由用户手动执行
-     - 必须使用有效的YAML格式：
+     - 必须使用有效合法的YAML格式：
      <START_TOOL_CALL>
      name: tool_name
      arguments:
@@ -164,7 +162,6 @@ arguments:
 ‼️ 工具调用必须是有效的YAML格式
 ‼️ 参数必须正确缩进
 ‼️ 使用YAML块样式(|)表示多行值
-‼️ <END_TOOL_CALL>后的内容将被丢弃
 ‼️ 工具由用户手动执行
 ‼️ 等待用户提供工具执行结果
 ‼️ 不要假设或想象用户回应
@@ -190,32 +187,21 @@ arguments:
 任务:
 {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": current_response
-                })
-
                 
                 if len(result) > 0:
                     try:
@@ -227,68 +213,29 @@ arguments:
                         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.prompt = "" 
         self.model.reset()

{jarvis_ai_assistant-0.1.10 → jarvis_ai_assistant-0.1.11}/src/jarvis/main.py

@@ -72,6 +72,10 @@ def select_task(tasks: dict) -> str:
 
 def main():
     """Main entry point for Jarvis."""
+    # 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()
 
     load_env_from_file()
     
@@ -95,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
         
         # 如果没有选择预定义任务，进入交互模式
@@ -104,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_ai_assistant-0.1.10 → jarvis_ai_assistant-0.1.11}/src/jarvis/models/base.py

@@ -5,10 +5,14 @@ class BaseModel(ABC):
     """大语言模型基类"""
     
     @abstractmethod
-    def chat(self, messages: List[Dict]) -> str:
+    def chat(self, message: str) -> str:
         """执行对话"""
         pass 
 
+    def upload_files(self, file_list: List[str]) -> List[Dict]:
+        """上传文件"""
+        pass
+
     def reset(self):
         """重置模型"""
         pass

jarvis_ai_assistant-0.1.11/src/jarvis/models/kimi.py

@@ -0,0 +1,258 @@
+from typing import Dict, List, Optional
+import requests
+import json
+import os
+import mimetypes
+from .base import BaseModel
+from ..utils import PrettyOutput, OutputType
+import time
+
+class KimiModel(BaseModel):
+    """Kimi模型实现"""
+    
+    def __init__(self, api_key: str = None):
+        """
+        初始化Kimi模型
+        Args:
+            api_key: Kimi API密钥，如果不提供则从环境变量获取
+        """
+        self.api_key = api_key or os.getenv("KIMI_API_KEY")
+        if not self.api_key:
+            raise Exception("KIMI_API_KEY is not set")
+        self.auth_header = f"Bearer {self.api_key}"
+        self.chat_id = ""
+        self.uploaded_files = []  # 存储已上传文件的信息
+        self.first_chat = True  # 添加标记，用于判断是否是第一次对话
+
+    def _create_chat(self) -> bool:
+        """创建新的对话会话"""
+        url = "https://kimi.moonshot.cn/api/chat"
+        payload = json.dumps({
+            "name": "未命名会话",
+            "is_example": False,
+            "kimiplus_id": "kimi"
+        })
+        headers = {
+            'Authorization': self.auth_header,
+            'Content-Type': 'application/json'
+        }
+        try:
+            response = requests.request("POST", url, headers=headers, data=payload)
+            self.chat_id = response.json()["id"]
+            return True
+        except Exception as e:
+            PrettyOutput.print(f"Failed to create chat: {e}", OutputType.ERROR)
+            return False
+
+    def _get_presigned_url(self, filename: str) -> Dict:
+        """获取预签名上传URL"""
+        url = "https://kimi.moonshot.cn/api/pre-sign-url"
+        mime_type, _ = mimetypes.guess_type(filename)
+        action = "image" if mime_type and mime_type.startswith('image/') else "file"
+        
+        payload = json.dumps({
+            "action": action,
+            "name": os.path.basename(filename)
+        })
+        
+        headers = {
+            'Authorization': self.auth_header,
+            'Content-Type': 'application/json'
+        }
+        
+        response = requests.post(url, headers=headers, data=payload)
+        return response.json()
+
+    def _upload_file(self, file_path: str, presigned_url: str) -> bool:
+        """上传文件到预签名URL"""
+        try:
+            with open(file_path, 'rb') as f:
+                content = f.read()
+                response = requests.put(presigned_url, data=content)
+                return response.status_code == 200
+        except Exception as e:
+            PrettyOutput.print(f"Failed to upload file: {e}", OutputType.ERROR)
+            return False
+
+    def _get_file_info(self, file_data: Dict, name: str) -> Dict:
+        """获取文件信息"""
+        url = "https://kimi.moonshot.cn/api/file"
+        payload = json.dumps({
+            "type": "file",
+            "name": name,
+            "object_name": file_data["object_name"],
+            "chat_id": self.chat_id,
+            "file_id": file_data.get("file_id", "")
+        })
+        
+        headers = {
+            'Authorization': self.auth_header,
+            'Content-Type': 'application/json'
+        }
+        
+        response = requests.post(url, headers=headers, data=payload)
+        return response.json()
+
+    def _wait_for_parse(self, file_id: str) -> bool:
+        """等待文件解析完成"""
+        url = "https://kimi.moonshot.cn/api/file/parse_process"
+        headers = {
+            'Authorization': self.auth_header,
+            'Content-Type': 'application/json'
+        }
+        
+        max_retries = 30
+        retry_count = 0
+        
+        while retry_count < max_retries:
+            payload = json.dumps({"ids": [file_id]})
+            response = requests.post(url, headers=headers, data=payload, stream=True)
+            
+            for line in response.iter_lines():
+                if not line:
+                    continue
+                    
+                line = line.decode('utf-8')
+                if not line.startswith("data: "):
+                    continue
+                    
+                try:
+                    data = json.loads(line[6:])
+                    if data.get("event") == "resp":
+                        status = data.get("file_info", {}).get("status")
+                        if status == "parsed":
+                            return True
+                        elif status == "failed":
+                            return False
+                except json.JSONDecodeError:
+                    continue
+            
+            retry_count += 1
+            time.sleep(1)
+        
+        return False
+
+    def upload_files(self, file_list: List[str]) -> List[Dict]:
+        """上传文件列表并返回文件信息"""
+        if not file_list:
+            return []
+
+        PrettyOutput.print("开始处理文件上传...", OutputType.PROGRESS)
+        
+        if not self.chat_id:
+            PrettyOutput.print("创建新的对话会话...", OutputType.PROGRESS)
+            if not self._create_chat():
+                raise Exception("Failed to create chat session")
+
+        uploaded_files = []
+        for index, file_path in enumerate(file_list, 1):
+            try:
+                PrettyOutput.print(f"处理文件 [{index}/{len(file_list)}]: {file_path}", OutputType.PROGRESS)
+                
+                # 获取预签名URL
+                PrettyOutput.print("获取上传URL...", OutputType.PROGRESS)
+                presigned_data = self._get_presigned_url(file_path)
+                
+                # 上传文件
+                PrettyOutput.print("上传文件内容...", OutputType.PROGRESS)
+                if self._upload_file(file_path, presigned_data["url"]):
+                    # 获取文件信息
+                    PrettyOutput.print("获取文件信息...", OutputType.PROGRESS)
+                    file_info = self._get_file_info(presigned_data, os.path.basename(file_path))
+                    
+                    # 等待文件解析
+                    PrettyOutput.print("等待文件解析完成...", OutputType.PROGRESS)
+                    if self._wait_for_parse(file_info["id"]):
+                        uploaded_files.append(file_info)
+                        PrettyOutput.print(f"✓ 文件处理成功: {file_path}", OutputType.SUCCESS)
+                    else:
+                        PrettyOutput.print(f"✗ 文件解析失败: {file_path}", OutputType.ERROR)
+                else:
+                    PrettyOutput.print(f"✗ 文件上传失败: {file_path}", OutputType.ERROR)
+                    
+            except Exception as e:
+                PrettyOutput.print(f"✗ 处理文件出错 {file_path}: {str(e)}", OutputType.ERROR)
+                continue
+        
+        if uploaded_files:
+            PrettyOutput.print(f"成功处理 {len(uploaded_files)}/{len(file_list)} 个文件", OutputType.SUCCESS)
+        else:
+            PrettyOutput.print("没有文件成功处理", OutputType.WARNING)
+        
+        self.uploaded_files = uploaded_files
+        return uploaded_files
+
+    def chat(self, message: str) -> str:
+        """发送消息并获取响应"""
+        if not self.chat_id:
+            PrettyOutput.print("创建新的对话会话...", OutputType.PROGRESS)
+            if not self._create_chat():
+                raise Exception("Failed to create chat session")
+
+        url = f"https://kimi.moonshot.cn/api/chat/{self.chat_id}/completion/stream"
+        
+        # 只在第一次对话时带上文件引用
+        refs = []
+        refs_file = []
+        if self.first_chat and self.uploaded_files:
+            PrettyOutput.print(f"首次对话，引用 {len(self.uploaded_files)} 个文件...", OutputType.PROGRESS)
+            refs = [f["id"] for f in self.uploaded_files]
+            refs_file = self.uploaded_files
+            self.first_chat = False
+        
+        PrettyOutput.print("发送请求...", OutputType.PROGRESS)
+        payload = {
+            "messages": [{"role": "user", "content": message}],
+            "use_search": True,
+            "extend": {"sidebar": True},
+            "kimiplus_id": "kimi",
+            "use_research": False,
+            "use_math": False,
+            "refs": refs,
+            "refs_file": refs_file
+        }
+
+        headers = {
+            'Authorization': self.auth_header,
+            'Content-Type': 'application/json'
+        }
+
+        try:
+            response = requests.post(url, headers=headers, json=payload, stream=True)
+            full_response = ""
+            
+            PrettyOutput.print("接收响应...", OutputType.PROGRESS)
+            for line in response.iter_lines():
+                if not line:
+                    continue
+                    
+                line = line.decode('utf-8')
+                if not line.startswith("data: "):
+                    continue
+                    
+                try:
+                    data = json.loads(line[6:])
+                    if data.get("event") == "cmpl":
+                        text = data.get("text", "")
+                        if text:
+                            PrettyOutput.print_stream(text, OutputType.SYSTEM)
+                            full_response += text
+                except json.JSONDecodeError:
+                    continue
+                    
+            PrettyOutput.print_stream_end()
+            return full_response
+
+        except Exception as e:
+            raise Exception(f"Chat failed: {str(e)}")
+
+    def reset(self):
+        """重置对话"""
+        self.chat_id = ""
+        self.uploaded_files = []
+        self.first_chat = True  # 重置first_chat标记
+
+
+if __name__ == "__main__":
+    kimi = KimiModel()
+    print(kimi.chat([{"role": "user", "content": "ollama如何部署"}]))

{jarvis_ai_assistant-0.1.10 → jarvis_ai_assistant-0.1.11}/src/jarvis_ai_assistant.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jarvis-ai-assistant
-Version: 0.1.10
+Version: 0.1.11
 Summary: Jarvis: An AI assistant that uses tools to interact with the system
 Home-page: https://github.com/skyfireitdiy/Jarvis
 Author: skyfire

jarvis_ai_assistant-0.1.10/src/jarvis/models/kimi.py

@@ -1,135 +0,0 @@
-from typing import Dict, List
-import requests
-import json
-import os
-from .base import BaseModel
-from ..utils import PrettyOutput, OutputType
-import time
-
-class KimiModel(BaseModel):
-    """Kimi模型实现"""
-    
-    def __init__(self, api_key: str = None):
-        """
-        初始化Kimi模型
-        Args:
-            api_key: Kimi API密钥，如果不提供则从环境变量获取
-        """
-        self.api_key = api_key or os.getenv("KIMI_API_KEY")
-        if not self.api_key:
-            raise Exception("KIMI_API_KEY is not set")
-        self.auth_header = f"Bearer {self.api_key}"
-        self.chat_id = ""
-
-    def _create_chat(self) -> bool:
-        """创建新的对话会话"""
-        url = "https://kimi.moonshot.cn/api/chat"
-        payload = json.dumps({
-            "name": "未命名会话",
-            "is_example": False,
-            "kimiplus_id": "kimi"
-        })
-        headers = {
-            'Authorization': self.auth_header,
-            'Content-Type': 'application/json'
-        }
-        try:
-            response = requests.request("POST", url, headers=headers, data=payload)
-            self.chat_id = response.json()["id"]
-            return True
-        except Exception as e:
-            PrettyOutput.print(f"Failed to create chat: {e}", OutputType.ERROR)
-            return False
-
-    def chat(self, messages: List[Dict]) -> str:
-        """
-        实现BaseModel的chat方法
-        Args:
-            messages: 对话消息列表
-        Returns:
-            str: 模型的回复内容
-        """
-        if not self.chat_id:
-            if not self._create_chat():
-                raise Exception("Failed to create chat")
-        
-        url = f"https://kimi.moonshot.cn/api/chat/{self.chat_id}/completion/stream"
-        payload = json.dumps({
-            "messages": [messages[-1]],
-            "use_search": True,
-            "extend": {
-                "sidebar": True
-            },
-            "kimiplus_id": "kimi",
-            "use_research": False,
-            "use_math": False,
-            "refs": [],
-            "refs_file": []
-        })
-        headers = {
-            'Authorization': self.auth_header,
-            'Content-Type': 'application/json'
-        }
-
-        try:
-            response = requests.request("POST", url, headers=headers, data=payload, stream=True)
-            full_response = ""
-            references = []
-            
-            for line in response.iter_lines():
-                if not line:
-                    continue
-                
-                line = line.decode('utf-8')
-                if not line.startswith("data: "):
-                    continue
-                
-                try:
-                    data = json.loads(line[6:])  # 去掉 "data: " 前缀
-                    
-                    # 处理不同类型的事件
-                    if data.get("event") == "cmpl":
-                        if "text" in data:
-                            text = data["text"]
-                            PrettyOutput.print_stream(text, OutputType.SYSTEM)  # 使用统一的流式输出
-                            full_response += text
-                    elif data.get("event") == "ref_docs":
-                        if "ref_cards" in data:
-                            for ref in data["ref_cards"]:
-                                reference = {
-                                    "title": ref.get("title", ""),
-                                    "url": ref.get("url", ""),
-                                    "abstract": ref.get("abstract", "")
-                                }
-                                references.append(reference)
-                                PrettyOutput.print(f"\n参考来源: {reference['title']} - {reference['url']}", 
-                                                 OutputType.INFO)
-                    elif data.get("event") == "error":
-                        error_msg = data.get("error", "Unknown error")
-                        raise Exception(f"Chat error: {error_msg}")
-                    elif data.get("event") == "all_done":
-                        break
-                    
-                except json.JSONDecodeError:
-                    continue
-            
-            # 如果有参考文献，在回答后面添加引用信息
-            if references:
-                full_response += "\n\n参考来源:\n"
-                for i, ref in enumerate(references, 1):
-                    full_response += f"{i}. {ref['title']} - {ref['url']}\n"
-            
-            PrettyOutput.print_stream_end()  # 结束流式输出
-            return full_response
-
-        except Exception as e:
-            raise Exception(f"Kimi API调用失败: {str(e)}")
-        
-    def reset(self):
-        """重置模型"""
-        self.chat_id = ""
-
-
-if __name__ == "__main__":
-    kimi = KimiModel()
-    print(kimi.chat([{"role": "user", "content": "ollama如何部署"}]))