From 6fc3ad3d5798ceb32bb3541bfb9661e832caec4b Mon Sep 17 00:00:00 2001 From: javis-bot Date: Mon, 16 Nov 2026 12:03:45 +0900 Subject: [PATCH] feat(worker): answer traces stored from the question on and filled in as the answer is made MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A trace is now kept the moment the request arrives (at the time it was asked, ms -1), its steps are stored as the engine adds each one, and it ends with the answer. Traces a killed run left unfinished are closed at start. The 대화 screen reads a trace still being made as pending. Co-Authored-By: Claude Opus 5.5 --- app/src/history_view.rs | 19 ++++++- src/jarvis/memory/history.py | 36 ++++++++++--- src/jarvis/memory/history.spec.md | 13 +++-- src/voice_worker/server.py | 77 +++++++++++++++++++-------- src/voice_worker/voice_worker.spec.md | 7 ++- tests/test_history_store.py | 30 +++++++++-- tests/test_voice_worker_brain.py | 33 ++++++++++-- 7 files changed, 171 insertions(+), 44 deletions(-) diff --git a/app/src/history_view.rs b/app/src/history_view.rs index 1c37bdb..5256d4a 100644 --- a/app/src/history_view.rs +++ b/app/src/history_view.rs @@ -215,11 +215,13 @@ pub fn query(path: &Path, bot: Option<&str>, q: &Query) -> Result let (id, ts): (i64, f64) = (r.get(0)?, r.get(1)?); let user: String = r.get(4)?; let steps: String = r.get(8)?; + let ms: i64 = r.get(7)?; Ok(((ts, 1, id), json!({ "key": format!("t{id}"), "type": "thought", "at": ts, "via": r.get::<_, String>(2)?, "channel": r.get::<_, Option>(3)?, "who": {"id": user.clone(), "name": name_of(&user)}, - "question": r.get::<_, String>(5)?, "answer": r.get::<_, String>(6)?, "ms": r.get::<_, i64>(7)?, + "question": r.get::<_, String>(5)?, "answer": r.get::<_, String>(6)?, "ms": ms.max(0), + "pending": ms < 0, "steps": serde_json::from_str::(&steps).unwrap_or(json!([])), }))) }).map_err(err)?; @@ -384,6 +386,21 @@ mod tests { assert!(Cursor::of(&json!({"at": 1.0, "key": "x1"})).is_none()); } + #[test] + fn a_trace_still_being_made_reads_as_pending_with_its_steps_so_far() { + let (path, c) = db("pending"); + rec(&c, 10.0, "voice", "vc", "1", "Alice", None, "서울 날씨 어때"); + c.execute("INSERT INTO traces(ts, via, channel_id, user_id, question, answer, ms, steps) VALUES (?,?,?,?,?,?,?,?)", + rusqlite::params![10.5, "voice", "vc", "1", "서울 날씨 어때", "", -1, r#"[{"kind":"tools","names":["getWeather"]}]"#]) + .unwrap(); + let v = query(&path, None, &Query::default()).unwrap(); + let t = &v["items"][1]; + assert_eq!((t["type"].as_str(), t["pending"].as_bool()), (Some("thought"), Some(true))); + assert_eq!(t["steps"][0]["names"], json!(["getWeather"])); + let done = query(&sample("pending-done"), None, &Query::default()).unwrap(); + assert_eq!(done["items"][1]["pending"], false); + } + #[test] fn the_bot_id_comes_from_its_token() { assert_eq!(bot_id_of_token("MTIzNDU2Nzg5MDEyMzQ1Njc4.GxYzAb.abcdef").as_deref(), Some("123456789012345678")); diff --git a/src/jarvis/memory/history.py b/src/jarvis/memory/history.py index f30a0de..f063cd9 100644 --- a/src/jarvis/memory/history.py +++ b/src/jarvis/memory/history.py @@ -44,13 +44,13 @@ CREATE TABLE IF NOT EXISTS presence ( CREATE INDEX IF NOT EXISTS presence_user ON presence(user_id, channel_id); CREATE TABLE IF NOT EXISTS traces ( id INTEGER PRIMARY KEY, - ts REAL NOT NULL, -- when the answer was ready + ts REAL NOT NULL, -- when it was asked via TEXT NOT NULL, -- voice | chat | task channel_id TEXT, -- where it was asked; none for a task user_id TEXT NOT NULL, question TEXT NOT NULL, answer TEXT NOT NULL, -- empty when the brain gave none - ms INTEGER NOT NULL, + ms INTEGER NOT NULL, -- -1 while the answer is being made steps TEXT NOT NULL -- JSON list (history.spec.md, "Traces") ); CREATE INDEX IF NOT EXISTS traces_ts ON traces(ts); @@ -107,6 +107,10 @@ class HistoryContext: matches: List[str] = field(default_factory=list) +def _steps_json(steps: list) -> str: + return json.dumps(steps, ensure_ascii=False, default=str) + + def _fold(text: str) -> str: """One Unicode folding for stored text and query words alike (NFKC, then case folding), so matching does not depend on SQLite's ASCII-only lower().""" @@ -225,16 +229,34 @@ class HistoryStore: # -- maintenance -------------------------------------------------------- - def add_trace(self, via: str, channel_id: Optional[str], user_id: str, question: str, answer: str, - steps: list, ms: int, ts: float) -> int: + def start_trace(self, via: str, channel_id: Optional[str], user_id: str, question: str, ts: float) -> int: + """A trace from the moment it was asked: no answer yet and ``ms`` -1.""" with self._lock: cur = self._conn.execute( - "INSERT INTO traces(ts, via, channel_id, user_id, question, answer, ms, steps) VALUES (?,?,?,?,?,?,?,?)", - (ts, via, channel_id, user_id, question, answer or "", int(ms), - json.dumps(steps, ensure_ascii=False, default=str))) + "INSERT INTO traces(ts, via, channel_id, user_id, question, answer, ms, steps) VALUES (?,?,?,?,?,'',-1,'[]')", + (ts, via, channel_id, user_id, question)) self._conn.commit() return int(cur.lastrowid) + def trace_steps(self, trace_id: int, steps: list) -> None: + """The steps so far of a trace still being made.""" + with self._lock: + self._conn.execute("UPDATE traces SET steps=? WHERE id=?", (_steps_json(steps), trace_id)) + self._conn.commit() + + def finish_trace(self, trace_id: int, answer: str, steps: list, ms: int) -> None: + with self._lock: + self._conn.execute("UPDATE traces SET answer=?, steps=?, ms=? WHERE id=?", + (answer or "", _steps_json(steps), max(0, int(ms)), trace_id)) + self._conn.commit() + + def close_unfinished_traces(self) -> int: + """End, with no answer, the traces a killed run left being made (the host calls it at start).""" + with self._lock: + n = self._conn.execute("UPDATE traces SET ms=0 WHERE ms < 0").rowcount + self._conn.commit() + return n + def traces_of(self, person: str) -> List[Trace]: with self._lock: rows = self._conn.execute( diff --git a/src/jarvis/memory/history.spec.md b/src/jarvis/memory/history.spec.md index b5543eb..e8683ce 100644 --- a/src/jarvis/memory/history.spec.md +++ b/src/jarvis/memory/history.spec.md @@ -73,10 +73,13 @@ Setting `since` (default none, meaning the whole history) drops records older th How each answer was made, for the management app's 대화 screen (`app/src/admin.spec.md`, "Conversations"). A trace is never a record: no read above returns it and it never reaches a prompt. -- `add_trace(via, channel_id, user_id, question, answer, steps, ms, ts)`: one per `reply` the brain - ran (`via` `voice`, `chat` or `task`; `channel_id` where it was asked, none for a task; `answer` - empty when the brain gave none; `ts` when it was ready; `ms` how long it took). `steps` is a JSON - list in the order they happened: +- One per `reply` the brain ran, kept from the moment it was asked so the screen can show it while + the answer is made: `start_trace(via, channel_id, user_id, question, ts)` (`via` `voice`, `chat` or + `task`; `channel_id` where it was asked, none for a task; `ts` when it was asked) stores it with no + answer and `ms` -1, `trace_steps(id, steps)` stores the steps so far, and + `finish_trace(id, answer, steps, ms)` the end (`answer` empty when the brain gave none; `ms` how + long it took). `close_unfinished_traces()`, which the host calls at start, ends with no answer the + traces a killed run left at -1. `steps` is a JSON list in the order they happened: - `{"kind": "records", "recent": [...], "matches": [...], "notes": n}`: the history lines and the number of personal notes the brain was given (the voice worker adds it first), - `{"kind": "tools", "names": [...]}`: the tools the turn was offered after routing, @@ -87,7 +90,7 @@ How each answer was made, for the management app's 대화 screen (`app/src/admin error (at most 2,000 characters), or `"skipped": "not_allowed" | "duplicate"` with `ok` false for a call the engine refused. The engine writes them through `turn_state.trace` (`reply/turn_state.py`), which does nothing when - no trace list was set (v1, evals). + no trace list was set (v1, evals); the voice worker's list stores the steps as each is added. - `traces_of(person)`: the person's traces, oldest first. `forget_person` deletes them too. - `purge_traces_older_than(ts)`: the voice worker keeps traces 30 days (`TRACE_KEEP_DAYS`) and removes older ones when it starts. `purge_older_than` removes old traces with the records. diff --git a/src/voice_worker/server.py b/src/voice_worker/server.py index 3276ff4..baa0c86 100644 --- a/src/voice_worker/server.py +++ b/src/voice_worker/server.py @@ -55,6 +55,37 @@ MAX_NOTE_CHARS = 300 TRACE_KEEP_DAYS = 30 +class _LiveTrace(list): + """A reply's trace (history.spec.md, "Traces"): stored as soon as the request arrives and again + as each step is added, so the 대화 screen fills it in while the answer is made. The engine adds + steps from the brain's thread. Storing never stops the answer.""" + + def __init__(self, store, via: str, channel: str | None, user: str, question: str): + super().__init__() + self.store, self.began, self.id = store, time.time(), None + if store is not None: + self.id = self._keep(store.start_trace, via, channel, user, question, ts=self.began) + + @staticmethod + def _keep(write, *args, **kw): + try: + return write(*args, **kw) + except Exception as e: # noqa: BLE001 - a trace is a view, not part of the answer + debug_log(f"trace not kept: {type(e).__name__}", "llm") + return None + + def append(self, step) -> None: + super().append(step) + if self.id is not None: + self._keep(self.store.trace_steps, self.id, list(self)) + + def finish(self, answer: str) -> None: + if self.id is not None: + self._keep(self.store.finish_trace, self.id, answer, list(self), + ms=round((time.time() - self.began) * 1000)) + self.id = None + + class VoiceWorker: def _partials_held(self) -> bool: return self.llm_game and self.answering > 0 @@ -118,6 +149,9 @@ class VoiceWorker: n = self.history.close_open_presence(time.time()) if n: debug_log(f"closed {n} presence intervals left open by a previous run", "voice_worker") + n = self.history.close_unfinished_traces() + if n: + debug_log(f"closed {n} answer traces left unfinished by a previous run", "voice_worker") n = self.history.purge_traces_older_than(time.time() - TRACE_KEEP_DAYS * 86400) if n: debug_log(f"removed {n} answer traces older than {TRACE_KEEP_DAYS} days", "voice_worker") @@ -609,26 +643,22 @@ class Session: asyncio.get_running_loop().create_task(self._reply(rid, user, text, via, speak, early, channel, notes)) @staticmethod - def _trace_start(history, notes: list | None) -> list: + def _records_step(history, notes: list | None) -> dict: """The first step of an answer's trace: the records and notes it was given.""" - return [{"kind": "records", "recent": list(history.recent), "matches": list(history.matches), - "notes": len(notes or [])}] - - def _trace_end(self, via: str, channel: str | None, user: str, question: str, answer: str, - steps: list, began: float) -> None: - """Keep how this answer was made (history.spec.md, "Traces"); never stops the answer.""" - if self.worker.history is None: - return - try: - self.worker.history.add_trace(via, channel, user, question, answer, steps, - ms=round((time.time() - began) * 1000), ts=time.time()) - except Exception as e: # noqa: BLE001 - a trace is a view, not part of the answer - debug_log(f"trace not kept: {type(e).__name__}", "llm") + return {"kind": "records", "recent": list(history.recent), "matches": list(history.matches), + "notes": len(notes or [])} async def _task(self, rid: str, user: str, text: str, notes: list | None = None) -> None: """A scheduled task (schedule.spec.md, "Tasks"): answered in the chat lane with the read-only tools, its own short-term memory and the person's history scope. It is not a turn of their conversation, so their turn count and delete confirmations stay as they are.""" + trace = _LiveTrace(self.worker.history, "task", None, user, text) + try: + await self._task_inner(rid, user, text, notes, trace) + finally: + trace.finish("") # only when it did not get to its answer + + async def _task_inner(self, rid: str, user: str, text: str, notes: list | None, trace: _LiveTrace) -> None: w = self.worker answer = None async with w.brain_people.setdefault(user, asyncio.Lock()), w.brain_lanes["chat"]: @@ -644,14 +674,14 @@ class Session: from jarvis.memory.history import HistoryContext history = HistoryContext() try: - steps = self._trace_start(history, notes) + trace.append(self._records_step(history, notes)) async with self._llm(): answer = await asyncio.to_thread(w.brain.reply, user, text, history, task=True, - notes=notes or [], trace=steps) + notes=notes or [], trace=trace) except Exception as e: # the brain must never take the session down debug_log(f"brain task {rid} failed: {type(e).__name__}", "llm") answer = (answer or "").strip() - self._trace_end("task", None, user, text, answer, steps, now) + trace.finish(answer) self.send({"type": "reply_text", "id": rid, "text": answer, "failed": not answer}) def _on_llm(self, msg: dict) -> None: @@ -791,9 +821,11 @@ class Session: async def _reply(self, rid: str, user: str, text: str, via: str, speak: bool, early: bool = False, channel: str | None = None, notes: list | None = None) -> None: + trace = _LiveTrace(self.worker.history, via, self.voice_channel if via == "voice" else channel, user, text) try: - await self._reply_inner(rid, user, text, via, speak, early, channel, notes or []) + await self._reply_inner(rid, user, text, via, speak, early, channel, notes or [], trace=trace) finally: + trace.finish("") # only when it did not get to its answer self.thinking_replies.discard(rid) self.cancelled_replies.discard(rid) if not self._handed_over.pop(rid, False): # else _delivered counts it @@ -830,7 +862,8 @@ class Session: self._delivered(rid, ok) async def _reply_inner(self, rid: str, user: str, text: str, via: str, speak: bool, early: bool, - chat_channel: str | None = None, notes: list | None = None) -> None: + chat_channel: str | None = None, notes: list | None = None, *, + trace: _LiveTrace) -> None: w = self.worker channel = self.voice_channel # Person first, then lane: a reply waiting for its asker's other answer holds no lane. @@ -858,7 +891,7 @@ class Session: schedule = AppBridge(self, asyncio.get_running_loop(), "schedule", *origin) notes_backend = AppBridge(self, asyncio.get_running_loop(), "note", *origin) screen = AppBridge(self, asyncio.get_running_loop(), "screen", *origin) - steps = self._trace_start(history, notes) + trace.append(self._records_step(history, notes)) try: async with self._llm(rid if speak else None): w.answering += 1 @@ -866,7 +899,7 @@ class Session: answer = await asyncio.to_thread(w.brain.reply, user, text, history, chat=chat, schedule=schedule, notes=notes or [], notes_backend=notes_backend, screen=screen, - trace=steps) + trace=trace) finally: w.answering -= 1 if not w.answering and w.scheduler: @@ -875,7 +908,7 @@ class Session: debug_log(f"brain reply {rid} failed: {type(e).__name__}", "llm") answer = None answer = (answer or "").strip() - self._trace_end(via, channel if via == "voice" else chat_channel, user, text, answer, steps, now) + trace.finish(answer) if not answer and rid in self.tts_requests: self._on_tts({"type": "tts", "id": rid, "text": "", "more": False}) # ends the notice's speech self.send({"type": "reply_text", "id": rid, "text": answer, "failed": not answer}) diff --git a/src/voice_worker/voice_worker.spec.md b/src/voice_worker/voice_worker.spec.md index ce5951a..664f167 100644 --- a/src/voice_worker/voice_worker.spec.md +++ b/src/voice_worker/voice_worker.spec.md @@ -248,8 +248,11 @@ which carry Discord's own time. still answering means the answer is not spoken: `reply_text` still comes, then `tts_done` with `cancelled: true` and no audio. Every reply, a task's too and one that failed, leaves a trace of how it was made (`history.spec.md`, "Traces"): the history lines and number of notes it was given, - then what the engine wrote down; a trace that cannot be stored never stops the answer. Traces older - than 30 days are removed when the worker starts. Each user keeps their own short-term dialogue + then what the engine wrote down. It is stored as soon as the request arrives (before it waits for + the asker's previous answer) and again as each step is added, then ends with the answer, or with + none when the reply fails, the session closes or the reply is cancelled; a trace that cannot be + stored never stops the answer. At start the worker ends the traces a killed run left unfinished + and removes those older than 30 days. Each user keeps their own short-term dialogue memory (tool carry-over) across replies. The brain runs the reply engine with v1's single-user memory off (`legacy_memory=False`: no warm profile, diary or graph), because several people share this assistant and only the asker's scoped history may reach the prompt. It answers in Korean diff --git a/tests/test_history_store.py b/tests/test_history_store.py index 8d66ddf..d0c8844 100644 --- a/tests/test_history_store.py +++ b/tests/test_history_store.py @@ -243,10 +243,11 @@ def test_chat_tool_reads_and_searches_one_channels_messages(store): def test_how_an_answer_was_made_is_kept_per_person_and_never_searched(store): steps = [{"kind": "tools", "names": ["getWeather"]}, {"kind": "tool", "name": "getWeather", "args": {"location": "서울"}, "ok": True, "result": "맑음"}] - store.add_trace("voice", VC, "a", "서울 날씨 어때", "맑습니다", steps, ms=1200, ts=T0) - store.add_trace("chat", CHAT, "b", "안녕", "", [], ms=50, ts=T0 + 1) + store.finish_trace(store.start_trace("voice", VC, "a", "서울 날씨 어때", ts=T0), "맑습니다", steps, ms=1200) + store.finish_trace(store.start_trace("chat", CHAT, "b", "안녕", ts=T0 + 1), "", [], ms=50) [t] = store.traces_of("a") assert (t.via, t.channel_id, t.question, t.answer, t.ms, t.steps) == ("voice", VC, "서울 날씨 어때", "맑습니다", 1200, steps) + assert t.ts == T0 # when it was asked, not when the answer was ready # A trace is no record: the brain never reads it back as history. assert store.search("a", "날씨", scope=Scope()) == [] assert store.recent("a", T0 + 2, scope=Scope()) == [] @@ -255,9 +256,30 @@ def test_how_an_answer_was_made_is_kept_per_person_and_never_searched(store): def test_traces_have_their_own_retention_and_follow_the_history_retention(store): - store.add_trace("voice", VC, "a", "옛 질문", "옛 답", [], ms=1, ts=T0) - store.add_trace("voice", VC, "a", "새 질문", "새 답", [], ms=1, ts=T0 + 100) + store.finish_trace(store.start_trace("voice", VC, "a", "옛 질문", ts=T0), "옛 답", [], ms=1) + store.finish_trace(store.start_trace("voice", VC, "a", "새 질문", ts=T0 + 100), "새 답", [], ms=1) store.purge_traces_older_than(T0 + 50) assert [t.question for t in store.traces_of("a")] == ["새 질문"] store.purge_older_than(T0 + 200) assert store.traces_of("a") == [] + + +def test_a_trace_is_kept_from_the_question_on_and_filled_in_as_the_answer_is_made(store): + tid = store.start_trace("voice", VC, "a", "서울 날씨 어때", ts=T0) + [t] = store.traces_of("a") + assert (t.question, t.answer, t.ms, t.steps) == ("서울 날씨 어때", "", -1, []) # -1: still being made + store.trace_steps(tid, [{"kind": "tools", "names": ["getWeather"]}]) + assert store.traces_of("a")[0].steps == [{"kind": "tools", "names": ["getWeather"]}] + assert store.traces_of("a")[0].ms == -1 + store.finish_trace(tid, "맑습니다", [{"kind": "tools", "names": ["getWeather"]}], ms=900) + [t] = store.traces_of("a") + assert (t.answer, t.ms, t.ts) == ("맑습니다", 900, T0) + + +def test_traces_a_killed_run_left_unfinished_are_closed_without_an_answer(store): + store.start_trace("voice", VC, "a", "끊긴 질문", ts=T0) + store.finish_trace(store.start_trace("voice", VC, "a", "끝난 질문", ts=T0 + 1), "답", [], ms=5) + assert store.close_unfinished_traces() == 1 + cut, done = store.traces_of("a") + assert (cut.answer, cut.ms >= 0) == ("", True) + assert (done.answer, done.ms) == ("답", 5) diff --git a/tests/test_voice_worker_brain.py b/tests/test_voice_worker_brain.py index 61fe5bd..b2f0fd2 100644 --- a/tests/test_voice_worker_brain.py +++ b/tests/test_voice_worker_brain.py @@ -244,6 +244,32 @@ def test_each_answer_keeps_how_it_was_made_with_the_records_it_was_given(store): assert (task.via, task.channel_id, task.answer) == ("task", None, "answer for task") +@pytest.mark.unit +def test_a_trace_is_stored_from_the_request_on_and_fills_in_while_the_answer_is_made(store): + import time + during = [] + + def answer(user, text): + during.append((store.traces_of(user), time.time())) # the engine has added its steps + return "answer" + + async def body(url): + async with connect(url) as ws: + await hello(ws) + await send(ws, type="voice_join", channel="vc1") + await send(ws, type="reply", id="r1", user="100", text="q", via="voice", speak=False) + await recv_until(ws, lambda m: isinstance(m, dict) and m.get("id") == "r1") + + asyncio.run(with_worker(body, store=store, brain=FakeBrain(answer))) + [(traces, answering_at)] = during + [t] = traces + assert (t.question, t.answer, t.ms) == ("q", "", -1) # -1: still being made + assert [s["kind"] for s in t.steps] == ["records", "tools"] + assert t.ts <= answering_at + [t] = store.traces_of("100") + assert (t.answer, t.ms >= 0, t.ts) == ("answer", True, traces[0].ts) + + @pytest.mark.unit def test_without_a_brain_reply_is_an_error(): async def body(url): @@ -337,15 +363,16 @@ def test_presence_left_open_by_a_previous_run_is_closed_at_start(store): def test_traces_older_than_thirty_days_are_removed_at_start(store): import time now = time.time() - store.add_trace("voice", "vc1", "100", "old", "a", [], ms=1, ts=now - 31 * 86400) - store.add_trace("voice", "vc1", "100", "new", "a", [], ms=1, ts=now - 29 * 86400) + store.finish_trace(store.start_trace("voice", "vc1", "100", "old", ts=now - 31 * 86400), "a", [], ms=1) + store.finish_trace(store.start_trace("voice", "vc1", "100", "new", ts=now - 29 * 86400), "a", [], ms=1) + store.start_trace("voice", "vc1", "100", "cut off", ts=now - 60) # a killed run never finished it async def body(url): async with connect(url) as ws: await hello(ws) asyncio.run(with_worker(body, store=store)) - assert [t.question for t in store.traces_of("100")] == ["new"] + assert [(t.question, t.ms >= 0) for t in store.traces_of("100")] == [("new", True), ("cut off", True)] @pytest.mark.unit