matrix-for-agents 0.1.2__py3-none-any.whl

agentmatrix/core/browser/google.py

@@ -0,0 +1,230 @@
+import traceback
+
+async def extract_search_results(adapter, tab):
+    """
+    Extract search results from Google search results page.
+
+    Args:
+        adapter: DrissionPageAdapter instance
+        tab: Current browser tab handle
+
+    Returns:
+        List of dictionaries containing title, url, and snippet for each search result
+    """
+    print("\n4. Extracting search results...")
+    results = []
+
+    try:
+        # Wait for search results to load
+        print("   Waiting for search results to load...")
+        import time
+        time.sleep(3)  # Give time for search results to appear
+
+        # Find all h3 elements (each h3 is a search result title)
+        search_result_elements = tab.eles('@tag()=h3')
+
+        print(f"   Found {len(search_result_elements)} h3 elements")
+
+        for idx, h3_element in enumerate(search_result_elements):
+            try:
+                print(f"   Processing result {idx+1}...")
+
+                # Extract title from h3
+                title = h3_element.text.strip()
+                if not title:
+                    print(f"   No title found in h3 {idx+1}")
+                    continue
+
+                print(f"   Found title: {title[:50]}...")
+
+                # Find the parent <a> element (h3's direct parent)
+                # Try to get parent - DrissionPage might have different API
+                a_element = h3_element.parent()
+
+                # Verify it's an <a> element
+                if not a_element or a_element.tag != 'a':
+                    # Try alternative: search for <a> in parent chain
+                    current = h3_element
+                    a_element = None
+                    for _ in range(3):  # Check up to 3 levels up
+                        current = current.parent() if current else None
+                        if current and current.tag == 'a':
+                            a_element = current
+                            break
+
+                if not a_element:
+                    print(f"   No parent <a> found for h3 {idx+1}")
+                    continue
+
+                # Extract URL from <a> element
+                url = a_element.attr('href')
+                if not url:
+                    print(f"   No href found in <a> of result {idx+1}")
+                    continue
+
+                print(f"   Found URL: {url}")
+
+                # Navigate up from <a> to find 3 levels of <div> elements
+                # Structure: a -> [possibly other elements] -> div -> div -> div
+                # Then find the sibling of the 3rd div, which contains the snippet
+
+                current = a_element
+                div_count = 0
+                target_div = None
+
+                # Navigate up to find the 3rd level div
+                while current and div_count < 3:
+                    current = current.parent()
+                    if current and current.tag == 'div':
+                        div_count += 1
+                        if div_count == 3:
+                            target_div = current
+                            break
+
+                if not target_div:
+                    print(f"   Could not find 3 levels of <div> for result {idx+1}")
+                    snippet = "No description available"
+                else:
+                    # Find the sibling div of the 3rd level div
+                    snippet_div = target_div.next()
+
+                    if snippet_div:
+                        snippet = snippet_div.text.strip() if snippet_div.text else "No description available"
+                        print(f"   Found snippet: {snippet[:50]}...")
+                    else:
+                        snippet = "No description available"
+
+                # Add result to list
+                if title and url:
+                    result = {
+                        'title': title,
+                        'url': url,
+                        'snippet': snippet
+                    }
+                    results.append(result)
+                    print(f"   ✓ Successfully extracted result {idx+1}")
+
+            except Exception as e:
+                print(f"   Error extracting result {idx+1}: {e}")
+                traceback.print_exc()
+                continue
+
+        print(f"✓ Successfully extracted {len(results)} search results")
+
+    except Exception as e:
+        traceback.print_exc()
+        print(f"❌ Error extracting search results: {e}")
+
+    return results
+
+
+async def search_google(adapter, tab, query, max_pages=5, page=None):
+    """
+    Perform a Google search and extract results from multiple pages.
+
+    Args:
+        adapter: DrissionPageAdapter instance
+        tab: Current browser tab handle
+        query: Search query string
+        max_pages: Maximum number of pages to extract (default: 5)
+        page: Specific page to extract (default: None). If specified, only returns results from that page.
+
+    Returns:
+        List of dictionaries containing title, url, and snippet for each search result
+    """
+    print(f"\n=== Google Search: {query} (max pages: {max_pages}) ===")
+
+    # Navigate to Google
+    print("1. Navigating to Google...")
+    interaction_report = await adapter.navigate(tab, "https://www.google.com")
+    print(f"✓ Navigation completed. URL changed: {interaction_report.is_url_changed}")
+
+    # Wait a moment for page to load
+    import time
+    time.sleep(2)
+
+    # Type search query in textarea and submit
+    print("2. Typing search query...")
+    await adapter.type_text(tab, "@@tag()=textarea", f"{query}", True)
+    search_btn = await adapter.find_element(tab, 'xpath:(//input[@type="submit" and @role="button"])[2]')
+    await adapter.click_and_observe(tab, search_btn)
+    print("✓ Search query submitted")
+
+    # Stabilize the search results page
+    print("\n3. Stabilizing search results page...")
+    stabilization_success = await adapter.stabilize(tab)
+    print(f"✓ Stabilization completed: {stabilization_success}")
+
+    # If page is specified, only extract that specific page
+    if page is not None:
+        print(f"\n=== Extracting page {page} only ===")
+
+        # Navigate to the specified page
+        target_page = page
+        while target_page > 1:
+            try:
+                next_page_selector = f'css:a[aria-label="Page {target_page}"]'
+                print(f"Looking for Page {target_page}...")
+                next_page_link = tab.ele(next_page_selector, timeout=2)
+
+                if next_page_link:
+                    print(f"✓ Found Page {target_page}, clicking...")
+                    next_page_link.click()
+                    time.sleep(2)
+                    await adapter.stabilize(tab)
+                    target_page -= 1
+                else:
+                    print(f"✗ Page {page} not found")
+                    return []
+            except Exception as e:
+                print(f"✗ Error navigating to page {page}: {e}")
+                return []
+
+        # Extract results from the specified page
+        print(f"\n=== Processing page {page} ===")
+        page_results = await extract_search_results(adapter, tab)
+        print(f"\n=== Total results collected: {len(page_results)} ===")
+        return page_results
+
+    # Extract search results from multiple pages (original logic)
+    all_results = []
+    current_page = 1
+
+    while current_page <= max_pages:
+        print(f"\n=== Processing page {current_page} ===")
+
+        # Extract results from current page
+        page_results = await extract_search_results(adapter, tab)
+        all_results.extend(page_results)
+
+        # Check if we should continue to next page
+        if current_page < max_pages:
+            # Look for next page link using aria-label="Page X"
+            next_page_num = current_page + 1
+            next_page_selector = f'css:a[aria-label="Page {next_page_num}"]'
+
+            try:
+                print(f"\nLooking for next page (Page {next_page_num})...")
+                next_page_link = tab.ele(next_page_selector, timeout=2)
+
+                if next_page_link:
+                    print(f"✓ Found next page link, clicking...")
+                    next_page_link.click()
+                    time.sleep(2)  # Wait for page to load
+
+                    # Stabilize after page change
+                    await adapter.stabilize(tab)
+                    current_page += 1
+                else:
+                    print(f"✓ No more pages available")
+                    break
+
+            except Exception as e:
+                print(f"✓ No more pages available or error finding next page: {e}")
+                break
+        else:
+            print(f"\n✓ Reached maximum page limit ({max_pages})")
+            break
+
+    print(f"\n=== Total results collected: {len(all_results)} ===")
+    return all_results

agentmatrix/core/cerebellum.py

@@ -0,0 +1,121 @@
+# core/cerebellum.py
+import json
+import textwrap
+from ..core.log_util import AutoLoggerMixin
+import logging
+class Cerebellum(AutoLoggerMixin):
+    _log_from_attr = "log_name"  # 日志名字来自 self.log_name 属性
+    _custom_log_level = logging.DEBUG
+    def __init__(self, backend_client, agent_name):
+        self.backend = backend_client
+        self.agent_name = agent_name
+        self.log_name = f"{agent_name}(Cerebellum)"
+        
+    async def think(self, messages):
+        return await self.backend.think(messages)
+
+    async def negotiate(self, initial_intent: str, tools_manifest: str, contacts,  brain_callback) -> dict:
+        """
+        谈判循环：如果意图不清晰，Cerebellum 会反问 Brain。
+        
+        Args:
+            initial_intent: Brain 最初的想法
+            tools_manifest: 工具列表
+            brain_callback: 一个异步函数，允许 Cerebellum 向 Brain 提问 (param: question_str) -> answer_str
+        """
+        system_prompt = textwrap.dedent(f"""
+            You are the Interface Manager (Cerebellum). Your job is to convert User Intent into a Function Call JSON.
+            
+            [Available Tools]:
+            {tools_manifest}
+
+            [Available Email Receipients]:
+            {contacts}
+            
+            [Instructions]:
+            1. Identify the tool the user wants to use.
+            2. Check if ALL required parameters for that tool are present in the Intent. Rview Intent carefully, find all required parameters and form a proper JSON as output.
+            3. DECISION:
+               - If READY: Output JSON `{{ "status": "READY", "action_json": {{ "action": "name", "params": {{...}} }} }}`
+               - If MISSING PARAM: Output JSON `{{ "status": "ASK", "question": "What is the value for [param_name]?" }}`
+               - If AMBIGUOUS: Output JSON `{{ "status": "ASK", "question": "whatever need to be clarified" }}`
+               - If Not fesible: Output JSON `{{ "status": "NOT_FEASIBLE", "reason": "No matching tool found." }}`
+            
+            Output ONLY valid JSON.
+            """)
+
+        initial_intent = textwrap.dedent(f"""[User Intent]:
+            {initial_intent}
+        """)
+        # 维护一个临时的谈判历史，避免 Brain 忘记自己刚才要做什么
+        negotiation_history =[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": initial_intent}
+        ]
+        
+        self.logger.debug(f"开始谈判：{initial_intent}")
+        
+        #print(f"准备分析大脑意图：{initial_intent}")
+        
+        max_turns = 5 # 防止两个模型在那儿没完没了地聊天
+        
+        for i in range(max_turns):
+            # 1. 小脑思考：我现在还需要什么？
+            # 这是一个特殊的 Prompt，要求小脑检查参数完整性
+            
+            
+            # 小脑进行推理（这里用 fast model）
+            response = await self.backend.think(messages=negotiation_history)
+            reasoning_str= response['reasoning']
+            reply_str= response['reply']
+            
+            #loop = asyncio.get_running_loop()
+            # 把同步的 logger.debug 扔到线程池执行
+            self.logger.debug(f"小脑思考：{reasoning_str}")
+            self.logger.debug(f"小脑回复：{reply_str}")
+
+
+
+            raw_content = response['reply'].replace("```json", "").replace("```", "").strip()
+            
+            try:
+                decision = json.loads(raw_content)
+                status = decision.get("status")
+                
+                if status == "READY":
+                    return decision["action_json"]
+                
+                elif status == "NOT_FEASIBLE":
+                    # 彻底放弃，返回错误动作
+                    question = "Intent is not feasible."
+                    # 记录这一轮对话
+                    self.logger.debug(question)
+                    answer = await brain_callback(question)
+                    negotiation_history.append({"role": "assistant", "content": "Need clarification."})
+                    negotiation_history.append({"role": "user", "content": answer})
+                
+                elif status == "ASK":
+                    # === 关键点：反问 Brain ===
+                    question = decision.get("question")
+                    self.logger.debug(question)
+                    
+                    # 记录这一轮对话
+                    
+                    
+                    # 调用回调函数，让 Brain 回答
+                    # Brain 会基于它原始的 Context + 这里的 Question 来回答
+                    answer = await brain_callback(question)
+                    
+                    self.logger.debug(question)
+                    self.logger.debug('[Brain Reply]:' + answer)
+                    negotiation_history.append({"role": "assistant", "content": question})
+                    negotiation_history.append({"role": "user", "content": answer})
+                    
+                    # 继续下一轮循环
+                    continue
+                    
+            except json.JSONDecodeError:
+                if len(negotiation_history)>2:
+                    negotiation_history.pop()
+                
+        return {"action": "_parse_failed", "params": {"error": "Negotiation timeout"}}

agentmatrix/core/events.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Dict
+
+@dataclass
+class AgentEvent:
+    event_type: str        # THINKING, MAIL_SENT, TOOL_USE...
+    source: str
+    source_status: str
+    content: str
+    payload: Dict[str, Any] = field(default_factory=dict)
+    timestamp: datetime = field(default_factory=datetime.now)
+
+    def to_dict(self):
+        return {
+            "type": self.event_type,
+            "source": self.source,
+            "source_status": self.source_status,
+            "content": self.content,
+            "payload": self.payload,
+            "time": self.timestamp.isoformat()
+        }

agentmatrix/core/loader.py

@@ -0,0 +1,185 @@
+import yaml
+import importlib
+import os
+import logging
+from typing import List, Any, Dict
+from dotenv import load_dotenv
+import json
+from ..backends.llm_client import LLMClient
+from ..core.cerebellum import Cerebellum
+from ..core.log_util import AutoLoggerMixin
+
+
+class AgentLoader(AutoLoggerMixin):
+    def __init__(self, profile_path):
+        self.profile_path = profile_path
+        env_file = os.path.join(profile_path, ".env")
+        if not os.path.exists(env_file):
+            raise FileNotFoundError(f"环境变量文件不存在: {self.profile_path}")
+
+        if not os.access(env_file, os.R_OK):
+            raise PermissionError(f"没有读取文件的权限: {self.profile_path}")
+
+        load_dotenv(env_file)
+        llm_config_file = os.path.join(self.profile_path, "llm_config.json")
+
+        with open(llm_config_file, 'r', encoding='utf-8') as f:
+            self.llm_config = json.load(f)
+
+        if "default_slm" not in self.llm_config:
+            raise ValueError("llm_config.json 中必须包含 'default_slm' 配置，用于驱动默认小脑。")
+
+        for config in self.llm_config.values():
+            if "API_KEY" in config:
+                api_key = config["API_KEY"]
+                if os.getenv(api_key) is not None:
+                    config["API_KEY"] = os.getenv(api_key)
+
+        prompts_path = os.path.join(self.profile_path, "prompts")
+        self.prompts = {}
+        for prompt_txt in os.listdir(prompts_path):
+            if prompt_txt.endswith(".txt"):
+                self.logger.info(f">>> 加载Prompt模板 {prompt_txt}...")
+                with open(os.path.join(prompts_path, prompt_txt), "r", encoding='utf-8') as f:
+                    self.prompts[prompt_txt[:-4]] = f.read()
+
+        self.logger.info(self.prompts)
+
+    def _parse_value(self, value):
+        """
+        解析配置文件中的值，支持基本类型
+        YAML会自动解析类型，但我们需要确保一致性
+        """
+        if isinstance(value, str):
+            # 尝试解析特殊字符串
+            value_lower = value.lower()
+            if value_lower == 'null':
+                return None
+            elif value_lower == 'true':
+                return True
+            elif value_lower == 'false':
+                return False
+        return value
+
+    def load_from_file(self, file_path: str) -> Any:
+        """从 YAML 文件加载并实例化一个 Agent (支持动态 Mixin 和属性初始化)"""
+        self.logger.info(f">>> 加载Agent配置文件 {file_path}...")
+        with open(file_path, 'r', encoding='utf-8') as f:
+            profile = yaml.safe_load(f)
+
+        # 1. 解析基础类信息
+        module_name = profile["module"]
+        class_name = profile["class_name"]
+
+        # 🆕 2. 解析 Mixin 列表（如果配置了）
+        mixin_classes = []
+        if "mixins" in profile and profile["mixins"]:
+            for mixin_path in profile["mixins"]:
+                mixin_module_name, mixin_class_name = mixin_path.rsplit('.', 1)
+                try:
+                    mixin_module = importlib.import_module(mixin_module_name)
+                    mixin_class = getattr(mixin_module, mixin_class_name)
+                    mixin_classes.append(mixin_class)
+                    self.logger.info(f">>> ✅ 加载Mixin: {mixin_path}")
+                except (ImportError, AttributeError) as e:
+                    self.logger.warning(f">>> ⚠️  加载Mixin失败 {mixin_path}: {e}")
+
+        # 🆕 3. 解析属性初始化配置
+        attribute_inits = profile.pop("attribute_initializations", {})
+
+        # 🆕 4. 解析类属性配置
+        class_attrs = profile.pop("class_attributes", {})
+
+        # 清理配置中的特殊字段
+        del profile["module"]
+        del profile["class_name"]
+        if "mixins" in profile:
+            del profile["mixins"]
+
+        # 5. 动态导入基础 Agent 类
+        try:
+            module = importlib.import_module(module_name)
+            base_agent_class = getattr(module, class_name)
+        except (ImportError, AttributeError) as e:
+            raise ImportError(f"无法加载 Agent 类: {module_name}.{class_name}. 错误: {e}")
+
+        # 🆕 6. 动态创建带 Mixin 的新类
+        if mixin_classes:
+            # 创建新类：DynamicAgent 继承自 base_agent_class 和所有 mixin_classes
+            dynamic_class_name = f"Dynamic{class_name}"
+            agent_class = type(
+                dynamic_class_name,
+                (base_agent_class, *mixin_classes),  # 继承元组
+                class_attrs  # 🆕 注入类属性
+            )
+            self.logger.info(f">>> 🎨 动态创建Agent类: {dynamic_class_name}")
+            self.logger.info(f">>>    继承链: {' -> '.join([c.__name__ for c in (base_agent_class, *mixin_classes)])}")
+            if class_attrs:
+                self.logger.info(f">>>    类属性: {class_attrs}")
+        else:
+            # 如果没有 Mixin，直接使用原类，但也要设置类属性
+            if class_attrs:
+                for attr_name, attr_value in class_attrs.items():
+                    setattr(base_agent_class, attr_name, attr_value)
+                self.logger.info(f">>>    设置类属性: {class_attrs}")
+            agent_class = base_agent_class
+
+        # 7. 注入 prompt template
+        if "prompte_template" not in profile:
+            profile["prompt_template"] = "base"
+        prompt_template_name = profile.get("prompt_template")
+        self.logger.info(f">>> 加载Prompt模板 {prompt_template_name}...")
+        if prompt_template_name in self.prompts:
+            prompt = self.prompts[prompt_template_name]
+            profile["full_prompt"] = prompt
+        else:
+            raise ValueError(f"加载Agent {file_path} 失败，Prompt 模板 {prompt_template_name} 未找到。")
+
+        # 8. 实例化 Agent
+        agent_instance = agent_class(profile.copy())
+
+        # 🆕 9. 注入实例属性（Mixin 需要的属性）
+        if attribute_inits:
+            for attr_name, attr_value in attribute_inits.items():
+                parsed_value = self._parse_value(attr_value)
+                setattr(agent_instance, attr_name, parsed_value)
+                self.logger.info(f">>> 🔧 初始化属性: {attr_name} = {parsed_value}")
+
+        # 10. 设置LLM backend
+        backend_model = agent_instance.backend_model
+        agent_instance.brain = self._create_llm_client(backend_model)
+        print(f"Agent {agent_instance.name} brain set to {backend_model}")
+
+        # 设置小脑 (Cerebellum)
+        cerebellum_config = profile.get("cerebellum")
+        slm_client = None
+
+        if cerebellum_config:
+            slm_model = cerebellum_config.get("backend_model", "default_slm")
+            slm_client = self._create_llm_client(slm_model)
+            print(f"[{agent_instance.name}] Using custom SLM: {slm_model}")
+        else:
+            slm_client = self._create_llm_client("default_slm")
+            print(f"[{agent_instance.name}] Using system default SLM.")
+
+        agent_instance.cerebellum = Cerebellum(slm_client, agent_instance.name)
+
+        return agent_instance
+
+    def _create_llm_client(self, model_name):
+        llm_config = self.llm_config[model_name]
+        url = llm_config['url']
+        api_key = llm_config['API_KEY']
+        model_name = llm_config['model_name']
+        llm_client = LLMClient(url, api_key, model_name)
+        return llm_client
+
+    def load_all(self) -> Dict[str, Any]:
+        agents = {}
+        for filename in os.listdir(self.profile_path):
+            if filename.endswith(".yml"):
+                full_path = os.path.join(self.profile_path, filename)
+                print(f"Loading agent from {filename}...")
+                agent = self.load_from_file(full_path)
+                agents[agent.name] = agent
+        return agents