perf: merge 3 cron tools into 1 cron manage tool, and add edit capability for cron tool. (#7445)

* perf: replace cron tools with FutureTaskTool for improved task management

* feat: enhance FutureTaskTool with edit functionality and improve descriptions

* feat: add edit functionality for cron jobs and update related UI components

Author: Soulter

astrbot/core/astr_main_agent.py

@@ -59,11 +59,7 @@
 from astrbot.core.skills.skill_manager import SkillManager, build_skills_prompt
 from astrbot.core.star.context import Context
 from astrbot.core.star.star_handler import star_map
-from astrbot.core.tools.cron_tools import (
-    CreateActiveCronTool,
-    DeleteCronJobTool,
-    ListCronJobsTool,
-)
+from astrbot.core.tools.cron_tools import FutureTaskTool
 from astrbot.core.tools.knowledge_base_tools import (
     KnowledgeBaseQueryTool,
     retrieve_knowledge_base,
@@ -1064,9 +1060,7 @@ def _proactive_cron_job_tools(req: ProviderRequest, plugin_context: Context) ->
     if req.func_tool is None:
         req.func_tool = ToolSet()
     tool_mgr = plugin_context.get_llm_tool_manager()
-    req.func_tool.add_tool(tool_mgr.get_builtin_tool(CreateActiveCronTool))
-    req.func_tool.add_tool(tool_mgr.get_builtin_tool(DeleteCronJobTool))
-    req.func_tool.add_tool(tool_mgr.get_builtin_tool(ListCronJobsTool))
+    req.func_tool.add_tool(tool_mgr.get_builtin_tool(FutureTaskTool))
 
 
 async def _apply_web_search_tools(

astrbot/core/tools/cron_tools.py

@@ -18,40 +18,58 @@ def _extract_job_session(job: Any) -> str | None:
     return str(session) if session is not None else None
 
 
+def _parse_run_at(run_at: Any) -> datetime | None:
+    if run_at in (None, ""):
+        return None
+    return datetime.fromisoformat(str(run_at))
+
+
 @builtin_tool
 @dataclass
-class CreateActiveCronTool(FunctionTool[AstrAgentContext]):
-    name: str = "create_future_task"
+class FutureTaskTool(FunctionTool[AstrAgentContext]):
+    name: str = "future_task"
     description: str = (
-        "Create a future task for your future. Supports recurring cron expressions or one-time run_at datetime. "
-        "Use this when you or the user want scheduled follow-up or proactive actions."
+        "Manage your future tasks. "
+        "Use action='create' to schedule a recurring cron task or one-time run_at task. "
+        "Use action='edit' to update an existing task. "
+        "Use action='list' to inspect existing tasks. "
+        "Use action='delete' to remove a task by job_id."
     )
     parameters: dict = Field(
         default_factory=lambda: {
             "type": "object",
             "properties": {
-                "cron_expression": {
+                "action": {
                     "type": "string",
-                    "description": "Cron expression defining recurring schedule (e.g., '0 8 * * *' or '0 23 * * mon-fri'). Prefer named weekdays like 'mon-fri' or 'sat,sun' instead of numeric day-of-week ranges such as '1-5' to avoid ambiguity across cron implementations.",
+                    "enum": ["create", "edit", "delete", "list"],
+                    "description": "Action to perform. 'list' takes no parameters. 'delete' requires only 'job_id'. 'edit' requires 'job_id' plus the fields to change.",
                 },
-                "run_at": {
+                "name": {
                     "type": "string",
-                    "description": "ISO datetime for one-time execution, e.g., 2026-02-02T08:00:00+08:00. Use with run_once=true.",
+                    "description": "Optional task label.",
                 },
-                "note": {
+                "cron_expression": {
                     "type": "string",
-                    "description": "Detailed instructions for your future agent to execute when it wakes.",
+                    "description": "Cron expression for a recurring schedule, e.g. '0 8 * * *' or '0 23 * * mon-fri'. Prefer named weekdays like 'mon-fri' or 'sat,sun' over numeric ranges like '1-5'.",
                 },
-                "name": {
+                "note": {
                     "type": "string",
-                    "description": "Optional label to recognize this future task.",
+                    "description": "Detailed instructions for your future agent to execute when it wakes.",
                 },
                 "run_once": {
                     "type": "boolean",
-                    "description": "If true, the task will run only once and then be deleted. Use run_at to specify the time.",
+                    "description": "Run only once and delete after execution. Use with run_at.",
+                },
+                "run_at": {
+                    "type": "string",
+                    "description": "ISO datetime for one-time execution, e.g. 2026-02-02T08:00:00+08:00.",
+                },
+                "job_id": {
+                    "type": "string",
+                    "description": "Task ID. Required for 'delete' and 'edit'.",
                 },
             },
-            "required": ["note"],
+            "required": ["action"],
         }
     )
 
@@ -62,130 +80,152 @@ async def call(
         if cron_mgr is None:
             return "error: cron manager is not available."
 
-        cron_expression = kwargs.get("cron_expression")
-        run_at = kwargs.get("run_at")
-        run_once = bool(kwargs.get("run_once", False))
-        note = str(kwargs.get("note", "")).strip()
-        name = str(kwargs.get("name") or "").strip() or "active_agent_task"
-
-        if not note:
-            return "error: note is required."
-        if run_once and not run_at:
-            return "error: run_at is required when run_once=true."
-        if (not run_once) and not cron_expression:
-            return "error: cron_expression is required when run_once=false."
-        if run_once and cron_expression:
-            cron_expression = None
-        run_at_dt = None
-        if run_at:
+        action = str(kwargs.get("action") or "").strip().lower()
+        if action == "create":
+            cron_expression = kwargs.get("cron_expression")
+            run_at = kwargs.get("run_at")
+            run_once = bool(kwargs.get("run_once", False))
+            note = str(kwargs.get("note", "")).strip()
+            name = str(kwargs.get("name") or "").strip() or "active_agent_task"
+
+            if not note:
+                return "error: note is required when action=create."
+            if run_once and not run_at:
+                return "error: run_at is required when run_once=true."
+            if (not run_once) and not cron_expression:
+                return "error: cron_expression is required when run_once=false."
+            if run_once and cron_expression:
+                cron_expression = None
             try:
-                run_at_dt = datetime.fromisoformat(str(run_at))
+                run_at_dt = _parse_run_at(run_at)
             except Exception:
                 return "error: run_at must be ISO datetime, e.g., 2026-02-02T08:00:00+08:00"
 
-        payload = {
-            "session": context.context.event.unified_msg_origin,
-            "sender_id": context.context.event.get_sender_id(),
-            "note": note,
-            "origin": "tool",
-        }
-
-        job = await cron_mgr.add_active_job(
-            name=name,
-            cron_expression=str(cron_expression) if cron_expression else None,
-            payload=payload,
-            description=note,
-            run_once=run_once,
-            run_at=run_at_dt,
-        )
-        next_run = job.next_run_time or run_at_dt
-        suffix = (
-            f"one-time at {next_run}"
-            if run_once
-            else f"expression '{cron_expression}' (next {next_run})"
-        )
-        return f"Scheduled future task {job.job_id} ({job.name}) {suffix}."
-
-
-@builtin_tool
-@dataclass
-class DeleteCronJobTool(FunctionTool[AstrAgentContext]):
-    name: str = "delete_future_task"
-    description: str = "Delete a future task (cron job) by its job_id."
-    parameters: dict = Field(
-        default_factory=lambda: {
-            "type": "object",
-            "properties": {
-                "job_id": {
-                    "type": "string",
-                    "description": "The job_id returned when the job was created.",
-                }
-            },
-            "required": ["job_id"],
-        }
-    )
+            payload = {
+                "session": context.context.event.unified_msg_origin,
+                "sender_id": context.context.event.get_sender_id(),
+                "note": note,
+                "origin": "tool",
+            }
+
+            job = await cron_mgr.add_active_job(
+                name=name,
+                cron_expression=str(cron_expression) if cron_expression else None,
+                payload=payload,
+                description=note,
+                run_once=run_once,
+                run_at=run_at_dt,
+            )
+            next_run = job.next_run_time or run_at_dt
+            suffix = (
+                f"one-time at {next_run}"
+                if run_once
+                else f"expression '{cron_expression}' (next {next_run})"
+            )
+            return f"Scheduled future task {job.job_id} ({job.name}) {suffix}."
 
-    async def call(
-        self, context: ContextWrapper[AstrAgentContext], **kwargs
-    ) -> ToolExecResult:
-        cron_mgr = context.context.context.cron_manager
-        if cron_mgr is None:
-            return "error: cron manager is not available."
         current_umo = context.context.event.unified_msg_origin
-        job_id = kwargs.get("job_id")
-        if not job_id:
-            return "error: job_id is required."
-        job = await cron_mgr.db.get_cron_job(str(job_id))
-        if not job:
-            return f"error: cron job {job_id} not found."
-        if _extract_job_session(job) != current_umo:
-            return "error: you can only delete future tasks in the current umo."
-        await cron_mgr.delete_job(str(job_id))
-        return f"Deleted cron job {job_id}."
-
+        if action == "edit":
+            job_id = kwargs.get("job_id")
+            if not job_id:
+                return "error: job_id is required when action=edit."
+            if not any(
+                key in kwargs
+                for key in ("name", "note", "run_once", "cron_expression", "run_at")
+            ):
+                return "error: no editable fields were provided."
+
+            job = await cron_mgr.db.get_cron_job(str(job_id))
+            if not job:
+                return f"error: cron job {job_id} not found."
+            if _extract_job_session(job) != current_umo:
+                return "error: you can only edit future tasks in the current umo."
+
+            payload = dict(job.payload) if isinstance(job.payload, dict) else {}
+
+            updates: dict[str, Any] = {}
+            if "name" in kwargs:
+                name = str(kwargs.get("name") or "").strip()
+                if not name:
+                    return "error: name cannot be empty when action=edit."
+                updates["name"] = name
+
+            if "note" in kwargs:
+                note = str(kwargs.get("note") or "").strip()
+                if not note:
+                    return "error: note cannot be empty when action=edit."
+                payload["note"] = note
+                updates["description"] = note
+
+            current_run_at = payload.get("run_at")
+            run_once = (
+                bool(kwargs["run_once"]) if "run_once" in kwargs else bool(job.run_once)
+            )
+            cron_expression = (
+                str(kwargs.get("cron_expression") or "").strip()
+                if "cron_expression" in kwargs
+                else job.cron_expression
+            )
+            cron_expression = cron_expression or None
 
-@builtin_tool
-@dataclass
-class ListCronJobsTool(FunctionTool[AstrAgentContext]):
-    name: str = "list_future_tasks"
-    description: str = "List existing future tasks (cron jobs) for inspection."
-    parameters: dict = Field(
-        default_factory=lambda: {
-            "type": "object",
-            "properties": {
-                "job_type": {
-                    "type": "string",
-                    "description": "Optional filter: basic or active_agent.",
-                }
-            },
-        }
-    )
+            try:
+                run_at_dt = (
+                    _parse_run_at(kwargs.get("run_at"))
+                    if "run_at" in kwargs
+                    else _parse_run_at(current_run_at)
+                )
+            except Exception:
+                return "error: run_at must be ISO datetime, e.g., 2026-02-02T08:00:00+08:00"
 
-    async def call(
-        self, context: ContextWrapper[AstrAgentContext], **kwargs
-    ) -> ToolExecResult:
-        cron_mgr = context.context.context.cron_manager
-        if cron_mgr is None:
-            return "error: cron manager is not available."
-        current_umo = context.context.event.unified_msg_origin
-        job_type = kwargs.get("job_type")
-        jobs = [
-            job
-            for job in await cron_mgr.list_jobs(job_type)
-            if _extract_job_session(job) == current_umo
-        ]
-        if not jobs:
-            return "No cron jobs found."
-        lines = []
-        for j in jobs:
-            lines.append(
-                f"{j.job_id} | {j.name} | {j.job_type} | run_once={getattr(j, 'run_once', False)} | enabled={j.enabled} | next={j.next_run_time}"
-            )
-        return "\n".join(lines)
+            if run_once:
+                if run_at_dt is None:
+                    return "error: run_at is required when run_once=true."
+                cron_expression = None
+                payload["run_at"] = run_at_dt.isoformat()
+            else:
+                if not cron_expression:
+                    return "error: cron_expression is required when run_once=false."
+                payload.pop("run_at", None)
+
+            updates["run_once"] = run_once
+            updates["cron_expression"] = cron_expression
+            updates["payload"] = payload
+
+            job = await cron_mgr.update_job(str(job_id), **updates)
+            if not job:
+                return f"error: cron job {job_id} not found."
+            return f"Updated future task {job.job_id} ({job.name})."
+
+        if action == "delete":
+            job_id = kwargs.get("job_id")
+            if not job_id:
+                return "error: job_id is required when action=delete."
+            job = await cron_mgr.db.get_cron_job(str(job_id))
+            if not job:
+                return f"error: cron job {job_id} not found."
+            if _extract_job_session(job) != current_umo:
+                return "error: you can only delete future tasks in the current umo."
+            await cron_mgr.delete_job(str(job_id))
+            return f"Deleted cron job {job_id}."
+
+        if action == "list":
+            jobs = [
+                job
+                for job in await cron_mgr.list_jobs()
+                if _extract_job_session(job) == current_umo
+            ]
+            if not jobs:
+                return "No cron jobs found."
+            lines = []
+            for j in jobs:
+                lines.append(
+                    f"{j.job_id} | {j.name} | {j.job_type} | run_once={getattr(j, 'run_once', False)} | enabled={j.enabled} | next={j.next_run_time}"
+                )
+            return "\n".join(lines)
+
+        return "error: action must be one of create, edit, delete, or list."
 
 
 __all__ = [
-    "CreateActiveCronTool",
-    "DeleteCronJobTool",
-    "ListCronJobsTool",
+    "FutureTaskTool",
 ]