jarvis-ai-assistant 0.1.2__py3-none-any.whl → 0.1.5__py3-none-any.whl

jarvis/__init__.py

@@ -1,3 +1,3 @@
 """Jarvis AI Assistant"""
 
-__version__ = "0.1.2" 
+__version__ = "0.1.5" 

jarvis/agent.py

@@ -3,21 +3,32 @@ import subprocess
 from typing import Dict, Any, List, Optional
 from .tools import ToolRegistry
 from .utils import Spinner, PrettyOutput, OutputType, get_multiline_input
-from .models import BaseModel, OllamaModel
+from .models import BaseModel
 import re
 import os
 from datetime import datetime
 
 class Agent:
-    def __init__(self, model: BaseModel, tool_registry: ToolRegistry):
+    def __init__(self, model: BaseModel, tool_registry: ToolRegistry, name: str = "Jarvis"):
+        """Initialize Agent with a model, optional tool registry and name"""
         self.model = model
-        self.tool_registry = tool_registry
+        self.tool_registry = tool_registry or ToolRegistry(model)
+        self.name = name
         # 编译正则表达式
         self.tool_call_pattern = re.compile(r'<tool_call>\s*({[^}]+})\s*</tool_call>')
         self.messages = [
             {
                 "role": "system",
-                "content": """You are a rigorous AI assistant, all data must be obtained through tools, and no fabrication or speculation is allowed. """ + "\n" + self.tool_registry.tool_help_text()
+                "content": f"""You are {name}, a rigorous AI assistant that executes tasks step by step.
+
+Key Principles:
+1. Execute ONE step at a time
+2. Wait for each step's result before planning the next
+3. Use tools to obtain all data, no fabrication
+4. Create sub-agents for independent subtasks
+5. Think carefully before each action
+
+""" + self.tool_registry.tool_help_text()
             }
         ]
         self.spinner = Spinner()
@@ -28,44 +39,38 @@ class Agent:
         try:
             return self.model.chat(
                 messages=messages,
-                tools=self.tool_registry.get_all_tools() if use_tools else None
+                tools=self.tool_registry.get_all_tools() if use_tools else []
             )
         except Exception as e:
-            raise Exception(f"模型调用失败: {str(e)}")
+            raise Exception(f"{self.name}: 模型调用失败: {str(e)}")
         finally:
             self.spinner.stop()
 
-
-    def run(self, user_input: str) :
-        """处理用户输入并返回响应"""
-        # 检查是否是结束命令
+    def run(self, user_input: str) -> str:
+        """处理用户输入并返回响应，返回任务总结报告"""
         self.clear_history()
         self.messages.append({
             "role": "user",
             "content": user_input
         })
+        
         while True:
             try:
-                # 获取初始响应
                 response = self._call_model(self.messages)
                 current_response = response
 
-                # 将工具执行结果添加到对话
                 self.messages.append({
                     "role": "assistant",
                     "content": response["message"].get("content", ""),
                     "tool_calls": current_response["message"]["tool_calls"]
                 })
                 
-                # 处理可能的多轮工具调用
                 if len(current_response["message"]["tool_calls"]) > 0:
-                    # 添加当前助手响应到输出（如果有内容）
                     if current_response["message"].get("content"):
-                        PrettyOutput.print(current_response["message"]["content"], OutputType.SYSTEM)
+                        PrettyOutput.print(f"{self.name}: {current_response['message']['content']}", OutputType.SYSTEM)
                         
-                    # 使用 ToolRegistry 的 handle_tool_calls 方法处理工具调用
                     tool_result = self.tool_registry.handle_tool_calls(current_response["message"]["tool_calls"])
-                    PrettyOutput.print(tool_result, OutputType.RESULT)
+                    PrettyOutput.print(f"{self.name} Tool Result: {tool_result}", OutputType.RESULT)
 
                     self.messages.append({
                         "role": "tool",
@@ -73,18 +78,46 @@ class Agent:
                     })
                     continue
                 
-                # 添加最终响应到对话历史和输出
                 final_content = current_response["message"].get("content", "")
-                
                 if final_content:
-                    PrettyOutput.print(final_content, OutputType.SYSTEM)
-                    
+                    PrettyOutput.print(f"{self.name}: {final_content}", OutputType.SYSTEM)
                 
-                # 如果没有工具调用且响应很短，可能需要继续对话
-                user_input = get_multiline_input("您可以继续输入，或输入空行结束当前任务")
-                if  not user_input:
-                    PrettyOutput.print("===============任务结束===============", OutputType.INFO)
-                    break
+                user_input = get_multiline_input(f"{self.name}: 您可以继续输入，或输入空行结束当前任务")
+                if not user_input:
+                    PrettyOutput.print(f"{self.name}: 正在生成任务总结...", OutputType.INFO)
+                    
+                    # 优化后的任务总结提示语
+                    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.print(f"==============={self.name} 任务总结===============", OutputType.INFO)
+                            PrettyOutput.print(summary, OutputType.SYSTEM)
+                            PrettyOutput.print("=" * (len(self.name) + 16), OutputType.INFO)
+                            
+                            return summary
+                            
+                        except Exception as e:
+                            error_msg = f"{self.name}: 生成任务总结时出错: {str(e)}"
+                            PrettyOutput.print(error_msg, OutputType.ERROR)
+                        
                 
                 self.messages.append({
                     "role": "user",
@@ -92,7 +125,7 @@ class Agent:
                 })
                 
             except Exception as e:
-                error_msg = f"处理响应时出错: {str(e)}"
+                error_msg = f"{self.name}: 处理响应时出错: {str(e)}"
                 PrettyOutput.print(error_msg, OutputType.ERROR)
 
     def clear_history(self):

jarvis/main.py

@@ -13,7 +13,8 @@ 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.utils import PrettyOutput, OutputType, get_multiline_input
+from jarvis.utils import PrettyOutput, OutputType, get_multiline_input, load_env_from_file
+from jarvis.zte_llm import create_zte_llm
 
 # 定义支持的平台和模型
 SUPPORTED_PLATFORMS = {
@@ -24,35 +25,48 @@ SUPPORTED_PLATFORMS = {
     "ddgs": {
         "models": ["gpt-4o-mini", "claude-3-haiku", "llama-3.1-70b", "mixtral-8x7b"],
         "default": "gpt-4o-mini"
+    },
+    "zte": {
+        "models": ["NebulaBiz", "nebulacoder", "NTele-72B"],
+        "default": "NebulaBiz"
     }
 }
 
-def load_tasks() -> list:
+def load_tasks() -> dict:
     """Load tasks from .jarvis file if it exists."""
     if not os.path.exists(".jarvis"):
-        return []
+        return {}
     
     try:
         with open(".jarvis", "r", encoding="utf-8") as f:
             tasks = yaml.safe_load(f)
             
-        if not isinstance(tasks, list):
-            PrettyOutput.print("Warning: .jarvis file should contain a list of tasks", OutputType.ERROR)
-            return []
+        if not isinstance(tasks, dict):
+            PrettyOutput.print("Warning: .jarvis file should contain a dictionary of task_name: task_description", OutputType.ERROR)
+            return {}
             
-        return [str(task) for task in tasks if task]  # Convert all tasks to strings and filter out empty ones
+        # Validate format and convert all values to strings
+        validated_tasks = {}
+        for name, desc in tasks.items():
+            if desc:  # Ensure description is not empty
+                validated_tasks[str(name)] = str(desc)
+                
+        return validated_tasks
     except Exception as e:
         PrettyOutput.print(f"Error loading .jarvis file: {str(e)}", OutputType.ERROR)
-        return []
+        return {}
 
-def select_task(tasks: list) -> str:
-    """Let user select a task from the list or skip."""
+def select_task(tasks: dict) -> str:
+    """Let user select a task from the list or skip. Returns task description if selected."""
     if not tasks:
         return ""
     
-    PrettyOutput.print("\nFound predefined tasks:", OutputType.INFO)
-    for i, task in enumerate(tasks, 1):
-        PrettyOutput.print(f"[{i}] {task}", OutputType.INFO)
+    # Convert tasks to list for ordered display
+    task_names = list(tasks.keys())
+    
+    PrettyOutput.print("\nAvailable tasks:", OutputType.INFO)
+    for i, name in enumerate(task_names, 1):
+        PrettyOutput.print(f"[{i}] {name}", OutputType.INFO)
     PrettyOutput.print("[0] Skip predefined tasks", OutputType.INFO)
     
     while True:
@@ -64,8 +78,9 @@ def select_task(tasks: list) -> str:
             choice = int(choice)
             if choice == 0:
                 return ""
-            elif 1 <= choice <= len(tasks):
-                return tasks[choice - 1]
+            elif 1 <= choice <= len(task_names):
+                selected_name = task_names[choice - 1]
+                return tasks[selected_name]  # Return the task description
             else:
                 PrettyOutput.print("Invalid choice. Please try again.", OutputType.ERROR)
         except ValueError:
@@ -79,7 +94,7 @@ def main():
     parser.add_argument(
         "--platform",
         choices=list(SUPPORTED_PLATFORMS.keys()),
-        default="ollama",
+        default="ddgs",
         help="选择运行平台 (默认: ollama)"
     )
     
@@ -97,6 +112,8 @@ def main():
     )
     
     args = parser.parse_args()
+
+    load_env_from_file()
     
     # 验证并设置默认模型
     if args.model:
@@ -119,11 +136,14 @@ def main():
                 api_base=args.api_base
             )
             platform_name = f"Ollama ({args.model})"
-        else:  # ddgs
+        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})"
 
-        tool_registry = ToolRegistry()
+        tool_registry = ToolRegistry(model)
         agent = Agent(model, tool_registry)
 
         # 欢迎信息

jarvis/models.py

@@ -20,31 +20,29 @@ class BaseModel(ABC):
     def extract_tool_calls(content: str) -> List[Dict]:
         """从内容中提取工具调用"""
         tool_calls = []
-        # 修改正则表达式以更好地处理多行内容
-        pattern = re.compile(
-            r'<tool_call>\s*({(?:[^{}]|(?:{[^{}]*})|(?:{(?:[^{}]|{[^{}]*})*}))*})\s*</tool_call>',
-            re.DOTALL  # 添加DOTALL标志以匹配跨行内容
-        )
+        # 使用非贪婪匹配来获取标签之间的所有内容
+        pattern = re.compile(r'<tool_call>(.*?)</tool_call>', re.DOTALL)
         
         matches = pattern.finditer(content)
         for match in matches:
             try:
-                tool_call_str = match.group(1).strip()
-                tool_call = json.loads(tool_call_str)
-                if isinstance(tool_call, dict) and "name" in tool_call and "arguments" in tool_call:
+                # 提取并解析 JSON
+                tool_call_text = match.group(1).strip()
+                tool_call_data = json.loads(tool_call_text)
+                
+                # 验证必要的字段
+                if "name" in tool_call_data and "arguments" in tool_call_data:
                     tool_calls.append({
                         "function": {
-                            "name": tool_call["name"],
-                            "arguments": tool_call["arguments"]
+                            "name": tool_call_data["name"],
+                            "arguments": tool_call_data["arguments"]
                         }
                     })
-                else:
-                    PrettyOutput.print(f"无效的工具调用格式: {tool_call_str}", OutputType.ERROR)
-            except json.JSONDecodeError as e:
-                PrettyOutput.print(f"JSON解析错误: {str(e)}", OutputType.ERROR)
-                PrettyOutput.print(f"解析内容: {tool_call_str}", OutputType.ERROR)
-                continue
-        
+            except json.JSONDecodeError:
+                continue  # 跳过无效的 JSON
+            except Exception:
+                continue  # 跳过其他错误
+                
         return tool_calls
 
 

jarvis/tools/__init__.py

@@ -3,9 +3,6 @@ from .python_script import PythonScript
 from .file_ops import FileOperationTool
 from .search import SearchTool
 from .shell import ShellTool
-from .user_interaction import UserInteractionTool
-from .user_confirmation import UserConfirmationTool
-from .rag import RAGTool
 from .webpage import WebpageTool
 
 __all__ = [
@@ -15,8 +12,5 @@ __all__ = [
     'FileOperationTool',
     'SearchTool',
     'ShellTool',
-    'UserInteractionTool',
-    'UserConfirmationTool',
-    'RAGTool',
     'WebpageTool',
 ] 

jarvis/tools/base.py

@@ -1,6 +1,7 @@
 from typing import Dict, Any, List, Optional, Callable
 import json
 from ..utils import PrettyOutput, OutputType
+from ..models import BaseModel
 
 class Tool:
     def __init__(self, name: str, description: str, parameters: Dict, func: Callable):
@@ -25,29 +26,25 @@ class Tool:
         return self.func(arguments)
 
 class ToolRegistry:
-    def __init__(self):
+    def __init__(self, model: BaseModel):
         self.tools: Dict[str, Tool] = {}
+        self.model = model
         self._register_default_tools()
 
     def _register_default_tools(self):
         """注册所有默认工具"""
         from .search import SearchTool
         from .shell import ShellTool
-        from .user_interaction import UserInteractionTool
-        from .user_confirmation import UserConfirmationTool
         from .python_script import PythonScriptTool
         from .file_ops import FileOperationTool
-        from .rag import RAGTool
         from .webpage import WebpageTool
+        from .sub_agent import SubAgentTool
 
         tools = [
             SearchTool(),
             ShellTool(),
-            UserInteractionTool(),
-            UserConfirmationTool(),
             PythonScriptTool(),
             FileOperationTool(),
-            RAGTool(),
             WebpageTool(),
         ]
 
@@ -59,6 +56,14 @@ 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)
@@ -117,64 +122,77 @@ class ToolRegistry:
     def tool_help_text(self) -> str:
         """返回所有工具的帮助文本"""
         return """Available Tools:
+
 1. search: Search for information using DuckDuckGo
 2. read_webpage: Extract content from webpages
 3. execute_python: Run Python code with dependency management
 4. execute_shell: Execute shell commands
-5. ask_user: Get input from user with options support
-6. ask_user_confirmation: Get yes/no confirmation from user
-7. file_operation: Read/write files in workspace directory
-8. rag_query: Query documents using RAG
-
-Output Guidelines:
-1. Focus on Essential Information
-   - Filter out irrelevant or redundant information
-   - Only output the most relevant search results
-   - Summarize long content when possible
-
-2. Context Management
-   - Avoid repeating information that's already known
-   - Don't echo back the entire content of files
-   - Use snippets instead of full documents
-
-3. Error Handling
-   - Only show relevant parts of error messages
-   - Include troubleshooting steps when appropriate
-   - Omit stack traces unless specifically requested
-
-4. Search Results
-   - Focus on the most relevant 2-3 results
-   - Extract key information instead of full articles
-   - Skip duplicate or similar content
-
-5. RAG Queries
-   - Return only the most relevant passages
-   - Combine similar information
-   - Skip redundant context
-
-Tool Usage Examples:
+5. file_operation: Read/write files in workspace directory
+6. create_sub_agent: Create a sub-agent to handle subtasks (ONLY for independent subtasks)
+
+Core Rules:
+1. ONE Step at a Time
+   - Execute only one action per response
+   - Explain what you're going to do before doing it
+   - Wait for the result before planning next step
+   - No multiple actions or parallel execution
+
+2. Sub-Agent Usage (ONLY for Subtasks)
+   - Create sub-agents ONLY to handle independent subtasks
+   - Main task should be broken down into clear subtasks first
+   - Examples of good subtask delegation:
+     * Analyzing each Python file in a directory
+     * Processing each data file in a batch
+     * Researching different aspects of a topic
+     * Reviewing multiple code components
+   - Do NOT use for:
+     * Main task execution
+     * Single file operations
+     * Simple sequential steps
+     * Tasks requiring continuous context
+
+3. Output Guidelines
+   - Focus on essential information
+   - Clear step-by-step explanations
+   - Summarize results concisely
+
+Tool Call Format:
+<tool_call>
+{
+    "name": "tool_name",
+    "arguments": {
+        "param1": "value1"
+    }
+}
+</tool_call>
+
+Example (Correct - Subtask Delegation):
+Assistant: I'll create a sub-agent to handle the code analysis subtask.
 <tool_call>
 {
-    "name": "search",
+    "name": "create_sub_agent",
     "arguments": {
-        "query": "Python GIL",
-        "max_results": 2  # Limit results to save context
+        "name": "CodeAnalyzer",
+        "task": "Analyze the utils.py file structure and generate documentation",
+        "context": "This is part of the larger documentation task"
     }
 }
 </tool_call>
 
+Example (Incorrect - Main Task):
+❌ Assistant: I'll create a sub-agent to handle the entire project analysis.
 <tool_call>
 {
-    "name": "read_webpage",
+    "name": "create_sub_agent",
     "arguments": {
-        "url": "https://example.com",
-        "extract_type": "text"  # Only get main content
+        "name": "ProjectAnalyzer",
+        "task": "Analyze and document the entire project"
     }
 }
 </tool_call>
 
 Remember:
-1. Quality over quantity
-2. Relevance over completeness
-3. Conciseness over verbosity
-4. Context efficiency is crucial"""
+1. ONE step at a time
+2. Create sub-agents ONLY for subtasks
+3. Explain before acting
+4. Wait for results"""

jarvis/tools/shell.py

@@ -4,13 +4,27 @@ from ..utils import PrettyOutput, OutputType
 
 class ShellTool:
     name = "execute_shell"
-    description = "Execute shell commands and return the results"
+    description = """Execute shell commands and return the results.
+    Guidelines for output optimization:
+    1. Use grep/awk/sed to filter output when possible
+    2. Avoid listing all files/dirs unless specifically needed
+    3. Prefer -q/--quiet flags when status is all that's needed
+    4. Use head/tail to limit long outputs
+    5. Redirect stderr to /dev/null for noisy commands
+    
+    Examples of optimized commands:
+    - 'ls -l file.txt' instead of 'ls -l'
+    - 'grep -c pattern file' instead of 'grep pattern file'
+    - 'ps aux | grep process | head -n 5' instead of 'ps aux'
+    - 'command 2>/dev/null' to suppress error messages
+    - 'df -h . ' instead of 'df -h'
+    """
     parameters = {
         "type": "object",
         "properties": {
             "command": {
                 "type": "string",
-                "description": "Shell command to execute"
+                "description": "Shell command to execute (use filters/limits for large outputs)"
             },
             "timeout": {
                 "type": "integer",

jarvis/tools/sub_agent.py

@@ -0,0 +1,79 @@
+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 = """Create a sub-agent to handle independent tasks.
+    
+Use this tool when:
+1. A subtask can be executed independently
+2. The task requires separate context management
+3. To optimize token usage of the main agent
+4. For parallel task processing
+
+The sub-agent will:
+1. Inherit all tools from the parent agent
+2. Maintain its own conversation history
+3. Return a comprehensive task summary
+"""
+    parameters = {
+        "type": "object",
+        "properties": {
+            "name": {
+                "type": "string",
+                "description": "Name for the sub-agent (e.g., 'FileAnalyzer', 'CodeReviewer')"
+            },
+            "task": {
+                "type": "string",
+                "description": "Task description with complete context"
+            },
+            "context": {
+                "type": "string",
+                "description": "Additional context or background information",
+                "default": ""
+            }
+        },
+        "required": ["name", "task"]
+    }
+
+    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", "")
+
+            PrettyOutput.print(f"Creating sub-agent '{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)
+            
+            # Prepare the task with context if provided
+            full_task = f"{context}\n\nTask: {task}" if context else task
+            
+            PrettyOutput.print(f"Sub-agent '{name}' executing task...", OutputType.INFO)
+            
+            # Execute the task and get the summary
+            summary = sub_agent.run(full_task)
+            
+            return {
+                "success": True,
+                "stdout": f"Sub-agent '{name}' completed the task.\n\nSummary:\n{summary}",
+                "stderr": ""
+            }
+
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Sub-agent execution failed: {str(e)}"
+            } 

jarvis/utils.py

@@ -1,11 +1,13 @@
+from pathlib import Path
 import sys
 import time
 import threading
-from typing import Optional
+from typing import Dict, Optional
 from enum import Enum
 from datetime import datetime
 import colorama
 from colorama import Fore, Style
+import os
 
 # 初始化colorama
 colorama.init()
@@ -102,4 +104,25 @@ def get_multiline_input(tip: str) -> str:
             PrettyOutput.print("\n输入已取消", OutputType.ERROR)
             return ""
     
-    return "\n".join(lines).strip()
+    return "\n".join(lines).strip()
+
+
+def load_env_from_file():
+    """Load environment variables from ~/.jarvis_env file"""
+    env_file = Path.home() / ".jarvis_env"
+    
+    if env_file.exists():
+        try:
+            with open(env_file, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith("#"):
+                        try:
+                            key, value = line.split("=", 1)
+                            os.environ[key.strip()] = value.strip().strip("'").strip('"')
+                        except ValueError:
+                            continue
+        except Exception as e:
+            print(f"Warning: Failed to read ~/.jarvis_env: {e}")
+    
+    

jarvis/zte_llm.py

@@ -0,0 +1,132 @@
+import requests
+import json
+import os
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+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
+        )
+        
+        response.raise_for_status()
+        result = response.json()
+        
+        if result["code"]["code"] != "0000":
+            raise Exception(f"API Error: {result['code']['msg']}")
+            
+        return result["bo"]
+
+    def chat(self, messages: List[Dict[str, Any]], tools: Optional[List[Dict]] = None) -> Dict[str, Any]:
+        """Chat with ZTE LLM"""
+        # Convert messages to prompt
+        prompt = self._convert_messages_to_prompt(messages)
+        
+        # Prepare data for API call
+        data = {
+            "chatUuid": "",
+            "chatName": "",
+            "stream": False,
+            "keep": False,
+            "text": prompt,
+            "model": self.model
+        }
+        
+        # If tools are provided, add them to the prompt
+        if tools:
+            tools_desc = "Available tools:\n\n" + json.dumps(tools, indent=2, ensure_ascii=False)
+            data["text"] = tools_desc + "\n\n" + data["text"]
+        
+        try:
+            result = self._make_request("chat", data)
+            
+            # Parse the response to extract potential tool calls
+            response_text = result["result"]
+            tool_calls = BaseModel.extract_tool_calls(response_text)
+            
+            return {
+                "message": {
+                    "content": response_text,
+                    "tool_calls": tool_calls
+                }
+            }
+            
+        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.2.dist-info → jarvis_ai_assistant-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: jarvis-ai-assistant
-Version: 0.1.2
+Version: 0.1.5
 Summary: Jarvis: An AI assistant that uses tools to interact with the system
 Home-page: https://github.com/skyfireitdiy/Jarvis
 Author: skyfire
@@ -21,13 +21,15 @@ 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: sentence-transformers>=2.5.1
-Requires-Dist: chromadb>=0.4.24
+Requires-Dist: colorama>=0.4.6
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: black; extra == "dev"
 Requires-Dist: isort; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
 
 <div align="center">
 

jarvis_ai_assistant-0.1.5.dist-info/RECORD

@@ -0,0 +1,38 @@
+jarvis/.jarvis,sha256=S4ZMmLqlVLHAPmnwHFQ3vYt0gnDFp-KQRH4okBh8Hpw,209
+jarvis/__init__.py,sha256=ArINt8uI8UveWy3H6iPntzn05IR-PEq6P7qb8dzmPjc,49
+jarvis/agent.py,sha256=YdtSBqwGl8xKN9xWIqYcAgxsLmXKyXzLcJ1D-Oie9fE,5536
+jarvis/main.py,sha256=egbfAhkHUGHI5J3j5ZMwb9EgOXE7ikJef-4lqFj0-mA,6063
+jarvis/models.py,sha256=NWXMsgnw6AHkfk22tvmGOjcyVhC74Us-t3T6rUF4R20,4186
+jarvis/utils.py,sha256=-5tugkGABZdi2QXVStVtCQfag9CRTfCsGUvReitmHUM,3816
+jarvis/zte_llm.py,sha256=ygUeGd8WGm0qrnkt5TrCLnaf5ZFZ0tdfwrA7nrByt4g,4504
+jarvis/__pycache__/__init__.cpython-313.pyc,sha256=viNe2ZOgBWfBtJpzh5J0oAhQphAwJi4m2ogxgBgCt6s,208
+jarvis/__pycache__/agent.cpython-313.pyc,sha256=7Ae1sOwF6W2HCGjzDToWdCOYFiS47EUqDZVCz2OxH9Q,7125
+jarvis/__pycache__/main.cpython-313.pyc,sha256=lNKrL5HZQahMGpv5cOVriWZoNOScMWRk_toYD7X-Xeo,7444
+jarvis/__pycache__/models.cpython-313.pyc,sha256=fot2VOV0lgODg4b_WuD-kkq-g7uZGLuZlYXiljlW13U,6350
+jarvis/__pycache__/tools.cpython-313.pyc,sha256=lAD4LrnnWzNZQmHXGfZ_2l7oskOpr2_2OC-gdFhxQY8,33933
+jarvis/__pycache__/utils.cpython-313.pyc,sha256=m9l4R4U1vCG2WkXXNWCTbSASRiS6tWYEWK8pu29EtY4,7175
+jarvis/__pycache__/zte_llm.cpython-313.pyc,sha256=PcS-P2H96EyelWcPleCIcu0lGYYoLrdi9VSZgg2cooA,5340
+jarvis/tools/__init__.py,sha256=NZqKPfIbBxeM5FOrN1ssQQ4S9gVXNCSVXa3ov73AyEk,356
+jarvis/tools/base.py,sha256=I_XIwxb6hCH82qCVPESbDNC93Dj0G3KVSZRXSh6mHIM,6516
+jarvis/tools/file_ops.py,sha256=05Vc4u-NGMjLD15WI52eL_nt_RyYt-Z_cXJnnBepf-c,3781
+jarvis/tools/python_script.py,sha256=_eK8LqNs-Mz50zdcgwbjdd8-qAeOl6kJ_qRDvWawGMw,5006
+jarvis/tools/search.py,sha256=dyJmeP_s2tWv5KQejOl-TuVF12B6SXViiXEyTemD1Wo,1412
+jarvis/tools/shell.py,sha256=VhEqEdoUGIRW6CT6F0YNMAlzJxpHcsKS9hSS0VC3ezw,2644
+jarvis/tools/sub_agent.py,sha256=vC495JBAEMgHbAkHzGlYhIPA5scKekwhy1RViNcwqy8,2683
+jarvis/tools/webpage.py,sha256=UTEomu5j7jbOw8c5az2jsjv5E7LeokWKj1QahvZO7xc,3077
+jarvis/tools/__pycache__/__init__.cpython-313.pyc,sha256=Qng3CpxPy9R_1hTjSSr_qLXHtlI8GneyYX6JHwUtmHE,642
+jarvis/tools/__pycache__/base.cpython-313.pyc,sha256=wXXQs94_MAEuHVhFx80q_IgWBRuo1I4Dc7wz3G9ZMo4,8544
+jarvis/tools/__pycache__/file_ops.cpython-313.pyc,sha256=bawv11xhWSj5wCtW0QeJLI-InhUBUXaSkogq6rZzvTQ,3636
+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=VX9zztOwIsPCkYwev0A0XJGyu4Tr0PQcQkbbqx8vfB0,1870
+jarvis/tools/__pycache__/shell.cpython-313.pyc,sha256=UUciwt3nW3mkHrMI7WvCASQ-YLwVx2N68RzQq97nL74,2972
+jarvis/tools/__pycache__/sub_agent.cpython-313.pyc,sha256=p6vgjqdHW7ZAJYaiDh6F39CMndeA3tutbxXB9cwc6xY,3003
+jarvis/tools/__pycache__/user_confirmation.cpython-313.pyc,sha256=wK3Ev10lHSUSRvoYmi7A0GzxYkzU-C4Wfhs5qW_HBqs,2271
+jarvis/tools/__pycache__/user_interaction.cpython-313.pyc,sha256=RuVZ-pmiPBDywY3efgXSfohMAciC1avMGPmBK5qlnew,3305
+jarvis/tools/__pycache__/webpage.cpython-313.pyc,sha256=VcpkaV8IyOOtebedXjn8ybjr8AglU-3-Cs80yzE4FYo,3628
+jarvis_ai_assistant-0.1.5.dist-info/METADATA,sha256=pZCtN2L3EmGQMvpbxA6vED4RHJIWdJqXC2JnaD0whEw,3690
+jarvis_ai_assistant-0.1.5.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+jarvis_ai_assistant-0.1.5.dist-info/entry_points.txt,sha256=iKu7OMfew9dtfGhW71gIMTg4wvafuPqKb4wyQOnMAGU,44
+jarvis_ai_assistant-0.1.5.dist-info/top_level.txt,sha256=1BOxyWfzOP_ZXj8rVTDnNCJ92bBGB0rwq8N1PCpoMIs,7
+jarvis_ai_assistant-0.1.5.dist-info/RECORD,,

{jarvis_ai_assistant-0.1.2.dist-info → jarvis_ai_assistant-0.1.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.7.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

jarvis/tools/rag.py

@@ -1,154 +0,0 @@
-from typing import Dict, Any, List
-import chromadb
-from chromadb.utils import embedding_functions
-import hashlib
-import re
-from ..utils import PrettyOutput, OutputType
-
-class RAGTool:
-    name = "rag_query"
-    description = """Execute RAG queries on documents.
-    Features:
-    1. Auto-creates document embeddings
-    2. Returns relevant passages
-    3. Maintains embedding database
-    """
-    parameters = {
-        "type": "object",
-        "properties": {
-            "files": {
-                "type": "array",
-                "items": {"type": "string"},
-                "description": "Files to process"
-            },
-            "query": {
-                "type": "string",
-                "description": "Query text"
-            },
-            "num_passages": {
-                "type": "integer",
-                "description": "Number of passages",
-                "default": 3
-            },
-            "chunk_size": {
-                "type": "integer",
-                "description": "Chunk size",
-                "default": 500
-            }
-        },
-        "required": ["files", "query"]
-    }
-
-    def _get_document_hash(self, content: str) -> str:
-        return hashlib.md5(content.encode()).hexdigest()
-
-    def _chunk_text(self, text: str, chunk_size: int = 500) -> List[str]:
-        """将文本分割成适当大小的块"""
-        # 按句子分割
-        sentences = re.split(r'(?<=[.!?])\s+', text)
-        chunks = []
-        current_chunk = []
-        current_length = 0
-        
-        for sentence in sentences:
-            sentence_length = len(sentence)
-            if current_length + sentence_length > chunk_size and current_chunk:
-                chunks.append(" ".join(current_chunk))
-                current_chunk = []
-                current_length = 0
-            current_chunk.append(sentence)
-            current_length += sentence_length
-            
-        if current_chunk:
-            chunks.append(" ".join(current_chunk))
-            
-        return chunks
-
-    def execute(self, args: Dict) -> Dict[str, Any]:
-        """执行RAG查询"""
-        try:
-            files = args["files"]
-            query = args["query"]
-            num_passages = args.get("num_passages", 3)
-            chunk_size = args.get("chunk_size", 500)
-            
-            # 初始化ChromaDB
-            chroma_client = chromadb.PersistentClient(path="./data/chromadb")
-            
-            # 使用sentence-transformers作为嵌入模型
-            embedding_function = embedding_functions.SentenceTransformerEmbeddingFunction(
-                model_name="all-MiniLM-L6-v2"
-            )
-            
-            # 获取或创建集合
-            collection = chroma_client.get_or_create_collection(
-                name="document_store",
-                embedding_function=embedding_function
-            )
-            
-            # 处理每个文件
-            for file_path in files:
-                try:
-                    with open(file_path, 'r', encoding='utf-8') as f:
-                        content = f.read()
-                    
-                    # 计算文档哈希值
-                    doc_hash = self._get_document_hash(content)
-                    
-                    # 检查文档是否已经存在且未更改
-                    existing_ids = collection.get(
-                        where={"doc_hash": doc_hash}
-                    )
-                    
-                    if not existing_ids["ids"]:
-                        # 分块处理文档
-                        chunks = self._chunk_text(content, chunk_size)
-                        
-                        # 为每个块生成唯一ID
-                        chunk_ids = [f"{doc_hash}_{i}" for i in range(len(chunks))]
-                        
-                        # 添加到数据库
-                        collection.add(
-                            documents=chunks,
-                            ids=chunk_ids,
-                            metadatas=[{
-                                "file_path": file_path,
-                                "doc_hash": doc_hash,
-                                "chunk_index": i
-                            } for i in range(len(chunks))]
-                        )
-                        
-                        PrettyOutput.print(f"已添加文档: {file_path}", OutputType.INFO)
-                    else:
-                        PrettyOutput.print(f"文档已存在且未更改: {file_path}", OutputType.INFO)
-                        
-                except Exception as e:
-                    PrettyOutput.print(f"处理文件 {file_path} 时出错: {str(e)}", OutputType.ERROR)
-            
-            # 执行查询
-            results = collection.query(
-                query_texts=[query],
-                n_results=num_passages
-            )
-            
-            # 格式化输出
-            output = [f"查询: {query}\n"]
-            output.append(f"找到 {len(results['documents'][0])} 个相关段落:\n")
-            
-            for i, (doc, metadata) in enumerate(zip(results['documents'][0], results['metadatas'][0]), 1):
-                output.append(f"\n段落 {i}:")
-                output.append(f"来源: {metadata['file_path']}")
-                output.append(f"相关内容:\n{doc}\n")
-                output.append("-" * 50)
-            
-            return {
-                "success": True,
-                "stdout": "\n".join(output),
-                "stderr": ""
-            }
-
-        except Exception as e:
-            return {
-                "success": False,
-                "error": f"RAG查询失败: {str(e)}"
-            } 

jarvis/tools/user_confirmation.py

@@ -1,58 +0,0 @@
-from typing import Dict, Any
-from ..utils import PrettyOutput, OutputType
-
-class UserConfirmationTool:
-    name = "ask_user_confirmation"
-    description = "Request confirmation from user, returns yes/no"
-    parameters = {
-        "type": "object",
-        "properties": {
-            "question": {
-                "type": "string",
-                "description": "Question to ask for confirmation"
-            },
-            "details": {
-                "type": "string",
-                "description": "Additional details or context",
-                "default": ""
-            }
-        },
-        "required": ["question"]
-    }
-
-    def execute(self, args: Dict) -> Dict[str, Any]:
-        """获取用户确认"""
-        try:
-            question = args["question"]
-            details = args.get("details", "")
-            
-            # 打印详细信息
-            if details:
-                PrettyOutput.print(details, OutputType.INFO)
-                PrettyOutput.print("", OutputType.INFO)  # 空行
-            
-            # 打印问题
-            PrettyOutput.print(f"{question} (y/n)", OutputType.INFO)
-            
-            while True:
-                response = input(">>> ").strip().lower()
-                if response in ['y', 'yes']:
-                    result = True
-                    break
-                elif response in ['n', 'no']:
-                    result = False
-                    break
-                else:
-                    PrettyOutput.print("请输入 y/yes 或 n/no", OutputType.ERROR)
-            
-            return {
-                "success": True,
-                "stdout": str(result),
-                "stderr": ""
-            }
-
-        except Exception as e:
-            return {
-                "success": False,
-                "error": f"获取用户确认失败: {str(e)}"
-            } 

jarvis/tools/user_interaction.py

@@ -1,86 +0,0 @@
-from typing import Dict, Any, List
-from ..utils import PrettyOutput, OutputType, get_multiline_input
-
-class UserInteractionTool:
-    name = "ask_user"
-    description = "Ask user for information, supports option selection and multiline input"
-    parameters = {
-        "type": "object",
-        "properties": {
-            "question": {
-                "type": "string",
-                "description": "Question to ask the user"
-            },
-            "options": {
-                "type": "array",
-                "items": {"type": "string"},
-                "description": "List of options for user to choose from",
-                "default": []
-            },
-            "multiline": {
-                "type": "boolean",
-                "description": "Allow multiline input",
-                "default": False
-            },
-            "description": {
-                "type": "string",
-                "description": "Additional description or context",
-                "default": ""
-            }
-        },
-        "required": ["question"]
-    }
-
-    def execute(self, args: Dict) -> Dict[str, Any]:
-        """获取用户输入"""
-        try:
-            question = args["question"]
-            options = args.get("options", [])
-            multiline = args.get("multiline", False)
-            description = args.get("description", "")
-            
-            # 打印问题描述
-            if description:
-                PrettyOutput.print(description, OutputType.INFO)
-            
-            # 如果有选项，显示选项列表
-            if options:
-                PrettyOutput.print("\n可选项:", OutputType.INFO)
-                for i, option in enumerate(options, 1):
-                    PrettyOutput.print(f"[{i}] {option}", OutputType.INFO)
-                
-                while True:
-                    try:
-                        choice = input("\n请选择 (输入数字): ").strip()
-                        if not choice:
-                            continue
-                        
-                        choice = int(choice)
-                        if 1 <= choice <= len(options):
-                            response = options[choice - 1]
-                            break
-                        else:
-                            PrettyOutput.print("无效选择，请重试", OutputType.ERROR)
-                    except ValueError:
-                        PrettyOutput.print("请输入有效数字", OutputType.ERROR)
-            
-            # 多行输入
-            elif multiline:
-                response = get_multiline_input(question)
-            
-            # 单行输入
-            else:
-                PrettyOutput.print(question, OutputType.INFO)
-                response = input(">>> ").strip()
-            
-            return {
-                "success": True,
-                "stdout": response,
-                "stderr": ""
-            }
-
-        except Exception as e:
-            return {
-                "success": False,
-                "error": f"获取用户输入失败: {str(e)}"
-            } 

jarvis_ai_assistant-0.1.2.dist-info/RECORD

@@ -1,36 +0,0 @@
-jarvis/.jarvis,sha256=S4ZMmLqlVLHAPmnwHFQ3vYt0gnDFp-KQRH4okBh8Hpw,209
-jarvis/__init__.py,sha256=V3Qwm3k_WFeGUNccLbLJuCyWQyXYnRUkY5-KlBUm4UU,49
-jarvis/agent.py,sha256=hEatrIothG6C_RuOsygZz4ez1aF1EycnUPwY2Krwiwk,4092
-jarvis/main.py,sha256=wAeeGoRq8fFiTWUCQ31MYVeU9o6SZ48ORUow0jlMJJE,5259
-jarvis/models.py,sha256=ZQAyc39e_UsNmHkME6ATp6053safQ7Gog-oWwETsrMM,4415
-jarvis/utils.py,sha256=-fOPAgiKVPC6DevHM7A7IJvvIzvvFlGM0pHBKyBXDcA,3044
-jarvis/__pycache__/__init__.cpython-313.pyc,sha256=u64PLu4KyOPrirhIqNXZSkj9B6yB1L_ohFYhPX8p334,208
-jarvis/__pycache__/agent.cpython-313.pyc,sha256=I1JYUKC-zedURwuxQQjd9saj_yQKUhpdbb1KNWlY6Ss,4940
-jarvis/__pycache__/models.cpython-313.pyc,sha256=fot2VOV0lgODg4b_WuD-kkq-g7uZGLuZlYXiljlW13U,6350
-jarvis/__pycache__/tools.cpython-313.pyc,sha256=lAD4LrnnWzNZQmHXGfZ_2l7oskOpr2_2OC-gdFhxQY8,33933
-jarvis/__pycache__/utils.cpython-313.pyc,sha256=o8Fubq8Dcrvv3ATzQ9BnZoZjQmU3_FNPrfTt0ANdKdI,5804
-jarvis/tools/__init__.py,sha256=FNF5X32UzKvlT08-hPz7-7vcIyqqMngQYj36LXyNbV0,553
-jarvis/tools/base.py,sha256=xdZaoqxCOYVAwBmof_zqICg5ixb5-ksX-XbNXJw1O7k,5938
-jarvis/tools/file_ops.py,sha256=05Vc4u-NGMjLD15WI52eL_nt_RyYt-Z_cXJnnBepf-c,3781
-jarvis/tools/python_script.py,sha256=_eK8LqNs-Mz50zdcgwbjdd8-qAeOl6kJ_qRDvWawGMw,5006
-jarvis/tools/rag.py,sha256=eBrn1fdqy-nd2nR0b4oH1EQpthTYVen-sYDhC5Ypl38,5647
-jarvis/tools/search.py,sha256=dyJmeP_s2tWv5KQejOl-TuVF12B6SXViiXEyTemD1Wo,1412
-jarvis/tools/shell.py,sha256=uGqwUGmqFg1cJkyTg7zyPk3jRwEr-woKTmqcTKdbbg8,1979
-jarvis/tools/user_confirmation.py,sha256=p0JverifHJfnALeIhtKtaVBBVEGkgSpUzT-PSycG4NY,1850
-jarvis/tools/user_interaction.py,sha256=xOaoYsCKTa9-K3mg5tsu1zegn1HKcO40k2aJ3VygZqM,3073
-jarvis/tools/webpage.py,sha256=UTEomu5j7jbOw8c5az2jsjv5E7LeokWKj1QahvZO7xc,3077
-jarvis/tools/__pycache__/__init__.cpython-313.pyc,sha256=wktmOMuGMwQjQ--eRzooUNsL5YjY0bS_CbcSFUWze54,674
-jarvis/tools/__pycache__/base.cpython-313.pyc,sha256=hqhRtxwQwWLnBEzNqZ1FqcWYuyX87iu89SgHxu10Gho,8192
-jarvis/tools/__pycache__/file_ops.cpython-313.pyc,sha256=bawv11xhWSj5wCtW0QeJLI-InhUBUXaSkogq6rZzvTQ,3636
-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=VX9zztOwIsPCkYwev0A0XJGyu4Tr0PQcQkbbqx8vfB0,1870
-jarvis/tools/__pycache__/shell.cpython-313.pyc,sha256=Xtqt-LzMRfsCXeCE7QxFY8TR8XEeQG_jic73YLkhXQw,2302
-jarvis/tools/__pycache__/user_confirmation.cpython-313.pyc,sha256=wK3Ev10lHSUSRvoYmi7A0GzxYkzU-C4Wfhs5qW_HBqs,2271
-jarvis/tools/__pycache__/user_interaction.cpython-313.pyc,sha256=RuVZ-pmiPBDywY3efgXSfohMAciC1avMGPmBK5qlnew,3305
-jarvis/tools/__pycache__/webpage.cpython-313.pyc,sha256=VcpkaV8IyOOtebedXjn8ybjr8AglU-3-Cs80yzE4FYo,3628
-jarvis_ai_assistant-0.1.2.dist-info/METADATA,sha256=0EX8k3LdrzeEWHqRTHlguT80fPxHLbVtpY65f1kMhOk,3675
-jarvis_ai_assistant-0.1.2.dist-info/WHEEL,sha256=A3WOREP4zgxI0fKrHUG8DC8013e3dK3n7a6HDbcEIwE,91
-jarvis_ai_assistant-0.1.2.dist-info/entry_points.txt,sha256=iKu7OMfew9dtfGhW71gIMTg4wvafuPqKb4wyQOnMAGU,44
-jarvis_ai_assistant-0.1.2.dist-info/top_level.txt,sha256=1BOxyWfzOP_ZXj8rVTDnNCJ92bBGB0rwq8N1PCpoMIs,7
-jarvis_ai_assistant-0.1.2.dist-info/RECORD,,