"""编排层：意图路由、资料收集、角色准入、多步串行执行、暂停/续跑、前置阻断、进度文档。 状态流转： collecting -> running -> paused(等用户回答 / 前置阻断) -> running -> submitted | completed \\-> failed \\-> blocked（被前置事项拦住，处理好可继续） 知识结构（knowledge/*.yaml）： systems 系统列表（入口、允许域名、登录方式） businesses 业务列表，每个业务有 role / required_inputs / workflow（多步，按顺序执行）/ learned learned 全局已知信息（门户结构等），与业务 learned 一起注入 prompt 身份模型：一个人在一个系统只有一个身份（密码本 system_accounts 按 人 × 系统 存，带 role）； 业务的 role 是准入条件；跨系统任务把各系统凭据按域名分组放进 sensitive_data，一个会话依次登录。 """ import asyncio import re from datetime import date from typing import Any from backend import hub_sync from backend.browser import runner from backend.config import PROFILES_DIR, settings from backend.db import database as db from backend.learning import draft_learned from backend.nlu import classify_and_extract from backend.orchestrator.progress_doc import append_progress, init_progress_doc, write_summary from backend.security import decrypt_secret COLLECTING = "collecting" RUNNING = "running" PAUSED = "paused" SUBMITTED = "submitted" COMPLETED = "completed" FAILED = "failed" BLOCKED = "blocked" # 被前置事项拦住，用户处理好后可点「继续」重试 REJECTED = "rejected" # 提交后被驳回 / 退回 TERMINAL = {SUBMITTED, COMPLETED, FAILED, BLOCKED, REJECTED} _APPROVED_WORDS = ("通过", "同意", "已审批", "审批完成", "办结", "已完成", "批准", "已生效", "归档") _REJECTED_WORDS = ("驳回", "退回", "拒绝", "不通过", "未通过", "否决", "作废", "撤销") _PENDING_WORDS = ("待审批", "未审批", "审批中", "待审核", "审核中", "处理中", "待处理", "已提交") def _classify_approval(text: str) -> str: """把页面上的审批状态原文归为 approved / rejected / pending / unknown。驳回词优先，避免「审批不通过」被当成通过。""" t = (text or "").strip() if not t: return "unknown" if any(w in t for w in _REJECTED_WORDS): return "rejected" if any(w in t for w in _PENDING_WORDS): return "pending" if any(w in t for w in _APPROVED_WORDS): return "approved" return "unknown" INTERNAL_INPUT_KEYS = {"goal", "business_id", "user_notes", "pending_blocker", "step_index"} # 多字词出现在回答任何位置都算同意；单字词只在开头才算，否则「课程是高等数学」里的「是」会被当成同意 _AFFIRMATIVE = ("可以", "同意", "确认", "已处理", "处理好", "处理完", "继续", "没问题", "麻烦你", "ok", "yes") _AFFIRMATIVE_PREFIX = ("是", "好", "行", "办", "去", "嗯", "对") _NEGATIVE = ("否", "不", "别", "取消", "算了", "先不", "不用", "no") def _is_negative(answer: str) -> bool: a = answer.strip().lower() return any(a.startswith(w) or w in a[:6] for w in _NEGATIVE) and not any(a.startswith(w) for w in ("不错", "不用担心")) def _is_affirmative(answer: str) -> bool: a = answer.strip().lower() if _is_negative(a): return False return any(w in a for w in _AFFIRMATIVE) or any(a.startswith(w) for w in _AFFIRMATIVE_PREFIX) # ---------- 知识访问 ---------- class _SafeDict(dict): def __missing__(self, key: str) -> str: return "{" + key + "}" def _render(template: str, values: dict) -> str: try: return str(template).format_map(_SafeDict(values)) except Exception: # noqa: BLE001 return str(template) def _businesses(knowledge: dict) -> list[dict]: return knowledge.get("businesses") or [] def _business_by_id(knowledge: dict, business_id: str | None) -> dict | None: return next((b for b in _businesses(knowledge) if b.get("id") == business_id), None) def _fallback_business(knowledge: dict) -> dict: businesses = _businesses(knowledge) return next((b for b in businesses if b.get("id") == "generic_explore"), businesses[0]) def _required_inputs(business: dict) -> list[dict]: return business.get("required_inputs") or [] def _missing_inputs(task: dict, business: dict) -> list[dict]: inputs = task.get("inputs") or {} return [f for f in _required_inputs(business) if f.get("required") and not inputs.get(f["name"])] def _missing_labels(missing: list[dict]) -> str: return "、".join(m["label"] for m in missing) def _enabled_steps(business: dict) -> list[dict]: return [s for s in business.get("workflow") or [] if s.get("enabled", True)] def _active_step(business: dict) -> dict | None: steps = _enabled_steps(business) return steps[0] if steps else None def _current_step(business: dict, inputs: dict) -> dict | None: steps = _enabled_steps(business) if not steps: return None idx = min(int((inputs or {}).get("step_index", 0) or 0), len(steps) - 1) return steps[idx] def _system_by_id(knowledge: dict, system_id: str | None) -> dict: systems = knowledge.get("systems") or [] return next((s for s in systems if s.get("id") == system_id), systems[0]) def _system_for(business: dict, knowledge: dict, step: dict | None = None) -> dict: wanted = (step or {}).get("system") or business.get("system") return _system_by_id(knowledge, wanted) def _systems_for_business(business: dict, knowledge: dict) -> list[dict]: seen: dict[str, dict] = {} for step in _enabled_steps(business) or [{}]: system = _system_for(business, knowledge, step) seen.setdefault(system.get("id", ""), system) if not seen: system = _system_for(business, knowledge) seen[system.get("id", "")] = system return list(seen.values()) def _profile_path(student_id: str, system_id: str, role: str | None) -> str: """一个人在一个系统一份登录态。测试环境同一系统会切不同角色的快捷登录，所以再按角色分开。""" path = PROFILES_DIR / student_id / f"{system_id}_{role or 'default'}" path.mkdir(parents=True, exist_ok=True) return str(path) _PLACEHOLDER_PREFIXES = ("未获取", "未找到", "未能", "无法", "失败", "没有", "不存在", "暂无", "n/a", "none", "null") def _meaningful(value: Any) -> bool: """产物里“未获取 / 无法读取”这类占位文字不算拿到了信息。""" text = str(value or "").strip().lower() return bool(text) and not text.startswith(_PLACEHOLDER_PREFIXES) def _criteria_met(step: dict, artifacts: dict) -> bool: keys = step.get("success_artifacts_any") or [] return any(_meaningful(artifacts.get(k)) for k in keys) def apply_verdict_overrides( verdict: str, agent_done: bool, step: dict, artifacts: dict, summary: str ) -> tuple[str, str, tuple[str, str] | None]: """Agent 自评失败，但实际结果不该算失败的两种情况。返回 (verdict, summary, 进度文档条目)。 Agent 的 is_successful 不稳定：同一个「用户点了取消」动作，它有时给 True、有时给 False， 于是同样的操作一次记成已完成、一次记成办理未完成。这里按客观产物纠正。 """ if verdict != "failed" or not agent_done: return verdict, summary, None if _meaningful(artifacts.get("cancelled")): # 用户在确认卡点了取消：按用户意愿结束，不是办砸了 return "success", summary, ("用户取消", "用户选择不提交，按已完成处理") if _criteria_met(step, artifacts): return ( "success", "（Agent 自评未完全达成，但产物已满足本步完成判据）\n" + summary, ("判定覆盖", "产物满足 success_artifacts_any，按完成处理"), ) return verdict, summary, None def _final_status(steps: list[dict], artifacts: dict) -> str: """全部步骤成功后的终态：有提交类步骤且真的提交了才是 submitted；用户取消优先。""" if artifacts.get("cancelled"): return COMPLETED for step in steps: if step.get("on_success_status") == SUBMITTED: keys = step.get("submitted_artifacts_any") or ["submitted_record", "result_message"] if any(artifacts.get(k) for k in keys): return SUBMITTED return COMPLETED def _tracking_cfg(business: dict) -> dict | None: cfg = business.get("tracking") if not cfg or not cfg.get("step"): return None return { "interval_minutes": int(cfg.get("interval_minutes", 60)), "max_checks": int(cfg.get("max_checks", 24)), "step": {**cfg["step"], "step_id": cfg["step"].get("step_id", "track_status")}, } def _next_check_str(minutes: int) -> str: from datetime import datetime, timedelta return (datetime.now() + timedelta(minutes=max(1, minutes))).strftime("%Y-%m-%d %H:%M:%S") def _prerequisite(step: dict, prereq_id: str) -> dict | None: for p in step.get("prerequisites") or []: if str(p.get("id")) == prereq_id: return p return None def _blocker_question(prereq: dict | None, message: str) -> str: if not prereq: return f"系统提示：{message}\n这不在我知道的前置事项里。你处理好之后回复「已处理」我再重试，或回复「取消」结束。" title = prereq.get("title") or prereq.get("id") if prereq.get("resolution") == "self" and prereq.get("business_id"): return ( f"系统提示：{message}\n需要先完成「{title}」。要我现在顺带帮你办吗？" "回复「是」我就去办，办完自动回来继续；回复「否」则先结束。" ) advice = prereq.get("advice") or f"先完成「{title}」" return f"系统提示：{message}\n这一步需要{advice}，我在系统里替你办不了。处理好之后回复「已处理」我再继续，或回复「取消」结束。" # ---------- 提示词 ---------- def _placeholders(system_id: str) -> tuple[str, str]: return f"x_username_{system_id}", f"x_password_{system_id}" def _login_instructions(system: dict, account: dict | None, role: str | None) -> str: login = system.get("login") or {} role_note = ( f"如果打开后页面已处于登录状态但身份不是「{role}」，先点击右上角「退出」回到登录页再登录。" if role else "" ) if account: u, p = _placeholders(system.get("id", "")) return ( f"系统已为你准备好「{system.get('name', '')}」的账号。在它的登录页：用户名框填 {u}，密码框填 {p}，然后点击登录。" "不要向用户询问账号密码，也不要把账号密码写进任何总结。" + role_note ) mode = login.get("fallback_mode", "manual") if mode == "quick_login" and role: return ( f"这是测试环境。登录页有「测试环境快捷登录」区域，点击「{role}」或「以{role}身份快捷登录」按钮即可登录，" "无需输入账号密码。" + role_note ) return "如遇登录页、验证码、扫码：调用 ask_user 请用户手动完成，用户回答后再继续。" def _inputs_block(business: dict, inputs: dict) -> str: lines = [f"- 用户原话：{inputs.get('goal', '')}"] for f in _required_inputs(business): v = inputs.get(f["name"]) if v: lines.append(f"- {f['label']}：{v}") for k, v in inputs.items(): if k not in INTERNAL_INPUT_KEYS and v and not any(f["name"] == k for f in _required_inputs(business)): lines.append(f"- {k}：{v}") return "\n".join(lines) def _artifacts_block(artifacts: dict) -> str: items = {k: v for k, v in (artifacts or {}).items() if k != "summary" and v} if not items: return "" lines = "\n".join(f"- {k}：{str(v)[:600]}" for k, v in items.items()) return f"\n\n## 之前步骤已取得的信息（可直接使用）\n{lines}" def _merged_learned(knowledge: dict, business: dict) -> dict: """YAML 出厂 learned 打底，库里审核过的（全局 + 本业务）叠加覆盖。""" merged = {**(knowledge.get("learned") or {}), **(business.get("learned") or {})} try: merged.update(db.verified_learned(knowledge.get("id", ""), business.get("id"))) except Exception: # noqa: BLE001 库不可用时退回 YAML pass return merged def _learned_block(knowledge: dict, business: dict, trials: list[dict] | None = None) -> str: """已确认经验当事实给，待验证线索单列一段并明确要求回执。 分级的原因：这些知识的真假只有真跑一遍才知道，读是读不出来的。压着等人审等于永远不生效， 所以草稿也注入，但降一级呈现，并让 Agent 在结束时逐条回答对不对——这是最准的裁判。 """ merged = _merged_learned(knowledge, business) parts: list[str] = [] if merged: lines = "\n".join(f"- {k}：{v}" for k, v in merged.items()) parts.append(f"\n\n## 已知信息（已确认，可直接利用，但仍以页面实际情况为准）\n{lines}") if trials: lines = "\n".join(f"- [{t['id']}] {t['key']}：{t['value']}" for t in trials) parts.append( "\n\n## 待验证线索（尚未确认，只当参考）\n" f"{lines}\n" "这些是系统自动沉淀、还没验证过的说法，可能过时或根本就是错的。用法：\n" "1. 与页面实际情况冲突时，**一律以页面为准**，不要为了迁就线索去做多余操作；\n" "2. 任务结束调用 done 时，在 text 末尾附一段「线索回执」，对每条用过或看到的线索给出判断，格式为每行\n" " `线索[编号] 相符|不符|没用上 一句话说明`，例如 `线索[42] 不符 提交按钮实际叫「保存并提交」`；\n" "3. 没去到相关页面的线索写「没用上」，不要猜。" ) return "".join(parts) _TRIAL_RECEIPT_RE = re.compile(r"线索\[?(\d+)\]?\s*[：:]?\s*(相符|不符|没用上|未用上|没有用上)\s*[，,。:：]?\s*(.*)") _TRIAL_OUTCOME_MAP = {"相符": "confirmed", "不符": "contradicted", "没用上": "unused", "未用上": "unused", "没有用上": "unused"} def parse_trial_receipt(text: str, allowed_ids: set[int]) -> list[dict]: """从 Agent 的 done 文本里解析线索回执。只认注入过的编号，避免它凭空编。""" outcomes: dict[int, dict] = {} for line in (text or "").splitlines(): match = _TRIAL_RECEIPT_RE.search(line.strip()) if not match: continue entry_id = int(match.group(1)) if entry_id not in allowed_ids: continue outcomes[entry_id] = { "id": entry_id, "outcome": _TRIAL_OUTCOME_MAP[match.group(2)], "note": match.group(3).strip()[:300], } return list(outcomes.values()) def _prerequisites_block(step: dict) -> str: prereqs = step.get("prerequisites") or [] if not prereqs: return "" lines = [] for p in prereqs: lines.append(f"- id={p.get('id')}：当页面提示包含「{p.get('match', p.get('title', ''))}」时 → 调用 report_blocker(\"{p.get('id')}\", 提示原文)") return "\n\n## 可能遇到的前置阻断\n遇到下列系统提示时不要绕过、不要反复重试、不要用 ask_user，直接调用 report_blocker 上报：\n" + "\n".join(lines) def _build_agent_task( step: dict, knowledge: dict, business: dict, task: dict, system: dict, account: dict | None, step_no: int = 1, total_steps: int = 1, trials: list[dict] | None = None, ) -> str: inputs = task.get("inputs") or {} values = {**{k: str(v)[:400] for k, v in (task.get("artifacts") or {}).items()}, **inputs, "today": date.today().isoformat()} notes = inputs.get("user_notes") or [] notes_block = ("\n\n## 用户补充说明\n" + "\n".join(f"- {n}" for n in notes)) if notes else "" rules = "\n".join(f"- {r}" for r in knowledge.get("rules", [])) instructions = "\n".join(f"- {_render(i, values)}" for i in step.get("instructions", [])) entry_url = _render(step.get("entry_url") or system["url"], values) role = business.get("role") if step.get("human_confirm_before"): submit_rule = ( "正式提交前必须调用 ask_user，把即将提交的每个字段和值逐项列出请用户确认；" "用户明确同意后才点击提交类按钮，提交成功后才保存 submitted_record 和 result_message。" "用户说不提交或取消：不要点提交，用 save_artifact 保存 cancelled（用户原话），" "不要保存 submitted_record / result_message，然后 done 说明已填未提交。" ) else: submit_rule = "本步骤是只读探索：不要填写表单、不要点击提交/保存/删除类按钮、不要修改任何数据。" step_header = f"（第 {step_no}/{total_steps} 步）" if total_steps > 1 else "" return f"""你是学校办事助手，正在独立浏览器窗口中以「{role or "用户"}」身份操作「{system["name"]}」。所有输出用中文。 ## 业务 {business.get("name", "")}{step_header} ## 本步目标 {_render(step.get("goal", ""), values)} ## 用户提供的资料 {_inputs_block(business, inputs)}{notes_block}{_artifacts_block(task.get("artifacts") or {})} ## 登录（{system.get("name", "")}） {_login_instructions(system, account, role)} ## 业务规则（必须遵守） {rules}{_learned_block(knowledge, business, trials)} ## 本步具体要求 {instructions or "- 按目标自主探索"}{_prerequisites_block(step)} ## 通用操作要求 1. 先打开：{entry_url} 2. 只在允许的域名内操作，不要访问其他站点；只通过页面上的菜单和链接导航，不要凭猜测拼 URL 3. 不确定、缺资料、需要用户决定时调用 ask_user，问题要具体；调用后任务会暂停等待用户 4. {submit_rule} 5. 关键信息用 save_artifact 保存，key 用英文（如 entry_url、form_fields、menus、submitted_record、result_message）；拿不到的信息不要用「未获取」之类的占位文字保存，不保存即可，在 done 里说明原因 6. 完成后用 done 结束，在 text 里用中文总结：做了什么、发现了什么、下一步建议 """ # ---------- 编排 ---------- class Orchestrator: def __init__(self) -> None: self._running: set[str] = set() # -- 对外入口 -- async def start_task(self, knowledge_id: str, message: str, student_id: str = "default") -> dict: knowledge = db.get_knowledge(knowledge_id) if not knowledge: raise ValueError(f"未知业务包: {knowledge_id}") businesses = _businesses(knowledge) if not businesses: raise ValueError("业务配置缺少 businesses") nlu = await classify_and_extract(message, businesses) business = _business_by_id(knowledge, nlu["business_id"]) or _fallback_business(knowledge) inputs: dict[str, Any] = {"goal": message, "business_id": business["id"], "step_index": 0} for f in _required_inputs(business): value = nlu["inputs"].get(f["name"]) if value: inputs[f["name"]] = value elif f.get("default") is not None: inputs[f["name"]] = f["default"] task = db.create_task(knowledge_id, student_id, inputs) first_system = _system_for(business, knowledge, _active_step(business)) task = db.update_task( task["id"], browser_profile_path=_profile_path(student_id, first_system.get("id", "sys"), business.get("role")), ) init_progress_doc(task["id"], f"{knowledge['name']} / {business['name']}", message) extracted = "，".join( f"{f['label']}={inputs[f['name']]}" for f in _required_inputs(business) if inputs.get(f["name"]) ) or "无" source = nlu["source"] + (f"，{nlu['error']}" if nlu.get("error") else "") append_progress( task["id"], "识别业务", COLLECTING, f"{business['name']}（{source}，置信度 {nlu['confidence']:.2f}）；抽取字段：{extracted}", ) denied = self._role_admission(task, knowledge, business) if denied: db.update_task(task["id"], status=FAILED, pause_reason=denied) append_progress(task["id"], "角色准入", FAILED, denied, level="warning") return {**db.get_task(task["id"]), "business_name": business.get("name"), "reply": denied, "status": FAILED} return self._schedule_or_return(task, knowledge, business, nlu.get("reply")) async def submit_inputs(self, task_id: str, inputs: dict | None = None, message: str | None = None) -> dict: task = db.get_task(task_id) if not task: raise ValueError("任务不存在") knowledge = db.get_knowledge(task["knowledge_id"]) business = _business_by_id(knowledge, task["inputs"].get("business_id")) or _fallback_business(knowledge) merged = dict(task["inputs"]) reply_hint = None if inputs: merged.update({k: v for k, v in inputs.items() if v}) append_progress(task_id, "用户补充资料", COLLECTING, str(inputs)) if message: nlu = await classify_and_extract(message, [business], existing=merged, fixed_business_id=business["id"]) for f in _required_inputs(business): value = nlu["inputs"].get(f["name"]) if value: merged[f["name"]] = value merged["user_notes"] = list(merged.get("user_notes") or []) + [message] reply_hint = nlu.get("reply") extracted = "，".join(f"{k}={v}" for k, v in nlu["inputs"].items()) or "无" append_progress(task_id, "用户补充资料", COLLECTING, f"{message}（抽取：{extracted}）") task = db.update_task(task_id, inputs=merged) return self._schedule_or_return(task, knowledge, business, reply_hint) async def resume_task(self, task_id: str, answer: str = "请继续执行") -> dict: """用户回答 / 点击继续。浏览器会话仍在时续跑同一个 Agent，否则带上说明重新执行当前步骤。""" task = db.get_task(task_id) if not task: raise ValueError("任务不存在") if task_id in self._running: return {**task, "reply": "任务正在执行中，请稍候", "status": RUNNING} if task["status"] not in (PAUSED, FAILED, BLOCKED): raise ValueError(f"当前状态为 {task['status']}，无需继续") pending = (task["inputs"] or {}).get("pending_blocker") if pending and runner.has_live_session(task_id): return await self._resume_from_blocker(task, pending, answer) if runner.has_live_session(task_id): append_progress(task_id, "用户回答", RUNNING, answer) question = task.get("pause_reason") or "" continuation = f"用户对你的提问「{question}」的回答：{answer}\n请据此继续完成当前步骤的目标；如果已经完成，用 done 总结。" self._launch(task_id, continuation=continuation) return {**db.get_task(task_id), "reply": "已收到，继续执行中", "status": RUNNING} inputs = {k: v for k, v in task["inputs"].items() if k != "pending_blocker"} inputs["user_notes"] = list(inputs.get("user_notes") or []) + [answer] db.update_task(task_id, inputs=inputs) append_progress(task_id, "重新执行", RUNNING, f"浏览器会话已结束，带上补充说明从当前步骤重新开始：{answer}") self._launch(task_id) return {**db.get_task(task_id), "reply": "浏览器会话已结束，正在带上你的说明重新执行", "status": RUNNING} # -- 前置阻断 -- async def _resume_from_blocker(self, task: dict, pending: dict, answer: str) -> dict: task_id = task["id"] inputs = {k: v for k, v in task["inputs"].items() if k != "pending_blocker"} title = pending.get("title") or pending.get("id") if _is_negative(answer): db.update_task(task_id, status=BLOCKED, inputs=inputs, pause_reason=f"被「{title}」拦住：{pending.get('message', '')}") append_progress(task_id, "前置阻断", BLOCKED, f"用户选择先不处理「{title}」，任务暂停在此。处理好后可点「继续执行」重试", level="warning") await runner.close_live_session(task_id) return { **db.get_task(task_id), "reply": f"好的，先到这里。等「{title}」处理好之后，点「继续执行」我再重新办理。", "status": BLOCKED, } knowledge = db.get_knowledge(task["knowledge_id"]) business = _business_by_id(knowledge, inputs.get("business_id")) or _fallback_business(knowledge) step = _current_step(business, inputs) or {} original_goal = _render(step.get("goal", ""), inputs) if pending.get("resolution") == "self" and pending.get("business_id") and _is_affirmative(answer): prereq_business = _business_by_id(knowledge, pending["business_id"]) prereq_step = _active_step(prereq_business) if prereq_business else None if prereq_business and prereq_step: sub_instructions = "\n".join(f"- {_render(i, inputs)}" for i in prereq_step.get("instructions", [])) learned = _learned_block(knowledge, prereq_business) continuation = ( f"用户同意先办前置事项「{title}」。现在切换到子目标：\n" f"{_render(prereq_step.get('goal', ''), inputs)}\n" f"子目标要求：\n{sub_instructions or '- 按目标自主完成'}{learned}\n\n" f"子目标完成后（或确认无法完成时），回到原目标继续：{original_goal}\n" f"注意：前置事项「{title}」这时已经处理过，不要再为它调用 report_blocker；" "只有页面再次弹出同样的拦截提示时才重新上报。" ) db.update_task(task_id, inputs=inputs) append_progress(task_id, "切换前置事项", RUNNING, f"用户同意，先办「{title}」，办完回到原目标") self._launch(task_id, continuation=continuation) return {**db.get_task(task_id), "reply": f"好，先去办「{title}」，办完自动回来继续。", "status": RUNNING} db.update_task(task_id, inputs=inputs) append_progress(task_id, "用户回答", RUNNING, answer) continuation = ( f"关于前置阻断「{title}」（系统提示：{pending.get('message', '')}），用户回答：{answer}\n" f"请重新尝试原目标：{original_goal}\n如果仍被同样的提示拦截，再次调用 report_blocker 上报。" ) self._launch(task_id, continuation=continuation) return {**db.get_task(task_id), "reply": "已收到，重新尝试中", "status": RUNNING} # -- 内部 -- @staticmethod def _pick_trials(knowledge: dict, business: dict) -> list[dict]: """挑一批待验证线索注入。数量有上限：注入太多会撑长提示词，也会让互相矛盾的说法干扰判断。""" if not settings.trial_enabled: return [] try: return db.trial_learned(knowledge.get("id", ""), business.get("id"), settings.trial_max_inject) except Exception: # noqa: BLE001 库不可用时照常执行，只是没有线索 return [] @staticmethod def _record_trial_receipt(task_id: str, trials: list[dict], summary: str) -> None: """从 Agent 的总结里解析线索回执，升级被证实的、降级被证伪的。""" if not trials: return try: outcomes = parse_trial_receipt(summary, {int(t["id"]) for t in trials}) db.record_trials(task_id, [int(t["id"]) for t in trials]) if not outcomes: append_progress(task_id, "线索回执", RUNNING, f"注入 {len(trials)} 条待验证线索，Agent 未给出回执") return stats = db.apply_trial_outcomes( task_id, outcomes, settings.trial_promote_after, settings.trial_demote_after ) detail = ( f"注入 {len(trials)} 条，回执 {len(outcomes)} 条：" f"相符 {stats['confirmed']}、不符 {stats['contradicted']}、没用上 {stats['unused']}；" f"升为已确认 {stats['promoted']}、降为驳回 {stats['demoted']}" ) append_progress(task_id, "线索回执", RUNNING, detail) except Exception as e: # noqa: BLE001 验证机制不能影响办事 append_progress(task_id, "线索回执", RUNNING, f"处理失败：{e}", level="warning") @staticmethod def _role_admission(task: dict, knowledge: dict, business: dict) -> str | None: """业务声明了 role，而当前用户在该系统的密码本账号是别的角色 → 直接告知办不了。没有账号时不拦（走 fallback 登录）。""" role = business.get("role") if not role: return None system = _system_for(business, knowledge, _active_step(business)) account = db.get_account(task["student_id"], system.get("id", "")) if account and account.get("role") and account["role"] != role: return ( f"「{business.get('name')}」需要以「{role}」身份办理，而你在「{system.get('name')}」的账号是「{account['role']}」，" "这件事我替你办不了。" ) return None def _schedule_or_return(self, task: dict, knowledge: dict, business: dict, reply_hint: str | None) -> dict: missing = _missing_inputs(task, business) if missing: labels = _missing_labels(missing) db.update_task(task["id"], status=COLLECTING) append_progress(task["id"], "收集资料", COLLECTING, f"缺少：{labels}") return { **db.get_task(task["id"]), "business_name": business.get("name"), "reply": reply_hint or f"好的，办理「{business['name']}」还需要你告诉我：{labels}", "needs_input": [m["name"] for m in missing], } if task["id"] in self._running: return {**task, "reply": "任务正在执行中", "status": RUNNING} self._launch(task["id"]) summary = "，".join( f"{f['label']} {task['inputs'][f['name']]}" for f in _required_inputs(business) if task["inputs"].get(f["name"]) ) steps = _enabled_steps(business) step_note = f"，共 {len(steps)} 步" if len(steps) > 1 else "" return { **db.get_task(task["id"]), "business_name": business.get("name"), "reply": f"已识别为「{business['name']}」" + (f"（{summary}）" if summary else "") + f"{step_note}，开始执行，浏览器窗口即将打开。", "status": RUNNING, } def _launch(self, task_id: str, continuation: str | None = None) -> None: self._running.add(task_id) asyncio.create_task(self._run_task_background(task_id, continuation)) async def _run_task_background(self, task_id: str, continuation: str | None) -> None: try: await self.run_task(task_id, continuation) except Exception as e: # noqa: BLE001 db.update_task(task_id, status=FAILED, pause_reason=str(e)) append_progress(task_id, "执行失败", FAILED, str(e), level="error") finally: self._running.discard(task_id) async def run_task(self, task_id: str, continuation: str | None = None) -> dict: """从 inputs.step_index 指向的步骤开始，按顺序执行业务的全部启用步骤（同一个浏览器会话）。""" task = db.get_task(task_id) if not task: raise ValueError("任务不存在") knowledge = db.get_knowledge(task["knowledge_id"]) if not knowledge: raise ValueError("业务配置不存在") business = _business_by_id(knowledge, task["inputs"].get("business_id")) or _fallback_business(knowledge) steps = _enabled_steps(business) if not steps: raise ValueError(f"业务「{business.get('name')}」未配置可执行的 workflow 步骤") systems = _systems_for_business(business, knowledge) allowed: list[str] = [] for s in systems: for d in s.get("allowed_domains", []): if d not in allowed: allowed.append(d) accounts = {s.get("id", ""): db.get_account(task["student_id"], s.get("id", "")) for s in systems} sensitive = self._sensitive_data(systems, accounts) idx = min(int((task["inputs"] or {}).get("step_index", 0) or 0), len(steps) - 1) artifacts: dict = dict(task.get("artifacts") or {}) first_iteration = True while idx < len(steps): step = steps[idx] system = _system_for(business, knowledge, step) inputs = {**task["inputs"], "step_index": idx} task = db.update_task(task_id, status=RUNNING, current_step=step["step_id"], pause_reason=None, inputs=inputs) # 待验证线索：草稿也注入，但降一级呈现并要回执，用运行结果当裁判（见 _learned_block） trials = self._pick_trials(knowledge, business) prompt = _build_agent_task( step, knowledge, business, task, system, accounts.get(system.get("id", "")), idx + 1, len(steps), trials ) if first_iteration and continuation is not None: cont: str | None = continuation # 用户回答 / 前置事项切换，续跑当前步骤 elif first_iteration: cont = None # 新会话（首次执行，或会话丢失后重跑） append_progress(task_id, step["step_id"], RUNNING, _render(step.get("goal", ""), inputs)) else: prev = steps[idx - 1] cont = f"上一步「{prev.get('step_id')}」已完成。现在开始下一步。\n\n{prompt}" append_progress(task_id, step["step_id"], RUNNING, _render(step.get("goal", ""), inputs)) if cont is not None and not runner.has_live_session(task_id): cont = None # 会话已不在，只能新开浏览器从当前步骤重跑 first_iteration = False result = await runner.run_browser_step( task_id=task_id, agent_task=prompt, profile_path=task["browser_profile_path"] or _profile_path(task["student_id"], system.get("id", "sys"), business.get("role")), allowed_domains=allowed, sensitive_data=sensitive, continuation=cont, max_steps=int(step.get("max_steps", 40)), max_actions_per_step=int(step.get("max_actions_per_step", 3)), keep_session=idx + 1 < len(steps), ) artifacts = {**artifacts, **result.get("artifacts", {})} verdict = result["verdict"] if verdict == "paused": return self._handle_pause(task_id, task, step, artifacts, result) summary = result.get("summary") or "执行结束" agent_done = bool((result.get("history") or {}).get("is_done")) verdict, summary, override = apply_verdict_overrides(verdict, agent_done, step, artifacts, summary) if override: append_progress(task_id, override[0], RUNNING, override[1]) # 用 Agent 刚在真实页面上的观察来升降级待验证线索 self._record_trial_receipt(task_id, trials, summary) db.add_run_log(task_id, step["step_id"], verdict, result.get("history")) if verdict != "success": await runner.close_live_session(task_id) db.update_task(task_id, status=FAILED, artifacts=artifacts, pause_reason=summary) append_progress(task_id, step["step_id"], FAILED, summary, level="error") return db.get_task(task_id) artifacts[f"summary_{step['step_id']}"] = summary[:2000] append_progress(task_id, step["step_id"], COMPLETED, summary, level="success") idx += 1 task = db.update_task(task_id, artifacts=artifacts, inputs={**task["inputs"], "step_index": idx}) if idx < len(steps) and not runner.has_live_session(task_id): append_progress(task_id, "会话结束", RUNNING, "浏览器会话已关闭，下一步将新开浏览器", level="warning") # 全部步骤完成 last = steps[-1] final_summary = artifacts.get(f"summary_{last['step_id']}") or "执行结束" artifacts["summary"] = final_summary final = _final_status(steps, artifacts) await self._sediment(task_id, knowledge, business, last, artifacts, {"history": None}, final_summary) await runner.close_live_session(task_id) next_check = None tracking = _tracking_cfg(business) if final == SUBMITTED and tracking: next_check = _next_check_str(tracking["interval_minutes"]) artifacts["tracking"] = {"checks": 0, "history": [], "max_checks": tracking["max_checks"]} append_progress(task_id, "提交后跟踪", SUBMITTED, f"已排定回查：{next_check}，每 {tracking['interval_minutes']} 分钟一次，最多 {tracking['max_checks']} 次") db.update_task(task_id, status=final, artifacts=artifacts, pause_reason=None, next_check_at=next_check) write_summary(task_id, final_summary) return db.get_task(task_id) # -- 提交后跟踪 -- async def run_tracking(self, task_id: str, force: bool = False) -> dict: """拉起一个短的只读任务回查审批状态。approved → completed，rejected → rejected，否则排下一次。""" task = db.get_task(task_id) if not task: raise ValueError("任务不存在") if task["status"] != SUBMITTED: raise ValueError(f"当前状态为 {task['status']}，不需要回查") if task_id in self._running: return {**task, "reply": "任务正在执行中，请稍候"} knowledge = db.get_knowledge(task["knowledge_id"]) business = _business_by_id(knowledge, task["inputs"].get("business_id")) or _fallback_business(knowledge) tracking = _tracking_cfg(business) if not tracking: raise ValueError(f"业务「{business.get('name')}」没有配置 tracking") if not force and runner.live_session_ids(): db.update_task(task_id, next_check_at=_next_check_str(5)) return {**task, "reply": "有其他任务在使用浏览器，5 分钟后再回查"} self._running.add(task_id) try: step = tracking["step"] system = _system_for(business, knowledge, step) account = db.get_account(task["student_id"], system.get("id", "")) sensitive = self._sensitive_data([system], {system.get("id", ""): account}) artifacts = dict(task.get("artifacts") or {}) state = artifacts.get("tracking") or {"checks": 0, "history": [], "max_checks": tracking["max_checks"]} n = int(state.get("checks", 0)) + 1 append_progress(task_id, f"跟踪回查 #{n}", SUBMITTED, _render(step.get("goal", ""), {**artifacts, **task["inputs"]})) prompt = _build_agent_task(step, knowledge, business, task, system, account) result = await runner.run_browser_step( task_id=task_id, agent_task=prompt, profile_path=task["browser_profile_path"] or _profile_path(task["student_id"], system.get("id", "sys"), business.get("role")), allowed_domains=system.get("allowed_domains", []), sensitive_data=sensitive, continuation=None, max_steps=int(step.get("max_steps", 20)), max_actions_per_step=int(step.get("max_actions_per_step", 3)), ) await runner.close_live_session(task_id) found = result.get("artifacts", {}) status_text = str(found.get("approval_status") or "").strip() note = str(found.get("approval_note") or "").strip() verdict = _classify_approval(status_text) if result["verdict"] == "success" else "unknown" from datetime import datetime entry = {"at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "status": status_text or "（未读到）", "verdict": verdict, "note": note[:300]} state["checks"] = n state["history"] = (state.get("history") or [])[-19:] + [entry] artifacts["tracking"] = state if status_text: artifacts["approval_status"] = status_text if note: artifacts["approval_note"] = note db.add_run_log(task_id, step["step_id"], result["verdict"], result.get("history")) if verdict == "approved": summary = f"审批已通过：{status_text}" + (f"。{note}" if note else "") db.update_task(task_id, status=COMPLETED, artifacts=artifacts, next_check_at=None, pause_reason=None) append_progress(task_id, f"跟踪回查 #{n}", COMPLETED, summary, level="success") write_summary(task_id, summary) return {**db.get_task(task_id), "reply": summary} if verdict == "rejected": summary = f"审批被驳回：{status_text}" + (f"。{note}" if note else "") db.update_task(task_id, status=REJECTED, artifacts=artifacts, next_check_at=None, pause_reason=summary) append_progress(task_id, f"跟踪回查 #{n}", REJECTED, summary, level="warning") write_summary(task_id, summary) return {**db.get_task(task_id), "reply": summary} if n >= int(state.get("max_checks", tracking["max_checks"])): db.update_task(task_id, artifacts=artifacts, next_check_at=None) append_progress(task_id, f"跟踪回查 #{n}", SUBMITTED, f"状态仍为「{status_text or '未知'}」，已达最多回查次数，停止自动回查", level="warning") return {**db.get_task(task_id), "reply": f"审批状态仍为「{status_text or '未知'}」，已停止自动回查，可手动点「立即回查」"} next_check = _next_check_str(tracking["interval_minutes"]) db.update_task(task_id, artifacts=artifacts, next_check_at=next_check) append_progress(task_id, f"跟踪回查 #{n}", SUBMITTED, f"状态「{status_text or '未读到'}」（{verdict}），下次回查 {next_check}") return {**db.get_task(task_id), "reply": f"审批状态：{status_text or '未读到'}，下次回查 {next_check}"} finally: self._running.discard(task_id) async def tracking_loop(self, poll_seconds: int) -> None: """后台调度：到点的已提交任务逐个回查。桌面端单用户，一次只跑一个。""" while True: try: for task in db.due_tracking_tasks(limit=3): if task["id"] in self._running: continue try: await self.run_tracking(task["id"]) except Exception as e: # noqa: BLE001 append_progress(task["id"], "跟踪回查", SUBMITTED, f"回查失败：{e}，30 分钟后重试", level="warning") db.update_task(task["id"], next_check_at=_next_check_str(30)) except Exception: # noqa: BLE001 库暂时不可用等，下一轮再来 pass await asyncio.sleep(max(10, int(poll_seconds))) def _handle_pause(self, task_id: str, task: dict, step: dict, artifacts: dict, result: dict) -> dict: blocker = result.get("blocker") if blocker: prereq = _prerequisite(step, blocker["id"]) question = _blocker_question(prereq, blocker["message"]) pending = { "id": blocker["id"], "message": blocker["message"], "resolution": (prereq or {}).get("resolution", "manual"), "business_id": (prereq or {}).get("business_id"), "title": (prereq or {}).get("title", blocker["id"]), "advice": (prereq or {}).get("advice", ""), } db.update_task( task_id, status=PAUSED, artifacts=artifacts, pause_reason=question, inputs={**task["inputs"], "pending_blocker": pending}, ) append_progress(task_id, "前置阻断", PAUSED, f"{pending['title']}（{pending['resolution']}）：{blocker['message']}", level="pause") return db.get_task(task_id) question = result["question"] db.update_task(task_id, status=PAUSED, artifacts=artifacts, pause_reason=question) append_progress(task_id, "等待用户", PAUSED, question, level="pause") return db.get_task(task_id) @staticmethod async def _sediment( task_id: str, knowledge: dict, business: dict, step: dict, artifacts: dict, result: dict, summary: str ) -> None: """任务成功后自动生成 learned 草稿，失败不影响任务本身。""" try: existing = _merged_learned(knowledge, business) drafts = {r["key"]: r["value"] for r in db.list_learned(knowledge.get("id", ""), business.get("id", ""), "draft")} entries, note = await draft_learned( business, step, artifacts, result.get("history"), summary, existing, drafts ) stats = db.add_learned_drafts(knowledge.get("id", ""), business.get("id", ""), entries, task_id) keys = "、".join(f"{e['key']}[{e.get('category', 'note')}]" for e in entries) or "无" append_progress( task_id, "沉淀草稿", RUNNING, f"新增 {stats['written']}，合并 {stats['merged']}，自动生效 {stats['promoted']}，已知跳过 {stats['skipped']}（{note}）：{keys}", ) except Exception as e: # noqa: BLE001 append_progress(task_id, "沉淀草稿", RUNNING, f"生成失败：{e}", level="warning") # 配了中心服务端就顺手报上去，让团队在审核台看到。后台跑，失败不影响任务。 if hub_sync.enabled(): asyncio.create_task(hub_sync.report_drafts(knowledge.get("id", ""), business.get("id", ""))) @staticmethod def _sensitive_data(systems: list[dict], accounts: dict[str, dict | None]) -> dict | None: """把任务涉及的所有系统的凭据按域名分组：占位符带系统后缀，只在对应域名的页面替换。LLM 看不到明文。""" data: dict[str, dict[str, str]] = {} for system in systems: sid = system.get("id", "") account = accounts.get(sid) if not account: continue u, p = _placeholders(sid) secrets = {u: account["username"], p: decrypt_secret(account["password_enc"])} domains = system.get("allowed_domains") or [] if not domains: data.update(secrets) continue for d in domains: data.setdefault(d, {}).update(secrets) return data or None def business_name_for(task: dict) -> str | None: knowledge = db.get_knowledge(task["knowledge_id"]) if not knowledge: return None business = _business_by_id(knowledge, (task.get("inputs") or {}).get("business_id")) return business.get("name") if business else None