diff --git a/src/jarvis/tools/builtin/chat_channels.spec.md b/src/jarvis/tools/builtin/chat_channels.spec.md index 7dd659b..40af2bd 100644 --- a/src/jarvis/tools/builtin/chat_channels.spec.md +++ b/src/jarvis/tools/builtin/chat_channels.spec.md @@ -21,7 +21,9 @@ written, send, edit its own messages, react, delete and pin. Product rules: `doc data; one word YES or NO). Any other answer, an error, a refusal, a question, another topic or a different message means no and cancels the request. A message longer than 600 characters is not judged and means no (cutting it could drop a later "don't"). A request not confirmed in the very - next turn lapses. Eval: `evals/test_chat_delete_consent.py`. + next turn lapses. The backend numbers the turns so that only a message sent after the person got + the question is their next turn (voice worker: `voice_worker.spec.md`, "History and brain"). Eval: + `evals/test_chat_delete_consent.py`. - **Raw data.** The tool returns plain text for the reply model; the only LLM call inside is the delete consent check. diff --git a/src/voice_worker/server.py b/src/voice_worker/server.py index d742256..a6f2aa6 100644 --- a/src/voice_worker/server.py +++ b/src/voice_worker/server.py @@ -62,10 +62,14 @@ class VoiceWorker: # chat_action ids are unique across connections and worker runs, so a late answer from an # earlier connection (or an earlier worker) never completes a newer action. self.chat_action_prefix = secrets.token_hex(4) - # Per person: how many replies they had (a delete is confirmed only in a later one) and the - # deletes they were asked to confirm (chat_channels.spec.md). + # Per person: how many replies they had (a delete is confirmed only in the very next one), + # the deletes they were asked to confirm (chat_channels.spec.md) and how many of their + # replies are not answered yet. A turn number is skipped for a request that arrived before + # the person's previous answer was given, and after an answer they never got, so a + # confirmation asked in that answer lapses. self.reply_turns: dict[str, int] = {} self.pending_deletes: dict[str, dict] = {} + self.replies_unanswered: dict[str, int] = {} self.scheduler: SttScheduler | None = None self.tts: TtsService | None = None self._ids = itertools.count(1) @@ -495,7 +499,10 @@ class Session: return if speak: self.thinking_replies.add(rid) - asyncio.get_running_loop().create_task(self._reply(rid, user, text, via, speak)) + waiting = self.worker.replies_unanswered + early = waiting.get(user, 0) > 0 # sent before their previous answer: not a reply to it + waiting[user] = waiting.get(user, 0) + 1 + asyncio.get_running_loop().create_task(self._reply(rid, user, text, via, speak, early)) def _on_addressed(self, msg: dict) -> None: got = self._strings(msg, "id", "user", "text") @@ -540,14 +547,18 @@ class Session: self.send({"type": "rank_result", "id": qid, "order": order or [], "failed": order is None}) asyncio.get_running_loop().create_task(rank()) - async def _reply(self, rid: str, user: str, text: str, via: str, speak: bool) -> None: + async def _reply(self, rid: str, user: str, text: str, via: str, speak: bool, early: bool = False) -> None: try: - await self._reply_inner(rid, user, text, via, speak) + await self._reply_inner(rid, user, text, via, speak, early) finally: self.thinking_replies.discard(rid) self.cancelled_replies.discard(rid) + waiting = self.worker.replies_unanswered + waiting[user] -= 1 + if not waiting[user]: + del waiting[user] - async def _reply_inner(self, rid: str, user: str, text: str, via: str, speak: bool) -> None: + async def _reply_inner(self, rid: str, user: str, text: str, via: str, speak: bool, early: bool) -> None: w = self.worker channel = self.voice_channel # Person first, then lane: a reply waiting for its asker's other answer holds no lane. @@ -563,7 +574,10 @@ class Session: else: from jarvis.memory.history import HistoryContext history = HistoryContext() - turn = w.reply_turns[user] = w.reply_turns.get(user, 0) + 1 + turn = w.reply_turns[user] = w.reply_turns.get(user, 0) + (2 if early else 1) + if early: + debug_log(f"brain reply {rid} arrived before the previous answer: a turn is skipped", + "voice_worker") from .chat_bridge import ChatBridge chat = ChatBridge(self, asyncio.get_running_loop(), turn, w.pending_deletes.setdefault(user, {})) \ if self.chat_channels else None @@ -574,6 +588,9 @@ class Session: answer = None answer = (answer or "").strip() self.send({"type": "reply_text", "id": rid, "text": answer, "failed": not answer}) + if not answer or (speak and rid in self.cancelled_replies): + # They never got this answer, so nothing it asked can be confirmed next. + w.reply_turns[user] = max(w.reply_turns.get(user, 0), turn + 1) if not answer: return if via == "voice" and channel and w.history is not None: diff --git a/src/voice_worker/voice_worker.spec.md b/src/voice_worker/voice_worker.spec.md index 6d08ca9..bfa3c8f 100644 --- a/src/voice_worker/voice_worker.spec.md +++ b/src/voice_worker/voice_worker.spec.md @@ -262,7 +262,10 @@ which carry Discord's own time. newer action. With no registered channels the tool is not offered. An action waits up to 15 s for its result (then it fails), and a closed session fails every waiting action. Each reply counts as one turn - per person, so a delete is confirmed only in that person's later reply. + per person, so a delete is confirmed only in that person's next reply. A reply sent before the + person's previous answer was given cannot answer it, and an answer they never got (failed, or + stopped before it was spoken) asked them nothing: in both cases a turn number is skipped, so a + delete asked in that previous answer lapses. - Memory settings, optional in `hello` as `"memory": {...}` and changeable with `{"type": "memory_config", ...}`: `chat` (true), `others` (true), `off` (false), `since_days` (null: whole history), `recent_minutes` (30), `recent_records` (20), `matches` (5), diff --git a/tests/test_voice_worker_brain.py b/tests/test_voice_worker_brain.py index 9643508..531e894 100644 --- a/tests/test_voice_worker_brain.py +++ b/tests/test_voice_worker_brain.py @@ -734,3 +734,110 @@ def test_one_persons_voice_and_chat_answers_are_written_one_at_a_time(store): started, order = asyncio.run(with_worker(body, store=store, brain=FakeBrain(answer))) assert started == ["chat question"], "the voice question started before the same person's chat answer" assert order == ["c1", "v1"] + + +DELETABLE = {"type": "chat_channels", "bot": "900", "channels": [ + {"id": "c1", "name": "일정", "description": "약속", "read": True, "send": True, "edit": True, + "react": True, "delete": True, "pin": False}]} + + +def delete_tool_brain(release, question="지울까요?"): + """A brain whose reply runs the real chatChannels tool: "지워" asks to delete message m1 (and waits + for ``release`` before answering), "응, 지워" confirms. The consent check always agrees.""" + from unittest.mock import patch + + from jarvis.reply import turn_state + from jarvis.tools.builtin.chat_channels import ChatChannelsTool + + class Cfg: + ollama_base_url = "http://x" + ollama_chat_model = "m" + + results = [] + + def answer(user, text): + turn_state.reset() + turn_state.set_chat(brain.chat) + args = {"action": "delete", "channel": "c1", "message_id": "m1", "confirm": text == "응, 지워"} + try: + with patch("jarvis.tools.builtin.chat_channels.call_llm_direct", return_value="YES"): + res = ChatChannelsTool().execute(db=None, cfg=Cfg(), tool_args=args, system_prompt="", + original_prompt=text, redacted_text=text, max_retries=0, + user_print=lambda m: None) + finally: + turn_state.reset() + results.append((text, res.success)) + if text == "지워": + release.wait(10) + return question if text == "지워" else "done" + + brain = FakeBrain(answer) + return brain, results + + +@pytest.mark.unit +def test_a_yes_sent_before_the_delete_question_was_answered_does_not_delete(store): + import threading + release = threading.Event() + brain, results = delete_tool_brain(release) + + async def body(url): + async with connect(url) as ws: + await hello(ws) + await ws.send(json.dumps(DELETABLE)) + await send(ws, type="reply", id="r1", user="100", text="지워", via="chat", speak=False) + await asyncio.sleep(0.2) + # Typed before the question reached them: it cannot be their answer to it. + await send(ws, type="reply", id="r2", user="100", text="응, 지워", via="voice", speak=False) + await asyncio.sleep(0.1) + release.set() + return await recv_until(ws, lambda m: isinstance(m, dict) and m.get("id") == "r2") + + seen = asyncio.run(with_worker(body, store=store, brain=brain)) + assert not any(isinstance(m, dict) and m.get("type") == "chat_action" for m in seen) + assert results == [("지워", True), ("응, 지워", False)] + + +@pytest.mark.unit +def test_a_yes_after_the_delete_question_deletes(store): + import threading + release = threading.Event() + release.set() + brain, results = delete_tool_brain(release) + + async def body(url): + async with connect(url) as ws: + await hello(ws) + await ws.send(json.dumps(DELETABLE)) + await send(ws, type="reply", id="r1", user="100", text="지워", via="chat", speak=False) + await recv_until(ws, lambda m: isinstance(m, dict) and m.get("id") == "r1") + await send(ws, type="reply", id="r2", user="100", text="응, 지워", via="voice", speak=False) + seen = await recv_until(ws, lambda m: isinstance(m, dict) and m.get("type") == "chat_action") + await send(ws, type="chat_action_result", id=seen[-1]["id"], ok=True) + await recv_until(ws, lambda m: isinstance(m, dict) and m.get("id") == "r2") + return seen[-1] + + action = asyncio.run(with_worker(body, store=store, brain=brain)) + assert (action["action"], action["channel"], action["message_id"]) == ("delete", "c1", "m1") + assert results == [("지워", True), ("응, 지워", True)] + + +@pytest.mark.unit +def test_a_yes_after_a_delete_question_they_never_got_does_not_delete(store): + import threading + release = threading.Event() + release.set() + brain, results = delete_tool_brain(release, question="") # the answer failed: nothing was asked + + async def body(url): + async with connect(url) as ws: + await hello(ws) + await ws.send(json.dumps(DELETABLE)) + await send(ws, type="reply", id="r1", user="100", text="지워", via="chat", speak=False) + await recv_until(ws, lambda m: isinstance(m, dict) and m.get("id") == "r1") + await send(ws, type="reply", id="r2", user="100", text="응, 지워", via="voice", speak=False) + return await recv_until(ws, lambda m: isinstance(m, dict) and m.get("id") == "r2") + + seen = asyncio.run(with_worker(body, store=store, brain=brain)) + assert not any(isinstance(m, dict) and m.get("type") == "chat_action" for m in seen) + assert results == [("지워", True), ("응, 지워", False)]