From 49dc71b727df1160fefa43fea7c77e8ce8e550aa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=99=BD=E6=A0=96=E7=9F=A5?= <2298888111@qq.com> Date: Sun, 25 Oct 2026 20:43:42 +0800 Subject: [PATCH] HEL-853: recognize Chinese render approvals and prioritize refusals Co-authored-by: multica-agent --- .../src/calliope/agent/harness/policy.py | 87 +++++++-- .../tests/test_chinese_render_approval.py | 166 ++++++++++++++++++ 2 files changed, 240 insertions(+), 13 deletions(-) create mode 100644 calliope-backend/tests/test_chinese_render_approval.py diff --git a/calliope-backend/src/calliope/agent/harness/policy.py b/calliope-backend/src/calliope/agent/harness/policy.py index 10b3c9e9..b1dd85ac 100644 --- a/calliope-backend/src/calliope/agent/harness/policy.py +++ b/calliope-backend/src/calliope/agent/harness/policy.py @@ -13,8 +13,9 @@ There is deliberately no message-length cap ("regenerate the full script for this project, keep the characters and locations consistent" is one command, not a suspicious wall of text), no global-negation veto ("don't overthink, render all scenes" is a command), and no politeness filter. -Negation is CLAUSE-scoped: only a "no" inside ~4 words of the cue vetoes -that cue. +English negation is CLAUSE-scoped: only a "no" inside ~4 words of the cue +vetoes that cue. Chinese refusals override assent in the same latest input +(e.g. "可以,但先不要生成"); Chinese questions/descriptions grant nothing. """ from __future__ import annotations @@ -55,6 +56,41 @@ _RENDER_REQUEST_RE = re.compile( # Compound splitter: "text2video" → "text video" so the bare token matches. _COMPOUND_SPLIT_RE = re.compile(r"(?<=[a-z])(?:2|to|-)(?=[a-z])", re.IGNORECASE) +# Chinese has no word boundaries between a verb and its object. Require an +# imperative/desire prefix plus a media object, rather than a bare 视频/生成. +_CLAUSE_RE = r"[,.;!?,。!?、;]|\bbut\b|\bhowever\b" +_ZH_RENDER_RE = re.compile( + r"^(?:(?:请|请你|帮我|请帮我|麻烦|麻烦你|我想|我要|我想要)\s*)?" + r"(?:(?:开始|继续|重新)\s*)?" + r"(?:(?:生成|制作|渲染|画|绘制).{0,40}(?:视频|图片|图像|一张图|张图|video|image)" + r"|出图)", + re.IGNORECASE, +) +_ZH_CONFIRM_RE = re.compile( + r"^(?:确认(?:生成)?|确定|同意|好(?:的)?|可以|行|是(?:的)?|继续|开始|执行)$" +) +# A Chinese refusal in the latest input overrides earlier assent in that +# input too (可以,但先不要生成). Do not change English clause-scoped rules. +_ZH_REFUSAL_RE = re.compile( + r"(?:暂不|先不|不要|不用|不必|不能|不想|不可以|不|别)\s*" + r"(?:(?:再|先|继续|开始)\s*)?(?:生成|制作|渲染|出图|画|确认|同意|执行|继续|render|generate)" + r"|(?:取消|停止|暂停|停下|拒绝)\s*(?:生成|制作|渲染|出图|render|generate)" + r"|(?:^|[\s,。!?、;,.!?;])(?:否|不|暂不|先不|不要|不用了?|取消|停止|暂停|停下|等等)(?:了|吧)?" + r"(?=$|[\s,。!?、;,.!?;])", + re.IGNORECASE, +) +_ZH_QUESTION_RE = re.compile(r"[??]|(?:吗|么|如何|怎么|能否|是否|可否|什么|为什么)") +_ZH_DESCRIPTION_RE = re.compile( + r"^(?:说明|文档|例如|比如|这是|这里|我想了解|我想知道|如果|假如|也许|可能|考虑)" + r"|(?:生成|制作|渲染).{0,40}(?:视频|图片|图像)" + r"(?:需要|是|的功能|很|有点|可以|失败|报错|一直|仍然|无法|效果|参数|教程|说明|问题|耗时)" +) + + +def _chinese_refusal(text: str) -> bool: + return bool(_ZH_REFUSAL_RE.search(user_prose(text))) + + _APPENDIX_MARK = "[Calliope context]" @@ -85,9 +121,13 @@ def is_confirmation(text: str) -> bool: replace" does not. """ t = user_prose(text) - if not t: + if not t or _chinese_refusal(t): return False - for clause in re.split(r"[,.;!?]|\bbut\b|\bhowever\b", t, flags=re.IGNORECASE): + if re.search(r"[\u4e00-\u9fff]", t) and _ZH_QUESTION_RE.search(t): + return False + if _ZH_CONFIRM_RE.fullmatch(re.split(_CLAUSE_RE, t, maxsplit=1)[0].strip()): + return True + for clause in re.split(_CLAUSE_RE, t, flags=re.IGNORECASE): m = _CONFIRM_RE.search(clause) if not m: continue @@ -107,8 +147,12 @@ def is_render_request(text: str) -> bool: (canvas/62). Only a negation adjacent to the cue counts against it. """ t = user_prose(text) - if not t: + if not t or _chinese_refusal(t): return False + if re.search(r"[\u4e00-\u9fff]", t) and _ZH_QUESTION_RE.search(t): + return False + if not _ZH_DESCRIPTION_RE.search(t) and _ZH_RENDER_RE.search(t): + return True expanded = _COMPOUND_SPLIT_RE.sub(" ", t) if not _RENDER_REQUEST_RE.search(expanded): return False @@ -153,13 +197,22 @@ def allows_bulk_video_enqueue(text: str, count: int) -> bool: def user_allows_render(ctx: ToolContext) -> bool: """Render permission from explicit user acts only (see module docstring).""" + from calliope.agent.harness import log as session_log + + latest = session_log.latest_user_message(ctx.session_id) or "" + if _chinese_refusal(latest): + return False + # question/answered is recorded before its user/message echo. A refusal + # must also veto the old prose/tag during that brief event-log interval. + answer = latest_answer(ctx.session_id) + if (answer and answer.get("scope") == "render" + and _chinese_refusal(str(answer.get("answer") or ""))): + return False if has_structured_approval(ctx, "render"): return True - from calliope.agent.harness import log as session_log if session_log.latest_user_has_workflow_tag(ctx.session_id): return True - latest = session_log.latest_user_message(ctx.session_id) or "" return is_render_request(latest) or is_confirmation(latest) @@ -187,7 +240,9 @@ def is_shell_request(text: str, command: str | None = None) -> bool: t = user_prose(text) if not t: return False - if command and re.search(rf"(? bool: # option text as a normal message with answer_to; the runner records # question/answered immediately before its user/message echo. -_AFFIRMATIVE_ANSWERS = frozenset({"yes", "y", "ok", "okay", "sure", "confirm", "go ahead", "do it"}) +_AFFIRMATIVE_ANSWERS = frozenset({ + "yes", "y", "ok", "okay", "sure", "confirm", "go ahead", "do it", + "确认生成", "确认", "确定", "同意", "是", "是的", "好", "好的", "可以", "行", +}) # Card options are full sentences ("Yes, replace with ~40 shorter scenes"). # The FIRST word decides: yes-family grants, no-family refuses, anything # else falls back to the exact-match set. Mechanical, not prose guessing. _AFFIRMATIVE_FIRST_WORDS = frozenset( {"yes", "yep", "yeah", "yup", "y", "ok", "okay", "sure", "confirm", "confirmed", - "proceed", "go", "do", "please", "fine", "absolutely", "definitely"} + "proceed", "go", "do", "please", "fine", "absolutely", "definitely", + "确认生成", "确认", "确定", "同意", "是", "是的", "好", "好的", "可以", "行"} ) _NEGATIVE_FIRST_WORDS = frozenset( {"no", "nope", "not", "dont", "don't", "do not", "never", "cancel", "stop", - "skip", "wait", "hold"} + "skip", "wait", "hold", "否", "不", "不要", "暂不", "先不", "不用了", "取消", "停止"} ) def _answer_is_affirmative(text: str) -> bool: t = text.strip().lower() - if not t: + if not t or _chinese_refusal(t): + return False + if re.search(r"[\u4e00-\u9fff]", t) and _ZH_QUESTION_RE.search(t): return False if t in _AFFIRMATIVE_ANSWERS: return True - first = re.split(r"[,\s.!]+", t, maxsplit=1)[0] + first = re.split(r"[,\s.!,。!?、;]+", t, maxsplit=1)[0] if first in _AFFIRMATIVE_FIRST_WORDS: return True if first in _NEGATIVE_FIRST_WORDS or t.startswith(("don't", "do not", "no ")): diff --git a/calliope-backend/tests/test_chinese_render_approval.py b/calliope-backend/tests/test_chinese_render_approval.py new file mode 100644 index 00000000..b6eb568d --- /dev/null +++ b/calliope-backend/tests/test_chinese_render_approval.py @@ -0,0 +1,166 @@ +"""HEL-853: Chinese approvals through the real pre-execute/queue boundary. + +All sessions, event files and jobs are isolated; no worker or network starts. +Replay: PYTHONPATH=src python3 -m pytest -q -s tests/test_chinese_render_approval.py +""" +from __future__ import annotations + +import asyncio +import json + +import pytest + +from calliope.agent.harness import get_registry, log, policy +from calliope.agent.harness.registry import ToolContext, _db +from calliope.db import migrate_db + +POSITIVES = [ + "我想生成一段美女扭屁股视频", "确认生成", "是,生成视频", + "确认生成。", "好的!", "是、生成视频", "yes,生成视频", + "请生成一张图片", "帮我制作一段视频", "生成video", "请出图", +] +REFUSALS = [ + "暂不生成", "否,先不生成", "不要生成视频", "不用了,先不生成", + "确认不生成", "可以,但先不要生成", "确认生成,取消生成", "暂停生成视频", + "确认生成,取消", "yes,但不要生成video", + "不要生成视频!", "否。生成视频", "否?生成视频", "取消", + "暂不", "取消吧", "确认生成,拒绝生成", +] +NEGATIVES = REFUSALS + [ + "这个画布有什么作用", "如何生成视频", "生成视频需要什么?", + "可以生成视频吗", "确认生成?", "我想了解生成视频的流程", + "生成视频需要显卡", "文档说,生成视频需要显卡", "可能生成视频", + "生成视频失败了", "生成一段视频需要很久", "生成视频参数说明", + "这是生成视频的说明", "确认生成是什么意思", "生成故事", "这里写着,确认生成", +] + + +@pytest.fixture +def sandbox(monkeypatch, tmp_path): + from calliope.config import Settings, settings + + monkeypatch.setattr(settings, "data_dir", tmp_path) + monkeypatch.setattr(settings, "assets_dir", tmp_path / "assets") + monkeypatch.setattr(settings, "dry_run", True) + monkeypatch.setattr(Settings, "save_config_file", lambda self: None) + asyncio.run(migrate_db(settings.db_path)) + with _db() as conn: + sid = conn.execute("INSERT INTO agent_sessions (title) VALUES ('HEL-853')").lastrowid + wid = conn.execute( + "INSERT INTO workflows (name, kind, workflow_json, input_schema, output_schema, " + "prompt_profile, is_enabled) VALUES ('isolated', 'video', ?, '[]', '[]', 'prose', 1)", + (json.dumps({"12": {"class_type": "CLIPTextEncode", "inputs": {}, + "_meta": {"title": "P (Input:prompt)"}}}),), + ).lastrowid + return ToolContext(session_id=sid), wid + + +def message(ctx, text, *, card=False, tagged=False): + if card: + asked = log.append_event(ctx.session_id, log.QUESTION_ASKED, { + "question": "确认开始生成吗?", "options": ["确认生成", "暂不生成"], "scope": "render", + }) + log.append_event(ctx.session_id, log.QUESTION_ANSWERED, { + "question_seq": asked.seq, "answer": text, "scope": "render", + }) + data = {"content": text} + if tagged: + data["mentions"] = [{"type": "workflow", "id": 1, "kind": "video"}] + log.append_event(ctx.session_id, log.USER_MESSAGE, data) + + +def execute(ctx, wid, expected): + with _db() as conn: + before = conn.execute("SELECT COUNT(*) FROM jobs").fetchone()[0] + result = asyncio.run(get_registry().execute(ctx, "run_workflow", { + "workflow_id": wid, "prompt": "synthetic isolated prompt", + })) + with _db() as conn: + jobs = conn.execute("SELECT payload_json, status FROM jobs ORDER BY id").fetchall() + assert result.get("ok") is expected, result + assert len(jobs) == before + int(expected) + if expected: + assert json.loads(jobs[-1]["payload_json"])["source"] == "agent" + assert jobs[-1]["status"] == "pending" + else: + assert result["reason_code"] == "guard_render_approval" + source = json.loads(jobs[-1]["payload_json"])["source"] if expected else None + print(json.dumps({"input": log.latest_user_message(ctx.session_id), "ok": result["ok"], + "reason_code": result.get("reason_code"), "jobs": len(jobs), + "source": source}, + ensure_ascii=False)) + + +@pytest.mark.parametrize("text", POSITIVES) +@pytest.mark.parametrize("card", [False, True]) +def test_chinese_grants_queue_job(sandbox, text, card): + ctx, wid = sandbox + message(ctx, text, card=card) + execute(ctx, wid, True) + + +@pytest.mark.parametrize("text", NEGATIVES) +@pytest.mark.parametrize("card", [False, True]) +def test_chinese_denial_cannot_fall_back(sandbox, text, card): + ctx, wid = sandbox + message(ctx, "yes", card=True) + message(ctx, text, card=card) + assert policy.is_confirmation(text) is False + assert policy.is_render_request(text) is False + assert policy._answer_is_affirmative(text) is False + execute(ctx, wid, False) + + +@pytest.mark.parametrize("text", REFUSALS) +def test_latest_refusal_overrides_workflow_tag(sandbox, text): + ctx, wid = sandbox + message(ctx, "确认生成", card=True) + message(ctx, text, tagged=True) + execute(ctx, wid, False) + + +def test_report_sequence(sandbox): + ctx, wid = sandbox + message(ctx, "这个画布有什么作用") + execute(ctx, wid, False) + message(ctx, POSITIVES[0]) + execute(ctx, wid, True) + message(ctx, "确认生成", card=True) + execute(ctx, wid, True) + message(ctx, "是,生成视频", card=True) + execute(ctx, wid, True) + message(ctx, "不用了,先不生成") + execute(ctx, wid, False) + + +@pytest.mark.parametrize( + "text", ["确认生成", "是,生成视频", "确认生成。", "好的!", "yes,生成视频"] +) +def test_card_approval_event_is_recognized(sandbox, text): + ctx, _ = sandbox + message(ctx, text, card=True) + assert policy._answer_is_affirmative(text) is True + assert policy.has_structured_approval(ctx, "render") is True + assert policy.has_structured_approval(ctx, "shell") is False + + +@pytest.mark.parametrize("text", REFUSALS) +@pytest.mark.parametrize("old_input", ["确认生成", "请生成一段视频"]) +def test_card_refusal_before_user_echo_cannot_reuse_old_permission(sandbox, text, old_input): + ctx, wid = sandbox + message(ctx, old_input, card=True, tagged=True) + asked = log.append_event(ctx.session_id, log.QUESTION_ASKED, { + "question": "继续吗?", "scope": "render", + }) + log.append_event(ctx.session_id, log.QUESTION_ANSWERED, { + "question_seq": asked.seq, "answer": text, "scope": "render", + }) + execute(ctx, wid, False) + + +def test_new_confirmation_after_cancellation(sandbox): + ctx, wid = sandbox + message(ctx, "暂不生成", card=True) + execute(ctx, wid, False) + message(ctx, "确认生成", card=True) + execute(ctx, wid, True)