mirror of
https://github.com/ThearchyHelios/AgentLab.git
synced 2026-11-15 05:31:59 +00:00
ThearchyHelios
672 lines
32 KiB
Python
672 lines
32 KiB
Python
"""助手的生成过程（总方案 L1，look 文档 D9）：画布改图、问数据、发布前修复、升级证据、应用润色共用一个循环。
|
||
|
||
循环只管四件事：读到 look 就停下、执行查看、接着写、计次数和上限。怎么落地（Applier）、怎么自查（Checker）由调用方
|
||
注入（app/look/base.py 的协议）：图用 GraphApplier / GraphChecker，应用用 AppApplier / AppChecker。
|
||
|
||
**接着写时的消息结构**（look 文档 §2.5.5）：
|
||
[system] 和起草时相同，不变
|
||
[human] 这一轮的请求（含历史）
|
||
[assistant] 模型到 look 那一行为止的输出（look 之后的内容已丢弃）
|
||
[human] 查看结果 + 「接着输出操作，已经落地的不要重复」+ 已落地的对象 id
|
||
看几次就重复几组 assistant / human。已落地的操作由 Applier 去重：完全相同的 add_edge 忽略、和已落地节点完全相同的
|
||
add_node 不转发、plan 只留第一次。
|
||
|
||
**ask。** 模型输出 {"op":"ask","question":…} 时这一轮就结束：循环里不等用户回答，不再自查修正；已经落地的改动照常
|
||
交付（附上自查问题），用户的回答就是下一轮。
|
||
|
||
**自查修正。** 起草完由 Checker 找出挡路的问题，交回模型改（最多 SELF_CHECK_ROUNDS 轮）；修正请求里带上这一轮的查看
|
||
结果（和起草时看到的是同一份文字），修正阶段另给 REPAIR_LOOK_LIMIT 次查看。
|
||
|
||
copilot.py 原来的读流（_iter_ops）、解析（_parse_op_line）、落地（_apply_op、merge_node_config）搬到这里，copilot.py
|
||
照原名再导出。
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
import copy
|
||
import json
|
||
import time
|
||
from collections.abc import AsyncIterator
|
||
from contextlib import aclosing
|
||
from typing import Any
|
||
|
||
from app.engine.schema import NodeType
|
||
from app.look.base import LOOK_LIMIT, REPAIR_LOOK_LIMIT, Applied, Applier, Checker, LookBudget
|
||
from app.look.service import LookService
|
||
from app.providers.budget import cut_off as _cut_off
|
||
|
||
#: 自查最多交回去改几轮。一轮只花一次"只输出改动"的调用；两轮还改不好，多半是需求本身有歧义，该让人看了
|
||
SELF_CHECK_ROUNDS = 2
|
||
#: 读到这几种操作就停下：done 说完了，look 要查看，ask 要等用户回答
|
||
_STOP_OPS = ("done", "look", "ask")
|
||
#: 不占次数的查看回话（need 没写、次数用完）连着来几次就不再接着写：模型在原地打转，再要下去只是花钱
|
||
_IDLE_LOOKS = 2
|
||
|
||
|
||
# ==========================================================================
|
||
# 读流
|
||
# ==========================================================================
|
||
|
||
|
||
def _parse_op_line(line: str) -> dict[str, Any] | None:
|
||
"""解析一行操作。围栏行、空行、解析失败、缺 op 的一律返回 None——
|
||
模型偶尔犯规不该毁掉整条流，跳过就是。"""
|
||
text = line.strip()
|
||
if not text or text.startswith("```"):
|
||
return None
|
||
try:
|
||
obj = json.loads(text)
|
||
except json.JSONDecodeError:
|
||
return None
|
||
if not isinstance(obj, dict) or "op" not in obj:
|
||
return None
|
||
return obj
|
||
|
||
|
||
class CopilotIncomplete(Exception):
|
||
"""模型这一轮没说完：输出被截断，或者一个操作都没给。画布不能按「无需修改」交付。"""
|
||
|
||
def __init__(self, reason: str, *, hint: str = "", detail: str = "") -> None:
|
||
super().__init__(reason)
|
||
self.hint = hint or "画布未修改。可以重试，或把需求拆成几步分别提出"
|
||
self.detail = detail
|
||
|
||
|
||
async def _iter_ops(model: Any, messages: list[Any], *, lines: list[str] | None = None):
|
||
"""流式读模型输出，按行切出操作。done、look、ask 之后即停——后面就算有闲话也不要了；look 之后停下也就是
|
||
「读到这一行就停止本次输出」，模型那条流随之关掉。
|
||
|
||
除了操作，还把模型的思考原样转出去（thinking_text：Claude 的 thinking 块、OpenAI 兼容系的 reasoning_content），
|
||
不把非 JSON 行当成思考。lines 给了的话，认出来的操作行原样记进去：接着写时作为 assistant 消息交回模型。
|
||
|
||
没等到 done 就因为额度用完停下的，抛 CopilotIncomplete：截断之前的操作照常转出去，由调用方决定整轮作废。
|
||
"""
|
||
from app.engine.state import message_text as _text
|
||
from app.engine.state import thinking_text
|
||
|
||
buffer = ""
|
||
cut = ""
|
||
async with aclosing(model.astream(messages)) as stream:
|
||
async for chunk in stream:
|
||
reasoning = thinking_text(chunk)
|
||
if reasoning:
|
||
yield {"op": "thinking", "delta": reasoning}
|
||
|
||
buffer += _text(chunk)
|
||
while "\n" in buffer:
|
||
line, buffer = buffer.split("\n", 1)
|
||
op = _parse_op_line(line)
|
||
if op:
|
||
if lines is not None:
|
||
lines.append(line.strip())
|
||
yield op
|
||
if op.get("op") in _STOP_OPS:
|
||
return
|
||
cut = _cut_off(chunk) or cut
|
||
op = _parse_op_line(buffer)
|
||
if op:
|
||
if lines is not None:
|
||
lines.append(buffer.strip())
|
||
yield op
|
||
if op.get("op") in _STOP_OPS:
|
||
return
|
||
if cut:
|
||
# 截断的流和说完了的流读起来一模一样：不在这里拦下，上面就会拿原图（或半张图）
|
||
# 去自查、交付，界面上写「无需修改」
|
||
limit = getattr(model, "max_tokens", None)
|
||
raise CopilotIncomplete(
|
||
"模型的输出超出了长度上限，修改没有写完",
|
||
detail=f"finish_reason={cut}" + (f"，本轮输出上限 {limit} token" if limit else ""))
|
||
|
||
|
||
# ==========================================================================
|
||
# 图的落地
|
||
# ==========================================================================
|
||
|
||
_NODE_TYPES = frozenset(t.value for t in NodeType)
|
||
|
||
#: 协作成员条目里写 "remove": true 就把这个成员拿掉。不复用 null：null 在合并里
|
||
#: 的意思是「删这个字段」，成员本身不是一个字段
|
||
_REMOVE_MEMBER = "remove"
|
||
|
||
|
||
def _member_key(member: dict[str, Any], index: int) -> str:
|
||
# 和 engine/nodes/multi.py 的叫法一致：没起名字的成员按位置叫 agentN
|
||
return str(member.get("name") or f"agent{index}")
|
||
|
||
|
||
def _merge_fields(old: dict[str, Any], patch: dict[str, Any]) -> dict[str, Any]:
|
||
"""按字段合并：写了的覆盖，写 null 的删掉，没写的原样保留。返回新 dict。"""
|
||
out = dict(old)
|
||
for key, value in patch.items():
|
||
if value is None:
|
||
out.pop(key, None)
|
||
else:
|
||
out[key] = value
|
||
return out
|
||
|
||
|
||
def _merge_members(old: list[Any], patch: list[Any]) -> list[Any]:
|
||
"""协作成员按 name 合并。原有成员保持原来的次序，新名字接在后面。"""
|
||
merged: list[Any] = list(old)
|
||
where = {_member_key(m, i): i for i, m in enumerate(merged) if isinstance(m, dict)}
|
||
dropped: set[int] = set()
|
||
for i, entry in enumerate(patch):
|
||
if not isinstance(entry, dict):
|
||
continue
|
||
key = _member_key(entry, i)
|
||
if entry.get(_REMOVE_MEMBER) is True:
|
||
if key in where:
|
||
dropped.add(where[key])
|
||
continue
|
||
fields = {k: v for k, v in entry.items() if k != _REMOVE_MEMBER}
|
||
if key in where:
|
||
merged[where[key]] = _merge_fields(merged[where[key]], fields)
|
||
else:
|
||
where[key] = len(merged)
|
||
merged.append({k: v for k, v in fields.items() if v is not None})
|
||
return [m for i, m in enumerate(merged) if i not in dropped]
|
||
|
||
|
||
def merge_node_config(
|
||
node_type: str, old: dict[str, Any], patch: dict[str, Any]
|
||
) -> dict[str, Any]:
|
||
"""update_node 的 config 怎么落到节点上。前端 store/studio.ts 必须是同一套规则。
|
||
|
||
以前是整体替换：模型只想改一句提示词，照协议也得把整份 config 抄一遍，
|
||
漏抄的字段就没了。真出过事——改写提示词时漏了 tools，三个要查库的 agent
|
||
全丢了工具，一次库都没查，最后把一堆工具调用的原始标记当答案交了出去。
|
||
改成按字段合并之后，漏写等于不改；真要删一个字段得显式写 null。
|
||
"""
|
||
if node_type == NodeType.SUPERVISOR.value and isinstance(patch.get("agents"), list):
|
||
members = old.get("agents") if isinstance(old.get("agents"), list) else []
|
||
patch = {**patch, "agents": _merge_members(members, patch["agents"])}
|
||
return _merge_fields(old, patch)
|
||
|
||
|
||
def _apply_op(nodes: dict[str, dict[str, Any]], edges: list[dict[str, Any]], op: dict[str, Any]) -> bool:
|
||
"""把一个操作应用到服务端维护的图状态。返回是否真的改了图。"""
|
||
kind = op.get("op")
|
||
if kind == "add_node":
|
||
node = op.get("node") or {}
|
||
# 类型不认识的节点不进图、也不转给前端：前端按类型查节点定义，查不到
|
||
# 以前是整站白屏，连带没保存的编辑一起丢
|
||
if not node.get("id") or node.get("type") not in _NODE_TYPES:
|
||
return False
|
||
nodes[node["id"]] = {
|
||
"id": node["id"],
|
||
"type": node["type"],
|
||
"position": {"x": 0, "y": 0},
|
||
"data": {"label": node.get("label") or "", "config": node.get("config") or {}},
|
||
}
|
||
return True
|
||
if kind == "update_node":
|
||
node = nodes.get(op.get("id") or "")
|
||
if not node:
|
||
return False
|
||
data = node.setdefault("data", {})
|
||
if op.get("label") is not None:
|
||
data["label"] = op["label"]
|
||
if isinstance(op.get("config"), dict):
|
||
data["config"] = merge_node_config(
|
||
str(node.get("type") or ""), data.get("config") or {}, op["config"])
|
||
return True
|
||
if kind == "remove_node":
|
||
node_id = op.get("id")
|
||
if node_id not in nodes:
|
||
return False
|
||
nodes.pop(node_id)
|
||
edges[:] = [e for e in edges if e["source"] != node_id and e["target"] != node_id]
|
||
return True
|
||
if kind == "add_edge":
|
||
edge = op.get("edge") or {}
|
||
if not edge.get("source") or not edge.get("target"):
|
||
return False
|
||
edges.append(
|
||
{
|
||
"source": edge["source"],
|
||
"target": edge["target"],
|
||
"sourceHandle": edge.get("sourceHandle"),
|
||
}
|
||
)
|
||
return True
|
||
if kind == "remove_edge":
|
||
before = len(edges)
|
||
edges[:] = [
|
||
e
|
||
for e in edges
|
||
if not (
|
||
e["source"] == op.get("source")
|
||
and e["target"] == op.get("target")
|
||
and (op.get("sourceHandle") is None or e.get("sourceHandle") == op.get("sourceHandle"))
|
||
)
|
||
]
|
||
return len(edges) != before
|
||
return False
|
||
|
||
|
||
class GraphApplier:
|
||
"""图的落地：_apply_op 改服务端维护的图（nodes、edges 原地改，调用方手里的同一份），外加这一轮要记下的东西。
|
||
|
||
- seen：起草时收到的图操作（含 plan、done），兜底重放到上一轮的图上时用（replay_onto）
|
||
- tried / effective：试过的、真改了图的操作（发布前修复、升级按它们复核）
|
||
- replied：模型说这句话不需要工作流时的 reply；之后只再收目录修改提案
|
||
- questions：发布前修复、升级里模型要人拿主意的 question（questions=True 时 reply 也算在里面）
|
||
- skipped_types：模型编出来的节点类型，收尾时说出来
|
||
|
||
patches：目录修改提案转不转（只有用户亲口说了数据事实的画布、问数据才转）。
|
||
"""
|
||
|
||
def __init__(self, nodes: dict[str, dict[str, Any]], edges: list[dict[str, Any]], *, patches: bool = True,
|
||
questions: bool = False) -> None:
|
||
self.nodes = nodes
|
||
self.edges = edges
|
||
self.patches = patches
|
||
self.questions_mode = questions
|
||
self.seen: list[dict[str, Any]] = []
|
||
self.tried: list[dict[str, Any]] = []
|
||
self.effective: list[dict[str, Any]] = []
|
||
self.skipped_types: list[str] = []
|
||
self.questions: list[dict[str, Any]] = []
|
||
self.replied: dict[str, Any] | None = None
|
||
self.plan: dict[str, Any] | None = None
|
||
self.explanation = ""
|
||
# 建完要不要跑，由模型在 done.run 里表态
|
||
self.autorun = True
|
||
self._landed: list[str] = []
|
||
self._continuing = False
|
||
self._repairing = False
|
||
|
||
def apply(self, op: dict[str, Any]) -> Applied:
|
||
kind = op.get("op")
|
||
if kind == "catalog_patch":
|
||
# 目录修改提案不进图：转给调用方核对后做成卡片（人点「保存」才写）
|
||
return Applied(False, self.patches and not self._repairing)
|
||
if kind in ("question", "reply") and self.questions_mode:
|
||
self.questions.append(op)
|
||
return Applied(False, False)
|
||
if self._repairing and kind == "reply":
|
||
return Applied(False, False)
|
||
if self.replied is not None:
|
||
return Applied(False, False)
|
||
if kind == "reply":
|
||
# 这句话不需要工作流：先压着，等模型说完（只再收它后面的提案）由调用方转出、收尾
|
||
self.replied = op
|
||
return Applied(False, False)
|
||
if kind == "plan":
|
||
if self.plan is not None and self._continuing:
|
||
return Applied(False, False)
|
||
self.plan = self.plan or op
|
||
self.seen.append(op)
|
||
return Applied(False, True)
|
||
if kind == "done":
|
||
self.explanation = str(op.get("explanation", ""))
|
||
# 用户要的是流程本身时（"设计一个每天跑的工作流"），建完就跑等于替他多花一次钱
|
||
self.autorun = op.get("run") is not False
|
||
self.seen.append(op)
|
||
return Applied(False, True)
|
||
if self._continuing and self._repeats(op):
|
||
return Applied(False, False)
|
||
self.seen.append(op)
|
||
self.tried.append(op)
|
||
changed = _apply_op(self.nodes, self.edges, op)
|
||
if changed:
|
||
self.effective.append(op)
|
||
nid = (op.get("node") or {}).get("id") if kind == "add_node" else op.get("id")
|
||
if isinstance(nid, str) and nid not in self._landed and kind in ("add_node", "update_node"):
|
||
self._landed.append(nid)
|
||
elif kind == "add_node":
|
||
bad = (op.get("node") or {}).get("type")
|
||
if bad and bad not in _NODE_TYPES:
|
||
self.skipped_types.append(str(bad))
|
||
return Applied(changed, changed)
|
||
|
||
def _repeats(self, op: dict[str, Any]) -> bool:
|
||
"""接着写时和已落地完全相同的操作（look §2.5.5）：已有的同一条连线、和已落地节点一模一样的节点、重发的同一个操作。"""
|
||
kind = op.get("op")
|
||
if kind == "add_edge":
|
||
edge = op.get("edge") or {}
|
||
return any(e["source"] == edge.get("source") and e["target"] == edge.get("target")
|
||
and e.get("sourceHandle") == edge.get("sourceHandle") for e in self.edges)
|
||
if kind == "add_node":
|
||
node = op.get("node") or {}
|
||
have = self.nodes.get(str(node.get("id") or ""))
|
||
return have is not None and have.get("type") == node.get("type") \
|
||
and (have.get("data") or {}).get("label") == (node.get("label") or "") \
|
||
and (have.get("data") or {}).get("config") == (node.get("config") or {})
|
||
return op in self.effective
|
||
|
||
def landed(self) -> list[str]:
|
||
return list(self._landed)
|
||
|
||
def continuing(self) -> None:
|
||
self._continuing = True
|
||
|
||
def repairing(self) -> None:
|
||
self._repairing = True
|
||
|
||
def replay_onto(self, graph: dict[str, Any]) -> None:
|
||
"""一个操作都没落地、而上一轮有图时：模型把这一轮当成「改上一张图」，只发了改动操作，而累加器是从空图起步的。
|
||
与其报一句「图是空的」，不如按它本来的意思做——把这些操作重放到上一轮那张图上。"""
|
||
self.nodes.clear()
|
||
self.nodes.update({n["id"]: copy.deepcopy(n) for n in graph.get("nodes") or [] if n.get("id")})
|
||
# 原地改，不能重新绑定：调用方手里拿的是同一份
|
||
self.edges[:] = [{k: v for k, v in e.items() if k in ("source", "target", "sourceHandle") and v}
|
||
for e in graph.get("edges") or []]
|
||
for op in self.seen:
|
||
_apply_op(self.nodes, self.edges, op)
|
||
|
||
|
||
class GraphChecker:
|
||
"""图的自查：按运行时同一套规则（copilot._blocking_issues）挑出挡路的问题，交回模型改。
|
||
|
||
known 给了（升级证据）：只把这一轮冒出来的问题交回去（图上原来就有的不归这一轮管），一个修改都没落地时不修。
|
||
"""
|
||
|
||
def __init__(self, applier: GraphApplier, *, scope: set[str] | None = None, sources: list[Any] | None = None,
|
||
baseline: list[dict[str, Any]] | None = None, level: str | None = None,
|
||
defaults: dict[str, Any] | None = None, checkers: dict[str, Any] | None = None,
|
||
known: set[Any] | None = None, chat_user: bool = False) -> None:
|
||
self.applier = applier
|
||
#: 图要以开登录后 user 角色的身份在问数据里发起（D-c）：使用者不能用的节点、工具也算挡路
|
||
self.chat_user = chat_user
|
||
self.scope = scope
|
||
self.sources = sources
|
||
self.baseline = baseline
|
||
self.level = level
|
||
self.defaults = defaults
|
||
self.checkers = checkers
|
||
self.known = known
|
||
|
||
def blocking(self) -> list[dict[str, Any]] | None:
|
||
from app.api.copilot import _blocking_issues
|
||
|
||
return _blocking_issues(self.applier.nodes, self.applier.edges, self.scope, sources=self.sources,
|
||
baseline=self.baseline, level=self.level, defaults=self.defaults,
|
||
checkers=self.checkers, chat_user=self.chat_user)
|
||
|
||
async def issues(self) -> list[dict[str, Any]]:
|
||
errors = self.blocking()
|
||
if self.known is None:
|
||
return errors or []
|
||
from app.engine.autofix import _sig
|
||
|
||
if not self.applier.effective:
|
||
return []
|
||
return [e for e in errors or [] if _sig(e) not in self.known]
|
||
|
||
def repair_request(self, issues: list[dict[str, Any]], looks_text: str) -> str:
|
||
from app.api.copilot import _repair_request
|
||
|
||
return _repair_request(self.applier.nodes, self.applier.edges, issues, looks=looks_text)
|
||
|
||
|
||
# ==========================================================================
|
||
# 应用的落地
|
||
# ==========================================================================
|
||
|
||
APP_REPAIR_PROMPT = (
|
||
"这是你刚改好的应用草稿：\n{spec}\n\n"
|
||
"应用检查（和发布同一套规则）发现下面这些问题：\n{issues}\n\n"
|
||
"只修这些问题，别的不要动。用应用操作输出修正；岗位绑定要人来做，不要替人绑。最后一行输出 done。{looks}"
|
||
)
|
||
REPAIR_LOOKS_PROMPT = "\n\n这一轮查看过的内容（和起草时看到的是同一份）：\n{text}"
|
||
|
||
#: 应用检查里只有人能处理的问题：钉住哪个版本、升版怎么处置、岗位和核实人绑给谁、授权、通知渠道。不交回模型改，
|
||
#: 照常列在交付的问题里
|
||
APP_HUMAN_ONLY = frozenset({
|
||
"app.pin_unpublished", "app.pin_retired", "app.pin_hash", "app.upgrade_policy", "app.slot_unbound",
|
||
"app.reconciler_unbound", "app.acl_empty", "app.notify_channel_missing", "app.process_unsafe",
|
||
"app.view_source_empty", "subgraph_version_unpublished", "subgraph_version_retired",
|
||
})
|
||
|
||
|
||
def _components(items: list[Any]) -> list[dict[str, Any]]:
|
||
out: list[dict[str, Any]] = []
|
||
for item in items or []:
|
||
if isinstance(item, dict):
|
||
out.append(item)
|
||
out += _components(item.get("children") or [])
|
||
return out
|
||
|
||
|
||
def app_component(spec: dict[str, Any], component_id: str) -> dict[str, Any] | None:
|
||
"""spec 里按 id 找组件（各页的组件树，含子组件）。"""
|
||
for page in spec.get("pages") or []:
|
||
for item in _components(page.get("body") or [] if isinstance(page, dict) else []):
|
||
if item.get("id") == component_id:
|
||
return item
|
||
return None
|
||
|
||
|
||
class AppApplier:
|
||
"""应用的落地：app/apps/ops.apply_app_op 改 spec（原地改），外加接着写时的去重。
|
||
|
||
plan、done 记下说明；reply 记下（这句话不需要改应用）；图操作、目录修改提案在这里一概不收。
|
||
|
||
润色只改呈现（D-h，app/apps/ops.polish_problem）：组件操作、页面、待办外观（task_ui）、表单的外观键照收；改钉住的
|
||
版本、入口、视图、岗位、表单的数据约束一律拒（Applied(False, False, problem)）。拒掉的原因记在 refused 里：自查时
|
||
交回模型（AppChecker.issues），交付时列给人看（refusals），不悄悄吞掉。
|
||
"""
|
||
|
||
def __init__(self, spec: dict[str, Any]) -> None:
|
||
self.spec = spec
|
||
self.effective: list[dict[str, Any]] = []
|
||
self.plan: dict[str, Any] | None = None
|
||
self.replied: dict[str, Any] | None = None
|
||
self.explanation = ""
|
||
#: 越界被拒的操作：[{op, path, message}]，按到来的顺序
|
||
self.refused: list[dict[str, Any]] = []
|
||
self._reported = 0
|
||
self._landed: list[str] = []
|
||
self._continuing = False
|
||
self._repairing = False
|
||
|
||
def apply(self, op: dict[str, Any]) -> Applied:
|
||
from app.apps import ops as app_ops
|
||
|
||
kind = str(op.get("op") or "")
|
||
if kind == "plan":
|
||
if self.plan is not None and self._continuing:
|
||
return Applied(False, False)
|
||
self.plan = self.plan or op
|
||
return Applied(False, True)
|
||
if kind == "done":
|
||
self.explanation = str(op.get("explanation", ""))
|
||
return Applied(False, True)
|
||
if kind == "reply":
|
||
if self.replied is None and not self._repairing:
|
||
self.replied = op
|
||
return Applied(False, False)
|
||
if not kind.startswith("app_"):
|
||
return Applied(False, False)
|
||
if self._continuing and self._repeats(op):
|
||
return Applied(False, False)
|
||
if problem := app_ops.polish_problem(self.spec, op):
|
||
path = f"{op.get('path')}.{op.get('key')}" if op.get("key") else str(op.get("path") or "")
|
||
self.refused.append({"op": kind, "path": path, "message": problem})
|
||
return Applied(False, False, problem)
|
||
applied = app_ops.apply_app_op(self.spec, op)
|
||
if applied.changed:
|
||
self.effective.append(op)
|
||
target = op.get("id") or (op.get("component") or {}).get("id") or (op.get("page") or {}).get("id") \
|
||
or op.get("key")
|
||
if isinstance(target, str) and target not in self._landed:
|
||
self._landed.append(target)
|
||
return applied
|
||
|
||
def _repeats(self, op: dict[str, Any]) -> bool:
|
||
"""接着写时：重发的同一个操作；加一个 spec 里已经一模一样存在的组件。"""
|
||
if op in self.effective:
|
||
return True
|
||
if op.get("op") == "app_add":
|
||
component = op.get("component") or {}
|
||
have = app_component(self.spec, str(component.get("id") or ""))
|
||
return have is not None and have == component
|
||
return False
|
||
|
||
def landed(self) -> list[str]:
|
||
return list(self._landed)
|
||
|
||
def continuing(self) -> None:
|
||
self._continuing = True
|
||
|
||
def repairing(self) -> None:
|
||
self._repairing = True
|
||
|
||
def unreported(self) -> list[dict[str, Any]]:
|
||
"""还没交回过模型的越界操作，取走即算交回过：同一条不在后面几轮自查里反复交回。"""
|
||
out = self.refused[self._reported:]
|
||
self._reported = len(self.refused)
|
||
return out
|
||
|
||
def refusals(self) -> list[dict[str, Any]]:
|
||
"""交付时列给人看的：形状同应用检查的问题（警告级），说明助手想改什么、为什么没改。"""
|
||
return [{"message": f"助手想改的这一处没有采纳：{r['message']}", "level": "warning", "code": POLISH_REFUSED,
|
||
"path": r["path"] or None} for r in self.refused]
|
||
|
||
|
||
#: 助手润色越界被拒（D-h）。不是应用检查的编号：不进发布检查，只在润色交付时列出来
|
||
POLISH_REFUSED = "app.polish_refused"
|
||
|
||
|
||
class AppChecker:
|
||
"""应用的自查：app/apps/lint.lint_app 的 error，去掉只有人能处理的（APP_HUMAN_ONLY），交回模型改。"""
|
||
|
||
def __init__(self, applier: AppApplier, *, bindings: dict[str, Any] | None = None) -> None:
|
||
self.applier = applier
|
||
self.bindings = bindings or {}
|
||
|
||
async def lint(self) -> list[dict[str, Any]]:
|
||
"""全部问题（各级都在），交付时列出来。另开短会话：流里请求的会话已经不能用了。"""
|
||
from app.apps import lint as app_lint
|
||
from app.db.base import SessionLocal
|
||
|
||
async with SessionLocal() as session:
|
||
return list(await app_lint.lint_app(session, self.applier.spec, self.bindings))
|
||
|
||
async def issues(self) -> list[dict[str, Any]]:
|
||
"""交回模型改的：应用检查的 error（去掉只有人能处理的），加上这之前越界被拒、还没交回过的操作。"""
|
||
refused = [{"message": r["message"], "level": "error", "code": POLISH_REFUSED, "path": r["path"] or None}
|
||
for r in self.applier.unreported()]
|
||
return [*refused,
|
||
*(i for i in await self.lint() if i.get("level") == "error" and i.get("code") not in APP_HUMAN_ONLY)]
|
||
|
||
def repair_request(self, issues: list[dict[str, Any]], looks_text: str) -> str:
|
||
lines = "\n".join(f"- {i.get('path') or ''} {i.get('message') or ''}".strip() for i in issues)
|
||
return APP_REPAIR_PROMPT.format(spec=json.dumps(self.applier.spec, ensure_ascii=False, indent=2),
|
||
issues=lines,
|
||
looks=REPAIR_LOOKS_PROMPT.format(text=looks_text) if looks_text else "")
|
||
|
||
|
||
# ==========================================================================
|
||
# 生成过程
|
||
# ==========================================================================
|
||
|
||
|
||
class Generation:
|
||
"""一轮生成：起草（draft）→ 自查修正（repair）。两段之间调用方可以插自己的判断（只回答了一句、兜底重放……）。
|
||
|
||
model 是按操作流写的模型（copilot._op_model）；looks 是这一轮的查看服务（app/look/service.py），起草和修正共用，
|
||
看过的对象、交回过的文字都在里面。asked：模型问了用户一个问题（这一轮结束）。
|
||
"""
|
||
|
||
def __init__(self, model: Any, *, system: str, applier: Applier, checker: Checker | None = None,
|
||
looks: LookService | None = None, started: float | None = None) -> None:
|
||
self.model = model
|
||
self.system = system
|
||
self.applier = applier
|
||
self.checker = checker
|
||
self.looks = looks if looks is not None else LookService([])
|
||
self.started = time.monotonic() if started is None else started
|
||
self.asked: dict[str, Any] | None = None
|
||
self.done: dict[str, Any] | None = None
|
||
self.repaired = 0
|
||
self.repair_error: Exception | None = None
|
||
#: 这一轮调了几次主模型（含接着写、修正），验收时统计
|
||
self.calls = 0
|
||
|
||
async def draft(self, request: str) -> AsyncIterator[dict[str, Any]]:
|
||
async for op in self._converse(request, LookBudget(LOOK_LIMIT), repair=False):
|
||
yield op
|
||
|
||
async def repair(self, rounds: int = SELF_CHECK_ROUNDS) -> AsyncIterator[dict[str, Any]]:
|
||
"""按 Checker 自查，挡路的问题交回模型改，改完再查。修不成（报错、截断）就停，照实发一条 check error，原因记在
|
||
repair_error；改到第几轮记在 repaired。模型问了用户（asked）的这一轮不修。"""
|
||
if self.checker is None or self.asked is not None:
|
||
return
|
||
budget = LookBudget(REPAIR_LOOK_LIMIT)
|
||
self.applier.repairing()
|
||
for round_no in range(1, rounds + 1):
|
||
errors = await self.checker.issues()
|
||
if not errors:
|
||
break
|
||
yield {"op": "check", "status": "repairing", "round": round_no, "issues": errors}
|
||
request = self.checker.repair_request(errors, self.looks.looked())
|
||
try:
|
||
async for op in self._converse(request, budget, repair=True):
|
||
yield op
|
||
except Exception as e: # noqa: BLE001 - 修不成就照实交付，调用方列出剩下的问题
|
||
from app.core.errors import explain, raw
|
||
|
||
self.repair_error = e
|
||
yield {"op": "check", "status": "error", "message": f"自查修正失败：{explain(e)[0]}",
|
||
"detail": raw(e)}
|
||
break
|
||
self.repaired = round_no
|
||
if self.asked is not None:
|
||
break
|
||
|
||
def _elapsed(self) -> int:
|
||
return int((time.monotonic() - self.started) * 1000)
|
||
|
||
async def _converse(self, request: str, budget: LookBudget, *, repair: bool) -> AsyncIterator[dict[str, Any]]:
|
||
"""一段对话：请模型写，读到 look 就停下、查看、把结果作为下一条消息交回，再请它接着写，直到 done / ask / 流结束。"""
|
||
messages: list[tuple[str, str]] = [("system", self.system), ("human", request)]
|
||
idle = 0
|
||
while True:
|
||
lines: list[str] = []
|
||
look: dict[str, Any] | None = None
|
||
self.calls += 1
|
||
async with aclosing(_iter_ops(self.model, messages, lines=lines)) as ops:
|
||
async for op in ops:
|
||
kind = op.get("op")
|
||
if kind == "thinking":
|
||
yield op
|
||
elif kind == "look":
|
||
look = op
|
||
elif kind == "ask":
|
||
self.asked = op
|
||
yield op
|
||
elif repair and kind in ("plan", "done"):
|
||
# 修补轮自己的开场和收尾，不是新方案，不覆盖原来的说明
|
||
continue
|
||
else:
|
||
if kind == "done":
|
||
self.done = op
|
||
if self.applier.apply(op).forward:
|
||
yield op
|
||
if look is None:
|
||
return
|
||
# 查看可能要等挑选模型：心跳的阶段换成「正在查看」
|
||
yield {"op": "heartbeat", "phase": "looking", "elapsed_ms": self._elapsed()}
|
||
result = await self.looks.look(look, budget)
|
||
if result.record is not None:
|
||
yield result.record
|
||
if not result.counted:
|
||
idle += 1
|
||
if idle >= _IDLE_LOOKS:
|
||
return
|
||
messages = [*messages, ("ai", "\n".join(lines)),
|
||
("human", result.text + self.looks.continue_prompt(self.applier.landed()))]
|
||
self.applier.continuing()
|
||
|
||
|
||
async def generate(model: Any, system: str, request: str, applier: Applier, checker: Checker | None = None,
|
||
looks: LookService | None = None, *, rounds: int = SELF_CHECK_ROUNDS) -> AsyncIterator[dict[str, Any]]:
|
||
"""附录 C 的生成过程协议：起草（含查看）→ 自查修正，产出一串操作和事件。中间不需要插判断的调用方直接用它。"""
|
||
gen = Generation(model, system=system, applier=applier, checker=checker, looks=looks)
|
||
async for op in gen.draft(request):
|
||
yield op
|
||
async for op in gen.repair(rounds):
|
||
yield op
|