- compact_prompt: the v2 persona in a tenth of v1's words, answers as short as possible, the full tool guidance only on turns with a data tool. A greeting's reply prompt went from about 4,500 to 1,400 tokens on Strata. - intent_judge: the tool router judges whether the turn needs tools; the planner runs only when it does. prepare_intent runs the pick ahead on a partial transcript (worker message prepare), and the reply reuses it. - Without stream_browser the screen-share tools are not offered. - The time context carries the 12-hour form (10:37 was read as pm). - A <tool_call> block written as the reply is parsed as a call, not spoken. Evals (Qwen3.6 on Strata, EVAL_COMPACT_PROMPT=1 EVAL_INTENT_JUDGE=1): 221 passed, 4 failed (known failures); new evals/test_voice_reply_length.py (v2 answers 234 chars against v1's 416) and test_reply_language_default.py. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
247 lines
11 KiB
Python
247 lines
11 KiB
Python
"""The brain the voice worker hosts: memory settings and the jarvis reply engine behind a small
|
|
interface, so the worker logic is tested with a fake (voice_worker.spec.md, "History and brain")."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import dataclasses
|
|
import difflib
|
|
import sys
|
|
import unicodedata
|
|
import threading
|
|
import time
|
|
from dataclasses import dataclass
|
|
from typing import Optional, Protocol
|
|
|
|
from .log import debug_log
|
|
from jarvis.memory.history import HistoryContext, Scope
|
|
|
|
|
|
class Brain(Protocol):
|
|
def reply(self, user: str, text: str, history: HistoryContext, chat=None) -> Optional[str]:
|
|
"""Blocking; called on a worker thread, one call per person at a time (a voice and a chat
|
|
reply for different people may overlap). ``chat``: the chat backend for
|
|
the chatChannels tool (voice_worker/chat_bridge.py), or None without registered channels."""
|
|
|
|
def addressed(self, user: str, text: str, names: list[str]) -> Optional[bool]:
|
|
"""Blocking: was ``text`` said to the assistant (called ``names``)? None when it could not tell.
|
|
Runs on its own thread, also while a reply runs."""
|
|
|
|
def rank(self, candidates: list[dict]) -> Optional[list[str]]:
|
|
"""Blocking: candidate ids (``{"id", "user", "text"}``) most important first; None on failure.
|
|
Runs on its own thread, also while a reply runs."""
|
|
|
|
def prepare(self, user: str, text: str, chat: bool) -> None:
|
|
"""Blocking: get ready to answer ``text`` (a partial transcript of a call still being said),
|
|
so the reply to about the same text starts further along. ``chat``: chat channels are
|
|
registered. Runs on its own thread, also while a reply runs. Optional."""
|
|
|
|
|
|
@dataclass
|
|
class MemorySettings:
|
|
chat: bool = True
|
|
others: bool = True
|
|
off: bool = False
|
|
since_days: Optional[float] = None
|
|
recent_minutes: float = 30
|
|
recent_records: int = 20
|
|
matches: int = 5
|
|
budget_tokens: float = 4000
|
|
|
|
_BOOLS = ("chat", "others", "off")
|
|
_NUMBERS = {"recent_minutes": (0, 24 * 60), "recent_records": (0, 200), "matches": (0, 20),
|
|
"budget_tokens": (0, 100_000)}
|
|
|
|
def update(self, changes: dict) -> None:
|
|
"""Apply ``changes`` atomically; raises ValueError naming the first bad field."""
|
|
new = dict(self.__dict__)
|
|
for key, value in changes.items():
|
|
if key in self._BOOLS:
|
|
if not isinstance(value, bool):
|
|
raise ValueError(f"{key} must be true or false")
|
|
elif key == "since_days":
|
|
if value is not None and (isinstance(value, bool) or not isinstance(value, (int, float))
|
|
or value <= 0):
|
|
raise ValueError("since_days must be a positive number or null")
|
|
elif key in self._NUMBERS:
|
|
lo, hi = self._NUMBERS[key]
|
|
if isinstance(value, bool) or not isinstance(value, (int, float)) or not lo <= value <= hi:
|
|
raise ValueError(f"{key} must be a number from {lo} to {hi}")
|
|
if key in ("recent_records", "matches"):
|
|
value = int(value)
|
|
else:
|
|
raise ValueError(f"unknown memory setting: {key}")
|
|
new[key] = value
|
|
self.__dict__.update(new)
|
|
|
|
def scope(self, now: float) -> Scope:
|
|
since = now - self.since_days * 86400 if self.since_days else None
|
|
return Scope(chat=self.chat, others=self.others, since=since, off=self.off)
|
|
|
|
|
|
class Muted:
|
|
"""Stand-in for sys.stdout/sys.stderr that drops every write while a brain reply runs.
|
|
|
|
The v1 reply engine and its tools print the question, the answer, tool arguments, URLs and
|
|
memory snippets (``print`` and ``debug_log``, also from helper threads such as the web fetch
|
|
pool); the worker's logs must never carry such text. Replies may overlap (a voice and a chat
|
|
lane); output stays muted while any of them runs. The worker's own log (``voice_worker.log``)
|
|
writes to the original stderr and is not muted.
|
|
"""
|
|
|
|
_lock = threading.Lock()
|
|
_depth = 0
|
|
|
|
def __init__(self, target):
|
|
self._target = target
|
|
|
|
def write(self, data):
|
|
if Muted._depth:
|
|
return len(data)
|
|
return self._target.write(data)
|
|
|
|
def __getattr__(self, name):
|
|
return getattr(self._target, name)
|
|
|
|
@classmethod
|
|
def run(cls, fn, *args, **kwargs):
|
|
with cls._lock:
|
|
for name in ("stdout", "stderr"):
|
|
stream = getattr(sys, name)
|
|
if not isinstance(stream, cls):
|
|
setattr(sys, name, cls(stream))
|
|
cls._depth += 1
|
|
try:
|
|
return fn(*args, **kwargs)
|
|
finally:
|
|
with cls._lock:
|
|
cls._depth -= 1
|
|
|
|
|
|
# A prepared intent is used for a reply whose text is at least this close to the text it was
|
|
# prepared for (letters and digits only): the last partial often lacks a final syllable or two.
|
|
PREPARED_SIMILARITY = 0.85
|
|
# ... and only this soon after it was prepared, and at most this long is waited for one in flight.
|
|
PREPARED_MAX_AGE_S = 30.0
|
|
PREPARED_WAIT_S = 5.0
|
|
|
|
|
|
def _letters(text: str) -> str:
|
|
return "".join(c for c in unicodedata.normalize("NFKD", text.lower()) if c.isalnum())
|
|
|
|
|
|
def similar(a: str, b: str) -> bool:
|
|
x, y = _letters(a), _letters(b)
|
|
return bool(x and y) and difflib.SequenceMatcher(None, x, y).ratio() >= PREPARED_SIMILARITY
|
|
|
|
|
|
@dataclass
|
|
class _Prepared:
|
|
text: str
|
|
turns: int # the asker's dialogue memory size it was made with
|
|
at: float
|
|
done: threading.Event = dataclasses.field(default_factory=threading.Event)
|
|
tools: Optional[list] = None # the intent judge's pick; None: none made
|
|
|
|
|
|
class JarvisBrain:
|
|
"""The existing jarvis reply engine with the user's history context.
|
|
|
|
Uses the jarvis settings (``ollama_base_url`` is Strata's ``/v1`` in v2) and its database for
|
|
the long-term memory it already keeps. Each user has their own short-term dialogue memory so
|
|
tool carry-over follows the person who asked.
|
|
"""
|
|
|
|
def __init__(self, language: Optional[str] = "ko", reply_language: Optional[str] = "Korean"):
|
|
from jarvis.config import load_settings
|
|
from jarvis.memory.db import Database
|
|
|
|
# v1's tts_engine names the v1 desktop voice (English-only Piper by default), which makes the
|
|
# engine lock replies to English. v2 speaks through the worker's TTS and chat answers are
|
|
# not spoken; the brain answers in ``reply_language`` (an OUTPUT_LANGUAGE lock still wins).
|
|
# stream_browser: v1's screen-share browser (controlBrowser, browseAndPlay, setBroadcast and
|
|
# browser-first web search) needs v1's Node bot; v2 has no on-screen browser until M6.
|
|
self.cfg = dataclasses.replace(load_settings(), tts_engine="melo", stream_browser=False)
|
|
self.db = Database(self.cfg.db_path, self.cfg.sqlite_vss_path)
|
|
# ``language``: the ISO code tools get (e.g. the Wikipedia host); ``reply_language``: replies
|
|
# come in it unless the asker explicitly asks for another language (None: the asker's).
|
|
self.language = language
|
|
self.reply_language = reply_language
|
|
self._memories: dict = {}
|
|
self._prepared: dict[str, _Prepared] = {}
|
|
self._lock = threading.Lock()
|
|
debug_log(f"brain ready: llm={self.cfg.ollama_base_url} model={self.cfg.ollama_chat_model}", "voice_worker")
|
|
|
|
def _memory(self, user: str):
|
|
from jarvis.memory.conversation import DialogueMemory
|
|
|
|
with self._lock:
|
|
mem = self._memories.get(user)
|
|
if mem is None:
|
|
mem = DialogueMemory(inactivity_timeout=self.cfg.dialogue_memory_timeout, max_interactions=20)
|
|
self._memories[user] = mem
|
|
return mem
|
|
|
|
@staticmethod
|
|
def _turns(mem) -> int:
|
|
return len(mem.get_recent_messages()) if mem.has_recent_messages() else 0
|
|
|
|
def prepare(self, user: str, text: str, chat: bool) -> None:
|
|
from jarvis.reply.engine import prepare_intent
|
|
|
|
mem = self._memory(user)
|
|
p = _Prepared(text=text, turns=self._turns(mem), at=time.monotonic())
|
|
with self._lock:
|
|
self._prepared[user] = p
|
|
t0 = time.perf_counter()
|
|
try:
|
|
p.tools = Muted.run(prepare_intent, self.cfg, text, mem, chat)
|
|
finally:
|
|
p.done.set()
|
|
debug_log(f"brain prepare user={user} picked={p.tools is not None} "
|
|
f"ms={(time.perf_counter() - t0) * 1000:.0f}", "voice_worker")
|
|
|
|
def _prepared_tools(self, user: str, text: str) -> Optional[list]:
|
|
"""The pick prepared for about this text, waiting for one still being made; None if none fits."""
|
|
with self._lock:
|
|
p = self._prepared.pop(user, None)
|
|
if p is None or not similar(p.text, text) or time.monotonic() - p.at > PREPARED_MAX_AGE_S:
|
|
return None
|
|
if not p.done.wait(PREPARED_WAIT_S) or p.turns != self._turns(self._memory(user)):
|
|
return None
|
|
return p.tools
|
|
|
|
def reply(self, user: str, text: str, history: HistoryContext, chat=None) -> Optional[str]:
|
|
from jarvis.reply import turn_state
|
|
from jarvis.reply.engine import run_reply_engine
|
|
|
|
t0 = time.perf_counter()
|
|
prepared = self._prepared_tools(user, text)
|
|
# legacy_memory=False: v1's profile, diary and graph belong to one user; several people
|
|
# share this assistant, so only the asker's scoped history may reach the prompt.
|
|
def turn():
|
|
# Tools with personal data (meals) read the asker from the turn state.
|
|
turn_state.reset()
|
|
turn_state.set_user(user)
|
|
turn_state.set_chat(chat)
|
|
try:
|
|
return run_reply_engine(self.db, self.cfg, None, text, self._memory(user),
|
|
language=self.language, history=history, legacy_memory=False,
|
|
default_language=self.reply_language, compact_prompt=True,
|
|
intent_judge=True, prepared_tools=prepared)
|
|
finally:
|
|
turn_state.reset()
|
|
|
|
answer = Muted.run(turn)
|
|
debug_log(f"brain reply user={user} ok={bool(answer)} prepared={prepared is not None} "
|
|
f"ms={(time.perf_counter() - t0) * 1000:.0f}", "voice_worker")
|
|
return answer
|
|
|
|
def addressed(self, user: str, text: str, names: list[str]) -> Optional[bool]:
|
|
from .judges import is_addressed
|
|
return is_addressed(self.cfg.ollama_base_url, self.cfg.ollama_chat_model, names, text)
|
|
|
|
def rank(self, candidates: list[dict]) -> Optional[list[str]]:
|
|
from .judges import rank_requests
|
|
order = rank_requests(self.cfg.ollama_base_url, self.cfg.ollama_chat_model, [c["text"] for c in candidates])
|
|
return None if order is None else [candidates[i]["id"] for i in order]
|