jarvis-ai-assistant 0.1.177__py3-none-any.whl → 0.1.179__py3-none-any.whl

jarvis/jarvis_mcp/streamable_mcp_client.py

@@ -0,0 +1,404 @@
+# -*- coding: utf-8 -*-
+import json
+import threading
+from typing import Any, Callable, Dict, List
+from urllib.parse import urljoin
+
+import requests
+
+from jarvis.jarvis_mcp import McpClient
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+
+
+class StreamableMcpClient(McpClient):
+    """Streamable HTTP MCP客户端实现
+    
+    参数:
+        config: 配置字典，包含以下字段：
+            - base_url: str - MCP服务器的基础URL
+            - auth_token: str - 认证令牌（可选）
+            - headers: Dict[str, str] - 额外的HTTP头（可选）
+    """
+    def __init__(self, config: Dict[str, Any]):
+        self.config = config
+        self.base_url = config.get('base_url', '')
+        if not self.base_url:
+            raise ValueError('No base_url specified in config')
+        
+        # 设置HTTP客户端
+        self.session = requests.Session()
+        self.session.headers.update({
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+        })
+        
+        # 添加认证令牌（如果提供）
+        auth_token = config.get('auth_token')
+        if auth_token:
+            self.session.headers['Authorization'] = f'Bearer {auth_token}'
+        
+        # 添加额外的HTTP头
+        extra_headers = config.get('headers', {})
+        self.session.headers.update(extra_headers)
+        
+        # 请求相关属性
+        self.pending_requests = {}  # 存储等待响应的请求 {id: Event}
+        self.request_results = {}   # 存储请求结果 {id: result}
+        self.notification_handlers = {}
+        self.event_lock = threading.Lock()
+        self.request_id_counter = 0
+        
+        # 初始化连接
+        self._initialize()
+
+    def _initialize(self) -> None:
+        """初始化MCP连接"""
+        try:
+            # 发送初始化请求
+            response = self._send_request('initialize', {
+                'processId': None,  # 远程客户端不需要进程ID
+                'clientInfo': {
+                    'name': 'jarvis',
+                    'version': '1.0.0'
+                },
+                'capabilities': {},
+                'protocolVersion': "2025-03-26"
+            })
+
+            # 验证服务器响应
+            if 'result' not in response:
+                raise RuntimeError(f"初始化失败: {response.get('error', 'Unknown error')}")
+
+            # 发送initialized通知
+            self._send_notification('notifications/initialized', {})
+
+        except Exception as e:
+            PrettyOutput.print(f"MCP初始化失败: {str(e)}", OutputType.ERROR)
+            raise
+
+    def register_notification_handler(self, method: str, handler: Callable) -> None:
+        """注册通知处理器
+        
+        参数:
+            method: 通知方法名
+            handler: 处理通知的回调函数，接收params参数
+        """
+        with self.event_lock:
+            if method not in self.notification_handlers:
+                self.notification_handlers[method] = []
+            self.notification_handlers[method].append(handler)
+
+    def unregister_notification_handler(self, method: str, handler: Callable) -> None:
+        """注销通知处理器
+        
+        参数:
+            method: 通知方法名
+            handler: 要注销的处理器函数
+        """
+        with self.event_lock:
+            if method in self.notification_handlers:
+                if handler in self.notification_handlers[method]:
+                    self.notification_handlers[method].remove(handler)
+                if not self.notification_handlers[method]:
+                    del self.notification_handlers[method]
+
+    def _get_next_request_id(self) -> str:
+        """获取下一个请求ID"""
+        with self.event_lock:
+            self.request_id_counter += 1
+            return str(self.request_id_counter)
+
+    def _send_request(self, method: str, params: Dict[str, Any]) -> Dict[str, Any]:
+        """发送请求到MCP服务器
+        
+        参数:
+            method: 请求方法
+            params: 请求参数
+            
+        返回:
+            Dict[str, Any]: 响应结果
+        """
+        # 生成唯一请求ID
+        req_id = self._get_next_request_id()
+        
+        # 创建事件标志，用于等待响应
+        event = threading.Event()
+        
+        with self.event_lock:
+            self.pending_requests[req_id] = event
+        
+        try:
+            # 构建请求
+            request = {
+                'jsonrpc': '2.0',
+                'method': method,
+                'params': params,
+                'id': req_id
+            }
+
+            # 发送请求到Streamable HTTP端点
+            mcp_url = urljoin(self.base_url, 'mcp')
+            response = self.session.post(
+                mcp_url,
+                json=request,
+                stream=True  # 启用流式传输
+            )
+            response.raise_for_status()
+
+            # 处理流式响应
+            result = None
+            for line in response.iter_lines(decode_unicode=True):
+                if line:
+                    try:
+                        data = json.loads(line)
+                        if 'id' in data and data['id'] == req_id:
+                            # 这是我们的请求响应
+                            result = data
+                            break
+                        elif 'method' in data:
+                            # 这是一个通知
+                            method = data.get('method', '')
+                            params = data.get('params', {})
+                            if method in self.notification_handlers:
+                                for handler in self.notification_handlers[method]:
+                                    try:
+                                        handler(params)
+                                    except Exception as e:
+                                        PrettyOutput.print(
+                                            f"处理通知时出错 ({method}): {e}", 
+                                            OutputType.ERROR
+                                        )
+                    except json.JSONDecodeError:
+                        PrettyOutput.print(f"无法解析响应: {line}", OutputType.WARNING)
+                        continue
+
+            if result is None:
+                raise RuntimeError(f"未收到响应: {method}")
+
+            return result
+
+        except Exception as e:
+            PrettyOutput.print(f"发送请求失败: {str(e)}", OutputType.ERROR)
+            raise
+        finally:
+            # 清理请求状态
+            with self.event_lock:
+                self.pending_requests.pop(req_id, None)
+                self.request_results.pop(req_id, None)
+
+    def _send_notification(self, method: str, params: Dict[str, Any]) -> None:
+        """发送通知到MCP服务器（不需要响应）
+        
+        参数:
+            method: 通知方法
+            params: 通知参数
+        """
+        try:
+            # 构建通知
+            notification = {
+                'jsonrpc': '2.0',
+                'method': method,
+                'params': params
+            }
+
+            # 发送通知到Streamable HTTP端点
+            mcp_url = urljoin(self.base_url, 'mcp')
+            response = self.session.post(
+                mcp_url,
+                json=notification
+            )
+            response.raise_for_status()
+
+        except Exception as e:
+            PrettyOutput.print(f"发送通知失败: {str(e)}", OutputType.ERROR)
+            raise
+
+    def get_tool_list(self) -> List[Dict[str, Any]]:
+        """获取工具列表
+        
+        返回:
+            List[Dict[str, Any]]: 工具列表，每个工具包含以下字段：
+                - name: str - 工具名称
+                - description: str - 工具描述
+                - parameters: Dict - 工具参数
+        """
+        try:
+            response = self._send_request('tools/list', {})
+            if 'result' in response and 'tools' in response['result']:
+                # 注意这里: 响应结构是 response['result']['tools']
+                tools = response['result']['tools']
+                # 将MCP协议字段转换为内部格式
+                formatted_tools = []
+                for tool in tools:
+                    # 从inputSchema中提取参数定义
+                    input_schema = tool.get('inputSchema', {})
+                    parameters = {}
+                    if 'properties' in input_schema:
+                        parameters = input_schema['properties']
+                    
+                    formatted_tools.append({
+                        'name': tool.get('name', ''),
+                        'description': tool.get('description', ''),
+                        'parameters': parameters
+                    })
+                return formatted_tools
+            else:
+                error_msg = "获取工具列表失败"
+                if 'error' in response:
+                    error_msg += f": {response['error']}"
+                elif 'result' in response:
+                    error_msg += f": 响应格式不正确 - {response['result']}"
+                else:
+                    error_msg += ": 未知错误"
+                    
+                PrettyOutput.print(error_msg, OutputType.ERROR)
+                return []
+        except Exception as e:
+            PrettyOutput.print(f"获取工具列表失败: {str(e)}", OutputType.ERROR)
+            return []
+
+    def execute(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """执行工具
+        
+        参数:
+            tool_name: 工具名称
+            arguments: 参数字典，包含工具执行所需的参数
+            
+        返回:
+            Dict[str, Any]: 执行结果，包含以下字段：
+                - success: bool - 是否执行成功
+                - stdout: str - 标准输出
+                - stderr: str - 标准错误
+        """
+        try:
+            response = self._send_request('tools/call', {
+                'name': tool_name,
+                'arguments': arguments
+            })
+            if 'result' in response:
+                result = response['result']
+                # 从content中提取输出信息
+                stdout = ''
+                stderr = ''
+                for content in result.get('content', []):
+                    if content.get('type') == 'text':
+                        stdout += content.get('text', '')
+                    elif content.get('type') == 'error':
+                        stderr += content.get('text', '')
+                
+                return {
+                    'success': True,
+                    'stdout': stdout,
+                    'stderr': stderr
+                }
+            else:
+                return {
+                    'success': False,
+                    'stdout': '',
+                    'stderr': response.get('error', 'Unknown error')
+                }
+        except Exception as e:
+            PrettyOutput.print(f"执行工具失败: {str(e)}", OutputType.ERROR)
+            return {
+                'success': False,
+                'stdout': '',
+                'stderr': str(e)
+            }
+
+    def get_resource_list(self) -> List[Dict[str, Any]]:
+        """获取资源列表
+        
+        返回:
+            List[Dict[str, Any]]: 资源列表，每个资源包含以下字段：
+                - uri: str - 资源的唯一标识符
+                - name: str - 资源的名称
+                - description: str - 资源的描述（可选）
+                - mimeType: str - 资源的MIME类型（可选）
+        """
+        try:
+            response = self._send_request('resources/list', {})
+            if 'result' in response and 'resources' in response['result']:
+                return response['result']['resources']
+            else:
+                error_msg = "获取资源列表失败"
+                if 'error' in response:
+                    error_msg += f": {response['error']}"
+                else:
+                    error_msg += ": 未知错误"
+                PrettyOutput.print(error_msg, OutputType.ERROR)
+                return []
+        except Exception as e:
+            PrettyOutput.print(f"获取资源列表失败: {str(e)}", OutputType.ERROR)
+            return []
+
+    def get_resource(self, uri: str) -> Dict[str, Any]:
+        """获取指定资源的内容
+        
+        参数:
+            uri: str - 资源的URI标识符
+            
+        返回:
+            Dict[str, Any]: 执行结果，包含以下字段：
+                - success: bool - 是否执行成功
+                - stdout: str - 资源内容（文本或base64编码的二进制内容）
+                - stderr: str - 错误信息
+        """
+        try:
+            response = self._send_request('resources/read', {
+                'uri': uri
+            })
+            if 'result' in response and 'contents' in response['result']:
+                contents = response['result']['contents']
+                if contents:
+                    content = contents[0]  # 获取第一个资源内容
+                    # 根据资源类型返回内容
+                    if 'text' in content:
+                        return {
+                            'success': True,
+                            'stdout': content['text'],
+                            'stderr': ''
+                        }
+                    elif 'blob' in content:
+                        return {
+                            'success': True,
+                            'stdout': content['blob'],
+                            'stderr': ''
+                        }
+                return {
+                    'success': False,
+                    'stdout': '',
+                    'stderr': '资源内容为空'
+                }
+            else:
+                error_msg = "获取资源内容失败"
+                if 'error' in response:
+                    error_msg += f": {response['error']}"
+                else:
+                    error_msg += ": 未知错误"
+                PrettyOutput.print(error_msg, OutputType.ERROR)
+                return {
+                    'success': False,
+                    'stdout': '',
+                    'stderr': error_msg
+                }
+        except Exception as e:
+            error_msg = f"获取资源内容失败: {str(e)}"
+            PrettyOutput.print(error_msg, OutputType.ERROR)
+            return {
+                'success': False,
+                'stdout': '',
+                'stderr': error_msg
+            }
+
+    def __del__(self):
+        """清理资源"""
+        # 清理请求状态
+        with self.event_lock:
+            for event in self.pending_requests.values():
+                event.set()  # 释放所有等待的请求
+            self.pending_requests.clear()
+            self.request_results.clear()
+            
+        # 关闭HTTP会话
+        if self.session:
+            self.session.close() 

jarvis/jarvis_methodology/main.py

@@ -8,18 +8,19 @@
 - 列出所有方法论
 """
 
+import argparse
 import hashlib
-import os
 import json
-import argparse
-import yaml # type: ignore
-from jarvis.jarvis_utils.methodology import (
-    _get_methodology_directory,
-    _load_all_methodologies
-)
+import os
+
+import yaml  # type: ignore
+from yaspin import yaspin  # type: ignore
+
 from jarvis.jarvis_platform.registry import PlatformRegistry
-from jarvis.jarvis_utils.output import PrettyOutput, OutputType
-from yaspin import yaspin # type: ignore
+from jarvis.jarvis_utils.methodology import (_get_methodology_directory,
+                                             _load_all_methodologies)
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+
 
 def import_methodology(input_file):
     """导入方法论文件（合并策略）"""

jarvis/jarvis_multi_agent/main.py

@@ -1,8 +1,10 @@
 # -*- coding: utf-8 -*-
 import yaml
+
 from jarvis.jarvis_multi_agent import MultiAgent
-from jarvis.jarvis_utils.utils import init_env
 from jarvis.jarvis_utils.input import get_multiline_input
+from jarvis.jarvis_utils.utils import init_env
+
 
 def main():
     """从YAML配置文件初始化并运行多智能体系统

jarvis/jarvis_platform/base.py

@@ -1,19 +1,23 @@
 # -*- coding: utf-8 -*-
-from abc import ABC, abstractmethod
 import re
+from abc import ABC, abstractmethod
 from typing import Generator, List, Tuple
 
+from rich import box
+from rich.live import Live
+from rich.panel import Panel
+from rich.text import Text
 from yaspin import yaspin
 
-from jarvis.jarvis_utils.config import get_max_input_token_count, get_pretty_output
+from jarvis.jarvis_utils.config import (get_max_input_token_count,
+                                        get_pretty_output, is_print_prompt)
 from jarvis.jarvis_utils.embedding import split_text_into_chunks
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-from jarvis.jarvis_utils.utils import get_context_token_count, is_context_overflow, while_success, while_true
-from jarvis.jarvis_utils.tag import ot, ct
-from rich.live import Live
-from rich.text import Text
-from rich.panel import Panel
-from rich import box
+from jarvis.jarvis_utils.tag import ct, ot
+from jarvis.jarvis_utils.utils import (get_context_token_count,
+                                       is_context_overflow, while_success,
+                                       while_true)
+
 
 class BasePlatform(ABC):
     """Base class for large language models"""
@@ -122,6 +126,8 @@ class BasePlatform(ABC):
         return response
     
     def chat_until_success(self, message: str) -> str:
+        if is_print_prompt():
+            PrettyOutput.print(f"{message}", OutputType.USER)
         return while_true(lambda: while_success(lambda: self._chat(message), 5), 5)
 
     @abstractmethod

jarvis/jarvis_platform/human.py

@@ -1,11 +1,13 @@
 # -*- coding: utf-8 -*-
-from typing import Generator, List, Tuple
 import random
 import string
+from typing import Generator, List, Tuple
+
 from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.jarvis_utils.input import get_multiline_input
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
+
 class HumanPlatform(BasePlatform):
     """人类交互平台实现，模拟大模型但实际上与人交互"""
 

jarvis/jarvis_platform/kimi.py

@@ -1,18 +1,21 @@
 # -*- coding: utf-8 -*-
-from typing import Dict, Generator, List, Tuple
-import requests # type: ignore
 import json
-import os
 import mimetypes
+import os
 import time
+from typing import Dict, Generator, List, Tuple
+
+import requests  # type: ignore
+from rich import box
 from rich.live import Live
-from rich.text import Text
 from rich.panel import Panel
-from rich import box
+from rich.text import Text
+
 from jarvis.jarvis_platform.base import BasePlatform
+from jarvis.jarvis_utils.config import get_data_dir
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import while_success
-from jarvis.jarvis_utils.config import get_data_dir
+
 
 class KimiModel(BasePlatform):
     """Kimi model implementation"""
@@ -183,7 +186,7 @@ class KimiModel(BasePlatform):
         if not file_list:
             return True
 
-        from yaspin import yaspin # type: ignore
+        from yaspin import yaspin  # type: ignore
         
         if not self.chat_id:
             with yaspin(text="创建聊天会话...", color="yellow") as spinner:

jarvis/jarvis_platform/openai.py

@@ -1,14 +1,13 @@
 # -*- coding: utf-8 -*-
-from typing import Dict, Generator, List, Tuple
 import os
+from typing import Dict, Generator, List, Tuple
+
 from openai import OpenAI
-from rich.live import Live
-from rich.text import Text
-from rich.panel import Panel
-from rich import box
+
 from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
+
 class OpenAIModel(BasePlatform):
     platform_name = "openai"
 
@@ -49,10 +48,27 @@ class OpenAIModel(BasePlatform):
         self.system_message = ""
 
     def upload_files(self, file_list: List[str]) -> bool:
+        """
+        上传文件到OpenAI平台
+        
+        参数:
+            file_list: 需要上传的文件路径列表
+            
+        返回:
+            bool: 上传是否成功 (当前实现始终返回False)
+        """
         return False
 
     def get_model_list(self) -> List[Tuple[str, str]]:
-        """Get model list"""
+        """
+        获取可用的OpenAI模型列表
+        
+        返回:
+            List[Tuple[str, str]]: 模型ID和名称的元组列表
+            
+        异常:
+            当API调用失败时会打印错误信息并返回空列表
+        """
         try:
             models = self.client.models.list()
             model_list = []
@@ -64,17 +80,41 @@ class OpenAIModel(BasePlatform):
             return []
 
     def set_model_name(self, model_name: str):
-        """Set model name"""
+        """
+        设置当前使用的模型名称
+        
+        参数:
+            model_name: 要设置的模型名称
+        """
 
         self.model_name = model_name
 
     def set_system_message(self, message: str):
-        """Set system message"""
+        """
+        设置系统消息(角色设定)
+        
+        参数:
+            message: 系统消息内容
+            
+        说明:
+            设置后会立即添加到消息历史中
+        """
         self.system_message = message
         self.messages.append({"role": "system", "content": self.system_message})
 
     def chat(self, message: str) -> Generator[str, None, None]:
-        """Execute conversation"""
+        """
+        执行对话并返回生成器
+        
+        参数:
+            message: 用户输入的消息内容
+            
+        返回:
+            Generator[str, None, None]: 生成器，逐块返回AI响应内容
+            
+        异常:
+            当API调用失败时会抛出异常并打印错误信息
+        """
         try:
 
             # Add user message to history
@@ -103,12 +143,25 @@ class OpenAIModel(BasePlatform):
             raise Exception(f"Chat failed: {str(e)}")
 
     def name(self) -> str:
-        """Return model name"""
+        """
+        获取当前使用的模型名称
+        
+        返回:
+            str: 当前配置的模型名称
+        """
         return self.model_name
 
 
     def delete_chat(self)->bool:
-        """Delete conversation"""
+        """
+        删除当前对话历史
+        
+        返回:
+            bool: 操作是否成功
+            
+        说明:
+            如果设置了系统消息，会保留系统消息
+        """
         if self.system_message:
             self.messages = [{"role": "system", "content": self.system_message}]
         else:
@@ -116,4 +169,10 @@ class OpenAIModel(BasePlatform):
         return True
 
     def support_web(self) -> bool:
+        """
+        检查是否支持网页访问功能
+        
+        返回:
+            bool: 当前是否支持网页访问 (OpenAI平台始终返回False)
+        """
         return False

jarvis/jarvis_platform/registry.py

@@ -3,9 +3,13 @@ import importlib
 import inspect
 import os
 import sys
-from typing import Dict, Type, Optional, List
+from typing import Dict, List, Optional, Type
+
 from jarvis.jarvis_platform.base import BasePlatform
-from jarvis.jarvis_utils.config import get_normal_model_name, get_normal_platform_name, get_thinking_model_name, get_thinking_platform_name, get_data_dir
+from jarvis.jarvis_utils.config import (get_data_dir, get_normal_model_name,
+                                        get_normal_platform_name,
+                                        get_thinking_model_name,
+                                        get_thinking_platform_name)
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 REQUIRED_METHODS = [