project-lyra/lyra/chat.py

"""The chat turn loop: persona + tiered memory + recent context -> reply.

Context is assembled in tiers (oldest/most-compacted first):
  1. persona
  2. long-term gist  — relevant *summaries* of other sessions
  3. sharp details   — a few raw cross-session exchanges (so specifics survive)
  4. recent raw turns of the current session (full fidelity)
  5. the new user message
After replying, the session is compacted if enough new turns have accumulated.
"""
from __future__ import annotations

from lyra import clock, config, llm, logbus, memory, persona, self_state, summary
from lyra.llm import Backend, Message

RECALL_K = 3  # raw cross-session "sharp detail" hits
RECENT_N = 10  # raw turns of the current session
SUMMARY_K = 3  # other-session gists


def _summary_note(summaries: list[memory.Summary]) -> Message:
    lines = [f"- ({s.created_at[:10]}) {s.content}" for s in summaries]
    body = "Gist of earlier sessions (compacted — ask if you need specifics):\n" + "\n".join(lines)
    return {"role": "system", "content": body}


def _detail_note(exchanges: list[memory.Exchange]) -> Message:
    lines = [f"- ({ex.created_at[:10]}, {ex.role}) {ex.content}" for ex in exchanges]
    body = "Specific things you recall from past conversations:\n" + "\n".join(lines)
    return {"role": "system", "content": body}


def _now_note() -> Message:
    """Current wall-clock time + how long since Brian last said anything.

    Stated as plain fact — she has no clock otherwise, so without this 'now' and
    the gap since the last turn are invisible to her.
    """
    line = f"The current date and time is {clock.stamp()}."
    gap = clock.humanize_gap(memory.last_exchange_at())
    line += (
        f" It has been {gap} since Brian last spoke with you."
        if gap else " This is the first thing Brian has ever said to you."
    )
    return {"role": "system", "content": line}


def _render(messages: list[Message]) -> str:
    """Human-readable dump of the exact prompt, for the live-log inspector."""
    return "\n\n".join(f"[{m['role']}]\n{m['content']}" for m in messages)


def build_messages(session_id: str, user_msg: str) -> list[Message]:
    """Assemble the full, tiered message list for one turn."""
    messages: list[Message] = [{"role": "system", "content": persona.system_prompt()}]

    # Autonomy Core: Lyra's own evolving interiority (mood, self-narrative). Comes
    # right after the persona — her sense of self before her model of the world.
    messages.append({"role": "system", "content": self_state.render_for_context(self_state.load())})

    # When she is: current time + the gap since Brian last spoke (she has no clock).
    messages.append(_now_note())

    # Semantic memory: the distilled profile (who Brian is) — answers identity
    # questions that raw recall can't. Always in context when it exists.
    profile = memory.get_profile()
    if profile:
        messages.append(
            {"role": "system", "content": "What you know about Brian:\n" + profile}
        )

    # Time-aware memory: the current narrative (recent arc, trends, callbacks).
    narrative = memory.get_narrative()
    if narrative:
        messages.append(
            {"role": "system", "content": "What's going on with Brian lately:\n" + narrative}
        )

    recent = memory.recent(session_id, n=RECENT_N)
    recent_ids = {ex.id for ex in recent}

    # Tier 1: compacted gists of *other* sessions (long-term, general idea).
    summaries = memory.recall_summaries(user_msg, k=SUMMARY_K, exclude_session=session_id)
    if summaries:
        messages.append(_summary_note(summaries))

    # Tier 2: a few sharp raw details from other sessions (so specifics survive
    # compaction). Skip the current session (its raw turns are in `recent`).
    recalled = [
        ex for ex in memory.recall(user_msg, k=RECALL_K)
        if ex.id not in recent_ids and ex.session_id != session_id
    ]
    if recalled:
        messages.append(_detail_note(recalled))

    # Tier 3: current session, full fidelity.
    for ex in recent:
        messages.append({"role": ex.role, "content": ex.content})

    messages.append({"role": "user", "content": user_msg})

    logbus.log(
        "debug", "context built",
        recent=len(recent), summaries=len(summaries), details=len(recalled),
        chars=sum(len(m["content"]) for m in messages), detail=_render(messages),
    )
    return messages


def respond(session_id: str, user_msg: str, backend: Backend = "cloud") -> str:
    """Produce Lyra's reply to a single user message and persist the exchange."""
    cfg = config.load()
    # Live chat uses the stronger chat_model on cloud (bulk consolidation keeps
    # cloud_model). local/mi50 use their own configured model.
    model = {"local": cfg.local_model, "cloud": cfg.chat_model, "mi50": cfg.mi50_model}.get(
        backend, backend
    )
    logbus.log(
        "info", "chat request", session=session_id, backend=backend,
        model=model, embed=cfg.embed_backend,
    )

    messages = build_messages(session_id, user_msg)
    reply = llm.complete(messages, backend=backend, model=model)
    logbus.log("info", "reply", session=session_id, chars=len(reply))

    memory.remember(session_id, "user", user_msg)
    memory.remember(session_id, "assistant", reply)

    # Compact this session once enough new turns have piled up.
    summary.maybe_summarize(session_id)
    return reply