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

jarvis/__init__.py

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

jarvis/agent.py

@@ -24,8 +24,69 @@ class Agent:
         self.tool_registry = tool_registry or ToolRegistry(model)
         self.name = name
         self.is_sub_agent = is_sub_agent
+        self.messages = []
+
+
+    @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, 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)
 
-        # 构建工具说明
         tools_prompt = "可用工具:\n"
         for tool in self.tool_registry.get_all_tools():
             tools_prompt += f"- 名称: {tool['name']}\n"
@@ -34,8 +95,8 @@ class Agent:
 
         self.messages = [
             {
-                "role": "system",
-                "content": f"""你是 {name}，一个严格遵循 ReAct 框架进行逐步推理和行动的 AI 助手。
+                "role": "user",
+                "content": f"""你是 {self.name}，一个严格遵循 ReAct 框架进行逐步推理和行动的 AI 助手。
 
 {tools_prompt}
 
@@ -125,78 +186,12 @@ arguments:
 - 不要虚构对话
 - 每个动作后停止
 - 只在有实际用户输入时继续
+
+任务:
+{user_input}
 """
             }
         ]
-
-    @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:
@@ -218,15 +213,15 @@ arguments:
 
                 self.messages.append({
                     "role": "assistant",
-                    "content": result[0]
+                    "content": current_response
                 })
 
                 
-                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)
@@ -295,4 +290,5 @@ arguments:
 
     def clear_history(self):
         """清除对话历史，只保留系统提示"""
-        self.messages = [self.messages[0]] 
+        self.messages = [] 
+        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."""
@@ -98,75 +74,20 @@ 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)"
-    )
-    
-    args = parser.parse_args()
-
-    args.model = args.model or os.getenv("JARVIS_MODEL")
     
-    # 修改模型验证逻辑
-    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()

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,15 @@
+from abc import ABC, abstractmethod
+from typing import Dict, List
+
+class BaseModel(ABC):
+    """大语言模型基类"""
+    
+    @abstractmethod
+    def chat(self, messages: List[Dict]) -> str:
+        """执行对话"""
+        pass 
+
+    def reset(self):
+        """重置模型"""
+        pass
+        

jarvis/models/kimi.py

@@ -0,0 +1,135 @@
+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如何部署"}]))

jarvis/tools/__init__.py

@@ -1,14 +1,10 @@
 from .base import Tool, ToolRegistry
 from .file_ops import FileOperationTool
-from .search import SearchTool
 from .shell import ShellTool
-from .webpage import WebpageTool
 
 __all__ = [
     'Tool',
     'ToolRegistry',
     'FileOperationTool',
-    'SearchTool',
     'ShellTool',
-    'WebpageTool',
 ] 

jarvis/tools/base.py

@@ -30,18 +30,12 @@ class ToolRegistry:
 
     def _register_default_tools(self):
         """注册所有默认工具"""
-        from .search import SearchTool
         from .shell import ShellTool
         from .file_ops import FileOperationTool
-        from .webpage import WebpageTool
-        from .sub_agent import SubAgentTool
 
         tools = [
-            SearchTool(self.model),
             ShellTool(),
             FileOperationTool(),
-            WebpageTool(),
-            SubAgentTool(self.model)
         ]
 
         for tool in tools:

{jarvis_ai_assistant-0.1.8.dist-info → jarvis_ai_assistant-0.1.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jarvis-ai-assistant
-Version: 0.1.8
+Version: 0.1.10
 Summary: Jarvis: An AI assistant that uses tools to interact with the system
 Home-page: https://github.com/skyfireitdiy/Jarvis
 Author: skyfire
@@ -17,12 +17,8 @@ Classifier: Programming Language :: Python :: 3.11
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: requests>=2.25.1
-Requires-Dist: beautifulsoup4>=4.9.3
-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.10.dist-info/RECORD

@@ -0,0 +1,39 @@
+jarvis/__init__.py,sha256=PifeyN0tR6cMlun7jfNuqaJFzH6pHXIbZ8zE-okSuR4,50
+jarvis/agent.py,sha256=t_J8-Hn3S-fLdetrnb7n8ZdP0mdVFqV4YDzYw6_YUq0,10645
+jarvis/main.py,sha256=m641nuFgg-EHGfupyhj0Z_KuNkzZ509U3H7cB7XcsrM,3938
+jarvis/utils.py,sha256=3hLtv-HcBL8Ngw69cowhARuIFrjcQ6yRP3Y1o9CvtsI,5992
+jarvis/__pycache__/__init__.cpython-313.pyc,sha256=SLcRG4m_RNF7YaqL8LpYiOd4FgneCJ_X3E_J9ZLlM4g,208
+jarvis/__pycache__/agent.cpython-313.pyc,sha256=IMD8Ng23CqurRq4P-JtzH89unYxJDDkbKiTfvyt5zh4,11392
+jarvis/__pycache__/main.cpython-313.pyc,sha256=61803cexmA3duJzFajeyLqR_4k3-FOwtUp9QSr8c0Ys,5558
+jarvis/__pycache__/models.cpython-313.pyc,sha256=uWuRIjGrY4YDB3dGW5PGDLWaS03et8g11O725TjY_eU,5960
+jarvis/__pycache__/tools.cpython-313.pyc,sha256=lAD4LrnnWzNZQmHXGfZ_2l7oskOpr2_2OC-gdFhxQY8,33933
+jarvis/__pycache__/utils.cpython-313.pyc,sha256=k4jyAlx4tlW0MKLMLzV7OOH9zsKrK0H955kY6M2SuFU,8772
+jarvis/__pycache__/zte_llm.cpython-313.pyc,sha256=kMm9IGundGmOPqjsgrm9oIaWLDagYGCPRAaE3ipkc-0,5662
+jarvis/models/__init__.py,sha256=B_IJFvKTaxdg19FAD1ea288tYp3-bRYRpkeGI0_OcBI,262
+jarvis/models/base.py,sha256=hBEcHaKzB8KASH93k4XNYr6OO6rKLH4z3tj1hwVQdFU,306
+jarvis/models/kimi.py,sha256=UlKvZfsfW5Hspk2gYR9CuRmi6v-P0vtmIf0VRsmhYB4,4925
+jarvis/models/__pycache__/__init__.cpython-313.pyc,sha256=jAwySX4diR7EWM_alK75tiIb_J8bVfs4Bh_U3bdjDLo,534
+jarvis/models/__pycache__/base.cpython-313.pyc,sha256=HzjCIJMvmapnFIMtASkUuSnKjJsL5iIwl5Rane3fq8I,901
+jarvis/models/__pycache__/kimi.cpython-313.pyc,sha256=k35PQUjCtlm5nh3FnJtgi1ZejgO9xMvRhGMwkthYfJ8,5857
+jarvis/tools/__init__.py,sha256=000SvX1Z0yzKtuVR9NS45r41DHUVpE6EiSEzzE99uR0,196
+jarvis/tools/base.py,sha256=qm73kMOkqAWHjUisUWFye-x69LJuZdwm0U3Tct-mmMc,3890
+jarvis/tools/file_ops.py,sha256=zTksx45NZm3iz9itN5iQGZ8DoxnSeTHdrnF08_ix7PU,3770
+jarvis/tools/shell.py,sha256=7q52lA3slf0TdjBjP1bkwugoO5pB0eqh6cYjAzAXNtI,2547
+jarvis/tools/__pycache__/__init__.cpython-313.pyc,sha256=6BQJ333a0Oh9uEDLlgh0HHeXS34I7NaPs9KFQI-sil8,347
+jarvis/tools/__pycache__/base.cpython-313.pyc,sha256=ZfkdDuQDiCuA7V3qx69coGwrkchLPqNDF6tCGPXKflU,6197
+jarvis/tools/__pycache__/bing_search.cpython-313.pyc,sha256=1G_wPbk5wcQYh7H0drLIS2Aw0XOG2ZM8ztgfQaqu3P8,2031
+jarvis/tools/__pycache__/file_ops.cpython-313.pyc,sha256=LbOp31JUzoRp5XVazy1VBqCQhpFg0qQYmVftFVY90V4,3628
+jarvis/tools/__pycache__/python_script.cpython-313.pyc,sha256=8JpryqTovEiTvBlWAK1KjZmPvHUuPc9GT9rTXBEQoJc,6693
+jarvis/tools/__pycache__/rag.cpython-313.pyc,sha256=JH6-PSZRMKAvTZqCwlRXJGClxYXNMs-vetU0q7hBLz0,6064
+jarvis/tools/__pycache__/search.cpython-313.pyc,sha256=wLMIkFwT-h4NGHgssytT4xme7sGO6ZhEnex7kjcy0-k,5990
+jarvis/tools/__pycache__/shell.cpython-313.pyc,sha256=QMaLUc1MtZXWod3msv_x7iMq2IybwMwz1OoaKsbm6U4,3271
+jarvis/tools/__pycache__/sub_agent.cpython-313.pyc,sha256=9spmVX8KSQ4qIH7FbXo5tmmZfNx8KfIGtjy2lxTSp4Y,3144
+jarvis/tools/__pycache__/user_confirmation.cpython-313.pyc,sha256=wK3Ev10lHSUSRvoYmi7A0GzxYkzU-C4Wfhs5qW_HBqs,2271
+jarvis/tools/__pycache__/user_input.cpython-313.pyc,sha256=JjTFOhObKsKF4Pn8KBRuKfV1_Ssj083fjU7Mfc_5z7c,2531
+jarvis/tools/__pycache__/user_interaction.cpython-313.pyc,sha256=RuVZ-pmiPBDywY3efgXSfohMAciC1avMGPmBK5qlnew,3305
+jarvis/tools/__pycache__/webpage.cpython-313.pyc,sha256=BjzSfnNzsKCrLETCcWjt32lNDLzwnjqcVGg4JfWd9OM,3008
+jarvis_ai_assistant-0.1.10.dist-info/METADATA,sha256=qlQS-5cO8H9Unc3698Ny3Kzptexy3IMQNwvvgKORPRk,3585
+jarvis_ai_assistant-0.1.10.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+jarvis_ai_assistant-0.1.10.dist-info/entry_points.txt,sha256=iKu7OMfew9dtfGhW71gIMTg4wvafuPqKb4wyQOnMAGU,44
+jarvis_ai_assistant-0.1.10.dist-info/top_level.txt,sha256=1BOxyWfzOP_ZXj8rVTDnNCJ92bBGB0rwq8N1PCpoMIs,7
+jarvis_ai_assistant-0.1.10.dist-info/RECORD,,

jarvis/models.py

@@ -1,122 +0,0 @@
-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/tools/search.py

@@ -1,144 +0,0 @@
-import os
-import requests
-from typing import Dict, Any, List
-from ..utils import PrettyOutput, OutputType
-from .webpage import WebpageTool
-
-class SearchTool:
-    name = "search"
-    description = "使用搜索引擎搜索信息，并根据问题提取关键信息"
-    parameters = {
-        "type": "object",
-        "properties": {
-            "query": {
-                "type": "string",
-                "description": "搜索关键词"
-            },
-            "question": {
-                "type": "string",
-                "description": "需要回答的具体问题，用于从搜索结果中提取相关信息"
-            },
-            "max_results": {
-                "type": "integer",
-                "description": "最大搜索结果数量",
-                "default": 3
-            }
-        },
-        "required": ["query", "question"]
-    }
-
-    def __init__(self, model):
-        """初始化搜索工具，需要传入语言模型用于信息提取"""
-        self.model = model
-        self.webpage_tool = WebpageTool()
-        self.api_key = os.getenv("SEARCH_API_KEY")
-        self.engine = os.getenv("SEARCH_ENGINE", "bing")
-        if not self.api_key:
-            raise ValueError("未设置SEARCH_API_KEY环境变量")
-
-    def _search(self, query: str, max_results: int) -> List[Dict]:
-        """执行搜索请求"""
-        url = "https://serpapi.webscrapingapi.com/v2"
-        params = {
-            "engine": self.engine,
-            "api_key": self.api_key,
-            "q": query
-        }
-        
-        try:
-            response = requests.get(url, params=params)
-            response.raise_for_status()
-            data = response.json()
-            
-            # 从搜索结果中提取有机结果
-            results = []
-            if "organic" in data:
-                for result in data["organic"][:max_results]:
-                    results.append({
-                        "title": result.get("title", ""),
-                        "href": result.get("link", ""),
-                        "body": result.get("description", "")
-                    })
-            return results
-        except Exception as e:
-            PrettyOutput.print(f"搜索请求失败: {str(e)}", OutputType.ERROR)
-            return []
-
-    def _extract_info(self, contents: List[str], question: str) -> str:
-        """使用语言模型从网页内容中提取关键信息"""
-        prompt = {
-            "role": "user",
-            "content": f"""请根据以下搜索结果内容，回答问题：{question}
-
-搜索结果内容：
-{'-' * 40}
-{''.join(contents)}
-{'-' * 40}
-
-请提供一个简洁、准确的答案，重点关注与问题直接相关的信息。如果搜索结果中没有相关信息，请明确说明。
-回答时注意：
-1. 保持客观性，只基于搜索结果提供信息
-2. 如果不同来源有冲突，请指出差异
-3. 适当引用信息来源
-4. 如果信息不完整或不确定，请说明"""
-        }
-
-        try:
-            response = self.model.chat([prompt])
-            return response
-        except Exception as e:
-            return f"信息提取失败: {str(e)}"
-
-    def execute(self, args: Dict) -> Dict[str, Any]:
-        """执行搜索并提取信息"""
-        try:
-            query = args["query"]
-            question = args["question"]
-            max_results = args.get("max_results", 3)
-            
-            # 打印搜索信息
-            PrettyOutput.print(f"搜索查询: {query}", OutputType.INFO)
-            PrettyOutput.print(f"相关问题: {question}", OutputType.INFO)
-            
-            # 获取搜索结果
-            results = self._search(query, max_results)
-            if not results:
-                return {
-                    "success": False,
-                    "error": "未能获取任何搜索结果"
-                }
-            
-            # 收集网页内容
-            contents = []
-            for i, result in enumerate(results, 1):
-                try:
-                    PrettyOutput.print(f"正在读取第 {i}/{len(results)} 个结果... {result['title']} - {result['href']}", OutputType.PROGRESS)
-                    webpage_result = self.webpage_tool.execute({"url": result["href"]})
-                    if webpage_result["success"]:
-                        contents.append(f"\n来源 {i}：{result['href']}\n")
-                        contents.append(webpage_result["stdout"])
-                except Exception as e:
-                    PrettyOutput.print(f"读取结果 {i} 失败: {str(e)}", OutputType.WARNING)
-                    continue
-            
-            if not contents:
-                return {
-                    "success": False,
-                    "error": "未能获取任何有效的搜索结果"
-                }
-            
-            # 提取信息
-            PrettyOutput.print("正在分析搜索结果...", OutputType.PROGRESS)
-            analysis = self._extract_info(contents, question)
-            
-            return {
-                "success": True,
-                "stdout": f"搜索分析结果：\n\n{analysis}",
-                "stderr": ""
-            }
-
-        except Exception as e:
-            return {
-                "success": False,
-                "error": f"搜索失败: {str(e)}"
-            } 

jarvis/tools/sub_agent.py

@@ -1,83 +0,0 @@
-from typing import Dict, Any
-from ..agent import Agent
-from ..models import BaseModel
-from ..utils import PrettyOutput, OutputType
-from .base import ToolRegistry
-
-class SubAgentTool:
-    name = "create_sub_agent"
-    description = """创建一个子代理来处理独立任务。（重要：子代理启动时没有任何上下文！必须提供完整的步骤和上下文。）"""
-
-    parameters = {
-        "type": "object",
-        "properties": {
-            "name": {
-                "type": "string",
-                "description": "子代理名称（例如：'文件分析器'）"
-            },
-            "task": {
-                "type": "string",
-                "description": "需要明确步骤和目标的任务"
-            },
-            "context": {
-                "type": "string",
-                "description": "必填：背景信息、执行步骤和预期结果",
-                "default": ""
-            }
-        },
-        "required": ["name", "task", "context"]
-    }
-
-    def __init__(self, model: BaseModel):
-        """Initialize with the same model as parent agent"""
-        self.model = model
-
-    def execute(self, args: Dict) -> Dict[str, Any]:
-        """Create and run a sub-agent for the specified task"""
-        try:
-            name = args["name"]
-            task = args["task"]
-            context = args.get("context")
-
-            if not context:
-                return {
-                    "success": False,
-                    "error": "必须提供上下文信息，包括完整的背景和执行步骤。"
-                }
-
-            PrettyOutput.print(f"正在创建子代理 '{name}'...", OutputType.INFO)
-            
-            # Create a new tool registry for the sub-agent
-            tool_registry = ToolRegistry(self.model)
-            
-            # Create the sub-agent with the specified name
-            sub_agent = Agent(self.model, tool_registry, name=name, is_sub_agent=True)
-            
-            # Prepare the task with context
-            full_task = f"""背景和步骤：
-{context}
-
-主要任务：
-{task}
-
-要求：
-1. 严格按照提供的步骤执行
-2. 每完成一个步骤都要报告进度
-3. 突出显示任何问题或不明确的点
-4. 提供符合预期输出的详细结果"""
-            
-            PrettyOutput.print(f"子代理 '{name}' 正在执行任务...", OutputType.INFO)
-            
-            # Execute the task and get the summary
-            summary = sub_agent.run(full_task)
-            return {
-                "success": True,
-                "stdout": f"子代理 '{name}' 已完成。\n\n结果：\n{summary}",
-                "stderr": ""
-            }
-
-        except Exception as e:
-            return {
-                "success": False,
-                "error": f"子代理执行失败：{str(e)}"
-            } 

jarvis/tools/webpage.py

@@ -1,76 +0,0 @@
-from typing import Dict, Any
-import requests
-from bs4 import BeautifulSoup
-from ..utils import PrettyOutput, OutputType
-
-class WebpageTool:
-    name = "read_webpage"
-    description = "读取网页内容，提取标题和正文文本"
-    parameters = {
-        "type": "object",
-        "properties": {
-            "url": {
-                "type": "string",
-                "description": "需要读取的网页URL"
-            }
-        },
-        "required": ["url"]
-    }
-
-    def execute(self, args: Dict) -> Dict[str, Any]:
-        """读取网页内容"""
-        try:
-            url = args["url"]
-            
-            # 设置请求头
-            headers = {
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
-            }
-            
-            # 发送请求
-            PrettyOutput.print(f"正在读取网页: {url}", OutputType.INFO)
-            response = requests.get(url, headers=headers, timeout=10)
-            response.raise_for_status()
-            
-            # 使用正确的编码
-            response.encoding = response.apparent_encoding
-            
-            # 解析HTML
-            soup = BeautifulSoup(response.text, 'html.parser')
-            
-            # 移除script和style标签
-            for script in soup(["script", "style"]):
-                script.decompose()
-            
-            # 提取标题
-            title = soup.title.string if soup.title else ""
-            title = title.strip() if title else "无标题"
-            
-            # 提取正文
-            text = soup.get_text(separator='\n', strip=True)
-            lines = [line.strip() for line in text.splitlines() if line.strip()]
-            
-            # 构建输出
-            output = [
-                f"标题: {title}",
-                "",
-                "正文内容:",
-                "\n".join(lines)
-            ]
-            
-            return {
-                "success": True,
-                "stdout": "\n".join(output),
-                "stderr": ""
-            }
-
-        except requests.RequestException as e:
-            return {
-                "success": False,
-                "error": f"网页请求失败: {str(e)}"
-            }
-        except Exception as e:
-            return {
-                "success": False,
-                "error": f"解析网页失败: {str(e)}"
-            } 

jarvis/zte_llm.py

@@ -1,135 +0,0 @@
-import requests
-import json
-import os
-from pathlib import Path
-from typing import Dict, Any, List, Optional
-
-from jarvis.utils import OutputType, PrettyOutput
-from .models import BaseModel
-
-class ZteLLM(BaseModel):
-    """ZTE Nebula LLM implementation"""
-    
-    def __init__(self, 
-                 app_id: str,
-                 app_key: str,
-                 emp_no: str,
-                 auth_value: str,
-                 model: str = "nebulacoder",
-                 ):
-        """Initialize ZTE LLM with required credentials"""
-        self.app_id = str(app_id)
-        self.app_key = str(app_key)
-        self.emp_no = str(emp_no)
-        self.auth_value = str(auth_value)
-        self.model = model
-        self.base_url = "https://studio.zte.com.cn/zte-studio-ai-platform/openapi/v1"
-        
-    def _make_request(self, endpoint: str, data: Dict[str, Any]) -> Dict[str, Any]:
-        """Make request to ZTE API"""
-        headers = {
-            'Content-Type': 'application/json',
-            'Authorization': f'Bearer {self.app_id}-{self.app_key}',
-            'X-Emp-No': self.emp_no,
-            'X-Auth-Value': self.auth_value
-        }
-        
-        response = requests.post(
-            f"{self.base_url}/{endpoint}",
-            headers=headers,
-            json=data,
-            stream=True  # 启用流式传输
-        )
-        
-        response.raise_for_status()
-        
-        full_content = []
-        for line in response.iter_lines():
-            if line:
-                # 解析 SSE 数据
-                line = line.decode('utf-8')
-                if line.startswith('data: '):
-                    try:
-                        data = json.loads(line[6:])  # 跳过 "data: " 前缀
-                        if "result" in data:
-                            result = data["result"]
-                            if result:  # 只处理非空结果
-                                full_content.append(result)
-                                PrettyOutput.print_stream(result, OutputType.SYSTEM)
-                            if data.get("finishReason") == "stop":
-                                break
-                    except json.JSONDecodeError:
-                        continue
-        PrettyOutput.print_stream_end()
-        
-        return "".join(full_content)
-
-    def chat(self, messages: List[Dict[str, Any]]) -> str:
-        """Chat with ZTE LLM"""
-        # Convert messages to prompt
-        prompt = self._convert_messages_to_prompt(messages)
-        
-        # Prepare data for API call
-        data = {
-            "chatUuid": "",
-            "chatName": "",
-            "stream": True,  # 启用流式响应
-            "keep": False,
-            "text": prompt,
-            "model": self.model
-        }
-        
-        try:
-            return self._make_request("chat", data)
-
-            
-        except Exception as e:
-            raise Exception(f"ZTE LLM chat failed: {str(e)}")
-
-    def _convert_messages_to_prompt(self, messages: List[Dict[str, Any]]) -> str:
-        """Convert message list to a single prompt string"""
-        prompt_parts = []
-        
-        for message in messages:
-            role = message["role"]
-            content = message.get("content", "")
-            
-            if role == "system":
-                prompt_parts.append(f"System: {content}")
-            elif role == "user":
-                prompt_parts.append(f"User: {content}")
-            elif role == "assistant":
-                prompt_parts.append(f"Assistant: {content}")
-            elif role == "tool":
-                prompt_parts.append(f"Tool Result: {content}")
-                
-        return "\n\n".join(prompt_parts)
-
-
-def create_zte_llm(model_name: str = "NebulaBiz") -> ZteLLM:
-    """Create ZTE LLM instance with provided parameters"""
-    # Load environment variables from file
-    
-    # Get credentials from parameters, env file, or system environment variables
-    app_id = os.getenv('ZTE_APP_ID') 
-    app_key = os.getenv('ZTE_APP_KEY') 
-    emp_no = os.getenv('ZTE_EMP_NO') 
-    auth_value = os.getenv('ZTE_AUTH_VALUE') 
-    
-    # Validate required credentials
-    if not all([app_id, app_key, emp_no, auth_value]):
-        raise ValueError(
-            "Missing required credentials. Please provide through either:\n"
-            "1. Function parameters\n"
-            "2. ~/.jarvis_env file\n"
-            "3. System environment variables\n\n"
-            "Required variables: ZTE_APP_ID, ZTE_APP_KEY, ZTE_EMP_NO, ZTE_AUTH_VALUE"
-        )
-    
-    return ZteLLM(
-        app_id=app_id,
-        app_key=app_key,
-        emp_no=emp_no,
-        auth_value=auth_value,
-        model=model_name
-    ) 

jarvis_ai_assistant-0.1.8.dist-info/RECORD

@@ -1,38 +0,0 @@
-jarvis/__init__.py,sha256=QIcBZBFMcOFbIudbA0VykyqY4RphA3fWQlRP_kUMcPM,49
-jarvis/agent.py,sha256=ePgdOCWdkw35KITvZOqcrJOGl-F4wzvrltHTw7N4p88,11014
-jarvis/main.py,sha256=4IqebMKGoBGJMSNFE6E6GQ_Ay-uuOT-BLsQPnQVW47k,6705
-jarvis/models.py,sha256=G9QkUqoyOyUx6eSqwbn3hCSwHguN0bUm7Nbd6Ql0IQs,3771
-jarvis/utils.py,sha256=3hLtv-HcBL8Ngw69cowhARuIFrjcQ6yRP3Y1o9CvtsI,5992
-jarvis/zte_llm.py,sha256=Us5D6zMdZT6SoSnUgKWQbxthGadXkulLs_oSmW5MPDo,4666
-jarvis/__pycache__/__init__.cpython-313.pyc,sha256=lGXFfeYKcGsFZjgHY8y4zLca1xBIkr2zKSQv06rhoBY,208
-jarvis/__pycache__/agent.cpython-313.pyc,sha256=itbFLk6qJ9FTjbiyj6DsQhu5NbdxVaP4g-SygRguvSc,11625
-jarvis/__pycache__/main.cpython-313.pyc,sha256=6hWRW-RG_bZrqwhSQXyhKaJBXexgLqKa-_SZzAk6_eo,8479
-jarvis/__pycache__/models.cpython-313.pyc,sha256=uWuRIjGrY4YDB3dGW5PGDLWaS03et8g11O725TjY_eU,5960
-jarvis/__pycache__/tools.cpython-313.pyc,sha256=lAD4LrnnWzNZQmHXGfZ_2l7oskOpr2_2OC-gdFhxQY8,33933
-jarvis/__pycache__/utils.cpython-313.pyc,sha256=k4jyAlx4tlW0MKLMLzV7OOH9zsKrK0H955kY6M2SuFU,8772
-jarvis/__pycache__/zte_llm.cpython-313.pyc,sha256=R_HT_Gc6OQelxRLRQ-yB8Tf0sYHcb18dh9E4RF6ivbE,5662
-jarvis/tools/__init__.py,sha256=tH6YaApKpqs1YSjEllRzOZZUd-OTFKSZ5oA0zs7HdSE,297
-jarvis/tools/base.py,sha256=zK-JteBwj9d2BD_7BSAp-zD7wgJbVBppAWyfFxaPObI,4114
-jarvis/tools/file_ops.py,sha256=zTksx45NZm3iz9itN5iQGZ8DoxnSeTHdrnF08_ix7PU,3770
-jarvis/tools/search.py,sha256=HJQ1_-CXB9M4wiq4wbLYdI-Vz92JiA6LGnog3b1dDd4,5293
-jarvis/tools/shell.py,sha256=7q52lA3slf0TdjBjP1bkwugoO5pB0eqh6cYjAzAXNtI,2547
-jarvis/tools/sub_agent.py,sha256=QJYWdil1goZfo95CQkuhkjZBl-Rx6UvyeFMiGnDyjOA,2832
-jarvis/tools/webpage.py,sha256=DBnh9gye6oL2nVjzU2SU4Jupsck8x9g9On-rbjV6d8Y,2386
-jarvis/tools/__pycache__/__init__.cpython-313.pyc,sha256=1d1eUI0FlaydGB8TFBln6s7cBKd6gcPdER2_DIfX2Aw,443
-jarvis/tools/__pycache__/base.cpython-313.pyc,sha256=2OJWYNsGJjKJs6Vdj9NcN_Snjd2bA_OLlB-zr2j4wfs,6462
-jarvis/tools/__pycache__/bing_search.cpython-313.pyc,sha256=t4OZJrEgP35xdidDjVypxsDN07JAlh5PcpTkauFyllA,7029
-jarvis/tools/__pycache__/file_ops.cpython-313.pyc,sha256=LbOp31JUzoRp5XVazy1VBqCQhpFg0qQYmVftFVY90V4,3628
-jarvis/tools/__pycache__/python_script.cpython-313.pyc,sha256=8JpryqTovEiTvBlWAK1KjZmPvHUuPc9GT9rTXBEQoJc,6693
-jarvis/tools/__pycache__/rag.cpython-313.pyc,sha256=JH6-PSZRMKAvTZqCwlRXJGClxYXNMs-vetU0q7hBLz0,6064
-jarvis/tools/__pycache__/search.cpython-313.pyc,sha256=7lS5jDmClpHJXKnbBaUCys8CmW1YBJtZAa4c64JGO6I,6624
-jarvis/tools/__pycache__/shell.cpython-313.pyc,sha256=QMaLUc1MtZXWod3msv_x7iMq2IybwMwz1OoaKsbm6U4,3271
-jarvis/tools/__pycache__/sub_agent.cpython-313.pyc,sha256=qzNLnQxqFZoAiYOPH4GrCGxaQVs-QWfTLspW5a1Xa6c,3144
-jarvis/tools/__pycache__/user_confirmation.cpython-313.pyc,sha256=wK3Ev10lHSUSRvoYmi7A0GzxYkzU-C4Wfhs5qW_HBqs,2271
-jarvis/tools/__pycache__/user_input.cpython-313.pyc,sha256=JjTFOhObKsKF4Pn8KBRuKfV1_Ssj083fjU7Mfc_5z7c,2531
-jarvis/tools/__pycache__/user_interaction.cpython-313.pyc,sha256=RuVZ-pmiPBDywY3efgXSfohMAciC1avMGPmBK5qlnew,3305
-jarvis/tools/__pycache__/webpage.cpython-313.pyc,sha256=BjzSfnNzsKCrLETCcWjt32lNDLzwnjqcVGg4JfWd9OM,3008
-jarvis_ai_assistant-0.1.8.dist-info/METADATA,sha256=3zrOu0XJCW5EO4UbCeRIK0xNw6JcW60tFr6b6VdWET4,3719
-jarvis_ai_assistant-0.1.8.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-jarvis_ai_assistant-0.1.8.dist-info/entry_points.txt,sha256=iKu7OMfew9dtfGhW71gIMTg4wvafuPqKb4wyQOnMAGU,44
-jarvis_ai_assistant-0.1.8.dist-info/top_level.txt,sha256=1BOxyWfzOP_ZXj8rVTDnNCJ92bBGB0rwq8N1PCpoMIs,7
-jarvis_ai_assistant-0.1.8.dist-info/RECORD,,