diff --git a/core/task_draft.py b/core/task_draft.py new file mode 100644 index 0000000..e63e000 --- /dev/null +++ b/core/task_draft.py @@ -0,0 +1,541 @@ +"""AI 建任务的 draft 契约：**校验 + 归一化**（唯一真相）。 + +## 为什么必须有这个模块 + +任务执行器对"写错的地方"是**静默跳过**的：未知步骤类型只打一条 warning 继续 +（`tasks/generic/task.py` 的 `_exec_one`），空 `selector_value` 直接 return。 +而 `POST /api/jobs` 只校验 `name` + `task_type`，`params` 完全盲存 +（`web/tasks_api.py`）。两者叠加的后果是：AI（或任何人）交上一条写错的任务， +**创建成功、运行不报错、但什么都没做**。 + +所以这里把执行器的每个"静默跳过点"前移成显式 error，在**落库之前**拦住。 +错误文案是给**模型**看的（走 `submit_task` 的返回值回灌，让它逐条改完重提）， +所以每条都要说清"哪个节点的哪个字段、错在哪、应该是什么"。 + +## 用法 + + res = validate_draft(draft, groups=..., pool=..., default_serial="...") + # → {"ok": bool, "errors": [...], "warnings": [...], "draft": 归一化后的草稿} + +`errors` 非空就是不能落库；`warnings` 只是提醒（前端醒目展示，不拦）。 + +契约与规则的权威描述见 `doc/AI_TASK_GEN.md`。 +""" +import re + +from core.logger import get_logger + +_log = get_logger("core.task_draft") + +# ================== 常量（规则的唯一来源） ================== + +# 单条任务最多多少个步骤节点（含嵌套），防止模型输出失控/被输出长度截断 +MAX_NODES = 60 +# 嵌套深度上限（执行器 >5 层直接跳过该分支，见 tasks/generic/task.py） +MAX_DEPTH = 5 +# 选择器值长度上限 +MAX_SELECTOR_LEN = 200 +# 单条 input_text 的候选文案条数 +MAX_TEXTS = 20 + +# 与编辑器下拉（static/admin/editor.js 的 selector_type 选项）严格同集。 +# 故意不含 textContains —— 下拉里没有它，用户一改就丢。 +SELECTOR_TYPES = ("xpath", "description", "text", "resourceId", + "descriptionContains", "className") +IF_SELECTOR_TYPES = SELECTOR_TYPES + ("ocr",) + +# 按键白名单（u2 的 d.press 支持更多，这里只放"不会把设备弄坏"的那些： +# 不含 power/camera —— 探索期误按 power 会让设备息屏、任务中途失联） +KEY_WHITELIST = ("back", "home", "enter", "menu", "recent", "delete", + "volume_up", "volume_down", "search") + +DIRECTIONS = ("up", "down", "left", "right") +LOOP_MODES = ("rounds", "time", "forever") +SCHEDULE_MODES = ("once", "cron", "cron_stop") +TARGET_MODES = ("all", "group", "serial") + +# 需要选择器的步骤类型（缺 selector_value 时执行器静默跳过） +NEED_SELECTOR = ("click", "long_click", "wait_el", "swipe_until", "if_el") +# 需要包名的步骤类型 +NEED_PACKAGE = ("open_app", "stop_app") +# 需要非空 children 的容器 +NEED_CHILDREN = ("loop", "group") + +# 有副作用的动作关键词：命中的步骤在 AI 通道只给 warning（人工复核），不拦 +DESTRUCTIVE_HINTS = ("评论", "发送", "发布", "投稿", "转发", "分享到", + "购买", "下单", "支付", "付款", "删除", "卸载", + "退出登录", "注销", "举报", "拉黑", "清空") +# 命中上面关键词的步骤，触发概率被压到这个值（可人工改回） +SAFE_PROBABILITY = 30 + +_PKG_RE = re.compile(r"^[A-Za-z][A-Za-z0-9_]*(\.[A-Za-z0-9_]+)+$") +_HHMM_RE = re.compile(r"^([01]\d|2[0-3]):[0-5]\d$") +# 「序号型」选择器的两种形态： +# (//*[@resource-id="x"])[4] ← 抓取器在语义消歧失败时给的（当前形态） +# //*[@resource-id="x"][4] ← 历史形态（执行器会自动纠正成上面那种） +# 两者都依赖"同类元素有几个"，界面一变就指到别的元素上，都值得提醒换语义选择器。 +_SEQ_SELECTOR_RE = re.compile(r"^(?:\(\s*//\*\[@[^\]]+\]\s*\)|//\*\[@[^\]]+\])\[\d+\]") + + +def _step_types(): + """步骤类型 → (label, 默认 params)，直接取自执行器的权威定义。""" + from tasks.generic.task import STEP_TYPES + return {s["type"]: (s.get("label", s["type"]), dict(s.get("params") or {})) + for s in STEP_TYPES} + + +def _is_num(v): + return isinstance(v, (int, float)) and not isinstance(v, bool) + + +def _num(params, key, default=None): + v = params.get(key, default) + return v if _is_num(v) else default + + +# ================== 步骤树校验 ================== + +def validate_steps(steps, depth=1, path="steps", errors=None, warnings=None, + types=None, counter=None): + """递归校验步骤树，返回 (errors, warnings, 节点总数)。 + + 每条 error 都带上路径（如 `steps[0].params.children[2]`），模型据此能直接定位。 + """ + errors = [] if errors is None else errors + warnings = [] if warnings is None else warnings + types = _step_types() if types is None else types + counter = [0] if counter is None else counter + + if not isinstance(steps, list): + errors.append(f"{path}: 必须是数组") + return errors, warnings, counter[0] + + for i, step in enumerate(steps): + here = f"{path}[{i}]" + if not isinstance(step, dict): + errors.append(f"{here}: 必须是对象") + continue + stype = step.get("type") + if not stype: + errors.append(f"{here}: 缺少 type 字段") + continue + if stype not in types: + errors.append(f"{here}: 未知步骤类型 {stype!r}（可用类型：" + f"{'、'.join(types)}）") + continue + if stype == "click_xy": + errors.append(f"{here}: 不允许坐标点击（click_xy）—— 坐标在不同分辨率/" + "设备上必失配，请改用 click + 选择器定位元素") + continue + + counter[0] += 1 + if counter[0] > MAX_NODES: + errors.append(f"{here}: 步骤节点总数超过 {MAX_NODES} 个，请精简" + "（去掉冗余的等待/滑动，合并重复结构）") + return errors, warnings, counter[0] + + params = step.get("params") + if params is None: + params = {} + if not isinstance(params, dict): + errors.append(f"{here}.params: 必须是对象") + continue + + # 触发概率（执行器对所有类型通用） + prob = params.get("probability") + if prob is not None: + if not _is_num(prob) or not (0 <= prob <= 100): + errors.append(f"{here}.params.probability: 必须是 0~100 的数字" + f"（当前 {prob!r}）") + + # 选择器类步骤 + if stype in NEED_SELECTOR: + sel = params.get("selector_value") + if not isinstance(sel, str) or not sel.strip(): + errors.append(f"{here}.params.selector_value: 不能为空 —— " + "该步骤没有定位目标，执行时会被静默跳过。" + "如果这一步还没探索出可靠的定位，请把它从 steps 里去掉，" + "需要人工确认的写进 notes") + else: + _check_selector(params, here, stype, errors, warnings) + + # 包名类步骤 + if stype in NEED_PACKAGE: + pkg = params.get("package") + if not isinstance(pkg, str) or not _PKG_RE.match(pkg.strip()): + errors.append(f"{here}.params.package: 必须是包名（如 " + "com.ss.android.ugc.aweme），当前 " + f"{pkg!r}") + + # 容器 + if stype in NEED_CHILDREN: + children = params.get("children") + if not isinstance(children, list) or not children: + errors.append(f"{here}.params.children: 不能为空 —— " + "空容器等于什么都没做") + continue + if depth >= MAX_DEPTH: + errors.append(f"{here}: 嵌套层级超过 {MAX_DEPTH} 层" + "（执行器会直接跳过这个分支）") + continue + validate_steps(children, depth + 1, f"{here}.params.children", + errors, warnings, types, counter) + + if stype == "loop": + mode, fixed = _norm_loop_mode(params.get("loop_mode")) + params["loop_mode"] = mode + if fixed: + warnings.append(f"{here}.params.loop_mode: 已按 {fixed!r} 归一为 " + f"{mode!r}（执行器对未知取值按轮次处理）") + if mode == "rounds": + it = params.get("max_iterations") + if it is None: + # 执行器默认 10（tasks/generic/task.py 的 _exec_loop）—— + # 能跑通的就不该拦，补默认值并提示即可 + params["max_iterations"] = 10 + warnings.append(f"{here}.params.max_iterations: 未填，按默认 10 轮") + elif not _is_num(it) or it < 1: + errors.append(f"{here}.params.max_iterations: 按轮次循环时" + f"必须 ≥1（当前 {it!r}）") + elif mode == "time": + dur = params.get("loop_duration") + # 按时间循环缺时长时执行器**直接跳过**整块（静默无操作）→ 必须拦 + if not _is_num(dur) or dur < 10: + errors.append(f"{here}.params.loop_duration: 按时间循环时" + f"必须 ≥10 秒（当前 {dur!r}）") + + if stype == "if_el": + then = params.get("then") + if not isinstance(then, list) or not then: + errors.append(f"{here}.params.then: 不能为空 —— " + "条件命中后必须做点什么") + if depth >= MAX_DEPTH: + errors.append(f"{here}: 嵌套层级超过 {MAX_DEPTH} 层") + continue + if isinstance(then, list): + validate_steps(then, depth + 1, f"{here}.params.then", + errors, warnings, types, counter) + else_ = params.get("else") + if isinstance(else_, list) and else_: + validate_steps(else_, depth + 1, f"{here}.params.else", + errors, warnings, types, counter) + + if stype == "swipe": + _check_direction(params, here, errors) + dmin, dmax = _num(params, "duration_min"), _num(params, "duration_max") + if dmin is not None and dmax is not None and dmin > dmax: + errors.append(f"{here}.params: duration_min({dmin}) 不能大于 " + f"duration_max({dmax})") + + if stype == "swipe_until": + _check_direction(params, here, errors) + n = params.get("max_swipes") + if not _is_num(n) or not (1 <= n <= 50): + errors.append(f"{here}.params.max_swipes: 必须是 1~50（当前 {n!r}）") + + if stype == "wait": + lo, hi = _num(params, "min"), _num(params, "max") + if lo is None or hi is None or lo < 0 or hi > 600 or lo > hi: + errors.append(f"{here}.params: 需要 0 ≤ min ≤ max ≤ 600" + f"（当前 min={lo!r} max={hi!r}）") + + if stype == "input_text": + mode = params.get("mode", "random") + if mode not in ("random", "fixed"): + errors.append(f"{here}.params.mode: 必须是 random 或 fixed" + f"（当前 {mode!r}）") + elif mode == "fixed": + if not str(params.get("fixed_text") or "").strip(): + errors.append(f"{here}.params.fixed_text: mode=fixed 时不能为空") + else: + texts = params.get("texts") + if not isinstance(texts, str) or not texts.strip(): + errors.append(f"{here}.params.texts: mode=random 时必须给候选" + "文案（换行分隔，如 \"你好\\n不错\"）") + elif len([t for t in texts.split("\n") if t.strip()]) > MAX_TEXTS: + errors.append(f"{here}.params.texts: 候选文案最多 {MAX_TEXTS} 条") + + if stype == "clipboard": + if not str(params.get("text") or "").strip(): + errors.append(f"{here}.params.text: 剪贴板内容不能为空") + + if stype == "keep_screen": + if params.get("mode", "on") not in ("on", "off"): + errors.append(f"{here}.params.mode: 必须是 on 或 off") + + if stype == "key_event": + key = params.get("key", "back") + if key not in KEY_WHITELIST: + errors.append(f"{here}.params.key: 不支持的按键 {key!r}" + f"（可用：{'、'.join(KEY_WHITELIST)}）") + + _check_destructive(step, here, warnings) + + return errors, warnings, counter[0] + + +def _check_selector(params, here, stype, errors, warnings): + """选择器类型/取值合法性（跨 xpath 与 u2 kwarg 两套语义）。""" + stype_ok = IF_SELECTOR_TYPES if stype == "if_el" else SELECTOR_TYPES + sel_type = params.get("selector_type") or "xpath" + value = (params.get("selector_value") or "").strip() + if sel_type not in stype_ok: + errors.append(f"{here}.params.selector_type: 不支持 {sel_type!r}" + f"（可用：{'、'.join(stype_ok)}）") + return + if len(value) > MAX_SELECTOR_LEN: + errors.append(f"{here}.params.selector_value: 太长（>{MAX_SELECTOR_LEN} 字符）") + return + if sel_type == "xpath": + if not (value.startswith("//") or value.startswith("(//")): + errors.append(f"{here}.params.selector_value: 类型是 xpath，但取值不是 " + f"// 或 (// 开头（当前 {value[:40]!r}）") + elif _SEQ_SELECTOR_RE.match(value): + # 执行器有 _norm_legacy_xpath 兜底纠正，所以只提醒不拦： + # 序号型选择器「同类元素个数一变就失配」，能换成文字限定就用文字 + warnings.append(f"{here}.params.selector_value: 序号型选择器" + f"（{value[:40]}）依赖同类元素个数，界面一变就会点空，" + "建议改用 @text/@content-desc 限定") + + +# 模型常见的近义写法 → 执行器认的枚举值。 +# 归一化而不是报错：执行器对未知 loop_mode 是按"轮次"处理的（else 分支）， +# 拦下来只会让模型反复重试（实测把一个 40 步的探索硬生生耗在改这一个字段上）。 +_LOOP_MODE_ALIAS = { + "count": "rounds", "times": "rounds", "round": "rounds", + "iterations": "rounds", "iteration": "rounds", "n": "rounds", + "duration": "time", "seconds": "time", "secs": "time", "timeout": "time", + "infinite": "forever", "infinity": "forever", "until_stop": "forever", + "while": "forever", "loop": "forever", +} + + +def _norm_loop_mode(mode): + """返回 (规范化后的 loop_mode, 原始值或 None)。""" + if mode in LOOP_MODES: + return mode, None + m = str(mode or "").strip().lower() + if m in _LOOP_MODE_ALIAS: + return _LOOP_MODE_ALIAS[m], mode + return "rounds", mode if mode is not None else None + + +def _check_direction(params, here, errors): + d = params.get("direction", "up") + if d not in DIRECTIONS: + errors.append(f"{here}.params.direction: 必须是 " + f"{'/'.join(DIRECTIONS)} 之一（当前 {d!r}）") + + +def _check_destructive(step, here, warnings): + """有副作用的步骤给 warning（不拦）：让人知道哪里需要复核。""" + text = " ".join(str(step.get(f) or "") for f in ("label",)) + text += " " + str((step.get("params") or {}).get("selector_value") or "") + text += " " + str((step.get("params") or {}).get("texts") or "") + hits = [w for w in DESTRUCTIVE_HINTS if w in text] + if not hits: + return + tags = "、".join(hits) + # 有副作用的动作默认调低触发概率（安全默认值，编辑器里可改回）： + # 探索期本来就不许真做这类动作（只核对元素存在），产物更不该一上来就每次都触发 + params = step.setdefault("params", {}) + prob = params.get("probability", 100) + if _is_num(prob) and prob > SAFE_PROBABILITY: + params["probability"] = SAFE_PROBABILITY + warnings.append(f"{here}: 含「{tags}」类有副作用的操作，触发概率已从 {prob}% " + f"降到 {SAFE_PROBABILITY}% —— 核对无误后可在步骤编辑器里改回") + else: + warnings.append(f"{here}: 含「{tags}」类有副作用的操作，" + "请人工复核后再启用") + + +# ================== draft 整体 ================== + +def validate_draft(draft, groups=None, pool=None, default_serial="", overrides=None): + """校验并归一化 AI 提交的任务草稿。 + + draft —— 模型提交的原始对象 + groups —— 现有分组名集合（校验 target.mode=group 时用；None=不校验） + pool —— 设备池 serial 集合（用于给"设备不在池"的 warning；None=不校验） + default_serial —— 本次探索用的设备（target 缺省时兜底） + overrides —— 页面上的"任务设置"覆盖项（用户在页面上填的优先） + + → {"ok", "errors", "warnings", "draft"} + """ + errors, warnings = [], [] + if not isinstance(draft, dict): + return {"ok": False, "errors": ["draft 必须是对象"], "warnings": [], + "draft": None} + + # ---- summary ---- + summary = str(draft.get("summary") or "").strip() + if not summary: + errors.append("summary: 不能为空 —— 用一句话说明这条任务做什么") + elif len(summary) > 200: + summary = summary[:200] + + # ---- task ---- + task = draft.get("task") + if not isinstance(task, dict): + errors.append("task: 缺少任务对象") + task = {} + task = _normalize_task(task, summary, default_serial, overrides or {}, + errors, warnings) + + types = _step_types() + steps = ((task.get("params") or {}).get("steps")) or [] + if not steps: + errors.append("task.params.steps: 不能为空 —— 没有步骤的任务创建后" + "每次运行都会报错") + else: + validate_steps(steps, 1, "task.params.steps", errors, warnings, types) + + _check_target(task, groups, pool, errors, warnings) + _check_schedule(task, errors, warnings) + + return {"ok": not errors, "errors": errors, "warnings": warnings, + "draft": {"summary": summary, "task": task, + "notes": [str(n) for n in (draft.get("notes") or [])][:5], + "evidence": list(draft.get("evidence") or [])[:10]}} + + +def _normalize_task(task, summary, default_serial, overrides, errors, warnings): + """补齐缺失字段（缺什么补什么，但**不掩盖**该报错的必填项）。""" + name = str(overrides.get("name") or task.get("name") or "").strip() + if not name: + name = (summary[:20] or "AI 任务").strip() + task["name"] = name[:40] + + task_type = task.get("task_type") or "generic_steps" + if task_type != "generic_steps": + errors.append(f"task.task_type: 目前只支持 generic_steps（收到 {task_type!r}）") + task["task_type"] = "generic_steps" + + target = task.get("target") + if not isinstance(target, dict) or not target.get("mode"): + target = {"mode": "serial", "serial": default_serial} if default_serial \ + else {"mode": "all"} + warnings.append(f"task.target: 未指定，已按探索设备兜底为 {target}") + # 页面上显式选了目标就以页面为准 + ov_mode = overrides.get("target_mode") + if ov_mode in TARGET_MODES: + target = {"mode": ov_mode} + if ov_mode == "group": + target["group_name"] = overrides.get("group_name") or "" + elif ov_mode == "serial": + target["serial"] = overrides.get("serial") or default_serial + task["target"] = target + + schedule = task.get("schedule") + if not isinstance(schedule, dict) or not schedule.get("mode"): + schedule = {"mode": "once"} + if overrides.get("schedule"): + schedule = overrides["schedule"] + task["schedule"] = schedule + + retry = task.get("retry") + if not isinstance(retry, dict): + retry = {} + attempts = retry.get("max_attempts", 1) + delay = retry.get("delay", 60) + if not _is_num(attempts) or not (1 <= attempts <= 10): + warnings.append(f"task.retry.max_attempts: 应为 1~10，已改为 1（原 {attempts!r}）") + attempts = 1 + if not _is_num(delay) or not (10 <= delay <= 3600): + warnings.append(f"task.retry.delay: 应为 10~3600 秒，已改为 60（原 {delay!r}）") + delay = 60 + task["retry"] = {"max_attempts": int(attempts), "delay": int(delay)} + task["enabled"] = bool(task.get("enabled", True)) + + params = task.get("params") + if not isinstance(params, dict): + params = {} + dur = overrides.get("max_duration", params.get("max_duration", 0)) + if not _is_num(dur) or dur < 0 or dur > 604800: + errors.append(f"task.params.max_duration: 必须是 0~604800 的秒数" + f"（当前 {dur!r}）") + dur = 0 + params["max_duration"] = int(dur) + # 步骤里的 id 由编辑器生成，落库前不需要（保留会让前端 id 重复） + if isinstance(params.get("steps"), list): + _strip_ids(params["steps"]) + task["params"] = params + return task + + +def _strip_ids(steps): + for s in steps: + if isinstance(s, dict): + s.pop("id", None) + p = s.get("params") + if isinstance(p, dict): + for key in ("children", "then", "else"): + if isinstance(p.get(key), list): + _strip_ids(p[key]) + + +def _check_target(task, groups, pool, errors, warnings): + target = task.get("target") or {} + mode = target.get("mode") + if mode not in TARGET_MODES: + errors.append(f"task.target.mode: 必须是 {'/'.join(TARGET_MODES)} 之一" + f"（当前 {mode!r}）") + return + if mode == "group": + gname = (target.get("group_name") or "").strip() + if not gname: + errors.append("task.target.group_name: mode=group 时必须给分组名") + elif groups is not None and gname not in groups: + errors.append(f"task.target.group_name: 分组 {gname!r} 不存在" + f"（现有：{'、'.join(groups) or '无'}）") + elif mode == "serial": + serial = (target.get("serial") or "").strip() + if not serial: + errors.append("task.target.serial: mode=serial 时必须给设备 serial") + elif pool is not None and serial not in pool: + warnings.append(f"task.target.serial: 设备 {serial} 不在设备池里，" + "任务运行时会被跳过") + + +def _check_schedule(task, errors, warnings): + sch = task.get("schedule") or {} + mode = sch.get("mode") + if mode not in SCHEDULE_MODES: + errors.append(f"task.schedule.mode: 必须是 {'/'.join(SCHEDULE_MODES)} 之一" + f"（当前 {mode!r}）") + return + if mode == "once": + return + cron = sch.get("cron") + if not isinstance(cron, str) or not _cron_ok(cron): + errors.append(f"task.schedule.cron: 不是合法的 5 段 crontab（分 时 日 月 周）" + f"，当前 {cron!r}") + if mode == "cron_stop": + stop = sch.get("stop_cron") + if not isinstance(stop, str) or not _cron_ok(stop): + errors.append("task.schedule.stop_cron: 定时停止必须给合法的 5 段 " + f"crontab，当前 {stop!r}") + win = sch.get("window") + if isinstance(win, dict): + start, end = win.get("start"), win.get("end") + if not (_HHMM_RE.match(str(start or "")) and _HHMM_RE.match(str(end or ""))): + warnings.append("task.schedule.window: 时间窗应形如 {\"start\":\"09:00\"," + "\"end\":\"18:00\"}，格式不对会被忽略") + elif start == end: + warnings.append("task.schedule.window: 起止相同等于不限制") + dur = (task.get("params") or {}).get("max_duration", 0) + if mode == "cron_stop" and not dur: + warnings.append("task.params.max_duration 为 0：本任务靠定时停止结束，" + "建议同时给一个运行时长上限（秒）兜底") + + +def _cron_ok(expr): + """5 段 crontab 且能被 APScheduler 解析（任务是**静默**不注册的，必须提前拦）。""" + if len(str(expr).split()) != 5: + return False + try: + from apscheduler.triggers.cron import CronTrigger + CronTrigger.from_crontab(expr) + return True + except Exception: + return False diff --git a/doc/AI_CONSOLE.md b/doc/AI_CONSOLE.md index 9f28e0c..a1ace17 100644 --- a/doc/AI_CONSOLE.md +++ b/doc/AI_CONSOLE.md @@ -7,7 +7,14 @@ ## 1. 它是什么 -「AI 控制台」是后台的一个顶级 Tab（仅管理员）：选一台设备，用自然语言下指令，AI 通过 MCP 工具**看屏幕、点按、输入**，边做边把过程和结论流式显示出来。 +「AI 控制台」是后台的一个顶级 Tab（仅管理员），下面有两个子分栏： + +| 子分栏 | 做什么 | 文档 | +|--------|--------|------| +| 💬 **聊天** | 选一台设备用自然语言下指令，AI 通过 MCP 工具**看屏幕、点按、输入**，边做边把过程和结论流式显示出来（本文内容） | 本文 | +| 🧭 **AI 建任务** | 描述"要什么样的自动化"，AI **自己在真机上探索**（看屏/读元素树/点按验证），把走通的路径写成**一条可调度任务**，校验后交人工在步骤编辑器确认 | [AI_TASK_GEN.md](AI_TASK_GEN.md) | + +> 两个子分栏共用**同一个运行槽**（全平台同时只允许一个 Agent 运行）：建任务在探索时，聊天页会显示"● 建任务探索中"并禁用发送，反之亦然。 ``` 你：「打开小红书搜索苏州好吃的饭店，把前 5 条列出来」 @@ -78,6 +85,11 @@ mcp_agent.Agent.run_stream(prompt, serial, history, on_delta, on_tool, on_usage, - 一轮整体超时 **900 秒**；达到步数上限会让模型做一次收尾总结 - 工具调用由 MCP Server 执行（`:8033`），后者再调平台 HTTP 接口/直连设备 - **设备忙时拒绝**：目标设备正在跑任务 → `409`（"AI 不与任务抢设备"） +- `mode:"designer"`（AI 建任务）走同一条链路，差别：换一套 system prompt（任务设计师）、 + 输出上限提到 8192、**不吃聊天历史**、多一个平台级本地工具 `submit_task` + （不经 MCP，服务端用 `core/task_draft` 校验，见 [AI_TASK_GEN.md](AI_TASK_GEN.md)） +- 工具结果必须是**连续的** tool 消息：一轮里若同时调了截图与别的工具，图像会攒到本轮工具 + 消息发完后再作为一条 user 消息附上（否则模型侧会以"工具回应不足"报 400） ### 3.2 会话消息模型 @@ -99,7 +111,7 @@ mcp_agent.Agent.run_stream(prompt, serial, history, on_delta, on_tool, on_usage, | `delta` | `{"text","kind":"content"\|"reasoning"}` | 正文增量渲染 Markdown；推理增量进入可折叠「💭 思考过程」 | | `step` | `{"tool","args","image"?}` | 追加工具卡片（含缩略截图，点击放大）；伪卡片提示经验/动作命中与沉淀 | | `usage` | `{"prompt_tokens","completion_tokens","total_tokens","calls"}` | 刷新单条消息脚注与顶栏「本会话累计」 | -| `done` | `{"answer","usage"}` | 最终答案 + 收尾 | +| `done` | `{"answer","usage","mode","draft"?,"warnings"?,"draft_error"?}` | 最终答案 + 收尾；`mode=designer` 时带任务草稿（或草稿被拦的原因） | | `error` | `{"message"}` | 展示错误（MCP 不可达等已转成明确文案） | **刷新/重连不丢进度**：服务端事件队列保留积压，页面重新订阅（`GET /api/agent/stream?run_id=`）后会补发 delta/step/usage/done；`EventSource.onerror` **刻意不结束运行**，靠自动重连续上。另外 `GET /api/agent/run` 提供状态快照（其他窗口/8s 轮询用）。 @@ -191,8 +203,10 @@ mcp_agent.Agent.run_stream(prompt, serial, history, on_delta, on_tool, on_usage, | `agent_api_key` | API Key（**明文存库**） | — | | `agent_default_serial` | 默认目标设备 | 空 | | `agent_max_steps` | 最大步数（钳制 1-200） | 40 | +| `agent_task_draft` | **AI 建任务**最近一份草稿（JSON：`{draft, warnings, prompt, created}`，只留最近一份；不是任务，入库仍走人工确认） | 空 | -其它常量：单轮超时 900s、推理链落库上限 6000 字符、会话消息上限 60 条、历史上下文取最近 12 轮。 +其它常量：单轮超时 900s、推理链落库上限 6000 字符、会话消息上限 60 条、历史上下文取最近 12 轮； +建任务模式（designer）输出上限 8192、单工具调用上限 40 次（`mcp_agent/agent.py`）。 --- diff --git a/doc/AI_TASK_GEN.md b/doc/AI_TASK_GEN.md index 49bfe97..22716a6 100644 --- a/doc/AI_TASK_GEN.md +++ b/doc/AI_TASK_GEN.md @@ -1,6 +1,7 @@ # AI 建任务（AI Task Generator）设计文档 -> 状态：**设计稿，尚未实现**（P0 未开工）——本文描述的是「要做什么、为什么这么做」，不是现状。 +> 状态：**P0 已实现**（2026-09-13）——§1~§9 是设计稿（与实现基本一致）， +> **§10 是实现记录**：差异、落地细节、怎么自测，以 §10 为准。 > 现状请读：[AI_CONSOLE.md](AI_CONSOLE.md)（AI 控制台已实现的能力）、[TASK_DEV.md](TASK_DEV.md)（任务与步骤）、[MCP.md](MCP.md)（已实现的 19 个工具）。 > 关联代码：`web/agent_api.py`、`mcp_server/`、`mcp_agent/`、`tasks/generic/`、`static/admin/editor.js`。最后核对：2026-09-10。 @@ -181,3 +182,61 @@ ### 9.4 分层与登记（红线） - 每新增/修改/删除一个 MCP 工具或平台配置：同步更新 `doc/MCP.md`（全清单）、`doc/MCP_DESIGN.md`（规格/层级），并在提交里体现——见全局「doc 同步红线」。 - `core/task_draft.py` 是 web 校验与 MCP 校验的**唯一来源**，杜绝两套规则漂移。 + +--- + +## 10. 实现记录（2026-09-13） + +### 10.1 与设计稿的差异（以本节为准） + +| 设计稿 | 实际实现 | 为什么 | +|---|---|---| +| 聊天页加「模式」开关 | AI 控制台下的**独立子分栏**「🧭 AI 建任务」 | 用户要求独立页面；探索回放 + 草稿预览需要自己的版面 | +| `submit_task` 作为平台工具（§9.2，未指定放哪层） | **Agent 本地工具**（`mcp_agent/agent.py` 的 `LOCAL_TOOL_SPECS`），**不进 MCP Server** | 放进 MCP 等于给外部客户端开"写任务"的口子，还要连带改 MCP.md/MCP_DESIGN.md 与审计；收益为零 | +| draft 经前端灌进步骤编辑器 | 同上，但草稿**先落 `app_meta`**（`agent_task_draft`，只留最近一份） | 刷新/重进页面能拿回来；**不新建表**，绕开备份覆盖红线（SUMMARY_TABLES / DEPLOY §3.5） | +| （未提） | designer 跑**不绑会话、不吃聊天历史**，且**不沉淀**经验/动作 | 探索轨迹里有试错与误点，沉淀会污染记忆库；"draft→经验"归到 P1 | +| —— | 校验失败把 `errors` **原样回灌模型**，最多重提 3 次（提示词约束） | 这是"AI 写坏任务"的唯一闸门：`POST /api/jobs` 对 params 盲存、执行器又静默跳过错误步骤 | + +### 10.2 关键实现点 + +- **校验器**：`core/task_draft.py`。`validate_draft()` 逐条复刻执行器的"静默跳过点" + （未知 type / 空 selector / 空 children / 嵌套 >5 / 深度节点数 >60 / cron 非法 / + 必填 params 缺失 / `click_xy` 直接拒）→ 返回可被模型读懂的 `errors` + 不拦的 `warnings`。 + `normalize_draft` 负责兜底（任务名、target、schedule、retry、时长）；页面上的任务设置 + 以 `overrides` 形式**优先**于模型给的。 +- **提示词**：`mcp_agent/agent.py` 的 `DESIGNER_SYSTEM_PROMPT`（16 条规则：先看再动、 + 定位优先级、禁坐标、禁序号型 XPath、**副作用动作只核对不真点**、时长语义映射、 + 随机化三件套、规模上限、收尾方式）。 +- **护栏**：单工具调用上限 40 次（`Agent.tool_call_limit`；总步数由 `max_steps` 兜底， + 两个值都要**大于**正常重试次数，否则会把一轮探索截断在"改字段"上——实测踩过）；输出上限 8192（designer）； + `json.loads` 容错（草稿被截断时返回可读错误而不是整轮崩）。 +- **前端**：`static/admin/taskgen.js` + `#agent-sub-taskgen`（子 Tab 机制见 + `static/admin/base.js` 的 `showSubTab`）。草稿预览能直接点「在步骤编辑器中打开」→ + `openTaskModal(null, prefill)` 预填（用唯一 draftKey，避开 localStorage 旧草稿覆盖）。 +- **两个页面共用一个运行槽**：`GET /api/agent/run` 回 `mode`，两个前端各按 mode 决定 + 是否订阅 SSE（一个 run 只有一个事件队列，两个 EventSource 同时消费会互相瓜分事件）。 + +### 10.3 附带修掉的一个协议 bug + +Chat 模式同样受益：一轮里若模型同时调了 `de_screenshot` 与别的工具，旧实现会把截图图像 +作为一条 `user` 消息**插在两条 tool 消息之间**，模型侧判定"工具回应不足"直接 400 +（`An assistant message with 'tool_calls' must be followed by tool messages…`）。 +现改为：本轮 tool 消息发完后再附一条 user 图像消息；`_repair_tool_messages` 也改成 +只数**连续**的 tool 消息。 + +### 10.4 还没做（P1 / 后续） + +- 「探索完直接创建」接口（服务端复验后 `add_job`）——目前一律走人工确认。 +- draft → `agent_experience` / `agent_action` 沉淀（模板重用）。 +- MCP 侧补 `de_snapshot`（截图+元素树一次取齐，见 `doc/research/U2_ELEMENT_SELECTORS.md`）。 +- 多设备并行探索、成本控制。 + +### 10.5 自测怎么跑 + +1. 纯逻辑：`core/task_draft` 的正反例（未知 type / 空 selector / `click_xy` / cron 少段 / + 深度 6 / probability 越界 …），断言 `errors` 文案模型能读懂。 +2. 真机：AI 控制台 →「AI 建任务」→ 选空闲设备 → 描述需求 → 看回放 → 核对草稿 → + 「在步骤编辑器中打开」→ 单步试跑 → 保存。 +3. 反例：需求里出现"自动评论并发送" → 草稿的这类步骤应是"只核对存在性"（`notes` 里提示 + 人工复核），**探索期审计日志里不应有对发送键的 `de_tap_*`**。 +4. 自测产生的东西（草稿/自建任务）用后即删，别碰用户真实数据。 diff --git a/doc/API.md b/doc/API.md index 3fa1e11..930f27a 100644 --- a/doc/API.md +++ b/doc/API.md @@ -198,8 +198,8 @@ |------|------|------| | GET/POST | `/api/agent/config` | 读写 AI 配置（key 打码回显） | | GET | `/api/agent/devices` | AI 可用设备（含名称与 busy 标记） | -| POST | `/api/agent/run` | 启动一轮 AI 会话 | -| GET | `/api/agent/run` | 运行状态（刷新恢复用） | +| POST | `/api/agent/run` | 启动一轮 AI 会话（`mode:"chat"`=聊天 / `"designer"`=AI 建任务） | +| GET | `/api/agent/run` | 运行状态（刷新恢复用；含 `mode`/`draft`） | | GET | `/api/agent/stream` | **SSE 事件流** | | POST | `/api/agent/stop` | 中断当前运行 | | POST | `/api/agent/clear` | 清空对话历史 | @@ -213,6 +213,21 @@ | GET | `/api/agent/actions` | 动作库列表 | | POST | `/api/agent/actions/save` | 新增/编辑动作（禁坐标） | | POST | `/api/agent/actions/delete` | 删除动作 | +| GET | `/api/agent/task_draft` | **AI 建任务**：读回最近一份草稿（`{saved, running, mode, run_id, draft, draft_error}`） | +| POST | `/api/agent/task_draft` | 回存草稿并**重新校验**（不通过返回 400 + `errors`） | +| POST | `/api/agent/task_draft/clear` | 丢弃草稿 | + +**AI 建任务（designer 模式）要点**（详见 [AI_TASK_GEN.md](AI_TASK_GEN.md)）： + +- `POST /api/agent/run` 额外接受 `mode:"designer"` 与 `settings`（页面上的任务设置，作为草稿 + 的 overrides：`name`/`target_mode`/`group_name`/`serial`/`schedule`/`max_duration`）。 + designer 跑**不绑会话**（单轮，不吃聊天历史、也不污染会话）。 +- designer 模式下 Agent 多一个**平台级本地工具** `submit_task(draft)`（**不在 MCP 层**）： + 服务端用 `core/task_draft.validate_draft` 校验，失败把 `errors` 回灌给模型让它改； + 通过也只**暂存**（运行态 + `app_meta.agent_task_draft`），**不落库**——入库仍要用户在 + 步骤编辑器里确认后走 `POST /api/jobs`。 +- `done` 事件在 designer 下多带 `{mode, draft, warnings, draft_error}`。 +- 设备忙 409、单实例运行、权限同聊天模式。 ### 2.10 system（`web/system_api.py`，全部 Admin） diff --git a/doc/ARCHITECTURE.md b/doc/ARCHITECTURE.md index 6541492..1feeb16 100644 --- a/doc/ARCHITECTURE.md +++ b/doc/ARCHITECTURE.md @@ -294,7 +294,8 @@ connecting ──获取设备──▶ u2 连接 ──▶ running ──▶ set | `tools.js` | 工具 Tab：剪贴板、adb 终端、Tailscale、设备池、自动发现、远程看屏 | | | `apps.js` | 应用管理：APK 上传/安装/删除、设备已装应用 | | | `admin.js` | 分组、日志、用户 + **全局初始化入口**（末尾 `initCsrf(); loadMe(); showTab('monitor')`） | | -| `agent.js` | AI 控制台：会话、SSE 流、Markdown / 推理链 / token 渲染、实时画面、经验库 / 动作库 | | +| `agent.js` | AI 控制台·聊天：会话、SSE 流、Markdown / 推理链 / token 渲染、实时画面、经验库 / 动作库 | | +| `taskgen.js` | AI 控制台·**AI 建任务**子页：发起探索、回放工具卡、草稿预览（步骤树/提醒/证据）、打开步骤编辑器预填 | 运行槽与聊天共用，按 `mode` 互斥订阅事件流 | | `system.js` | 系统 Tab：备份导出 / 导入预览与应用 | | 加载顺序见根 [README](../README.md)；都是全局脚本（非 ES module），靠加载顺序保证依赖。 diff --git a/doc/DATA_MODEL.md b/doc/DATA_MODEL.md index 66ca311..4e99e47 100644 --- a/doc/DATA_MODEL.md +++ b/doc/DATA_MODEL.md @@ -228,6 +228,7 @@ UTF-8 等价于字节序）。 | `agent_api_key` | API Key（**明文存库**） | 同上 | | `agent_default_serial` | 默认目标设备 | 同上 | | `agent_max_steps` | 最大步数（钳制 1-200，默认 40） | 同上 | +| `agent_task_draft` | **AI 建任务**最近一份任务草稿（JSON `{draft,warnings,prompt,created}`，只留最近一份、超限自动瘦身）。**不是任务**：入库仍要用户在步骤编辑器确认后走 `POST /api/jobs` | AI 建任务页 / `submit_task` 工具 | | `discovery_enabled` | 自动发现开关（`"1"`/`"0"`） | 工具页「设备池管理」 | | `discovery_subnets` | 扫描网段 JSON 数组 | 同上 | | `discovery_interval` | 扫描周期秒（10-3600） | 同上 | diff --git a/doc/DEVELOPMENT.md b/doc/DEVELOPMENT.md index fd4f3bc..23f7239 100644 --- a/doc/DEVELOPMENT.md +++ b/doc/DEVELOPMENT.md @@ -97,6 +97,7 @@ MCP_ALLOW_WRITE=1 MCP_PLATFORM_USER=admin MCP_PLATFORM_PASS=<密码> \ | 前端验证 | 无 npm/构建，改完强刷；浏览器控制台看报错 | | 接口 500 巡检 | `python scripts/regression_test.py`（**⚠️ 当前在 Windows 上会因 `signal.alarm` 报错**，Linux/macOS 可用） | | 停止设备/清异常 | 监控页「停止全部 / 停止选中 / 清除全部异常」 | +| AI 建任务（designer）验证 | AI 控制台 →「AI 建任务」选**空闲**设备跑一轮；脚本方式见 [AI_TASK_GEN.md](AI_TASK_GEN.md) §10.5。草稿只落 `app_meta.agent_task_draft`（不是任务），验证完 `POST /api/agent/task_draft/clear` 清掉。**注意它会真在设备上点按**（导航类动作），且与聊天共用同一个运行槽 | > **改了数据库/配置想复原**：删 `data/users.db*` 会丢数据，别这么干；用「系统 → 备份/导入」或先手工复制一份 `data/`。 diff --git a/doc/README.md b/doc/README.md index de7e852..5628d03 100644 --- a/doc/README.md +++ b/doc/README.md @@ -17,7 +17,7 @@ | [MCP.md](MCP.md) | **MCP 手机控制手册**：19 个 `de_*` 工具用法、写操作门控、坐标换算、接入示例 | 接入方、数字员工 | | [MCP_DESIGN.md](MCP_DESIGN.md) | **MCP 设计文档**：边界划分、错误码、白名单/审计设计、演进方向 | 平台开发者 | | [AI_CONSOLE.md](AI_CONSOLE.md) | **AI 控制台**：会话/SSE、经验库、动作库、巡检、Markdown 渲染、推理链、token 统计 | 使用者、平台开发者 | -| [AI_TASK_GEN.md](AI_TASK_GEN.md) | **AI 建任务**：设计稿与里程碑（P0 未实现，属规划） | 平台开发者 | +| [AI_TASK_GEN.md](AI_TASK_GEN.md) | **AI 建任务**：AI 自己在真机探索 → 写出可调度任务 → 人工确认入库（P0 已实现；契约与红线） | 平台开发者、使用者 | | [DEVICE_AGENT.md](DEVICE_AGENT.md) | **设备端 Agent 接口契约**：应用商店的设备专用接口（清单/下载/上报）、adb 指令协议、版本约定 —— 与设备端 APK 仓库共享的契约 | 设备端开发者、平台开发者 | | [DEPLOY.md](DEPLOY.md) | **部署与运维**：环境准备、生产容器、数据备份导出/导入、故障排查 | 运维、部署者 | | [DEVELOPMENT.md](DEVELOPMENT.md) | **开发手册**：git 流程、技术红线、本地开发与调试、常见开发任务、文档同步约定 | 所有开发者 | diff --git a/doc/backlog/TODO.md b/doc/backlog/TODO.md index 8bc1907..6dd8349 100644 --- a/doc/backlog/TODO.md +++ b/doc/backlog/TODO.md @@ -96,7 +96,8 @@ ## D. AI 控制台 / 经验与动作 - [ ] 「🧠 经验库 / 🎬 动作库」合为一个面板（标签页切换）。 -- [ ] AI 建任务 P0：平台级 MCP 工具（只读清单 `task_types/groups/pool` + `submit_task(draft)` 校验）+ 把**动作库**当作 generic_steps 的预制件复用（见 [AI_TASK_GEN.md](../AI_TASK_GEN.md) §9）。 +- [x] ~~AI 建任务 P0~~（✅ 2026-09-13：独立子页「AI 建任务」+ `submit_task` 校验 + 草稿预览/预填，见 [AI_TASK_GEN.md](../AI_TASK_GEN.md) §10）。 + - 仍未做：平台级 MCP 只读清单（`task_types/groups/pool`）、把**动作库**当 generic_steps 预制件复用、draft→经验/动作沉淀、「探索完直接创建」接口。 - [ ] 新增 MCP `de_screen_text`（文本化看屏：前台包名 + screen_state + 可点元素文本 + OCR），并把操作纪律写进工具 description。 - [ ] 经验召回改进：现为 bigram + `ORDER BY hits`（候选只看 top50、hits 对所有命中行回写 → 马太效应）；改为对称相似度 / 更合理候选集，`hits` 仅在真正注入时 +1。 - [ ] 经验/动作入库依赖模型蒸馏成功：加失败重试与可视化观测（现在只在日志里）。 diff --git a/mcp_agent/agent.py b/mcp_agent/agent.py index 8951bc4..8373d9a 100644 --- a/mcp_agent/agent.py +++ b/mcp_agent/agent.py @@ -25,10 +25,16 @@ _log = logging.getLogger("agent") S = AgentSettings() +# 模型单次回复的长度上限。建任务模式要一次性输出整份任务 JSON（几十个步骤）， +# 4096 很容易被截断 → 工具参数变成半截 JSON（见 _execute_tool 的容错）。 +_DEFAULT_MAX_TOKENS = 4096 +_DESIGNER_MAX_TOKENS = 8192 + + class _UsageUnsupported(RuntimeError): """模型/网关不认 stream_options.include_usage（400/422 或报错点名该字段）——降级重试用。""" -SYSTEM_PROMPT = """你是手机自动化控制助手。你通过工具实时操作 Android 手机。 +CHAT_SYSTEM_PROMPT = """你是手机自动化控制助手。你通过工具实时操作 Android 手机。 工作规范： 1. 先 de_list_devices 确定目标设备（在线才可操作）；设备有 name（名称）与 serial（地址）， @@ -54,6 +60,103 @@ SYSTEM_PROMPT = """你是手机自动化控制助手。你通过工具实时操 可用工具清单将由系统提供。""" +# 兼容旧名（CLI / 其它调用方仍可能 import SYSTEM_PROMPT） +SYSTEM_PROMPT = CHAT_SYSTEM_PROMPT + + +# ================== 建任务模式（designer）================== +# 与聊天模式的根本区别：**产出物是一条任务，不是"替用户做完这件事"**。 +# 所以它要"看懂了就写下来"，而不是"一路点到底"；有副作用的动作只许核对、不许真做。 +DESIGNER_SYSTEM_PROMPT = """你是手机自动化**任务设计师**。你的产出物是**一条可调度、可在步骤编辑器里继续修改的任务**（不是替用户把这件事做完）。 + +工作方式：在真机上探索够用即止 → 把探索到的元素与操作写成任务步骤 → 调 submit_task 提交草稿 → 人工确认后才会真正入库执行。 + +## 探索规范 +1. 只用本次指定的设备 serial；给用户汇报时用设备名。设备离线/异常/被任务占用时**立即停止并说明**，不要硬试。 +2. **先看再动**：`de_screenshot` 看屏 → `de_ui_tree(limit=80~150)` 拿元素（字段只有 text/id/desc/class/clickable/bounds，**没有 xpath**）。同一屏只 dump 一次，不要反复截图。 +3. 不知道包名先 `de_list_apps(keyword=…)`，再 `de_open_app(package)`；用 `de_foreground_app` 确认前台。 +4. **定位优先级**：`text` / `description` / `resourceId` > `xpath` > 坐标。**禁止坐标**（绝不产 `click_xy`）。 + 包含匹配只能 `descriptionContains`，或 `xpath` 里的 `//*[contains(@text,"…")]`（没有 textContains 这个类型）。 +5. XPath 写法：`//*[@resource-id="包名:id/xxx"]`、`//*[@text="…"]`、`//*[@text="…" and @resource-id="…"]`。 + **禁止** `//*[@id="x"][3]` 这种位置谓词（那是"父节点内第 3 个"，同类元素一多就全失配）。 +6. 验证分两档： + - **无害导航类**（tab、返回、搜索框、列表项、设置项）→ 可以 `de_tap_element` 真点一次确认能命中，记 `evidence.verified="tapped"`； + - **有副作用类**（点赞/关注/评论/发送/转发/购买/删除/退出登录）→ **只核对元素存在**（`verified="present"`），**绝不真点**；写进任务时 `probability ≤ 30`，并在 `notes` 里写明"请人工复核"。 +7. 没验证命中的元素**一律不写进任务**；拿不准的进 `notes`。宁可少写一步，也不要编一个选择器。 + +## 步骤规范 +8. 只能用这 18 种步骤类型：open_app / stop_app / screen_on / screen_off / keep_screen / key_event / swipe / swipe_until / click / long_click / wait_el / input_text / clipboard / wait / loop / group / if_el（click_xy 禁用）。 +9. 输入文字必须"先 click 输入框，再 input_text"；滚动用 `swipe{direction}`，不用像素。 +10. 时长语义必须映射对： + - "跑 2 小时" → `params.max_duration = 7200` + 一个顶层 `loop{loop_mode:"forever"}`； + - "每天 8-9 点" → `schedule{mode:"cron_stop", cron:"0 8 * * *", stop_cron:"0 9 * * *"}`； + - **长任务必须给 max_duration**，否则等于无限跑。 +11. 随机化三件套：随机等待 `wait{min,max}`、随机文案 `input_text{mode:"random",texts:"a\\nb"}`、随机触发 `group{probability:<100}` 包住子步骤（概率对任何类型都生效）。 +12. 首步建议 `screen_on`（必要时 `keep_screen{mode:"on"}`）；**末步用 `key_event{key:"home"}` 把设备还给用户**（不要默认息屏）。 +13. 规模控制：工具调用 ≤ 25 步、steps ≤ 30 个节点、notes ≤ 5 条、evidence ≤ 10 条。结构要精简（去掉冗余的等待/滑动）。 + +## 收尾 +14. 探索够了就调 `submit_task` 提交草稿。**校验失败时按返回的 errors 逐条修正后重提（最多 3 次）**，不要重复提交同一份草稿。 +15. 提交成功后**不要再调用任何工具**，用一句中文总结："建了什么任务、哪些步骤需要人工复核"。 +16. 若 system 里注入了"可复用动作"，优先复用其中的定位，跳过重复探索。 + +可用工具清单将由系统提供。""" + + +# 平台级（本地）工具：不经 MCP server，由 Agent 直接分派到调用方注册的 handler。 +# 为什么不放进 mcp_server：这些工具要读写平台自身的任务/草稿（依赖 Flask app context 与 +# 平台权限模型），放进 MCP 层等于给外部客户端开一个写任务的后门，且要连带改 +# MCP.md/MCP_DESIGN.md 与审计——收益为零（见 doc/AI_TASK_GEN.md §9.2）。 +LOCAL_TOOL_SPECS = { + "submit_task": { + "name": "submit_task", + "description": "提交任务草稿（**结束性调用**：提交成功后就不要再调任何工具，直接总结）。" + "服务端会校验草稿（步骤类型/必填参数/嵌套深度/调度格式），" + "校验失败返回 errors 数组，请逐条修正后重新调用本工具。" + "常见被打回的原因：步骤缺 selector_value；loop 的 loop_mode 不是 " + "rounds/time/forever（别写 count）；按时间循环缺 loop_duration；" + "cron 不是 5 段；steps 为空。提交前请自己先按这些自查一遍。", + "parameters": { + "type": "object", + "properties": { + "summary": {"type": "string", + "description": "一句话说明这条任务做什么（≤200 字）"}, + "task": { + "type": "object", + "description": "任务信封，字段同平台任务：name/target/schedule/retry/enabled/params", + "properties": { + "name": {"type": "string", "description": "任务名（≤40 字）"}, + "target": {"type": "object", + "description": '{"mode":"all"|"group"|"serial", "serial":"…", "group_name":"…"}'}, + "schedule": {"type": "object", + "description": '{"mode":"once"} 或 {"mode":"cron","cron":"分 时 日 月 周"} 或 {"mode":"cron_stop","cron":"…","stop_cron":"…"}'}, + "retry": {"type": "object", + "description": '{"max_attempts":1-10,"delay":10-3600}'}, + "enabled": {"type": "boolean"}, + "params": { + "type": "object", + "properties": { + "max_duration": {"type": "integer", + "description": "单次运行时长上限（秒），0=不限时"}, + "steps": {"type": "array", + "description": "步骤树：[{type,label,params}]，容器用 params.children / params.then / params.else", + "items": {"type": "object"}}, + }, + "required": ["steps"], + }, + }, + "required": ["params"], + }, + "notes": {"type": "array", "items": {"type": "string"}, + "description": "需要人工复核/拿不准的点（≤5 条）"}, + "evidence": {"type": "array", "items": {"type": "object"}, + "description": "每个选择器的探索依据：{screen,element,selector_type,selector_value,verified}"}, + }, + "required": ["summary", "task"], + }, + }, +} + class Agent: def __init__(self, settings: AgentSettings = None): @@ -73,6 +176,32 @@ class Agent: "total_tokens": 0, "calls": 0} self._include_usage = True # 模型不认 stream_options 时自动置 False self._mcp = None + # ---- 建任务模式（designer）相关 ---- + self.mode = "chat" + # 平台级本地工具：{名字: async handler(args) -> dict}，不走 MCP + self._local_handlers = {} + # 本轮每个工具调用了几次（防"原地打转"：同一个工具反复调不推进目标） + self._tool_counts = {} + # 单个工具本轮最多调用次数（防"原地打转"）。要**大于**正常重试次数： + # 探索里 submit_task 反复被校验驳回调几次是正常的，卡太死会把整轮探索截断 + # （实测 25 时正好把一轮设计任务耗在修字段上）。总步数由 max_steps 兜底。 + self.tool_call_limit = 40 + self.max_tokens = None # 模型单次回复上限（None=用 _DEFAULT_MAX_TOKENS） + + # ---------- 本地（平台级）工具 ---------- + def register_local_tool(self, name, handler): + """注册平台级本地工具。**必须在 `_load_tools()` 之前调用**（schema 在加载时组装）。 + + handler: `async def(args: dict) -> dict`，返回值会作为工具结果回给模型并推给前端。 + """ + if name not in LOCAL_TOOL_SPECS: + raise KeyError(f"未定义的本地工具: {name}（需先在 LOCAL_TOOL_SPECS 里声明 schema）") + self._local_handlers[name] = handler + + def _count_tool_call(self, name): + n = self._tool_counts.get(name, 0) + 1 + self._tool_counts[name] = n + return n # ---------- MCP 工具桥 ---------- async def _load_tools(self): @@ -91,6 +220,12 @@ class Agent: "type": "function", "function": {"name": name, "description": desc, "parameters": schema}}) + # 平台级本地工具（如 submit_task）随 MCP 工具一起暴露给模型， + # 执行时由 _execute_tool 本地分派（不发给 MCP server） + for name in self._local_handlers: + spec = LOCAL_TOOL_SPECS.get(name) + if spec: + self.tools_schema.append({"type": "function", "function": spec}) _log.info("MCP 工具已加载: %s", [s["function"]["name"] for s in self.tools_schema]) async def close(self): @@ -123,7 +258,7 @@ class Agent: "model": self.s.model, "messages": self.messages, "tools": self.tools_schema if self.tools_schema else None, - "max_tokens": 4096, + "max_tokens": self.max_tokens or _DEFAULT_MAX_TOKENS, "stream": True, } if with_usage: @@ -185,9 +320,44 @@ class Agent: # ---------- 工具执行 ---------- async def _execute_tool(self, name, arguments): - """执行 MCP 工具，返回 (文本结果, image_data_or_None)。""" - args = json.loads(arguments) if isinstance(arguments, str) else (arguments or {}) + """执行工具（MCP 或平台级本地工具），返回 (文本结果, image_data_or_None)。""" + try: + args = json.loads(arguments) if isinstance(arguments, str) else (arguments or {}) + except (json.JSONDecodeError, TypeError) as e: + # 长参数被输出长度截断时 arguments 是半截 JSON。**不能整轮报错**—— + # 把"坏了"告诉模型，让它精简后重发（designer 的 steps 可能很长）。 + _log.warning("工具 %s 参数不是合法 JSON: %s", name, e) + return {"ok": False, + "error": f"参数不是合法 JSON（{e}）——常见原因是这次输出过长被截断，" + "请精简要提交的内容后重新调用一次"}, None + if not isinstance(args, dict): + return {"ok": False, "error": "工具参数必须是 JSON 对象"}, None _log.info("执行工具 %s %s", name, args) + + # 同一个工具被反复调用（原地打转）时给模型一个明确的刹车 + if self._count_tool_call(name) > self.tool_call_limit: + return {"ok": False, + "error": f"{name} 本轮调用次数已达上限（{self.tool_call_limit} 次），" + "请换一种做法推进，或直接总结当前进展"}, None + + # 平台级本地工具：不发给 MCP server + handler = self._local_handlers.get(name) + if handler is not None: + # 平台级工具自己会推更贴切的提示卡（📝 任务草稿 / 草稿被拦下 / 未存下）， + # 这里**不再重复推一张工具卡**——只在 handler 意外抛异常（自己没来得及推）时补一张 + try: + result = await handler(args) + except Exception as e: + _log.exception("本地工具 %s 执行失败", name) + result = {"ok": False, "error": f"工具执行失败: {e}"} + if self.on_tool: + try: + self.on_tool({"tool": name, "args": args, + "result": result, "image": None}) + except Exception: + pass + return result, None + try: result = await self._mcp.call_tool(name, args) data = getattr(result, "data", result) @@ -216,10 +386,14 @@ class Agent: for i in range(len(self.messages) - 1, -1, -1): m = self.messages[i] if m.get("role") == "assistant" and m.get("tool_calls"): - # 统计其后 tool 消息数是否匹配 + # 只数**紧跟着的连续** tool 消息：模型侧要求工具回应连续排列， + # 中间夹一条 user（如截图图像）就会被判成"回应不足"。 need = len(m["tool_calls"]) - have = sum(1 for x in self.messages[i + 1:] - if x.get("role") == "tool") + have = 0 + for x in self.messages[i + 1:]: + if x.get("role") != "tool": + break + have += 1 if have < need: _log.warning("修复不完整 tool_calls 段（need=%d have=%d），回退 %d 条消息", need, have, len(self.messages) - i) @@ -229,7 +403,8 @@ class Agent: # ---------- 主循环（流式） ---------- async def run_stream(self, prompt: str, serial: str = "", history=None, on_delta=None, on_tool=None, - should_stop=None, extra_context=None, on_usage=None): + should_stop=None, extra_context=None, on_usage=None, + mode: str = "chat"): """流式执行一轮指令，返回最终完整文本。 history：上一轮的 [{"role": "user"|"assistant", "content": 文本}] 列表， @@ -239,16 +414,21 @@ class Agent: should_stop：可调用 fn() -> bool，每轮模型调用前检查（用户中断用） extra_context：附加文本（经验记忆注入，放在 system prompt 末尾） on_usage(usage)：每完成一次模型调用回调一次（累计值，见 self.usage） + mode：`chat`（默认，AI 控制台聊天）或 `designer`（AI 建任务：改系统提示词、 + 放宽输出长度上限、注册的本地工具生效） 本轮累计 token 用量同时留在 self.usage（调用方可直接读）。 """ self.on_delta = on_delta self.on_tool = on_tool self.on_usage = on_usage + self.mode = mode + self.max_tokens = _DESIGNER_MAX_TOKENS if mode == "designer" else _DEFAULT_MAX_TOKENS + self._tool_counts = {} self.usage = {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0, "calls": 0} target = serial or self.s.default_serial - sys_txt = SYSTEM_PROMPT + sys_txt = DESIGNER_SYSTEM_PROMPT if mode == "designer" else CHAT_SYSTEM_PROMPT if target: sys_txt += f"\n\n本次默认目标设备 serial：{target}（未指定设备时用它）。" if extra_context: @@ -321,6 +501,12 @@ class Agent: self.messages.append({"role": "assistant", "content": full_content, "tool_calls": tcs}) + # 工具结果必须**连续**跟在带 tool_calls 的 assistant 消息后面： + # 中间插任何消息都会被模型侧判成"工具回应不足"而 400 + # （An assistant message with 'tool_calls' must be followed by tool + # messages responding to each 'tool_call_id'）。 + # 截图图像因此先攒着，等本轮所有 tool 消息都发完，再作为一条 user 消息附上。 + pending_images = [] for tc in tcs: fn = tc["function"] text_result, image_b64 = await self._execute_tool( @@ -329,13 +515,15 @@ class Agent: "role": "tool", "tool_call_id": tc["id"], "content": json.dumps(text_result, ensure_ascii=False)[:4000]}) if image_b64: - self.messages.append({ - "role": "user", - "content": [{"type": "text", - "text": "这是最新屏幕截图，请基于它继续判断"}, - {"type": "image_url", - "image_url": {"url": - f"data:image/jpeg;base64,{image_b64}"}}]}) + pending_images.append(image_b64) + if pending_images: + content = [{"type": "text", + "text": "这是最新屏幕截图，请基于它继续判断"}] + for img in pending_images: + content.append({"type": "image_url", + "image_url": {"url": + f"data:image/jpeg;base64,{img}"}}) + self.messages.append({"role": "user", "content": content}) continue # 无工具调用：本轮即最终回答 diff --git a/static/admin/agent.js b/static/admin/agent.js index c6335e2..4d510a8 100644 --- a/static/admin/agent.js +++ b/static/admin/agent.js @@ -55,6 +55,9 @@ function initAgentChat(){ function restoreRunningFlow(){ apiGet('/api/agent/run').then(r=>{ if(!r||!r.ok) return; + // 建任务模式（designer）的运行由「AI 建任务」子页订阅。这里必须让开： + // 服务端一个 run 只有一个事件队列，两个 EventSource 同时消费会互相瓜分事件。 + if(r.mode === 'designer') return; if(r.state === 'running' && r.run_id){ setRunning(true); listenStream(r.run_id); @@ -116,14 +119,18 @@ function pollRunState(){ apiGet('/api/agent/run').then(r=>{ if(!r||!r.ok)return; const running = r.state === 'running'; - document.getElementById('agent-running-tag').style.display = running ? 'inline' : 'none'; + // 运行槽是全平台唯一的：建任务探索在跑时，聊天页也不能再发起（如实显示） + const tag = document.getElementById('agent-running-tag'); + tag.style.display = running ? 'inline' : 'none'; + tag.textContent = running && r.mode === 'designer' ? '● 建任务探索中' : '● 运行中'; document.getElementById('btn-agent-stop').style.display = running ? 'inline-block' : 'none'; const hint = document.getElementById('agent-target-hint'); if(hint){ + const dev = r.serial ? ' · ' + _agentTargetText(r.serial) : ''; hint.textContent = running - ? ('⏳ 运行中' + (r.started ? ' ' + r.started + ' 起' : '') - + (r.serial ? ' · ' + _agentTargetText(r.serial) : '') - + '：' + (r.prompt||'').slice(0,70)) + ? ((r.mode === 'designer' ? '⏳ AI 正在「AI 建任务」页探索设备' + : '⏳ 运行中' + (r.started ? ' ' + r.started + ' 起' : '')) + + dev + '：' + (r.prompt || '').slice(0, 70)) : (document.getElementById('agent-target-select').value ? '将操作：' + _agentTargetText(document.getElementById('agent-target-select').value) : ''); diff --git a/static/admin/base.js b/static/admin/base.js index 5bb4fd4..120dd5b 100644 --- a/static/admin/base.js +++ b/static/admin/base.js @@ -107,14 +107,17 @@ function showTab(name){ if(name==='tasks'){showSubTab('tasks',_activeSubs.tasks);loadTasks();loadCustomActions();} if(name==='tools'){showSubTab('tools',_activeSubs.tools);loadToolsDevices();loadAdbDevices();loadTailscaleDevices();loadApks();} if(name==='logs'){loadLogs();if(document.getElementById('log-auto').checked)_logTimer=setInterval(loadLogs,3000);} - if(name==='agent' && typeof initAgentChat==='function') initAgentChat(); + if(name==='agent'){ + showSubTab('agent', _activeSubs.agent||'chat'); // 聊天 / AI 建任务 + if(typeof initAgentChat==='function') initAgentChat(); + } if(name==='users')loadUsers(); if(name==='system'){showSubTab('system',_activeSubs.system||'backup');} } // ================== 页内子分栏（任务/工具 通用） ================== // 每个带子分栏的 Tab 记住上次选中的子分栏，切走再切回来保持原位 -let _activeSubs = {tasks: 'plan', tools: 'clipboard', system: 'backup'}; +let _activeSubs = {tasks: 'plan', tools: 'clipboard', system: 'backup', agent: 'chat'}; let _discoveryTimer = null; // 设备自动发现 10s 轮询（仅 devpool 子分栏激活时） function showSubTab(tabId, name){ @@ -122,6 +125,7 @@ function showSubTab(tabId, name){ const tab = document.getElementById('tab-'+tabId); tab.querySelectorAll('.sub-tab').forEach(b=>b.classList.toggle('active', b.dataset.sub===name)); tab.querySelectorAll('.sub-panel').forEach(p=>p.classList.toggle('active', p.id===tabId+'-sub-'+name)); + if(tabId==='agent' && name==='taskgen' && typeof initTaskGen==='function') initTaskGen(); if(name==='groups' && typeof loadGroups==='function') loadGroups(); if(name==='apks' && typeof loadAgentStore==='function') loadAgentStore(); if(name==='devpool' && typeof loadDevPool==='function'){ diff --git a/static/admin/taskgen.js b/static/admin/taskgen.js new file mode 100644 index 0000000..c0562a1 --- /dev/null +++ b/static/admin/taskgen.js @@ -0,0 +1,416 @@ +// ================== AI 建任务（AI 自己探索 → 写出任务步骤） ================== +// 链路： +// 需求 → POST /api/agent/run{mode:'designer'} +// → AI 用 de_* 工具在真机上探索（看屏 / 读元素树 / 点按验证） +// → 调平台级本地工具 submit_task 提交草稿（服务端用 core/task_draft 校验， +// 不通过就把 errors 回灌给模型让它改） +// → SSE done 带草稿 → 这里预览 → 打开步骤编辑器预填 → **用户点保存才入库** +// 设计见 doc/AI_TASK_GEN.md；契约与两条红线（AI 不直接落库、有副作用的动作不真做）在 §5。 + +let _tgInit = false; +let _tgStream = null; // EventSource +let _tgBusy = false; +let _tgDraft = null; // {summary, task, notes, evidence} +let _tgWarnings = []; +let _tgPrompt = ''; // 本次需求（回存草稿时带上） +let _tgLiveSerial = ''; + +// ---------------- 初始化 ---------------- +function initTaskGen(){ + if(!_tgInit){ + _tgInit = true; + const inp = document.getElementById('tg-prompt'); + if(inp){ + inp.addEventListener('keydown', ev=>{ + if(ev.key==='Enter' && (ev.ctrlKey||ev.metaKey)){ ev.preventDefault(); startExplore(); } + }); + } + } + tgLoadDevices(); + tgLoadGroups(); + tgRestore(); +} + +function tgExample(){ + const inp = document.getElementById('tg-prompt'); + if(!inp) return; + inp.value = '建一个跑 2 小时的任务：自动刷抖音，随机点赞（概率低一点，像真人）；' + + '有弹窗就关掉；评论这种拿不准的先别真发。'; + inp.focus(); +} + +function tgToggleAdv(){ + const box = document.getElementById('tg-adv'); + const arrow = document.getElementById('tg-adv-arrow'); + if(!box) return; + const show = box.style.display === 'none'; + box.style.display = show ? 'block' : 'none'; + if(arrow) arrow.textContent = show ? '▾' : '▸'; +} +function tgToggleTarget(){ + const v = (document.getElementById('tg-target')||{}).value; + const w = document.getElementById('tg-group-wrap'); + if(w) w.style.display = (v==='group') ? 'block' : 'none'; +} +function tgToggleSched(){ + const v = (document.getElementById('tg-sched-mode')||{}).value; + const w = document.getElementById('tg-sched-wrap'); + if(w) w.style.display = (v==='daily') ? 'flex' : 'none'; +} + +// ---------------- 设备 / 分组 ---------------- +function tgLoadDevices(){ + apiGet('/api/agent/devices').then(r=>{ + if(!r||!r.ok) return; + const sel = document.getElementById('tg-serial'); + if(!sel) return; + const cur = sel.value; + const devs = (r.devices||[]).filter(x=>x.online); + // 建任务页不按 serial 形态过滤：USB 序列号与 IP:5555 都是合法的 AI 目标 + sel.innerHTML = '' + + devs.map(d=>{ + const label = devText(d.name, d.serial) + (d.model ? ' · ' + d.model : '') + + (d.busy ? ' ⛔ 任务中：' + d.task_job : ''); + return ''; + }).join(''); + if(cur && [...sel.options].some(o=>o.value===cur)) sel.value = cur; + }); +} + +function tgLoadGroups(){ + apiGet('/api/groups').then(r=>{ + if(!r||!r.ok) return; + const sel = document.getElementById('tg-group'); + if(!sel) return; + sel.innerHTML = '' + + (r.groups||[]).map(g=>'').join(''); + }); +} + +// ---------------- 收集页面上的任务设置 ---------------- +// 返回 {settings, hints}：settings 是服务端 validate_draft 的 overrides（页面填的说了算）， +// hints 是要写进提示词告诉模型的自然语言（避免模型自己编一套跟页面冲突的调度）。 +function tgCollectSettings(){ + const v = id => { const e = document.getElementById(id); return e ? (e.value||'').trim() : ''; }; + const s = {}, hints = []; + if(v('tg-name')) s.name = v('tg-name'); + const tmode = v('tg-target'); + const serial = v('tg-serial'); + if(tmode){ s.target_mode = tmode; s.serial = serial; } + if(tmode === 'group'){ + if(!v('tg-group')){ showToast('选了「按分组」但没选分组','error'); return null; } + s.group_name = v('tg-group'); + } + const smode = v('tg-sched-mode'); + if(smode === 'once'){ s.schedule = {mode:'once'}; s.schedule_hint = '手动启动（不自动跑）'; } + if(smode === 'daily'){ + const st = v('tg-sched-start'), sp = v('tg-sched-stop'); + if(!st){ showToast('选了「每天定时」但没填启动时间','error'); return null; } + const cron = tgTimeToCron(st); + if(sp){ + s.schedule = {mode:'cron_stop', cron:cron, stop_cron:tgTimeToCron(sp)}; + s.schedule_hint = '每天 ' + st + ' 启动、' + sp + ' 停止'; + }else{ + s.schedule = {mode:'cron', cron:cron}; + s.schedule_hint = '每天 ' + st + ' 启动（不自动停止）'; + } + } + const dur = parseInt(v('tg-maxdur'), 10); + if(dur > 0){ s.max_duration = dur; } + return {settings: s, hints: hints}; +} + +// "20:30" → "30 20 * * *"（每天） +function tgTimeToCron(hhmm){ + const m = String(hhmm||'').match(/^(\d{1,2}):(\d{2})$/); + if(!m) return ''; + return parseInt(m[2],10) + ' ' + parseInt(m[1],10) + ' * * *'; +} + +// ---------------- 发起探索 ---------------- +function startExplore(){ + if(_tgBusy) return; + const prompt = ((document.getElementById('tg-prompt')||{}).value||'').trim(); + if(!prompt){ showToast('先说说要做什么','error'); return; } + const serial = ((document.getElementById('tg-serial')||{}).value||'').trim(); + if(!serial){ showToast('请选择一台设备（AI 只操作你选定的设备）','error'); return; } + const cfg = tgCollectSettings(); + if(!cfg) return; + _tgPrompt = prompt; + _tgDraft = null; _tgWarnings = []; + document.getElementById('tg-stream').innerHTML = ''; + document.getElementById('tg-draft').innerHTML = ''; + tgSetBusy(true, '正在启动…'); + apiPost('/api/agent/run', {prompt: prompt, serial: serial, + mode: 'designer', settings: cfg.settings}) + .then(r=>{ + if(!r || !r.ok){ + tgSetBusy(false, ''); + showToast((r&&r.error)||'启动失败','error'); + return; + } + tgWatch(serial); + listenTaskGenStream(r.run_id); + }); +} + +function stopExplore(){ + apiPost('/api/agent/stop', {}).then(r=>{ + showToast((r&&r.ok) ? '已请求停止' : ((r&&r.error)||'停止失败'), + (r&&r.ok)?'success':'error'); + }); +} + +function tgSetBusy(busy, text){ + _tgBusy = busy; + const b = document.getElementById('tg-start'), s = document.getElementById('tg-stop'); + if(b) b.disabled = busy; + if(s) s.style.display = busy ? 'inline-block' : 'none'; + if(text !== undefined) tgStatus(text); +} +function tgStatus(t){ + const el = document.getElementById('tg-status'); + if(el) el.textContent = t || ''; +} + +// ---------------- 事件流 ---------------- +function listenTaskGenStream(runId){ + if(_tgStream) _tgStream.close(); + const es = new EventSource('/api/agent/stream?run_id=' + runId); + _tgStream = es; + let steps = 0; + + es.addEventListener('delta', ev=>{ + let d = {}; try{ d = JSON.parse(ev.data) || {}; }catch(e){} + if(d.kind === 'reasoning') return; // 推理链不铺在回放区（噪音太大） + if(d.text) tgStatus('AI 思考中… ' + String(d.text).replace(/\s+/g,' ').slice(-60)); + }); + + es.addEventListener('usage', ev=>{ + let d = {}; try{ d = JSON.parse(ev.data) || {}; }catch(e){} + tgToken(d); + }); + + es.addEventListener('step', ev=>{ + let d = {}; try{ d = JSON.parse(ev.data) || {}; }catch(e){} + steps++; + tgFollow(d.args); + tgAddCard(d.tool, d.args, d.image, d.error); + tgStatus('已执行 ' + steps + ' 步…'); + }); + + es.addEventListener('done', ev=>{ + let d = {}; try{ d = JSON.parse(ev.data) || {}; }catch(e){} + tgSetBusy(false, ''); + if(d.draft){ + _tgDraft = d.draft; _tgWarnings = d.warnings || []; + tgRenderDraft(); + tgStatus('探索完成，共 ' + steps + ' 步。请核对草稿后创建任务。'); + }else{ + tgStatus(steps ? ('探索结束（' + steps + ' 步），但没有产出草稿。') + : '没有什么可做的，AI 没给出草稿。'); + tgAddCard('⚠ 未产出草稿', + (d.draft_error || 'AI 没有提交任务草稿 —— 可能是需求太模糊，或设备/App 不可用。' + + ' 可以补一句更具体的要求再试。')); + } + endTaskGenStream(); + }); + + es.addEventListener('error', ev=>{ + let msg = '连接中断'; + try{ if(ev.data) msg = (JSON.parse(ev.data)||{}).message || msg; }catch(e){} + tgSetBusy(false, ''); + tgAddCard('⚠ 出错', msg); + endTaskGenStream(); + }); + + es.onerror = ()=>{ + // 与聊天页同理：不在这里收尾——断网/节流会触发 onerror，但后台仍在跑， + // EventSource 会自动重连，服务端队列保留积压事件。 + if(_tgBusy && es.readyState === EventSource.CLOSED){ + tgStatus('⚠ 实时连接中断，探索仍在后台进行；刷新页面可恢复。'); + } + }; +} + +function endTaskGenStream(){ + if(_tgStream){ _tgStream.close(); _tgStream = null; } +} + +function tgAddCard(tool, args, image, err){ + const box = document.getElementById('tg-stream'); + if(!box) return; + const empty = box.querySelector('.agent-empty'); + if(empty) empty.remove(); + const card = document.createElement('div'); + card.className = 'agent-toolcard'; + const argsTxt = typeof args === 'string' ? args + : JSON.stringify(args || {}, null, 0).slice(0, 240); + card.innerHTML = '' + + '' + esc(tool||'') + ' ' + + '' + esc(argsTxt || '') + ''; + if(err){ + const e = document.createElement('div'); + e.className = 'tg-err'; + e.textContent = '⚠ ' + err; + card.appendChild(e); + } + if(image){ + const img = document.createElement('img'); + img.src = 'data:image/jpeg;base64,' + image; + img.style.cursor = 'zoom-in'; + img.onclick = ()=> zoomScreenshot(img); + card.appendChild(img); + } + box.appendChild(card); + box.scrollTop = box.scrollHeight; +} + +function tgToken(u){ + const el = document.getElementById('tg-token'); + if(el && u && u.total_tokens) el.textContent = 'token ' + _fmtInt(u.total_tokens) + + '（' + (u.calls||0) + ' 次调用）'; +} + +// 跟随画面：AI 一动哪个设备就切哪个（复用平台 MJPEG 流） +function tgFollow(args){ + let a = args; + if(typeof args === 'string'){ try{ a = JSON.parse(args); }catch(e){ return; } } + if(a && a.serial) tgWatch(a.serial); +} +function tgWatch(serial){ + if(!serial || serial === _tgLiveSerial) return; + _tgLiveSerial = serial; + const card = document.getElementById('tg-live-card'); + const img = document.getElementById('tg-live-img'); + if(!card || !img) return; + card.style.display = 'block'; + img.style.display = 'block'; + img.src = '/api/screen/stream?serial=' + encodeURIComponent(serial) + + '&q=80&fps=8&t=' + Date.now(); + const s = document.getElementById('tg-live-serial'); + if(s) s.textContent = serial; +} + +// ---------------- 草稿预览 ---------------- +function tgRenderDraft(){ + const box = document.getElementById('tg-draft'); + if(!box) return; + if(!_tgDraft){ box.innerHTML = ''; return; } + const task = _tgDraft.task || {}; + const steps = ((task.params||{}).steps) || []; + const html = [] + .concat(['

📝 ' + esc(task.name || _tgDraft.summary || '任务草稿') + '

']) + .concat(['
' + esc(_tgDraft.summary || '') + '
']) + .concat(['
目标：' + esc(tgTargetText(task.target)) + + ' ｜ 调度：' + esc(tgScheduleText(task.schedule)) + + ' ｜ 时长上限：' + esc(String((task.params||{}).max_duration || 0)) + ' 秒
']) + .concat(['
']) + .concat(tgRenderSteps(steps, 0)) + .concat(['
']); + if((_tgWarnings||[]).length){ + html.push('
⚠ ' + _tgWarnings.length + ' 处提醒（不拦，但请核对）' + + _tgWarnings.map(w=>'
· ' + esc(w) + '
').join('') + '
'); + } + if((_tgDraft.notes||[]).length){ + html.push('
需要人工复核' + + _tgDraft.notes.map(n=>'
· ' + esc(n) + '
').join('') + '
'); + } + const ev = _tgDraft.evidence || []; + if(ev.length){ + html.push('
探索依据（' + ev.length + ' 条）' + + ev.map(e=>'
' + esc(e.screen || '') + ' · ' + + esc(e.selector_type || '') + '=' + + esc(e.selector_value || '') + ' · ' + + esc(e.verified || '') + '
').join('') + + '
'); + } + html.push('
' + + '' + + '' + + '
'); + box.innerHTML = '
' + html.join('') + '
'; +} + +function tgRenderSteps(steps, depth){ + const pad = ' '.repeat(Math.min(depth, 5)); + return (steps||[]).map(s=>{ + const p = s.params || {}; + const bits = []; + if(p.selector_value) bits.push(p.selector_type + '=' + p.selector_value); + if(p.package) bits.push(p.package); + if(p.direction) bits.push(p.direction); + if(p.key) bits.push(p.key); + if(p.min !== undefined && p.max !== undefined) bits.push(p.min + '~' + p.max + 's'); + if(p.loop_mode) bits.push(p.loop_mode); + if(p.probability !== undefined && p.probability < 100) bits.push(p.probability + '%'); + let row = '
' + esc(pad) + '' + esc(s.type) + '' + + (s.label ? ' 「' + esc(s.label) + '」' : '') + + (bits.length ? ' ' + esc(bits.join(' · ')) + '' : '') + + '
'; + if(Array.isArray(p.children)) row += tgRenderSteps(p.children, depth+1); + if(Array.isArray(p.then)) row += tgRenderSteps(p.then, depth+1); + if(Array.isArray(p.else)) row += tgRenderSteps(p.else, depth+1); + return row; + }).join(''); +} + +function tgTargetText(t){ + t = t || {}; + if(t.mode === 'serial') return '指定设备 ' + (t.serial || ''); + if(t.mode === 'group') return '分组 ' + (t.group_name || ''); + return '全部空闲设备'; +} +function tgScheduleText(s){ + s = s || {}; + if(s.mode === 'cron') return '每天/定时 ' + (s.cron || ''); + if(s.mode === 'cron_stop') return '定时 ' + (s.cron || '') + ' → 停 ' + (s.stop_cron || ''); + return '手动（不自动启动）'; +} + +// ---------------- 草稿的动作 ---------------- +async function openDraftInEditor(){ + if(!_tgDraft){ showToast('还没有草稿','error'); return; } + // 步骤编辑器要用到任务类型/分组/设备下拉，先确保它们已加载 + await loadTasks(); + openTaskModal(null, {task: _tgDraft.task, notes: _tgDraft.notes || [], + warnings: _tgWarnings}); +} + +function discardDraft(){ + if(!confirm('丢弃这份草稿？')) return; + apiPost('/api/agent/task_draft/clear', {}).then(r=>{ + if(!r||!r.ok){ showToast((r&&r.error)||'丢弃失败','error'); return; } + _tgDraft = null; _tgWarnings = []; + document.getElementById('tg-draft').innerHTML = ''; + tgStatus('已丢弃草稿'); + }); +} + +// ---------------- 页面恢复（刷新/重进） ---------------- +function tgRestore(){ + apiGet('/api/agent/task_draft').then(r=>{ + if(!r||!r.ok) return; + // 运行中的 designer 由本页接管订阅；聊天页见 agent.js 的 mode 判断 + if(r.running && r.mode === 'designer' && r.run_id){ + tgSetBusy(true, '探索进行中…（刷新后已重新连接）'); + listenTaskGenStream(r.run_id); + return; + } + if(r.draft){ // 运行态里就有（同一次会话内切页回来） + _tgDraft = r.draft; _tgWarnings = []; + tgRenderDraft(); + return; + } + const saved = r.saved; + if(saved && saved.draft){ + _tgDraft = saved.draft; _tgWarnings = saved.warnings || []; + tgRenderDraft(); + tgStatus('已恢复 ' + (saved.created || '') + ' 的草稿（可直接创建，或重新探索）'); + const inp = document.getElementById('tg-prompt'); + if(inp && saved.prompt) inp.value = saved.prompt; + } + }); +} diff --git a/static/admin/tasks.js b/static/admin/tasks.js index bf55eed..509c39a 100644 --- a/static/admin/tasks.js +++ b/static/admin/tasks.js @@ -64,14 +64,35 @@ function renderTaskRow(j){ ''; } -function openTaskModal(jobId){ +// 任务信封归一化：补齐 7 个键，避免下游无保护访问 +// （原文只对"已存在的 job"安全，AI 草稿/半成品信封会让 j.retry.max_attempts 之类直接抛错） +function _normalizeTaskEnv(env){ + const e=env||{}, t=e.target||{}, s=e.schedule||{}, r=e.retry||{}, p=e.params||{}; + return { + name:e.name||'', + task_type:e.task_type||'generic_steps', + enabled:(e.enabled===undefined)?true:!!e.enabled, + target:{mode:t.mode||'all', group_name:t.group_name||'', serial:t.serial||''}, + schedule:{mode:s.mode||'once', cron:s.cron||'', stop_cron:s.stop_cron||'', + window:s.window||null}, + retry:{max_attempts:r.max_attempts||1, delay:r.delay||60}, + params:Object.assign({}, p) + }; +} + +// openTaskModal(jobId, prefill) +// jobId —— 传 id = 编辑已有任务 +// prefill —— AI 建任务的草稿：{task, notes, warnings}（服务端已校验，这里只预填给人核对） +function openTaskModal(jobId, prefill){ const job=jobId?(_jobsData||[]).find(j=>j.id===jobId):null; const isEdit=!!job; - document.getElementById('modal-title').textContent=isEdit?'编辑任务':'新建任务'; + const pf=(prefill&&prefill.task)?prefill:null; + document.getElementById('modal-title').textContent= + isEdit?'编辑任务':(pf?'AI 生成任务（请核对后保存）':'新建任务'); // 任务编辑器含步骤编辑，加宽弹窗；关闭时在 closeModal 移除 document.getElementById('modal-box').classList.add('wide-modal'); - const j=job||{name:'',task_type:'generic_steps',enabled:true,target:{mode:'all'},params:{},schedule:{mode:'once'},retry:{max_attempts:1,delay:60}}; + const j=_normalizeTaskEnv(job||(pf&&pf.task)||{}); const tt=_taskTypes.map(t=>'').join(''); const gl=_groupsList.map(g=>'').join(''); const dl=_devicesList.map(x=>'