diff --git a/docs/architecture/rfcs/app-conversation-and-async-inbox-v0.md b/docs/architecture/rfcs/app-conversation-and-async-inbox-v0.md index f3e3950a5b..ac01613378 100644 --- a/docs/architecture/rfcs/app-conversation-and-async-inbox-v0.md +++ b/docs/architecture/rfcs/app-conversation-and-async-inbox-v0.md @@ -298,6 +298,11 @@ it or starts model work. Before every write and receipt recovery, Core rechecks the Session, current binding and audience, and the provider verifies the original source. Posts identify the App speaker, stay in canonical append order within that outbox and retain complete long text through the existing rich-post parts. +When Lark supplies a message link for the verified App input mirror, a new +answer includes a link to the question from the same Turn. Multipart inputs +use the last concrete post. The outbox retains the link before the first send +and reuses it when recovering the same attempt. If Lark cannot supply a link in +the original private chat, the existing body delivery proceeds. An exact App-origin terminal error also projects a public-safe failure notice with the original completion time. The notice is derived from the stored Turn and its matching error row, without exporting raw diagnostics. It uses the same @@ -336,10 +341,10 @@ actual provider presentation remain separate acceptance work. Use **Continue original conversation** or the explicitly selected App steward entry above to reach this path. Old ordinary history is retained separately. -This checkpoint covers text and bounded App image projection, not reply/thread -relation mirroring, retroactive insertion into Lark chronology or all-channel -broadcast. Canonical App images reuse the existing resource uploader and post -sender, retaining caption and ordered inline images in the original private +This checkpoint covers text, question links and bounded App image projection. +Native reply and topic placement, retroactive insertion into Lark chronology, +and all-channel broadcast remain open. Canonical App images reuse the existing +resource uploader and post sender, retaining caption and ordered inline images in the original private chat. Long captions keep images on the final concrete post only. Every upload and send rechecks the original source and current Core message/grant. Sends and edits check again after provider preview, before recording the write intent; diff --git a/docs/architecture/rfcs/app-conversation-and-async-inbox-v0.zh-CN.md b/docs/architecture/rfcs/app-conversation-and-async-inbox-v0.zh-CN.md index 51f8d2bccc..6482108035 100644 --- a/docs/architecture/rfcs/app-conversation-and-async-inbox-v0.zh-CN.md +++ b/docs/architecture/rfcs/app-conversation-and-async-inbox-v0.zh-CN.md @@ -210,6 +210,9 @@ Web 来源,通过已有 Core 队列及新鲜来源准入。连接列表独立 输入只提供地址来源证据;投影不会重新受理它或启动模型工作。每次发送和恢复回执前, Core 重查 Session、当前绑定与受众,provider 核验原来源。消息标明 App 发言者,在 该 outbox 内按 canonical 追加顺序发送,长正文沿用既有富文本分段,保留完整内容。 +飞书能为已核验送达的 App 提问镜像提供消息链接时,新回复会链接到同一 Turn 的提问。 +长提问使用最后一条实际分段消息。outbox 在首次发送前保留链接,恢复时沿用同一发送 +尝试的正文。原私聊取不到链接时,正文继续沿既有路径送达。 App 来源 Turn 的终态错误也沿原私聊补齐。根据原 Turn 与精确匹配的错误行生成 失败提示,并标注原结束时间。原始诊断留在 App。恢复时使用原 outbox 与消息身份, 已送达的输入可以补回一条历史失败提示。先前未确认的停止提示与已完成的 Turn @@ -235,8 +238,8 @@ provider 消息;反馈失败保留可恢复回执,不阻断正文送达或 Lark 表情和 provider 呈现仍独立验收。 通过上述 **继续原会话** 或明确选定的 App 管家入口使用该路径;旧普通历史继续 -独立保留。本检查点覆盖文本及有界 App 图片投影,不覆盖回复/话题关系镜像、向 -Lark 历史回插旧时间或全渠道广播。Core 中的 App 图片复用既有资源上传与 post +独立保留。本检查点覆盖文本、提问链接及有界 App 图片投影。原生回复和话题位置、 +向 Lark 历史回插旧时间及全渠道广播仍待处理。Core 中的 App 图片复用既有资源上传与 post 发送器,正文及有序行内图片留在原私聊;长正文只在最后一个实际分段携带图片。 每次上传和发送均重新核验原来源、当前 Core 消息与授权。发送和编辑在 provider 预检返回后、记录写入意图前再次检查;每个继续或恢复的富文本分段复用该边界。 diff --git a/loopx/canary/module_metric_baseline.json b/loopx/canary/module_metric_baseline.json index f03e7d17ad..df260d2757 100644 --- a/loopx/canary/module_metric_baseline.json +++ b/loopx/canary/module_metric_baseline.json @@ -126,7 +126,7 @@ "loopx/extensions/lark/manager_returns.py": { "any_count": 0, "dict_any_count": 0, - "lines": 443 + "lines": 500 }, "loopx/extensions/lark/presentation/explore_results.py": { "any_count": 45, diff --git a/loopx/extensions/lark/manager_returns.py b/loopx/extensions/lark/manager_returns.py index 28c9d8d842..5dce461ff2 100644 --- a/loopx/extensions/lark/manager_returns.py +++ b/loopx/extensions/lark/manager_returns.py @@ -4,22 +4,27 @@ from collections.abc import Callable, Mapping, Sequence from pathlib import Path +import re from typing import TYPE_CHECKING, Protocol, cast from ...capabilities.manager_context import authority from ...capabilities.manager_context.roundtrip import ReturnResolutionBlocked +from ...chat_store import _atomic_write_json from ...file_lock import exclusive_file_lock from .conversation_identity import identity_ref from .event_inbox import _load_processed, load_lark_event_inbox_config from .goal_channel_contracts import bindings_for_goal from .goal_channel_targets import goal_channel_target_for_name +from .goal_channel_transport import json_payload from .goal_topic_runtime import _inbox_config +from .identity_shapes import LARK_MESSAGE_ID_PATTERN from .inbox_reply import ( - CommandRunner, _bot_identity_verified, _default_runner, _verified_reply_result, + CommandRunner, _bot_identity_verified, _call, _default_runner, _message, _verified_reply_result, reply_lark_event_inbox, verify_lark_inbox_reply, ) from .manager_routing import authorized_manager_goal_ids from .outbound import present_lark_conversation_text +from .post_delivery import attachment_reply from .return_files import uploaded_result_files, verify_result_files if TYPE_CHECKING: @@ -136,6 +141,72 @@ def _private_return_authority( return private_transport +def _private_message_link(link: object, chat_id: str) -> bool: + return bool(chat_id) and isinstance(link, str) and re.fullmatch( + r"https://applink\.(?:feishu\.cn|larksuite\.com)/client/chat/open" + r"\?openChatId=" + re.escape(chat_id) + r"&position=-?[0-9]+", link, + ) is not None + + +def _app_mirror_text(message: PayloadView, phase: PayloadView, chat_id: str) -> str: + user_input = message["role"] == "user" + speaker = "你" if user_input else "LoopX" + text = _str_field(message, "text") + link = phase.get("question_link") + if link is not None: + if user_input or not _private_message_link(link, chat_id): + raise ValueError("App mirror question link changed") + text = f"[查看对应提问]({link})\n\n{text}" + return f"**{speaker}(App)**\n\n{text}" + + +def prepare_app_mirror_text( + transport: _PrivateTransport, path: Path, row: Payload, messages: Sequence[PayloadView], message: PayloadView, +) -> str: + """Attach a provider-supplied link before the first answer attempt.""" + deliveries = cast(dict[str, Payload], row["deliveries"]) + key = "web." + _str_field(message, "message_id") + phase = deliveries.get(key, {}) + chat = _str_field(_mapping(row["event"]), "chat_id") + if message["role"] != "user" and not {"question_link", "text", "started", "attempt"}.intersection(phase): + inputs = [item for item in messages if item["role"] == "user" and item["turn_id"] == message["turn_id"]] + if len(inputs) == 1: + original = deliveries.get("web." + _str_field(inputs[0], "message_id"), {}) + link = _app_input_link(transport, row, original, chat) + if link is not None: + # Retain the chosen link before provider preflight. Recovery + # reproduces the same text even if the link later disappears. + phase["question_link"] = link + deliveries[key] = phase + _atomic_write_json(path, row) + return _app_mirror_text(message, phase, chat) + + +def _app_input_link(transport: _PrivateTransport, row: Payload, original: PayloadView, chat: str) -> str | None: + if original.get("verified") is not True or not isinstance(original.get("attempt"), Mapping): + return None + try: + _, attempt = cast(Callable[..., tuple[str, object]], attachment_reply)( + project=transport.runtime_root, config_path=transport._inbox(row), + text=_str_field(original, "text"), attempt=original["attempt"]) + if not isinstance(attempt, Mapping): + return None + ref = _str_field(attempt, "message_ref") + except (LookupError, OSError, TypeError, ValueError): + return None + if not LARK_MESSAGE_ID_PATTERN.fullmatch(ref): + return None + result = _call(transport._reply_runner, ["lark-cli", "--profile", _str_field(row, "profile"), + "im", "+messages-mget", "--message-ids", ref, "--as", "bot", "--format", "json", "--no-reactions"]) + payload = json_payload(result) + observed = _message(payload, ref) if result.get("returncode") == 0 and payload.get("ok") is True else None + if (observed is None or observed.get("chat_id") != chat or observed.get("deleted") is True + or _mapping(observed.get("sender")).get("sender_type") != "app"): + return None + link = observed.get("message_app_link") + return link if isinstance(link, str) and _private_message_link(link, chat) else None + + def _verify_web_mirror( route: PayloadView, session: PayloadView, turn: PayloadView, text: str, private_transport: _PrivateTransport, attempt: AttemptRecord | None, record_attempt: AttemptRecorder | None, @@ -170,7 +241,8 @@ def _verify_web_mirror( mirrored = phase.get("attempt") if phase.get("verified") is not True or not isinstance(mirrored, dict): raise _blocked("initial_delivery_receipt_unavailable", "App mirror remains unverified") - expected, phase_text = f"**LoopX(App)**\n\n{_str_field(message, 'text')}", phase.get("text") + expected = _app_mirror_text(message, phase, _str_field(_mapping(row["event"]), "chat_id")) + phase_text = phase.get("text") if (not isinstance(phase_text, str) or phase_text not in (expected, present_lark_conversation_text(expected)) or (attempt is not None and dict(attempt) != mirrored)): raise ValueError("App mirror intent changed") diff --git a/loopx/extensions/lark/post_delivery.py b/loopx/extensions/lark/post_delivery.py index 56aff757a3..32bd76513d 100644 --- a/loopx/extensions/lark/post_delivery.py +++ b/loopx/extensions/lark/post_delivery.py @@ -6,6 +6,7 @@ from __future__ import annotations +from collections.abc import Mapping import json import hashlib import re @@ -295,9 +296,18 @@ def attachment_reply(*, project, config_path, attempt, text): state = json.loads( _path(project, config_path, "sha256:" + match[1]).read_text(encoding="utf-8") ) + if not isinstance(state, Mapping): + raise ValueError("rich reply attachment parts unavailable") if state.get("intent_digest") != attempt.get("intent_digest") or state.get( "provider_receipt" ) != attempt.get("provider_receipt"): raise ValueError("rich reply attachment intent changed") - index = len(state["delivery_parts"]) - 1 - return state["delivery_parts"][index], state["delivery_part_attempts"][str(index)] + parts = state.get("delivery_parts") + attempts = state.get("delivery_part_attempts") + if not isinstance(parts, list) or not parts or not isinstance(attempts, Mapping): + raise ValueError("rich reply attachment parts unavailable") + index = len(parts) - 1 + part_attempt = attempts.get(str(index)) + if not isinstance(part_attempt, Mapping): + raise ValueError("rich reply attachment attempt unavailable") + return parts[index], part_attempt diff --git a/loopx/extensions/lark/private_web_projection.py b/loopx/extensions/lark/private_web_projection.py index 2a36b136a0..1d7835ce95 100644 --- a/loopx/extensions/lark/private_web_projection.py +++ b/loopx/extensions/lark/private_web_projection.py @@ -437,8 +437,8 @@ def authorized_source(profile: str, chat_id: str, message_id: str) -> tuple[str return name, pending in self._web_projection_messages(row) except (OSError, ValueError, KeyError): return None, False - who = "你" if pending["role"] == "user" else "LoopX" - text = f"**{who}(App)**\n\n{pending['text']}" + from .manager_returns import prepare_app_mirror_text + text = prepare_app_mirror_text(self, path, row, messages, pending) phase_key = "web." + pending["message_id"] if self.reaction_feedback and pending["role"] == "user": # Persist feedback intent before a mirror write/recovery; diff --git a/tests/extensions/test_lark_private_manager_returns.py b/tests/extensions/test_lark_private_manager_returns.py index add488b030..8c041204f1 100644 --- a/tests/extensions/test_lark_private_manager_returns.py +++ b/tests/extensions/test_lark_private_manager_returns.py @@ -368,6 +368,14 @@ def test_web_result_adopts_original_mirror_and_recovers_readback_without_send( capture = store.root.parent.parent / "requests.jsonl" starts = capture.read_bytes() frozen_turn = store._turn_path(session["session_id"], turn["turn_id"]).read_bytes() + question = next(item for item in store.messages(session["session_id"]) + if item["role"] == "user" and item["turn_id"] == turn["turn_id"]) + question_phase = _read_json(mirror)["deliveries"]["web." + question["message_id"]] + question_ref = question_phase["attempt"]["message_ref"] + question_link = ("https://applink.feishu.cn/client/chat/open?openChatId=" + f"{provider.messages[question_ref]['chat_id']}&position=23") + if not legacy_result: + provider.messages[question_ref]["message_app_link"] = question_link remainder = {"summary": "Validate installation", "resume_when": "The same worker has the original installation proof"} body = ("完整结果与独立证据。\n" * 1200 if long_result else "Concrete original result.") + "UNIQUE_RESULT_END" report(sender.root, route["goal_id"], route["agent_id"], route["request_id"], "conclusion", body, @@ -419,7 +427,10 @@ def test_web_result_adopts_original_mirror_and_recovers_readback_without_send( marker = f"({index}/{len(parts)})\n\n" assert text.startswith(marker) parts[index - 1] = text[len(marker):] - remaining = f"**LoopX(App)**\n\n{expected}" + prefix = "**LoopX(App)**\n\n" + if not legacy_result: + prefix += f"[查看对应提问]({question_link})\n\n" + remaining = prefix + expected for index, text in enumerate(parts): assert remaining.startswith(text) remaining = remaining[len(text):] @@ -430,6 +441,9 @@ def test_web_result_adopts_original_mirror_and_recovers_readback_without_send( assert remaining == "" original_mirror = mirror.read_bytes() phase = _read_json(mirror)["deliveries"]["web." + message["message_id"]] + if not legacy_result: + assert phase["question_link"] == question_link + del provider.messages[question_ref]["message_app_link"] writes = list(provider.writes) runner = transport.runner @@ -467,6 +481,73 @@ def unavailable(args, cwd=None, timeout=None): assert actual["text"] == returned[0]["text"] and actual["return_delivery"]["status"] == "delivered" +def test_web_result_recovers_negative_question_link_with_plain_text_downgrade(web_return, monkeypatch): + import threading + import time + from loopx.extensions.lark.goal_topic_runtime_service import LarkGoalTopicRuntimeService + + sender, session, turn, route, provider, transport, mirror, _, request = web_return + runtime, store = transport.core.controller, transport.core.controller.store + question = next(item for item in store.messages(session["session_id"]) + if item["role"] == "user" and item["turn_id"] == turn["turn_id"]) + question_ref = _read_json(mirror)["deliveries"]["web." + question["message_id"]]["attempt"]["message_ref"] + question_link = ("https://applink.feishu.cn/client/chat/open?openChatId=" + f"{provider.messages[question_ref]['chat_id']}&position=-1") + provider.messages[question_ref]["message_app_link"] = question_link + body = r"Concrete result for @contributor.\nDetails: quoted" + downgraded = "Concrete result for @contributor.\nDetails: ‹at unsupported>quoted‹/at>" + report(sender.root, route["goal_id"], route["agent_id"], route["request_id"], "conclusion", body) + provenance = f"协作回复 · {route['agent_id']} · 委托 {route['request_id'][:8]}" + writes = list(provider.writes) + drain(sender.root, runtime.registry_path, store, sender) + assert provider.writes == writes + message = next(item for item in store.messages(session["session_id"]) + if item.get("origin") == "manager_followup" and item["turn_id"] == turn["turn_id"]) + service = LarkGoalTopicRuntimeService(snapshot_provider=lambda: {}, runtime_root=transport.runtime_root, + runtime_controller=runtime, private_conversations=transport) + worker = threading.Thread(target=service._reconcile_private, daemon=True) + transport._web_projection_scan_at = 0 + worker.start() + try: + deadline = time.monotonic() + 20 + while not _read_json(mirror)["deliveries"].get("web." + message["message_id"], {}).get("verified"): + assert time.monotonic() < deadline + time.sleep(.02) + finally: + service.close() + worker.join(10) + assert not worker.is_alive() + expected_sent = f"**LoopX(App)**\n\n[查看对应提问]({question_link})\n\n{downgraded}\n\n{provenance}" + assert provider.writes[len(writes):] == [("steward-app", expected_sent)] + original_mirror = mirror.read_bytes() + phase = _read_json(mirror)["deliveries"]["web." + message["message_id"]] + assert phase["question_link"] == question_link and phase["text"] == expected_sent + del provider.messages[question_ref]["message_app_link"] + writes = list(provider.writes) + runner = transport.runner + + def unavailable(args, cwd=None, timeout=None): + if "+messages-mget" in args and args[args.index("--message-ids") + 1].startswith("om_out_"): + return {"returncode": 1, "stdout": ""} + return runner(args, cwd, timeout) + + monkeypatch.setattr(transport, "runner", unavailable) + clock = datetime.now(timezone.utc) + timedelta(minutes=10) + drain(sender.root, runtime.registry_path, store, sender, now=clock) + state = _read_json(_root(sender.root) / "replies" / route["request_id"] / "conclusion.delivery.json") + assert state["status"] == "verification_required" and state["attempt"] == phase["attempt"] + monkeypatch.setattr(transport, "runner", runner) + recovered = ChatSessionStore(store.root.parent) + restarted = LarkManagerReturnTransport(sender.server, sender.root) + drain(sender.root, runtime.registry_path, recovered, restarted, now=clock + timedelta(minutes=10)) + assert reply_status(sender.root, route)[0]["status"] == "delivered" + assert provider.writes == writes and mirror.read_bytes() == original_mirror + code, snapshot = request(f"/api/chat/sessions/{session['session_id']}") + assert code == 200 + actual = next(item for item in snapshot["messages"] if item["message_id"] == message["message_id"]) + assert body in actual["text"] and actual["return_delivery"]["status"] == "delivered" + + @pytest.mark.parametrize("fault", ["unknown", "revoked", "revoked-after-read", "scope", "scope-after-read", "audience", "body", "receipt"]) def test_web_result_keeps_unknown_or_revoked_mirror_without_duplicate_delivery(web_return, monkeypatch, fault): sender, session, turn, route, provider, transport, mirror, flush, _ = web_return diff --git a/tests/extensions/test_lark_rich_parts.py b/tests/extensions/test_lark_rich_parts.py index 534feb72ca..3c99a051ad 100644 --- a/tests/extensions/test_lark_rich_parts.py +++ b/tests/extensions/test_lark_rich_parts.py @@ -285,6 +285,45 @@ def test_attachments_stay_on_last_concrete_post(tmp_path): assert part.endswith("测") +@pytest.mark.parametrize( + "mutation", + [ + lambda state: state.update(delivery_parts=[]), + lambda state: state.pop("delivery_parts", None), + lambda state: state.pop("delivery_part_attempts", None), + lambda state: state["delivery_part_attempts"].pop( + str(len(state["delivery_parts"]) - 1), None + ), + ], + ids=["empty-parts", "missing-parts", "missing-attempts", "missing-last-attempt"], +) +def test_attachment_reply_rejects_empty_or_missing_part_attempts(tmp_path, mutation): + provider = RichProvider() + attempts = [] + args, result = send( + tmp_path, + provider, + "测" * 20000, + delivery_attempt_recorder=attempts.append, + ) + assert result["reply_verified"] + journal = next( + Path(args["project"]).glob( + ".loopx/inbox/feedback/manager-delivery/parts/*.json" + ) + ) + state = json.loads(journal.read_text()) + mutation(state) + journal.write_text(json.dumps(state)) + with pytest.raises(ValueError, match="unavailable"): + attachment_reply( + project=args["project"], + config_path=args["config_path"], + attempt=attempts[-1], + text=args["text"], + ) + + def test_preview_and_denied_review_do_not_write_or_record_an_attempt(tmp_path): provider = RichProvider() config, _, project = _fixture(tmp_path, lifecycle=False) diff --git a/tests/test_lark_private_conversations.py b/tests/test_lark_private_conversations.py index cdb603ebc3..6eb048d6d2 100644 --- a/tests/test_lark_private_conversations.py +++ b/tests/test_lark_private_conversations.py @@ -4049,11 +4049,41 @@ def vanished(path): runtime.close() -def test_app_messages_and_answers_reach_the_original_chat_once_without_new_execution(ordinary): # noqa: F811 +@pytest.mark.parametrize("source_link", ["original", "negative", "larksuite", "foreign", "non_integer", "unavailable"]) +def test_app_messages_and_answers_reach_the_original_chat_once_without_new_execution(ordinary, source_link): # noqa: F811 store, runtime, provider, transport, original, turns, before = _app_projection_journey(ordinary) sid = original["session_id"] canonical = [message for message in store.messages(sid) if message.get("turn_id") in turns] requests_before = ordinary[4].read_text() + + def build_link(chat_id: str, ref: str) -> str | None: + if source_link == "unavailable": + return None + domain = "applink.larksuite.com" if source_link == "larksuite" else "applink.feishu.cn" + chat = "oc_a_different_private_chat" if source_link == "foreign" else chat_id + index = int(ref.removeprefix("om_out_")) + if source_link == "original": + position: int | str = index + elif source_link in {"negative", "larksuite", "foreign"}: + position = -1 - index + else: + position = "1.5" + return f"https://{domain}/client/chat/open?openChatId={chat}&position={position}" + + def with_source_links(args, cwd=None, timeout=None): + response = provider(args, cwd, timeout) + if "+messages-mget" not in args: + return response + payload = json.loads(response["stdout"]) + for row in payload.get("data", {}).get("items", []): + ref = row["message_id"] + if ref.startswith("om_out_"): + link = build_link(row["chat_id"], ref) + if link is not None: + row["message_app_link"] = link + return {**response, "stdout": json.dumps(payload, ensure_ascii=False)} + + transport.runner = with_source_links try: _drain_app_projection(transport, lambda: len(provider.writes) >= before + len(canonical)) projected = provider.writes[before:] @@ -4062,6 +4092,21 @@ def test_app_messages_and_answers_reach_the_original_chat_once_without_new_execu for (profile, text), message in zip(projected, canonical): assert profile == "notes-app" and message["text"] in text assert ("你(App)" if message["role"] == "user" else "LoopX(App)") in text + journal, = (transport.root / "web-projections").glob("*.json") + deliveries = json.loads(journal.read_text())["deliveries"] + canonical_inputs = {m["turn_id"]: m["message_id"] for m in canonical if m["role"] == "user"} + for message in canonical: + current = deliveries["web." + message["message_id"]] + if source_link in {"original", "negative", "larksuite"} and message["role"] == "agent": + parent = deliveries["web." + canonical_inputs[message["turn_id"]]] + expected = build_link("oc_notes_app", parent["attempt"]["message_ref"]) + assert expected is not None and current["question_link"] == expected + provider_message = provider.messages[current["attempt"]["message_ref"]] + contents = json.loads(provider_message["body"]["content"])["zh_cn"]["content"] + assert f"[查看对应提问]({expected})" in contents[0][0]["text"] + else: + assert "查看对应提问" not in current["text"] + assert "question_link" not in current restarted = LarkPrivateConversations(controller=runtime, runtime_root=transport.runtime_root, runner=provider, cli_bin="lark-cli") for _ in range(3): @@ -4612,6 +4657,175 @@ def test_app_long_input_feedback_uses_its_last_verified_post(ordinary): # noqa: runtime.close() +@pytest.mark.parametrize("question_parts", ["available", "empty", "missing_parts", "missing_attempt"]) +def test_app_long_input_mirror_delivers_answer_when_question_parts_unavailable(ordinary, question_parts): # noqa: F811 + from loopx.extensions.lark.post_delivery import POST_PARTS_LOCATOR, _path + + store, runtime, provider, transport, original, turns, before = _app_projection_journey(ordinary) + text = "Long App input with complete source.\n" * 900 + "END_APP_INPUT" + sid = original["session_id"] + try: + status, turn = ordinary[3](f"/api/chat/sessions/{sid}/turns", + {"message": text, "client_turn_id": f"long-app-mirror-{question_parts}"}) + assert status == 202 + assert runtime.wait_for_turn(session_id=sid, turn_id=turn["turn_id"], timeout_sec=10)["status"] == "completed" + _drain_app_projection(transport, lambda: any("END_APP_INPUT" in body for _, body in provider.writes[before:])) + refs = {ref for ref, message in provider.messages.items() + if "Long App input" in json.dumps(message.get("body", {})) or "END_APP_INPUT" in json.dumps(message.get("body", {}))} + last = next(ref for ref in refs if "END_APP_INPUT" in json.dumps(provider.messages[ref])) + + question, answer = [message for message in store.messages(sid) if message["turn_id"] == turn["turn_id"]] + journal, = (transport.root / "web-projections").glob("*.json") + row = json.loads(journal.read_text()) + question_key, answer_key = ("web." + message["message_id"] for message in (question, answer)) + question_phase = row["deliveries"][question_key] + assert question_phase["verified"] and answer_key not in row["deliveries"] + link = "https://applink.feishu.cn/client/chat/open?openChatId=oc_notes_app&position=-1" + provider.messages[last]["message_app_link"] = link + match = POST_PARTS_LOCATOR.fullmatch(question_phase["attempt"]["message_ref"]) + assert match is not None + state_path = _path(transport.runtime_root, transport._inbox(row), match[1]) + if question_parts == "empty": + state = json.loads(state_path.read_text()) + state["delivery_parts"] = [] + state_path.write_text(json.dumps(state)) + elif question_parts == "missing_parts": + state = json.loads(state_path.read_text()) + state.pop("delivery_parts", None) + state_path.write_text(json.dumps(state)) + elif question_parts == "missing_attempt": + state = json.loads(state_path.read_text()) + state.pop("delivery_part_attempts", None) + state_path.write_text(json.dumps(state)) + frozen_parts = state_path.read_bytes() + original_requests = ordinary[4].read_bytes() + writes = len(provider.writes) + + _drain_app_projection(transport, lambda: json.loads(journal.read_text())["deliveries"].get(answer_key, {}).get("verified")) + phase = json.loads(journal.read_text())["deliveries"][answer_key] + expected = "**LoopX(App)**\n\n" + if question_parts == "available": + expected += f"[查看对应提问]({link})\n\n" + assert provider.writes[writes:] == [("notes-app", expected + answer["text"])] + assert phase.get("question_link") == (link if question_parts == "available" else None) + restarted = LarkPrivateConversations(controller=runtime, runtime_root=transport.runtime_root, + runner=provider, cli_bin="lark-cli") + for _ in range(3): + restarted.reconcile() + assert len(provider.writes) == writes + 1 + assert state_path.read_bytes() == frozen_parts + assert ordinary[4].read_bytes() == original_requests + finally: + runtime.close() + + +def test_app_mirror_negative_link_persists_before_send_recovers_and_downgrades(ordinary, monkeypatch): # noqa: F811 + import copy + from loopx.extensions.lark.manager_returns import prepare_app_mirror_text + + store, runtime, provider, transport = connect(ordinary) + raw_answer = r"Result @contributor.\nDetails: quoted" + downgraded = "Result @contributor.\nDetails: ‹at unsupported>quoted‹/at>" + ordinary[-2].write_text(ordinary[-2].read_text().replace('"Runtime response."', json.dumps(raw_answer))) + event = provider.event("notes-app", "original-app-negative-link", "Original source conversation") + transport.admit("notes-app", event) + original = next(row for row in transport.core.pending() if row["message"] == event["content"]) + assert runtime.wait_for_turn(session_id=original["session_id"], turn_id=original["turn_id"], timeout_sec=10)["status"] == "completed" + transport.reconcile() + sid = original["session_id"] + try: + with monkeypatch.context() as queued: + queued.setattr(runtime, "resume_session_queue", lambda **_: None) + status, turn = ordinary[3](f"/api/chat/sessions/{sid}/turns", + {"message": "Question needing signed position", "client_turn_id": "negative-link-pre-send"}) + assert status == 202 + _drain_app_projection(transport, lambda: any("Question needing signed position" in body for _, body in provider.writes)) + question, = [m for m in store.messages(sid) if m["turn_id"] == turn["turn_id"]] + journal, = (transport.root / "web-projections").glob("*.json") + row = json.loads(journal.read_text()) + question_key = "web." + question["message_id"] + question_ref = row["deliveries"][question_key]["attempt"]["message_ref"] + assert row["deliveries"][question_key]["verified"] + + runtime.resume_session_queue(session_id=sid, work_dir=ordinary[-1], objective="") + assert runtime.wait_for_turn(session_id=sid, turn_id=turn["turn_id"], timeout_sec=10)["status"] == "completed" + _, answer = [m for m in store.messages(sid) if m["turn_id"] == turn["turn_id"]] + answer_key = "web." + answer["message_id"] + messages = transport._web_projection_messages(row) + + # Reject malformed/non-integer/wrong-domain/foreign-chat links without touching the journal. + invalid_links = [ + "https://applink.feishu.cn/client/chat/open?openChatId=oc_notes_app&position=1.5", + "https://applink.feishu.cn/client/chat/open?openChatId=oc_notes_app&position=abc", + "https://applink.feishu.cn/client/chat/open?openChatId=oc_notes_app&position=-", + "https://applink.feishu.cn/client/chat/open?openChatId=oc_notes_app&position=+1", + "https://applink.feishu.cn/client/chat/open?openChatId=oc_notes_app&position=", + "https://applink.feishu.cn/client/chat/open?openChatId=oc_notes_app&position=-1)", + "https://applink.feishu.cn/client/chat/open?openChatId=oc_notes_app&position=-1&extra=1", + "https://applink.feishu.cn/client/chat/open?openChatId=oc_other_chat&position=-1", + "https://applink.feishu.cn/client/thread/open?openChatId=oc_notes_app&position=-1", + "https://evil.example/client/chat/open?openChatId=oc_notes_app&position=-1", + "http://applink.feishu.cn/client/chat/open?openChatId=oc_notes_app&position=-1", + ] + for bad_link in invalid_links: + provider.messages[question_ref]["message_app_link"] = bad_link + probe_row = copy.deepcopy(row) + assert prepare_app_mirror_text(transport, journal, probe_row, messages, answer) == f"**LoopX(App)**\n\n{raw_answer}" + assert answer_key not in probe_row["deliveries"] + + link = "https://applink.feishu.cn/client/chat/open?openChatId=oc_notes_app&position=-1" + provider.messages[question_ref]["message_app_link"] = link + writes_before = len(provider.writes) + + # Pre-send persistence: preview outage after prepare_app_mirror_text keeps question_link on disk. + def fail_preview(args, cwd=None, timeout=None): + if "+messages-send" in args and "--dry-run" in args: + return {"returncode": 1, "stdout": "", "stderr": "synthetic preview outage"} + return provider(args, cwd, timeout) + + transport.runner = fail_preview + transport._web_projection_scan_at = 0 + transport.reconcile() + persisted = json.loads(journal.read_text())["deliveries"][answer_key] + assert persisted == { + "question_link": link, + "verified": False, + "blocker": "lark_inbox_reply_provider_preview_mismatch", + } + assert len(provider.writes) == writes_before + + # Link disappears from provider before first send; restarted worker uses persisted link + # and plain-text presentation downgrade on the real outbox. + del provider.messages[question_ref]["message_app_link"] + provider.verify_replies = False + restarted = LarkPrivateConversations(controller=runtime, runtime_root=transport.runtime_root, + runner=provider, cli_bin="lark-cli") + _drain_app_projection(restarted, lambda: json.loads(journal.read_text())["deliveries"][answer_key].get("attempt") is not None) + expected_body = f"**LoopX(App)**\n\n[查看对应提问]({link})\n\n{downgraded}" + assert provider.writes[writes_before:] == [("notes-app", expected_body)] + attempted = json.loads(journal.read_text())["deliveries"][answer_key] + assert attempted["question_link"] == link + assert attempted["text"] == expected_body + assert not attempted.get("verified") + assert not any("+chat-members-list" in call for call in provider.calls) + + # Post-restart recovery readback verifies the saved attempt without resending. + provider.verify_replies = True + writes_after = list(provider.writes) + requests_before = ordinary[4].read_bytes() + recovered = LarkPrivateConversations(controller=runtime, runtime_root=transport.runtime_root, + runner=provider, cli_bin="lark-cli") + _drain_app_projection(recovered, lambda: json.loads(journal.read_text())["deliveries"][answer_key].get("verified")) + recovered.reconcile() + final_phase = json.loads(journal.read_text())["deliveries"][answer_key] + assert final_phase["verified"] and final_phase["question_link"] == link + assert final_phase["attempt"] == attempted["attempt"] + assert provider.writes == writes_after + assert ordinary[4].read_bytes() == requests_before + finally: + runtime.close() + + def test_enabling_app_feedback_does_not_backfill_old_finished_mirrors(ordinary, monkeypatch): # noqa: F811 store, runtime, provider, transport, original, turns, before = _app_projection_journey(ordinary) transport.reaction_feedback = False