feat: key management and scheduled task tools

agent/tools/scheduler/README.md

@@ -0,0 +1,286 @@
+# 定时任务工具 (Scheduler Tool)
+
+## 功能简介
+
+定时任务工具允许 Agent 创建、管理和执行定时任务，支持：
+
+- ⏰ **定时提醒**: 在指定时间发送消息
+- 🔄 **周期性任务**: 按固定间隔或 cron 表达式重复执行
+- 🔧 **动态工具调用**: 定时执行其他工具并发送结果（如搜索新闻、查询天气等）
+- 📋 **任务管理**: 查询、启用、禁用、删除任务
+
+## 安装依赖
+
+```bash
+pip install croniter>=2.0.0
+```
+
+## 使用方法
+
+### 1. 创建定时任务
+
+Agent 可以通过自然语言创建定时任务，支持两种类型：
+
+#### 1.1 静态消息任务
+
+发送预定义的消息：
+
+**示例对话：**
+```
+用户: 每天早上9点提醒我开会
+Agent: [调用 scheduler 工具]
+      action: create
+      name: 每日开会提醒
+      message: 该开会了！
+      schedule_type: cron
+      schedule_value: 0 9 * * *
+```
+
+#### 1.2 动态工具调用任务
+
+定时执行工具并发送结果：
+
+**示例对话：**
+```
+用户: 每天早上8点帮我搜索一下当前新闻
+Agent: [调用 scheduler 工具]
+      action: create
+      name: 每日新闻
+      tool_call:
+        tool_name: bocha_search
+        tool_params:
+          query: 今日新闻
+        result_prefix: 📰 今日新闻播报
+      schedule_type: cron
+      schedule_value: 0 8 * * *
+```
+
+**工具调用参数说明：**
+- `tool_name`: 要调用的工具名称（如 `bocha_search`、`web_fetch` 等）
+- `tool_params`: 工具的参数（字典格式）
+- `result_prefix`: 可选，在结果前添加的前缀文本
+
+### 2. 支持的调度类型
+
+#### Cron 表达式 (`cron`)
+使用标准 cron 表达式：
+
+```
+0 9 * * *      # 每天 9:00
+0 */2 * * *    # 每 2 小时
+30 8 * * 1-5   # 工作日 8:30
+0 0 1 * *      # 每月 1 号
+```
+
+#### 固定间隔 (`interval`)
+以秒为单位的间隔：
+
+```
+3600           # 每小时
+86400          # 每天
+1800           # 每 30 分钟
+```
+
+#### 一次性任务 (`once`)
+指定具体时间（ISO 格式）：
+
+```
+2024-12-25T09:00:00
+2024-12-31T23:59:59
+```
+
+### 3. 查询任务列表
+
+```
+用户: 查看我的定时任务
+Agent: [调用 scheduler 工具]
+      action: list
+```
+
+### 4. 查看任务详情
+
+```
+用户: 查看任务 abc123 的详情
+Agent: [调用 scheduler 工具]
+      action: get
+      task_id: abc123
+```
+
+### 5. 删除任务
+
+```
+用户: 删除任务 abc123
+Agent: [调用 scheduler 工具]
+      action: delete
+      task_id: abc123
+```
+
+### 6. 启用/禁用任务
+
+```
+用户: 暂停任务 abc123
+Agent: [调用 scheduler 工具]
+      action: disable
+      task_id: abc123
+
+用户: 恢复任务 abc123
+Agent: [调用 scheduler 工具]
+      action: enable
+      task_id: abc123
+```
+
+## 任务存储
+
+任务保存在 JSON 文件中：
+```
+~/cow/scheduler/tasks.json
+```
+
+任务数据结构：
+
+**静态消息任务：**
+```json
+{
+  "id": "abc123",
+  "name": "每日提醒",
+  "enabled": true,
+  "created_at": "2024-01-01T10:00:00",
+  "updated_at": "2024-01-01T10:00:00",
+  "schedule": {
+    "type": "cron",
+    "expression": "0 9 * * *"
+  },
+  "action": {
+    "type": "send_message",
+    "content": "该开会了！",
+    "receiver": "wxid_xxx",
+    "receiver_name": "张三",
+    "is_group": false,
+    "channel_type": "wechat"
+  },
+  "next_run_at": "2024-01-02T09:00:00",
+  "last_run_at": "2024-01-01T09:00:00"
+}
+```
+
+**动态工具调用任务：**
+```json
+{
+  "id": "def456",
+  "name": "每日新闻",
+  "enabled": true,
+  "created_at": "2024-01-01T10:00:00",
+  "updated_at": "2024-01-01T10:00:00",
+  "schedule": {
+    "type": "cron",
+    "expression": "0 8 * * *"
+  },
+  "action": {
+    "type": "tool_call",
+    "tool_name": "bocha_search",
+    "tool_params": {
+      "query": "今日新闻"
+    },
+    "result_prefix": "📰 今日新闻播报",
+    "receiver": "wxid_xxx",
+    "receiver_name": "张三",
+    "is_group": false,
+    "channel_type": "wechat"
+  },
+  "next_run_at": "2024-01-02T08:00:00"
+}
+```
+
+## 后台服务
+
+定时任务由后台服务 `SchedulerService` 管理：
+
+- 每 30 秒检查一次到期任务
+- 自动执行到期任务
+- 计算下次执行时间
+- 记录执行历史和错误
+
+服务在 Agent 初始化时自动启动，无需手动配置。
+
+## 接收者确定
+
+定时任务会发送给**创建任务时的对话对象**：
+
+- 如果在私聊中创建，发送给该用户
+- 如果在群聊中创建，发送到该群
+- 接收者信息在创建时自动保存
+
+## 常见用例
+
+### 1. 每日提醒（静态消息）
+```
+用户: 每天早上8点提醒我吃药
+Agent: ✅ 定时任务创建成功
+       任务ID: a1b2c3d4
+       调度: 每天 8:00
+       消息: 该吃药了！
+```
+
+### 2. 工作日提醒（静态消息）
+```
+用户: 工作日下午6点提醒我下班
+Agent: [创建 cron: 0 18 * * 1-5]
+       消息: 该下班了！
+```
+
+### 3. 倒计时提醒（静态消息）
+```
+用户: 1小时后提醒我
+Agent: [创建 interval: 3600]
+```
+
+### 4. 每日新闻推送（动态工具调用）
+```
+用户: 每天早上8点帮我搜索一下当前新闻
+Agent: ✅ 定时任务创建成功
+       任务ID: news001
+       调度: 每天 8:00
+       工具: bocha_search(query='今日新闻')
+       前缀: 📰 今日新闻播报
+```
+
+### 5. 定时天气查询（动态工具调用）
+```
+用户: 每天早上7点查询今天的天气
+Agent: [创建 cron: 0 7 * * *]
+       工具: bocha_search(query='今日天气')
+       前缀: 🌤️ 今日天气预报
+```
+
+### 6. 周报提醒（动态工具调用）
+```
+用户: 每周五下午5点搜索本周热点
+Agent: [创建 cron: 0 17 * * 5]
+       工具: bocha_search(query='本周热点新闻')
+       前缀: 📊 本周热点回顾
+```
+
+### 4. 特定日期提醒
+```
+用户: 12月25日早上9点提醒我圣诞快乐
+Agent: [创建 once: 2024-12-25T09:00:00]
+```
+
+## 注意事项
+
+1. **时区**: 使用系统本地时区
+2. **精度**: 检查间隔为 30 秒，实际执行可能有 ±30 秒误差
+3. **持久化**: 任务保存在文件中，重启后自动恢复
+4. **一次性任务**: 执行后自动禁用，不会删除（可手动删除）
+5. **错误处理**: 执行失败会记录错误，不影响其他任务
+
+## 技术实现
+
+- **TaskStore**: 任务持久化存储
+- **SchedulerService**: 后台调度服务
+- **SchedulerTool**: Agent 工具接口
+- **Integration**: 与 AgentBridge 集成
+
+## 依赖
+
+- `croniter`: Cron 表达式解析（轻量级，仅 ~50KB）

agent/tools/scheduler/__init__.py

@@ -0,0 +1,7 @@
+"""
+Scheduler tool for managing scheduled tasks
+"""
+
+from .scheduler_tool import SchedulerTool
+
+__all__ = ["SchedulerTool"]

agent/tools/scheduler/integration.py

@@ -0,0 +1,239 @@
+"""
+Integration module for scheduler with AgentBridge
+"""
+
+import os
+from typing import Optional
+from config import conf
+from common.log import logger
+from bridge.context import Context, ContextType
+from bridge.reply import Reply, ReplyType
+
+# Global scheduler service instance
+_scheduler_service = None
+_task_store = None
+
+
+def init_scheduler(agent_bridge) -> bool:
+    """
+    Initialize scheduler service
+    
+    Args:
+        agent_bridge: AgentBridge instance
+        
+    Returns:
+        True if initialized successfully
+    """
+    global _scheduler_service, _task_store
+    
+    try:
+        from agent.tools.scheduler.task_store import TaskStore
+        from agent.tools.scheduler.scheduler_service import SchedulerService
+        
+        # Get workspace from config
+        workspace_root = os.path.expanduser(conf().get("agent_workspace", "~/cow"))
+        store_path = os.path.join(workspace_root, "scheduler", "tasks.json")
+        
+        # Create task store
+        _task_store = TaskStore(store_path)
+        logger.info(f"[Scheduler] Task store initialized: {store_path}")
+        
+        # Create execute callback
+        def execute_task_callback(task: dict):
+            """Callback to execute a scheduled task"""
+            try:
+                action = task.get("action", {})
+                action_type = action.get("type")
+                
+                if action_type == "send_message":
+                    _execute_send_message(task, agent_bridge)
+                elif action_type == "tool_call":
+                    _execute_tool_call(task, agent_bridge)
+                else:
+                    logger.warning(f"[Scheduler] Unknown action type: {action_type}")
+            except Exception as e:
+                logger.error(f"[Scheduler] Error executing task {task.get('id')}: {e}")
+        
+        # Create scheduler service
+        _scheduler_service = SchedulerService(_task_store, execute_task_callback)
+        _scheduler_service.start()
+        
+        logger.info("[Scheduler] Scheduler service initialized and started")
+        return True
+        
+    except Exception as e:
+        logger.error(f"[Scheduler] Failed to initialize scheduler: {e}")
+        return False
+
+
+def get_task_store():
+    """Get the global task store instance"""
+    return _task_store
+
+
+def get_scheduler_service():
+    """Get the global scheduler service instance"""
+    return _scheduler_service
+
+
+def _execute_send_message(task: dict, agent_bridge):
+    """
+    Execute a send_message action
+    
+    Args:
+        task: Task dictionary
+        agent_bridge: AgentBridge instance
+    """
+    try:
+        action = task.get("action", {})
+        content = action.get("content", "")
+        receiver = action.get("receiver")
+        is_group = action.get("is_group", False)
+        channel_type = action.get("channel_type", "unknown")
+        
+        if not receiver:
+            logger.error(f"[Scheduler] Task {task['id']}: No receiver specified")
+            return
+        
+        # Create context for sending message
+        context = Context(ContextType.TEXT, content)
+        context["receiver"] = receiver
+        context["isgroup"] = is_group
+        context["session_id"] = receiver
+        
+        # For web channel, generate a virtual request_id
+        if channel_type == "web":
+            import uuid
+            request_id = f"scheduler_{task['id']}_{uuid.uuid4().hex[:8]}"
+            context["request_id"] = request_id
+            logger.debug(f"[Scheduler] Generated request_id for web channel: {request_id}")
+        
+        # Create reply
+        reply = Reply(ReplyType.TEXT, content)
+        
+        # Get channel and send
+        from channel.channel_factory import create_channel
+        
+        try:
+            channel = create_channel(channel_type)
+            if channel:
+                # For web channel, register the request_id to session mapping
+                if channel_type == "web" and hasattr(channel, 'request_to_session'):
+                    channel.request_to_session[request_id] = receiver
+                    logger.debug(f"[Scheduler] Registered request_id {request_id} -> session {receiver}")
+                
+                channel.send(reply, context)
+                logger.info(f"[Scheduler] Task {task['id']} executed: sent message to {receiver}")
+            else:
+                logger.error(f"[Scheduler] Failed to create channel: {channel_type}")
+        except Exception as e:
+            logger.error(f"[Scheduler] Failed to send message: {e}")
+            
+    except Exception as e:
+        logger.error(f"[Scheduler] Error in _execute_send_message: {e}")
+
+
+def _execute_tool_call(task: dict, agent_bridge):
+    """
+    Execute a tool_call action
+    
+    Args:
+        task: Task dictionary
+        agent_bridge: AgentBridge instance
+    """
+    try:
+        action = task.get("action", {})
+        tool_name = action.get("tool_name")
+        tool_params = action.get("tool_params", {})
+        result_prefix = action.get("result_prefix", "")
+        receiver = action.get("receiver")
+        is_group = action.get("is_group", False)
+        channel_type = action.get("channel_type", "unknown")
+        
+        if not tool_name:
+            logger.error(f"[Scheduler] Task {task['id']}: No tool_name specified")
+            return
+        
+        if not receiver:
+            logger.error(f"[Scheduler] Task {task['id']}: No receiver specified")
+            return
+        
+        # Get tool manager and create tool instance
+        from agent.tools.tool_manager import ToolManager
+        tool_manager = ToolManager()
+        tool = tool_manager.create_tool(tool_name)
+        
+        if not tool:
+            logger.error(f"[Scheduler] Task {task['id']}: Tool '{tool_name}' not found")
+            return
+        
+        # Execute tool
+        logger.info(f"[Scheduler] Task {task['id']}: Executing tool '{tool_name}' with params {tool_params}")
+        result = tool.execute(tool_params)
+        
+        # Get result content
+        if hasattr(result, 'result'):
+            content = result.result
+        else:
+            content = str(result)
+        
+        # Add prefix if specified
+        if result_prefix:
+            content = f"{result_prefix}\n\n{content}"
+        
+        # Send result as message
+        context = Context(ContextType.TEXT, content)
+        context["receiver"] = receiver
+        context["isgroup"] = is_group
+        context["session_id"] = receiver
+        
+        # For web channel, generate a virtual request_id
+        if channel_type == "web":
+            import uuid
+            request_id = f"scheduler_{task['id']}_{uuid.uuid4().hex[:8]}"
+            context["request_id"] = request_id
+            logger.debug(f"[Scheduler] Generated request_id for web channel: {request_id}")
+        
+        reply = Reply(ReplyType.TEXT, content)
+        
+        # Get channel and send
+        from channel.channel_factory import create_channel
+        
+        try:
+            channel = create_channel(channel_type)
+            if channel:
+                # For web channel, register the request_id to session mapping
+                if channel_type == "web" and hasattr(channel, 'request_to_session'):
+                    channel.request_to_session[request_id] = receiver
+                    logger.debug(f"[Scheduler] Registered request_id {request_id} -> session {receiver}")
+                
+                channel.send(reply, context)
+                logger.info(f"[Scheduler] Task {task['id']} executed: sent tool result to {receiver}")
+            else:
+                logger.error(f"[Scheduler] Failed to create channel: {channel_type}")
+        except Exception as e:
+            logger.error(f"[Scheduler] Failed to send tool result: {e}")
+            
+    except Exception as e:
+        logger.error(f"[Scheduler] Error in _execute_tool_call: {e}")
+
+
+def attach_scheduler_to_tool(tool, context: Context = None):
+    """
+    Attach scheduler components to a SchedulerTool instance
+    
+    Args:
+        tool: SchedulerTool instance
+        context: Current context (optional)
+    """
+    if _task_store:
+        tool.task_store = _task_store
+    
+    if context:
+        tool.current_context = context
+        
+        # Also set channel_type from config
+        channel_type = conf().get("channel_type", "unknown")
+        if not tool.config:
+            tool.config = {}
+        tool.config["channel_type"] = channel_type

agent/tools/scheduler/scheduler_service.py

@@ -0,0 +1,192 @@
+"""
+Background scheduler service for executing scheduled tasks
+"""
+
+import time
+import threading
+from datetime import datetime, timedelta
+from typing import Callable, Optional
+from croniter import croniter
+from common.log import logger
+
+
+class SchedulerService:
+    """
+    Background service that executes scheduled tasks
+    """
+    
+    def __init__(self, task_store, execute_callback: Callable):
+        """
+        Initialize scheduler service
+        
+        Args:
+            task_store: TaskStore instance
+            execute_callback: Function to call when executing a task
+        """
+        self.task_store = task_store
+        self.execute_callback = execute_callback
+        self.running = False
+        self.thread = None
+        self._lock = threading.Lock()
+    
+    def start(self):
+        """Start the scheduler service"""
+        with self._lock:
+            if self.running:
+                logger.warning("[Scheduler] Service already running")
+                return
+            
+            self.running = True
+            self.thread = threading.Thread(target=self._run_loop, daemon=True)
+            self.thread.start()
+            logger.info("[Scheduler] Service started")
+    
+    def stop(self):
+        """Stop the scheduler service"""
+        with self._lock:
+            if not self.running:
+                return
+            
+            self.running = False
+            if self.thread:
+                self.thread.join(timeout=5)
+            logger.info("[Scheduler] Service stopped")
+    
+    def _run_loop(self):
+        """Main scheduler loop"""
+        logger.info("[Scheduler] Scheduler loop started")
+        
+        while self.running:
+            try:
+                self._check_and_execute_tasks()
+            except Exception as e:
+                logger.error(f"[Scheduler] Error in scheduler loop: {e}")
+            
+            # Sleep for 30 seconds between checks
+            time.sleep(30)
+    
+    def _check_and_execute_tasks(self):
+        """Check for due tasks and execute them"""
+        now = datetime.now()
+        tasks = self.task_store.list_tasks(enabled_only=True)
+        
+        for task in tasks:
+            try:
+                # Check if task is due
+                if self._is_task_due(task, now):
+                    logger.info(f"[Scheduler] Executing task: {task['id']} - {task['name']}")
+                    self._execute_task(task)
+                    
+                    # Update next run time
+                    next_run = self._calculate_next_run(task, now)
+                    if next_run:
+                        self.task_store.update_task(task['id'], {
+                            "next_run_at": next_run.isoformat(),
+                            "last_run_at": now.isoformat()
+                        })
+                    else:
+                        # One-time task, disable it
+                        self.task_store.update_task(task['id'], {
+                            "enabled": False,
+                            "last_run_at": now.isoformat()
+                        })
+                        logger.info(f"[Scheduler] One-time task completed and disabled: {task['id']}")
+            except Exception as e:
+                logger.error(f"[Scheduler] Error processing task {task.get('id')}: {e}")
+    
+    def _is_task_due(self, task: dict, now: datetime) -> bool:
+        """
+        Check if a task is due to run
+        
+        Args:
+            task: Task dictionary
+            now: Current datetime
+            
+        Returns:
+            True if task should run now
+        """
+        next_run_str = task.get("next_run_at")
+        if not next_run_str:
+            # Calculate initial next_run_at
+            next_run = self._calculate_next_run(task, now)
+            if next_run:
+                self.task_store.update_task(task['id'], {
+                    "next_run_at": next_run.isoformat()
+                })
+                return False
+            return False
+        
+        try:
+            next_run = datetime.fromisoformat(next_run_str)
+            return now >= next_run
+        except:
+            return False
+    
+    def _calculate_next_run(self, task: dict, from_time: datetime) -> Optional[datetime]:
+        """
+        Calculate next run time for a task
+        
+        Args:
+            task: Task dictionary
+            from_time: Calculate from this time
+            
+        Returns:
+            Next run datetime or None for one-time tasks
+        """
+        schedule = task.get("schedule", {})
+        schedule_type = schedule.get("type")
+        
+        if schedule_type == "cron":
+            # Cron expression
+            expression = schedule.get("expression")
+            if not expression:
+                return None
+            
+            try:
+                cron = croniter(expression, from_time)
+                return cron.get_next(datetime)
+            except Exception as e:
+                logger.error(f"[Scheduler] Invalid cron expression '{expression}': {e}")
+                return None
+        
+        elif schedule_type == "interval":
+            # Interval in seconds
+            seconds = schedule.get("seconds", 0)
+            if seconds <= 0:
+                return None
+            return from_time + timedelta(seconds=seconds)
+        
+        elif schedule_type == "once":
+            # One-time task at specific time
+            run_at_str = schedule.get("run_at")
+            if not run_at_str:
+                return None
+            
+            try:
+                run_at = datetime.fromisoformat(run_at_str)
+                # Only return if in the future
+                if run_at > from_time:
+                    return run_at
+            except:
+                pass
+            return None
+        
+        return None
+    
+    def _execute_task(self, task: dict):
+        """
+        Execute a task
+        
+        Args:
+            task: Task dictionary
+        """
+        try:
+            # Call the execute callback
+            self.execute_callback(task)
+        except Exception as e:
+            logger.error(f"[Scheduler] Error executing task {task['id']}: {e}")
+            # Update task with error
+            self.task_store.update_task(task['id'], {
+                "last_error": str(e),
+                "last_error_at": datetime.now().isoformat()
+            })

agent/tools/scheduler/scheduler_tool.py

@@ -0,0 +1,439 @@
+"""
+Scheduler tool for creating and managing scheduled tasks
+"""
+
+import uuid
+from datetime import datetime
+from typing import Any, Dict, Optional
+from croniter import croniter
+
+from agent.tools.base_tool import BaseTool, ToolResult
+from bridge.context import Context, ContextType
+from bridge.reply import Reply, ReplyType
+from common.log import logger
+
+
+class SchedulerTool(BaseTool):
+    """
+    Tool for managing scheduled tasks (reminders, notifications, etc.)
+    """
+    
+    name: str = "scheduler"
+    description: str = (
+        "创建、查询和管理定时任务。支持两种任务类型：\n"
+        "1. 静态消息任务：定时发送预定义的消息\n"
+        "2. 动态工具任务：定时执行工具调用并发送结果（如搜索新闻、查询天气等）\n\n"
+        "使用方法：\n"
+        "- 创建静态消息任务：action='create', name='任务名', message='消息内容', schedule_type='interval'/'cron'/'once', schedule_value='间隔秒数/cron表达式/时间'\n"
+        "- 创建动态工具任务：action='create', name='任务名', tool_call={'tool_name': '工具名', 'tool_params': {...}, 'result_prefix': '前缀'}, schedule_type='interval'/'cron'/'once', schedule_value='值'\n"
+        "- 查询列表：action='list'\n"
+        "- 查看详情：action='get', task_id='任务ID'\n"
+        "- 删除任务：action='delete', task_id='任务ID'\n"
+        "- 启用任务：action='enable', task_id='任务ID'\n"
+        "- 禁用任务：action='disable', task_id='任务ID'\n\n"
+        "调度类型说明：\n"
+        "- interval: 固定间隔秒数（如3600表示每小时）\n"
+        "- cron: cron表达式（如'0 9 * * *'表示每天9点，'*/10 * * * *'表示每10分钟）\n"
+        "- once: 一次性任务，ISO时间格式（如'2024-12-25T09:00:00'）\n\n"
+        "示例：每天早上8点搜索新闻\n"
+        "action='create', name='每日新闻', tool_call={'tool_name': 'bocha_search', 'tool_params': {'query': '今日新闻'}, 'result_prefix': '📰 今日新闻播报'}, schedule_type='cron', schedule_value='0 8 * * *'"
+    )
+    params: dict = {
+        "type": "object",
+        "properties": {
+            "action": {
+                "type": "string",
+                "enum": ["create", "list", "get", "delete", "enable", "disable"],
+                "description": "操作类型: create(创建), list(列表), get(查询), delete(删除), enable(启用), disable(禁用)"
+            },
+            "task_id": {
+                "type": "string",
+                "description": "任务ID (用于 get/delete/enable/disable 操作)"
+            },
+            "name": {
+                "type": "string",
+                "description": "任务名称 (用于 create 操作)"
+            },
+            "message": {
+                "type": "string",
+                "description": "要发送的静态消息内容 (用于 create 操作，与tool_call二选一)"
+            },
+            "tool_call": {
+                "type": "object",
+                "description": "要执行的工具调用 (用于 create 操作，与message二选一)",
+                "properties": {
+                    "tool_name": {
+                        "type": "string",
+                        "description": "工具名称，如 'bocha_search'"
+                    },
+                    "tool_params": {
+                        "type": "object",
+                        "description": "工具参数"
+                    },
+                    "result_prefix": {
+                        "type": "string",
+                        "description": "结果前缀，如 '今日新闻：'"
+                    }
+                },
+                "required": ["tool_name"]
+            },
+            "schedule_type": {
+                "type": "string",
+                "enum": ["cron", "interval", "once"],
+                "description": "调度类型 (用于 create 操作): cron(cron表达式), interval(固定间隔秒数), once(一次性)"
+            },
+            "schedule_value": {
+                "type": "string",
+                "description": (
+                    "调度值 (用于 create 操作):\n"
+                    "- cron类型: cron表达式，如 '0 9 * * *' (每天9点)，'*/10 * * * *' (每10分钟)\n"
+                    "- interval类型: 间隔秒数，如 '3600' (每小时)，'10' (每10秒)\n"
+                    "- once类型: ISO时间，如 '2024-12-25T09:00:00'"
+                )
+            }
+        },
+        "required": ["action"]
+    }
+    
+    def __init__(self, config: dict = None):
+        super().__init__()
+        self.config = config or {}
+        
+        # Will be set by agent bridge
+        self.task_store = None
+        self.current_context = None
+    
+    def execute(self, params: dict) -> ToolResult:
+        """
+        Execute scheduler operations
+        
+        Args:
+            params: Dictionary containing:
+                - action: Operation type (create/list/get/delete/enable/disable)
+                - Other parameters depending on action
+            
+        Returns:
+            ToolResult object
+        """
+        # Extract parameters
+        action = params.get("action")
+        kwargs = params
+        
+        if not self.task_store:
+            return ToolResult.fail("错误: 定时任务系统未初始化")
+        
+        try:
+            if action == "create":
+                result = self._create_task(**kwargs)
+                return ToolResult.success(result)
+            elif action == "list":
+                result = self._list_tasks(**kwargs)
+                return ToolResult.success(result)
+            elif action == "get":
+                result = self._get_task(**kwargs)
+                return ToolResult.success(result)
+            elif action == "delete":
+                result = self._delete_task(**kwargs)
+                return ToolResult.success(result)
+            elif action == "enable":
+                result = self._enable_task(**kwargs)
+                return ToolResult.success(result)
+            elif action == "disable":
+                result = self._disable_task(**kwargs)
+                return ToolResult.success(result)
+            else:
+                return ToolResult.fail(f"未知操作: {action}")
+        except Exception as e:
+            logger.error(f"[SchedulerTool] Error: {e}")
+            return ToolResult.fail(f"操作失败: {str(e)}")
+    
+    def _create_task(self, **kwargs) -> str:
+        """Create a new scheduled task"""
+        name = kwargs.get("name")
+        message = kwargs.get("message")
+        tool_call = kwargs.get("tool_call")
+        schedule_type = kwargs.get("schedule_type")
+        schedule_value = kwargs.get("schedule_value")
+        
+        # Validate required fields
+        if not name:
+            return "错误: 缺少任务名称 (name)"
+        if not message and not tool_call:
+            return "错误: 必须提供 message 或 tool_call 之一"
+        if message and tool_call:
+            return "错误: message 和 tool_call 不能同时提供，请选择其一"
+        if not schedule_type:
+            return "错误: 缺少调度类型 (schedule_type)"
+        if not schedule_value:
+            return "错误: 缺少调度值 (schedule_value)"
+        
+        # Validate schedule
+        schedule = self._parse_schedule(schedule_type, schedule_value)
+        if not schedule:
+            return f"错误: 无效的调度配置 - type: {schedule_type}, value: {schedule_value}"
+        
+        # Get context info for receiver
+        if not self.current_context:
+            return "错误: 无法获取当前对话上下文"
+        
+        context = self.current_context
+        
+        # Create task
+        task_id = str(uuid.uuid4())[:8]
+        
+        # Build action based on message or tool_call
+        if message:
+            action = {
+                "type": "send_message",
+                "content": message,
+                "receiver": context.get("receiver"),
+                "receiver_name": self._get_receiver_name(context),
+                "is_group": context.get("isgroup", False),
+                "channel_type": self.config.get("channel_type", "unknown")
+            }
+        else:  # tool_call
+            action = {
+                "type": "tool_call",
+                "tool_name": tool_call.get("tool_name"),
+                "tool_params": tool_call.get("tool_params", {}),
+                "result_prefix": tool_call.get("result_prefix", ""),
+                "receiver": context.get("receiver"),
+                "receiver_name": self._get_receiver_name(context),
+                "is_group": context.get("isgroup", False),
+                "channel_type": self.config.get("channel_type", "unknown")
+            }
+        
+        task = {
+            "id": task_id,
+            "name": name,
+            "enabled": True,
+            "created_at": datetime.now().isoformat(),
+            "updated_at": datetime.now().isoformat(),
+            "schedule": schedule,
+            "action": action
+        }
+        
+        # Calculate initial next_run_at
+        next_run = self._calculate_next_run(task)
+        if next_run:
+            task["next_run_at"] = next_run.isoformat()
+        
+        # Save task
+        self.task_store.add_task(task)
+        
+        # Format response
+        schedule_desc = self._format_schedule_description(schedule)
+        receiver_desc = task["action"]["receiver_name"] or task["action"]["receiver"]
+        
+        if message:
+            content_desc = f"💬 消息: {message}"
+        else:
+            tool_name = tool_call.get("tool_name")
+            tool_params_str = str(tool_call.get("tool_params", {}))
+            prefix = tool_call.get("result_prefix", "")
+            content_desc = f"🔧 工具调用: {tool_name}({tool_params_str})"
+            if prefix:
+                content_desc += f"\n📝 结果前缀: {prefix}"
+        
+        return (
+            f"✅ 定时任务创建成功\n\n"
+            f"📋 任务ID: {task_id}\n"
+            f"📝 名称: {name}\n"
+            f"⏰ 调度: {schedule_desc}\n"
+            f"👤 接收者: {receiver_desc}\n"
+            f"{content_desc}\n"
+            f"🕐 下次执行: {next_run.strftime('%Y-%m-%d %H:%M:%S') if next_run else '未知'}"
+        )
+    
+    def _list_tasks(self, **kwargs) -> str:
+        """List all tasks"""
+        tasks = self.task_store.list_tasks()
+        
+        if not tasks:
+            return "📋 暂无定时任务"
+        
+        lines = [f"📋 定时任务列表 (共 {len(tasks)} 个)\n"]
+        
+        for task in tasks:
+            status = "✅" if task.get("enabled", True) else "❌"
+            schedule_desc = self._format_schedule_description(task.get("schedule", {}))
+            next_run = task.get("next_run_at")
+            next_run_str = datetime.fromisoformat(next_run).strftime('%m-%d %H:%M') if next_run else "未知"
+            
+            lines.append(
+                f"{status} [{task['id']}] {task['name']}\n"
+                f"   ⏰ {schedule_desc} | 下次: {next_run_str}"
+            )
+        
+        return "\n".join(lines)
+    
+    def _get_task(self, **kwargs) -> str:
+        """Get task details"""
+        task_id = kwargs.get("task_id")
+        if not task_id:
+            return "错误: 缺少任务ID (task_id)"
+        
+        task = self.task_store.get_task(task_id)
+        if not task:
+            return f"错误: 任务 '{task_id}' 不存在"
+        
+        status = "启用" if task.get("enabled", True) else "禁用"
+        schedule_desc = self._format_schedule_description(task.get("schedule", {}))
+        action = task.get("action", {})
+        next_run = task.get("next_run_at")
+        next_run_str = datetime.fromisoformat(next_run).strftime('%Y-%m-%d %H:%M:%S') if next_run else "未知"
+        last_run = task.get("last_run_at")
+        last_run_str = datetime.fromisoformat(last_run).strftime('%Y-%m-%d %H:%M:%S') if last_run else "从未执行"
+        
+        return (
+            f"📋 任务详情\n\n"
+            f"ID: {task['id']}\n"
+            f"名称: {task['name']}\n"
+            f"状态: {status}\n"
+            f"调度: {schedule_desc}\n"
+            f"接收者: {action.get('receiver_name', action.get('receiver'))}\n"
+            f"消息: {action.get('content')}\n"
+            f"下次执行: {next_run_str}\n"
+            f"上次执行: {last_run_str}\n"
+            f"创建时间: {datetime.fromisoformat(task['created_at']).strftime('%Y-%m-%d %H:%M:%S')}"
+        )
+    
+    def _delete_task(self, **kwargs) -> str:
+        """Delete a task"""
+        task_id = kwargs.get("task_id")
+        if not task_id:
+            return "错误: 缺少任务ID (task_id)"
+        
+        task = self.task_store.get_task(task_id)
+        if not task:
+            return f"错误: 任务 '{task_id}' 不存在"
+        
+        self.task_store.delete_task(task_id)
+        return f"✅ 任务 '{task['name']}' ({task_id}) 已删除"
+    
+    def _enable_task(self, **kwargs) -> str:
+        """Enable a task"""
+        task_id = kwargs.get("task_id")
+        if not task_id:
+            return "错误: 缺少任务ID (task_id)"
+        
+        task = self.task_store.get_task(task_id)
+        if not task:
+            return f"错误: 任务 '{task_id}' 不存在"
+        
+        self.task_store.enable_task(task_id, True)
+        return f"✅ 任务 '{task['name']}' ({task_id}) 已启用"
+    
+    def _disable_task(self, **kwargs) -> str:
+        """Disable a task"""
+        task_id = kwargs.get("task_id")
+        if not task_id:
+            return "错误: 缺少任务ID (task_id)"
+        
+        task = self.task_store.get_task(task_id)
+        if not task:
+            return f"错误: 任务 '{task_id}' 不存在"
+        
+        self.task_store.enable_task(task_id, False)
+        return f"✅ 任务 '{task['name']}' ({task_id}) 已禁用"
+    
+    def _parse_schedule(self, schedule_type: str, schedule_value: str) -> Optional[dict]:
+        """Parse and validate schedule configuration"""
+        try:
+            if schedule_type == "cron":
+                # Validate cron expression
+                croniter(schedule_value)
+                return {"type": "cron", "expression": schedule_value}
+            
+            elif schedule_type == "interval":
+                # Parse interval in seconds
+                seconds = int(schedule_value)
+                if seconds <= 0:
+                    return None
+                return {"type": "interval", "seconds": seconds}
+            
+            elif schedule_type == "once":
+                # Parse datetime
+                datetime.fromisoformat(schedule_value)
+                return {"type": "once", "run_at": schedule_value}
+            
+        except Exception as e:
+            logger.error(f"[SchedulerTool] Invalid schedule: {e}")
+            return None
+        
+        return None
+    
+    def _calculate_next_run(self, task: dict) -> Optional[datetime]:
+        """Calculate next run time for a task"""
+        schedule = task.get("schedule", {})
+        schedule_type = schedule.get("type")
+        now = datetime.now()
+        
+        if schedule_type == "cron":
+            expression = schedule.get("expression")
+            cron = croniter(expression, now)
+            return cron.get_next(datetime)
+        
+        elif schedule_type == "interval":
+            seconds = schedule.get("seconds", 0)
+            from datetime import timedelta
+            return now + timedelta(seconds=seconds)
+        
+        elif schedule_type == "once":
+            run_at_str = schedule.get("run_at")
+            return datetime.fromisoformat(run_at_str)
+        
+        return None
+    
+    def _format_schedule_description(self, schedule: dict) -> str:
+        """Format schedule as human-readable description"""
+        schedule_type = schedule.get("type")
+        
+        if schedule_type == "cron":
+            expr = schedule.get("expression", "")
+            # Try to provide friendly description
+            if expr == "0 9 * * *":
+                return "每天 9:00"
+            elif expr == "0 */1 * * *":
+                return "每小时"
+            elif expr == "*/30 * * * *":
+                return "每30分钟"
+            else:
+                return f"Cron: {expr}"
+        
+        elif schedule_type == "interval":
+            seconds = schedule.get("seconds", 0)
+            if seconds >= 86400:
+                days = seconds // 86400
+                return f"每 {days} 天"
+            elif seconds >= 3600:
+                hours = seconds // 3600
+                return f"每 {hours} 小时"
+            elif seconds >= 60:
+                minutes = seconds // 60
+                return f"每 {minutes} 分钟"
+            else:
+                return f"每 {seconds} 秒"
+        
+        elif schedule_type == "once":
+            run_at = schedule.get("run_at", "")
+            try:
+                dt = datetime.fromisoformat(run_at)
+                return f"一次性 ({dt.strftime('%Y-%m-%d %H:%M')})"
+            except:
+                return "一次性"
+        
+        return "未知"
+    
+    def _get_receiver_name(self, context: Context) -> str:
+        """Get receiver name from context"""
+        try:
+            msg = context.get("msg")
+            if msg:
+                if context.get("isgroup"):
+                    return msg.other_user_nickname or "群聊"
+                else:
+                    return msg.from_user_nickname or "用户"
+        except:
+            pass
+        return "未知"

agent/tools/scheduler/task_store.py

@@ -0,0 +1,200 @@
+"""
+Task storage management for scheduler
+"""
+
+import json
+import os
+import threading
+from datetime import datetime
+from typing import Dict, List, Optional
+from pathlib import Path
+
+
+class TaskStore:
+    """
+    Manages persistent storage of scheduled tasks
+    """
+    
+    def __init__(self, store_path: str = None):
+        """
+        Initialize task store
+        
+        Args:
+            store_path: Path to tasks.json file. Defaults to ~/cow/scheduler/tasks.json
+        """
+        if store_path is None:
+            # Default to ~/cow/scheduler/tasks.json
+            home = os.path.expanduser("~")
+            store_path = os.path.join(home, "cow", "scheduler", "tasks.json")
+        
+        self.store_path = store_path
+        self.lock = threading.Lock()
+        self._ensure_store_dir()
+    
+    def _ensure_store_dir(self):
+        """Ensure the storage directory exists"""
+        store_dir = os.path.dirname(self.store_path)
+        os.makedirs(store_dir, exist_ok=True)
+    
+    def load_tasks(self) -> Dict[str, dict]:
+        """
+        Load all tasks from storage
+        
+        Returns:
+            Dictionary of task_id -> task_data
+        """
+        with self.lock:
+            if not os.path.exists(self.store_path):
+                return {}
+            
+            try:
+                with open(self.store_path, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    return data.get("tasks", {})
+            except Exception as e:
+                print(f"Error loading tasks: {e}")
+                return {}
+    
+    def save_tasks(self, tasks: Dict[str, dict]):
+        """
+        Save all tasks to storage
+        
+        Args:
+            tasks: Dictionary of task_id -> task_data
+        """
+        with self.lock:
+            try:
+                # Create backup
+                if os.path.exists(self.store_path):
+                    backup_path = f"{self.store_path}.bak"
+                    try:
+                        with open(self.store_path, 'r') as src:
+                            with open(backup_path, 'w') as dst:
+                                dst.write(src.read())
+                    except:
+                        pass
+                
+                # Save tasks
+                data = {
+                    "version": 1,
+                    "updated_at": datetime.now().isoformat(),
+                    "tasks": tasks
+                }
+                
+                with open(self.store_path, 'w', encoding='utf-8') as f:
+                    json.dump(data, f, ensure_ascii=False, indent=2)
+            except Exception as e:
+                print(f"Error saving tasks: {e}")
+                raise
+    
+    def add_task(self, task: dict) -> bool:
+        """
+        Add a new task
+        
+        Args:
+            task: Task data dictionary
+            
+        Returns:
+            True if successful
+        """
+        tasks = self.load_tasks()
+        task_id = task.get("id")
+        
+        if not task_id:
+            raise ValueError("Task must have an 'id' field")
+        
+        if task_id in tasks:
+            raise ValueError(f"Task with id '{task_id}' already exists")
+        
+        tasks[task_id] = task
+        self.save_tasks(tasks)
+        return True
+    
+    def update_task(self, task_id: str, updates: dict) -> bool:
+        """
+        Update an existing task
+        
+        Args:
+            task_id: Task ID
+            updates: Dictionary of fields to update
+            
+        Returns:
+            True if successful
+        """
+        tasks = self.load_tasks()
+        
+        if task_id not in tasks:
+            raise ValueError(f"Task '{task_id}' not found")
+        
+        # Update fields
+        tasks[task_id].update(updates)
+        tasks[task_id]["updated_at"] = datetime.now().isoformat()
+        
+        self.save_tasks(tasks)
+        return True
+    
+    def delete_task(self, task_id: str) -> bool:
+        """
+        Delete a task
+        
+        Args:
+            task_id: Task ID
+            
+        Returns:
+            True if successful
+        """
+        tasks = self.load_tasks()
+        
+        if task_id not in tasks:
+            raise ValueError(f"Task '{task_id}' not found")
+        
+        del tasks[task_id]
+        self.save_tasks(tasks)
+        return True
+    
+    def get_task(self, task_id: str) -> Optional[dict]:
+        """
+        Get a specific task
+        
+        Args:
+            task_id: Task ID
+            
+        Returns:
+            Task data or None if not found
+        """
+        tasks = self.load_tasks()
+        return tasks.get(task_id)
+    
+    def list_tasks(self, enabled_only: bool = False) -> List[dict]:
+        """
+        List all tasks
+        
+        Args:
+            enabled_only: If True, only return enabled tasks
+            
+        Returns:
+            List of task dictionaries
+        """
+        tasks = self.load_tasks()
+        task_list = list(tasks.values())
+        
+        if enabled_only:
+            task_list = [t for t in task_list if t.get("enabled", True)]
+        
+        # Sort by next_run_at
+        task_list.sort(key=lambda t: t.get("next_run_at", float('inf')))
+        
+        return task_list
+    
+    def enable_task(self, task_id: str, enabled: bool = True) -> bool:
+        """
+        Enable or disable a task
+        
+        Args:
+            task_id: Task ID
+            enabled: True to enable, False to disable
+            
+        Returns:
+            True if successful
+        """
+        return self.update_task(task_id, {"enabled": enabled})