jarvis-ai-assistant 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

jarvis/models/kimi.py

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

jarvis/tools/__init__.py

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

jarvis/tools/base.py

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

{jarvis_ai_assistant-0.1.9.dist-info → jarvis_ai_assistant-0.1.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jarvis-ai-assistant
-Version: 0.1.9
+Version: 0.1.11
 Summary: Jarvis: An AI assistant that uses tools to interact with the system
 Home-page: https://github.com/skyfireitdiy/Jarvis
 Author: skyfire
@@ -17,13 +17,8 @@ Classifier: Programming Language :: Python :: 3.11
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: requests>=2.25.1
-Requires-Dist: beautifulsoup4>=4.9.3
-Requires-Dist: duckduckgo-search>=3.0.0
 Requires-Dist: pyyaml>=5.1
-Requires-Dist: ollama>=0.1.6
 Requires-Dist: colorama>=0.4.6
-Requires-Dist: openai>=1.2.0
-Requires-Dist: playwright>=1.41.1
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: black; extra == "dev"

jarvis_ai_assistant-0.1.11.dist-info/RECORD

@@ -0,0 +1,39 @@
+jarvis/__init__.py,sha256=_aIzFZNgMY8TxeqpWoDZOcvaSQ7uK4SxZvtdW_HPIHw,50
+jarvis/agent.py,sha256=AJCRmjrvlK19K-yj5zNwrFvVDbZ3mWEnzwHwxKCXTL8,8462
+jarvis/main.py,sha256=_1hE0MZ1OsIJpmlipUwtqFszh9rm7VmQcnnWr80o3p4,4176
+jarvis/utils.py,sha256=3hLtv-HcBL8Ngw69cowhARuIFrjcQ6yRP3Y1o9CvtsI,5992
+jarvis/__pycache__/__init__.cpython-313.pyc,sha256=QtWKLHgbSECIa7pnYFe-pSmrHEzJUhP4Aorar8bxZqA,209
+jarvis/__pycache__/agent.cpython-313.pyc,sha256=sLDZttVT9sOC6WKgs_SWhrEzfsN9vzlMhknMJkEqkVY,9746
+jarvis/__pycache__/main.cpython-313.pyc,sha256=o80rvS95KbpeL4MSEoMC0rt0Y91-asDHbHPJU8M8kxo,5933
+jarvis/__pycache__/models.cpython-313.pyc,sha256=uWuRIjGrY4YDB3dGW5PGDLWaS03et8g11O725TjY_eU,5960
+jarvis/__pycache__/tools.cpython-313.pyc,sha256=lAD4LrnnWzNZQmHXGfZ_2l7oskOpr2_2OC-gdFhxQY8,33933
+jarvis/__pycache__/utils.cpython-313.pyc,sha256=k4jyAlx4tlW0MKLMLzV7OOH9zsKrK0H955kY6M2SuFU,8772
+jarvis/__pycache__/zte_llm.cpython-313.pyc,sha256=kMm9IGundGmOPqjsgrm9oIaWLDagYGCPRAaE3ipkc-0,5662
+jarvis/models/__init__.py,sha256=B_IJFvKTaxdg19FAD1ea288tYp3-bRYRpkeGI0_OcBI,262
+jarvis/models/base.py,sha256=GgVl5N0qDqn-yqRcX_PX3wHjogouE6GPFAWktG40cXg,403
+jarvis/models/kimi.py,sha256=J_0QB6XY61tY-Oeu2cexWto58QbMU_liYj1f6PKbNRw,9763
+jarvis/models/__pycache__/__init__.cpython-313.pyc,sha256=jAwySX4diR7EWM_alK75tiIb_J8bVfs4Bh_U3bdjDLo,534
+jarvis/models/__pycache__/base.cpython-313.pyc,sha256=4I9KZlXHvTB7vENA9YWK4Fx0sns_KvIOtWqzE9y_-Co,1094
+jarvis/models/__pycache__/kimi.cpython-313.pyc,sha256=doDXu1nPClQOVqnDFGGBl2p_3AMDuDaiFAgdsP-G1NM,12524
+jarvis/tools/__init__.py,sha256=000SvX1Z0yzKtuVR9NS45r41DHUVpE6EiSEzzE99uR0,196
+jarvis/tools/base.py,sha256=qm73kMOkqAWHjUisUWFye-x69LJuZdwm0U3Tct-mmMc,3890
+jarvis/tools/file_ops.py,sha256=zTksx45NZm3iz9itN5iQGZ8DoxnSeTHdrnF08_ix7PU,3770
+jarvis/tools/shell.py,sha256=7q52lA3slf0TdjBjP1bkwugoO5pB0eqh6cYjAzAXNtI,2547
+jarvis/tools/__pycache__/__init__.cpython-313.pyc,sha256=6BQJ333a0Oh9uEDLlgh0HHeXS34I7NaPs9KFQI-sil8,347
+jarvis/tools/__pycache__/base.cpython-313.pyc,sha256=ZfkdDuQDiCuA7V3qx69coGwrkchLPqNDF6tCGPXKflU,6197
+jarvis/tools/__pycache__/bing_search.cpython-313.pyc,sha256=1G_wPbk5wcQYh7H0drLIS2Aw0XOG2ZM8ztgfQaqu3P8,2031
+jarvis/tools/__pycache__/file_ops.cpython-313.pyc,sha256=LbOp31JUzoRp5XVazy1VBqCQhpFg0qQYmVftFVY90V4,3628
+jarvis/tools/__pycache__/python_script.cpython-313.pyc,sha256=8JpryqTovEiTvBlWAK1KjZmPvHUuPc9GT9rTXBEQoJc,6693
+jarvis/tools/__pycache__/rag.cpython-313.pyc,sha256=JH6-PSZRMKAvTZqCwlRXJGClxYXNMs-vetU0q7hBLz0,6064
+jarvis/tools/__pycache__/search.cpython-313.pyc,sha256=wLMIkFwT-h4NGHgssytT4xme7sGO6ZhEnex7kjcy0-k,5990
+jarvis/tools/__pycache__/shell.cpython-313.pyc,sha256=QMaLUc1MtZXWod3msv_x7iMq2IybwMwz1OoaKsbm6U4,3271
+jarvis/tools/__pycache__/sub_agent.cpython-313.pyc,sha256=9spmVX8KSQ4qIH7FbXo5tmmZfNx8KfIGtjy2lxTSp4Y,3144
+jarvis/tools/__pycache__/user_confirmation.cpython-313.pyc,sha256=wK3Ev10lHSUSRvoYmi7A0GzxYkzU-C4Wfhs5qW_HBqs,2271
+jarvis/tools/__pycache__/user_input.cpython-313.pyc,sha256=JjTFOhObKsKF4Pn8KBRuKfV1_Ssj083fjU7Mfc_5z7c,2531
+jarvis/tools/__pycache__/user_interaction.cpython-313.pyc,sha256=RuVZ-pmiPBDywY3efgXSfohMAciC1avMGPmBK5qlnew,3305
+jarvis/tools/__pycache__/webpage.cpython-313.pyc,sha256=BjzSfnNzsKCrLETCcWjt32lNDLzwnjqcVGg4JfWd9OM,3008
+jarvis_ai_assistant-0.1.11.dist-info/METADATA,sha256=PLBiD-OM5rCBVi3MWF93SXePf6piXNW0OI8I_D2tUP8,3585
+jarvis_ai_assistant-0.1.11.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+jarvis_ai_assistant-0.1.11.dist-info/entry_points.txt,sha256=iKu7OMfew9dtfGhW71gIMTg4wvafuPqKb4wyQOnMAGU,44
+jarvis_ai_assistant-0.1.11.dist-info/top_level.txt,sha256=1BOxyWfzOP_ZXj8rVTDnNCJ92bBGB0rwq8N1PCpoMIs,7
+jarvis_ai_assistant-0.1.11.dist-info/RECORD,,

jarvis/models.py

@@ -1,122 +0,0 @@
-import re
-import time
-from typing import Dict, List, Optional, Tuple
-from duckduckgo_search import DDGS
-import ollama
-from abc import ABC, abstractmethod
-import yaml
-import openai
-
-from .utils import OutputType, PrettyOutput
-
-class BaseModel(ABC):
-    """大语言模型基类"""
-    
-    @abstractmethod
-    def chat(self, messages: List[Dict]) -> str:
-        """执行对话"""
-        pass
-
-
-class DDGSModel(BaseModel):
-    def __init__(self, model_name: str = "gpt-4o-mini"):
-        """
-        [1]: gpt-4o-mini
-        [2]: claude-3-haiku
-        [3]: llama-3.1-70b
-        [4]: mixtral-8x7b
-        """
-        self.model_name = model_name
-
-    def __make_prompt(self, messages: List[Dict]) -> str:
-        prompt = ""
-        for message in messages:
-            prompt += f"[{message['role']}]: {message['content']}\n"
-        return prompt
-
-    def chat(self, messages: List[Dict]) -> str:
-        ddgs = DDGS()
-        prompt = self.__make_prompt(messages)
-        content = ddgs.chat(prompt)
-        PrettyOutput.print(content, OutputType.SYSTEM)
-        return content
-
-
-class OllamaModel(BaseModel):
-    """Ollama模型实现"""
-    
-    def __init__(self, model_name: str = "qwen2.5:14b", api_base: str = "http://localhost:11434"):
-        self.model_name = model_name
-        self.api_base = api_base
-        self.client = ollama.Client(host=api_base)
-
-    def chat(self, messages: List[Dict]) -> str:
-        """调用Ollama API获取响应"""
-        try:
-            # 使用流式调用
-            stream = self.client.chat(
-                model=self.model_name,
-                messages=messages,
-                stream=True
-            )
-
-            # 收集完整响应
-            content_parts = []
-            for chunk in stream:
-                if chunk.message.content:
-                    content_parts.append(chunk.message.content)
-                    # 实时打印内容
-                    PrettyOutput.print_stream(chunk.message.content, OutputType.SYSTEM)
-
-            PrettyOutput.print_stream_end()
-
-            # 合并完整内容
-            return "".join(content_parts)
-            
-        except Exception as e:
-            raise Exception(f"Ollama API调用失败: {str(e)}") 
-
-
-class OpenAIModel(BaseModel):
-    """OpenAI模型实现"""
-    
-    def __init__(self, model_name: str = "deepseek-chat", api_key: Optional[str] = None, api_base: Optional[str] = None):
-        """
-        初始化OpenAI模型
-        Args:
-            model_name: 模型名称，默认为 deepseek-chat
-            api_key: OpenAI API密钥
-            api_base: 可选的API基础URL，用于自定义端点
-        """
-        self.model_name = model_name
-        if api_key:
-            openai.api_key = api_key
-        if api_base:
-            openai.base_url = api_base
-        
-    def chat(self, messages: List[Dict]) -> str:
-        """调用OpenAI API获取响应"""
-        try:
-            # 使用流式调用
-            stream = openai.chat.completions.create(
-                model=self.model_name,
-                messages=messages,
-                stream=True
-            )
-            
-            # 收集完整响应
-            content_parts = []
-            for chunk in stream:
-                if chunk.choices[0].delta.content:
-                    content = chunk.choices[0].delta.content
-                    content_parts.append(content)
-                    # 实时打印内容
-                    PrettyOutput.print_stream(content, OutputType.SYSTEM)
-                    
-            PrettyOutput.print_stream_end()
-            
-            # 合并完整内容
-            return "".join(content_parts)
-            
-        except Exception as e:
-            raise Exception(f"OpenAI API调用失败: {str(e)}") 

jarvis/tools/bing_search.py

@@ -1,38 +0,0 @@
-from playwright.sync_api import sync_playwright
-from urllib.parse import quote
-
-def bing_search(query):
-    try:
-        with sync_playwright() as p:
-            browser = p.chromium.launch()
-            page = browser.new_page()
-            page.goto(
-                f"https://www.bing.com/search?form=QBRE&q={quote(query)}&cc=US"
-            )
-
-            page.wait_for_selector("#b_results", timeout=10000)
-            
-            summaries = page.evaluate("""() => {
-                const liElements = Array.from(
-                    document.querySelectorAll("#b_results > .b_algo")
-                );
-                return liElements.map((li) => {
-                    const abstractElement = li.querySelector(".b_caption > p");
-                    const linkElement = li.querySelector("a");
-                    const href = linkElement.getAttribute("href");
-                    const title = linkElement.textContent;
-                    const abstract = abstractElement ? abstractElement.textContent : "";
-                    return { href, title, abstract };
-                });
-            }""")
-            
-            browser.close()
-            print(summaries)
-            return summaries
-    except Exception as error:
-        print("An error occurred:", error)
-
-if __name__ == "__main__":
-    # results = bing_search("北京到西雅图的距离")
-    results = bing_search("北京到西雅图的距离")
-    print(results)

jarvis/tools/search.py

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