jarvis-ai-assistant 0.1.32__py3-none-any.whl

jarvis/models/oyi.py

@@ -0,0 +1,271 @@
+import mimetypes
+import os
+from typing import Dict, List
+from jarvis.models.base import BaseModel
+from jarvis.utils import PrettyOutput, OutputType
+import requests
+import json
+
+class OyiModel(BaseModel):
+    """Oyi model implementation"""
+    
+    model_name = "oyi"
+    BASE_URL = "https://api-10086.rcouyi.com"
+    
+    def __init__(self):
+        """Initialize model"""
+        self.messages = []
+        self.system_message = ""
+        self.conversation = None
+        self.upload_files = []
+        self.first_chat = True
+        self.model = os.getenv("OYI_MODEL") or "deepseek-chat"
+        self.token = os.getenv("OYI_API_KEY")
+        if not all([self.model, self.token]):
+            raise Exception("OYI_MODEL or OYI_API_KEY is not set")
+
+        
+    def create_conversation(self) -> bool:
+        """Create a new conversation"""
+        try:
+            headers = {
+                'Authorization': f'Bearer {self.token}',
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36'
+            }
+            
+            payload = {
+                "id": 0,
+                "roleId": 0,
+                "title": "新对话",
+                "isLock": False,
+                "systemMessage": "",
+                "params": json.dumps({
+                    "model": "gpt-4o-mini",
+                    "is_webSearch": True,
+                    "message": [],
+                    "systemMessage": None,
+                    "requestMsgCount": 1000,
+                    "temperature": 0.8,
+                    "speechVoice": "Alloy",
+                    "max_tokens": 8192,
+                    "chatPluginIds": []
+                })
+            }
+            
+            response = requests.post(
+                f"{self.BASE_URL}/chatapi/chat/save",
+                headers=headers,
+                json=payload
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                if data['code'] == 200 and data['type'] == 'success':
+                    self.conversation = data
+                    PrettyOutput.print(f"创建会话成功: {data['result']['id']}", OutputType.SUCCESS)
+                    return True
+                else:
+                    PrettyOutput.print(f"创建会话失败: {data['message']}", OutputType.ERROR)
+                    return False
+            else:
+                PrettyOutput.print(f"创建会话失败: {response.status_code}", OutputType.ERROR)
+                return False
+                
+        except Exception as e:
+            PrettyOutput.print(f"创建会话异常: {str(e)}", OutputType.ERROR)
+            return False
+    
+    def set_system_message(self, message: str):
+        """Set system message"""
+        self.system_message = message
+        
+    def chat(self, message: str) -> str:
+        """Execute chat with the model
+        
+        Args:
+            message: User input message
+            
+        Returns:
+            str: Model response
+        """
+        try:
+            # 确保有会话ID
+            if not self.conversation:
+                if not self.create_conversation():
+                    raise Exception("Failed to create conversation")
+            
+            # 1. 发送消息
+            headers = {
+                'Authorization': f'Bearer {self.token}',
+                'Content-Type': 'application/json',
+                'Accept': 'application/json, text/plain, */*',
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
+                'Origin': 'https://ai.rcouyi.com',
+                'Referer': 'https://ai.rcouyi.com/'
+            }
+            
+            payload = {
+                "topicId": self.conversation['result']['id'],
+                "messages": self.messages,
+                "content": message,
+                "contentFiles": []
+            }
+            
+            # 如果有上传的文件，添加到请求中
+            if self.first_chat:
+                if self.upload_files:
+                    for file_data in self.upload_files:
+                        file_info = {
+                            "contentType": 1,  # 1 表示图片
+                            "fileUrl": file_data['result']['url'],
+                            "fileId": file_data['result']['id'],
+                            "fileName": file_data['result']['fileName']
+                        }
+                        payload["contentFiles"].append(file_info)
+                    # 清空已使用的文件列表
+                    self.upload_files = []
+                message = self.system_message + "\n" + message
+                payload["content"] = message
+                self.first_chat = False
+
+            self.messages.append({"role": "user", "content": message})
+            
+            # 发送消息
+            response = requests.post(
+                f"{self.BASE_URL}/chatapi/chat/message",
+                headers=headers,
+                json=payload
+            )
+            
+            if response.status_code != 200:
+                error_msg = f"聊天请求失败: {response.status_code}"
+                PrettyOutput.print(error_msg, OutputType.ERROR)
+                raise Exception(error_msg)
+            
+            data = response.json()
+            if data['code'] != 200 or data['type'] != 'success':
+                error_msg = f"聊天失败: {data.get('message', '未知错误')}"
+                PrettyOutput.print(error_msg, OutputType.ERROR)
+                raise Exception(error_msg)
+            
+            message_id = data['result'][-1]
+            
+            # 获取响应内容
+            response = requests.post(
+                f"{self.BASE_URL}/chatapi/chat/message/{message_id}",
+                headers=headers
+            )
+            
+            if response.status_code == 200:
+                PrettyOutput.print(response.text, OutputType.SYSTEM)
+                self.messages.append({"role": "assistant", "content": response.text})
+                return response.text
+            else:
+                error_msg = f"获取响应失败: {response.status_code}"
+                PrettyOutput.print(error_msg, OutputType.ERROR)
+                raise Exception(error_msg)
+            
+        except Exception as e:
+            PrettyOutput.print(f"聊天异常: {str(e)}", OutputType.ERROR)
+            raise e
+            
+    def name(self) -> str:
+        """Return model name"""
+        return self.model_name
+        
+    def reset(self):
+        """Reset model state"""
+        self.messages = []
+        self.conversation = None
+        self.upload_files = []
+        self.first_chat = True
+            
+    def delete_chat(self) -> bool:
+        """Delete current chat session"""
+        try:
+            if not self.conversation:
+                return True
+            
+            headers = {
+                'Authorization': f'Bearer {self.token}',
+                'Content-Type': 'application/json',
+                'Accept': 'application/json, text/plain, */*',
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
+                'Origin': 'https://ai.rcouyi.com',
+                'Referer': 'https://ai.rcouyi.com/'
+            }
+            
+            response = requests.post(
+                f"{self.BASE_URL}/chatapi/chat/{self.conversation['result']['id']}",
+                headers=headers,
+                json={}
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                if data['code'] == 200 and data['type'] == 'success':
+                    PrettyOutput.print("会话删除成功", OutputType.SUCCESS)
+                    self.reset()
+                    return True
+                else:
+                    error_msg = f"删除会话失败: {data.get('message', '未知错误')}"
+                    PrettyOutput.print(error_msg, OutputType.ERROR)
+                    return False
+            else:
+                error_msg = f"删除会话请求失败: {response.status_code}"
+                PrettyOutput.print(error_msg, OutputType.ERROR)
+                return False
+            
+        except Exception as e:
+            PrettyOutput.print(f"删除会话异常: {str(e)}", OutputType.ERROR)
+            return False
+    
+    def upload_file(self, file_path: str) -> Dict:
+        """Upload a file to OYI API
+        
+        Args:
+            file_path: Path to the file to upload
+            
+        Returns:
+            Dict: Upload response data
+        """
+        try:
+            headers = {
+                'Authorization': f'Bearer {self.token}',
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
+                'Accept': '*/*',
+                'DNT': '1',
+                'Origin': 'https://ai.rcouyi.com',
+                'Referer': 'https://ai.rcouyi.com/'
+            }
+            
+            with open(file_path, 'rb') as f:
+                files = {
+                    'file': (os.path.basename(file_path), f, mimetypes.guess_type(file_path)[0])  # Adjust content-type based on file type
+                }
+                
+                response = requests.post(
+                    f"{self.BASE_URL}/chatapi/m_file/uploadfile",
+                    headers=headers,
+                    files=files
+                )
+                
+                if response.status_code == 200:
+                    data = response.json()
+                    if data.get('code') == 200:
+                        PrettyOutput.print("文件上传成功", OutputType.SUCCESS)
+                        print(data)
+                        self.upload_files.append(data)
+                        return data
+                    else:
+                        PrettyOutput.print(f"文件上传失败: {data.get('message')}", OutputType.ERROR)
+                        return None
+                else:
+                    PrettyOutput.print(f"文件上传失败: {response.status_code}", OutputType.ERROR)
+                    return None
+                
+        except Exception as e:
+            PrettyOutput.print(f"文件上传异常: {str(e)}", OutputType.ERROR)
+            return None

jarvis/models/registry.py

@@ -0,0 +1,199 @@
+import importlib
+import inspect
+import os
+import sys
+from typing import Dict, Type, Optional, List
+from .base import BaseModel
+from ..utils import PrettyOutput, OutputType
+
+REQUIRED_METHODS = [
+    ('chat', ['message']),           # 方法名和参数列表
+    ('name', []),
+    ('delete_chat', []),
+    ('reset', []),
+    ('set_system_message', ['message'])
+]
+
+class ModelRegistry:
+    """模型注册器"""
+
+    global_model_name = "kimi"
+    global_model_registry = None
+
+    @staticmethod
+    def get_models_dir() -> str:
+        user_models_dir = os.path.expanduser("~/.jarvis_models")
+        if not os.path.exists(user_models_dir):
+            try:
+                os.makedirs(user_models_dir)
+                # 创建 __init__.py 使其成为 Python 包
+                with open(os.path.join(user_models_dir, "__init__.py"), "w") as f:
+                    pass
+                PrettyOutput.print(f"已创建模型目录: {user_models_dir}", OutputType.INFO)
+            except Exception as e:
+                PrettyOutput.print(f"创建模型目录失败: {str(e)}", OutputType.ERROR)
+                return ""
+        return user_models_dir
+
+    @staticmethod
+    def check_model_implementation(model_class: Type[BaseModel]) -> bool:
+        """检查模型类是否实现了所有必要的方法
+        
+        Args:
+            model_class: 要检查的模型类
+            
+        Returns:
+            bool: 是否实现了所有必要的方法
+        """
+        missing_methods = []
+        
+        for method_name, params in REQUIRED_METHODS:
+            if not hasattr(model_class, method_name):
+                missing_methods.append(method_name)
+                continue
+                
+            method = getattr(model_class, method_name)
+            if not callable(method):
+                missing_methods.append(method_name)
+                continue
+                
+            # 检查方法参数
+            import inspect
+            sig = inspect.signature(method)
+            method_params = [p for p in sig.parameters if p != 'self']
+            if len(method_params) != len(params):
+                missing_methods.append(f"{method_name}(参数不匹配)")
+        
+        if missing_methods:
+            PrettyOutput.print(
+                f"模型 {model_class.__name__} 缺少必要的方法: {', '.join(missing_methods)}", 
+                OutputType.ERROR
+            )
+            return False
+            
+        return True
+
+    @staticmethod
+    def load_models_from_dir(directory: str) -> Dict[str, Type[BaseModel]]:
+        """从指定目录加载模型
+        
+        Args:
+            directory: 模型目录路径
+            
+        Returns:
+            Dict[str, Type[BaseModel]]: 模型名称到模型类的映射
+        """
+        models = {}
+        
+        # 确保目录存在
+        if not os.path.exists(directory):
+            PrettyOutput.print(f"模型目录不存在: {directory}", OutputType.ERROR)
+            return models
+            
+        # 获取目录的包名
+        package_name = None
+        if directory == os.path.dirname(__file__):
+            package_name = "jarvis.models"
+            
+        # 添加目录到Python路径
+        if directory not in sys.path:
+            sys.path.append(directory)
+        
+        # 遍历目录下的所有.py文件
+        for filename in os.listdir(directory):
+            if filename.endswith('.py') and not filename.startswith('__'):
+                module_name = filename[:-3]  # 移除.py后缀
+                try:
+                    # 导入模块
+                    if package_name:
+                        module = importlib.import_module(f"{package_name}.{module_name}")
+                    else:
+                        module = importlib.import_module(module_name)
+                    
+                    # 遍历模块中的所有类
+                    for name, obj in inspect.getmembers(module):
+                        # 检查是否是BaseModel的子类，但不是BaseModel本身
+                        if (inspect.isclass(obj) and 
+                            issubclass(obj, BaseModel) and 
+                            obj != BaseModel and
+                            hasattr(obj, 'model_name')):
+                            # 检查模型实现
+                            if not ModelRegistry.check_model_implementation(obj):
+                                continue
+                            models[obj.model_name] = obj
+                            PrettyOutput.print(f"从 {directory} 加载模型: {obj.model_name}", OutputType.INFO)
+                            break
+                except Exception as e:
+                    PrettyOutput.print(f"加载模型 {module_name} 失败: {str(e)}", OutputType.ERROR)
+        
+        return models
+
+
+    @staticmethod
+    def get_model_registry():
+        """获取全局模型注册器"""
+        if ModelRegistry.global_model_registry is None:
+            ModelRegistry.global_model_registry = ModelRegistry()
+            
+            # 从用户模型目录加载额外模型
+            models_dir = ModelRegistry.get_models_dir()
+            if models_dir and os.path.exists(models_dir):
+                for model_name, model_class in ModelRegistry.load_models_from_dir(models_dir).items():
+                    ModelRegistry.global_model_registry.register_model(model_name, model_class)
+            models_dir = os.path.dirname(__file__)
+            if models_dir and os.path.exists(models_dir):
+                for model_name, model_class in ModelRegistry.load_models_from_dir(models_dir).items():
+                    ModelRegistry.global_model_registry.register_model(model_name, model_class)
+        return ModelRegistry.global_model_registry
+    
+    def __init__(self):
+        """初始化模型注册器
+        """
+        self.models: Dict[str, Type[BaseModel]] = {}
+
+    @staticmethod
+    def get_global_model() -> BaseModel:
+        """获取全局模型实例"""
+        model = ModelRegistry.get_model_registry().create_model(ModelRegistry.global_model_name)
+        if not model:
+            raise Exception(f"Failed to create model: {ModelRegistry.global_model_name}")
+        return model
+        
+    def register_model(self, name: str, model_class: Type[BaseModel]):
+        """注册模型类
+        
+        Args:
+            name: 模型名称
+            model_class: 模型类
+        """
+        self.models[name] = model_class
+        PrettyOutput.print(f"已注册模型: {name}", OutputType.INFO)
+            
+    def create_model(self, name: str) -> Optional[BaseModel]:
+        """创建模型实例
+        
+        Args:
+            name: 模型名称
+            
+        Returns:
+            BaseModel: 模型实例
+        """
+        if name not in self.models:
+            PrettyOutput.print(f"未找到模型: {name}", OutputType.ERROR)
+            return None
+            
+        try:
+            model = self.models[name]()
+            PrettyOutput.print(f"已创建模型实例: {name}", OutputType.INFO)
+            return model
+        except Exception as e:
+            PrettyOutput.print(f"创建模型失败: {str(e)}", OutputType.ERROR)
+            return None
+            
+    def get_available_models(self) -> List[str]:
+        """获取可用模型列表"""
+        return list(self.models.keys()) 
+    
+    def set_global_model(self, model_name: str):
+        """设置全局模型"""
+        ModelRegistry.global_model_name = model_name

jarvis/tools/__init__.py

@@ -0,0 +1,5 @@
+from .registry import ToolRegistry
+
+__all__ = [
+    'ToolRegistry',
+] 

jarvis/tools/base.py

@@ -0,0 +1,23 @@
+from typing import Dict, Any, Callable
+import json
+
+
+
+class Tool:
+    def __init__(self, name: str, description: str, parameters: Dict, func: Callable):
+        self.name = name
+        self.description = description
+        self.parameters = parameters
+        self.func = func
+
+    def to_dict(self) -> Dict:
+        """转换为工具格式"""
+        return {
+            "name": self.name,
+            "description": self.description,
+            "parameters": json.dumps(self.parameters, ensure_ascii=False)
+        }
+
+    def execute(self, arguments: Dict) -> Dict[str, Any]:
+        """执行工具函数"""
+        return self.func(arguments)

jarvis/tools/file_ops.py

@@ -0,0 +1,110 @@
+from typing import Dict, Any, Protocol
+import os
+from enum import Enum
+
+from jarvis.utils import OutputType, PrettyOutput
+
+
+class FileOperationTool:
+    name = "file_operation"
+    description = "文件操作 (read/write/append/exists)"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "operation": {
+                "type": "string",
+                "enum": ["read", "write", "append", "exists"],
+                "description": "Type of file operation to perform"
+            },
+            "filepath": {
+                "type": "string",
+                "description": "Absolute or relative path to the file"
+            },
+            "content": {
+                "type": "string",
+                "description": "Content to write (required for write/append operations)",
+                "default": ""
+            },
+            "encoding": {
+                "type": "string",
+                "description": "File encoding (default: utf-8)",
+                "default": "utf-8"
+            }
+        },
+        "required": ["operation", "filepath"]
+    }
+
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        """执行文件操作"""
+        try:
+            operation = args["operation"]
+            filepath = args["filepath"]
+            encoding = args.get("encoding", "utf-8")
+            
+            # 记录操作和完整路径
+            abs_path = os.path.abspath(filepath)
+            PrettyOutput.print(f"文件操作: {operation} - {abs_path}", OutputType.INFO)
+            
+            if operation == "exists":
+                exists = os.path.exists(filepath)
+                return {
+                    "success": True,
+                    "stdout": str(exists),
+                    "stderr": ""
+                }
+                
+            elif operation == "read":
+                if not os.path.exists(filepath):
+                    return {
+                        "success": False,
+                        "error": f"文件不存在: {filepath}"
+                    }
+                    
+                # 检查文件大小
+                if os.path.getsize(filepath) > 10 * 1024 * 1024:  # 10MB
+                    return {
+                        "success": False,
+                        "error": "文件过大 (>10MB)"
+                    }
+                    
+                with open(filepath, 'r', encoding=encoding) as f:
+                    content = f.read()
+                return {
+                    "success": True,
+                    "stdout": content,
+                    "stderr": ""
+                }
+                
+            elif operation in ["write", "append"]:
+                if not args.get("content"):
+                    return {
+                        "success": False,
+                        "error": "写入/追加操作需要提供content参数"
+                    }
+                
+                # 创建目录（如果不存在）
+                os.makedirs(os.path.dirname(os.path.abspath(filepath)), exist_ok=True)
+                    
+                mode = 'a' if operation == "append" else 'w'
+                with open(filepath, mode, encoding=encoding) as f:
+                    f.write(args["content"])
+                    
+                return {
+                    "success": True,
+                    "stdout": f"成功{operation}内容到 {filepath}",
+                    "stderr": ""
+                }
+                
+            else:
+                return {
+                    "success": False,
+                    "error": f"未知操作: {operation}"
+                }
+                
+        except Exception as e:
+            PrettyOutput.print(str(e), OutputType.ERROR)
+            return {
+                "success": False,
+                "error": f"文件操作失败: {str(e)}"
+            }