localgate 0.7.0__py3-none-any.whl

localgate/__init__.py

@@ -0,0 +1,8 @@
+"""localgate — a local-first API gateway for open-source LLMs.
+
+Adds authentication, RAG-powered memory extension, database connectors,
+and token accounting on top of any local inference backend
+(Ollama, llama.cpp, vLLM).
+"""
+
+__version__ = "0.7.0"

localgate/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for `python -m localgate`."""
+
+from localgate.cli import app
+
+if __name__ == "__main__":
+    app()

localgate/agent/__init__.py

@@ -0,0 +1,8 @@
+"""``localgate code`` — a minimal agentic coding loop over a chat-completions backend.
+
+This is deliberately small: three filesystem tools (`agent.tools`) and a loop that
+feeds tool calls back to the model until it answers in plain text (`agent.loop`).
+See CODING_AGENT_PLAN.md for what this is a first step toward.
+"""
+
+from __future__ import annotations

localgate/agent/gitutil.py

@@ -0,0 +1,104 @@
+"""Minimal git plumbing for the coding agent's safety net.
+
+Shells out to the ``git`` binary rather than adding a dependency like GitPython —
+these are a handful of read-only or trivially-reversible commands, not a reason to
+carry a whole library. Every write here (`commit_all`, `checkout_file`,
+`reset_hard_last`) exists to make an agent's mistake a five-second `git` command
+away from undone, per CODING_AGENT_PLAN.md's git-aware safety net.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+#: Commit messages the agent makes are prefixed with this, so `/undo` can refuse
+#: to `reset --hard` a commit a human made themselves.
+AGENT_COMMIT_PREFIX = "localgate-agent:"
+
+
+class GitError(RuntimeError):
+    """A git command exited non-zero, or git isn't installed."""
+
+
+def _run(root: Path, *args: str) -> str:
+    try:
+        result = subprocess.run(
+            ["git", *args], cwd=root, capture_output=True, text=True, check=False
+        )
+    except FileNotFoundError as exc:
+        raise GitError("git is not installed or not on PATH") from exc
+    if result.returncode != 0:
+        message = result.stderr.strip() or result.stdout.strip() or f"git {' '.join(args)} failed"
+        raise GitError(message)
+    return result.stdout
+
+
+def is_repo(root: Path) -> bool:
+    try:
+        return _run(root, "rev-parse", "--is-inside-work-tree").strip() == "true"
+    except GitError:
+        return False
+
+
+def is_dirty(root: Path) -> bool:
+    return bool(_run(root, "status", "--porcelain").strip())
+
+
+def status(root: Path) -> str:
+    return _run(root, "status", "--porcelain")
+
+
+def diff(root: Path, path: str | None = None) -> str:
+    args = ["diff"] if path is None else ["diff", "--", path]
+    return _run(root, *args)
+
+
+def last_commit_message(root: Path) -> str | None:
+    try:
+        return _run(root, "log", "-1", "--format=%s").strip()
+    except GitError:
+        return None  # no commits yet
+
+
+def commit_all(root: Path, message: str) -> bool:
+    """Stage and commit everything. Returns False if there was nothing to commit."""
+    _run(root, "add", "-A")
+    try:
+        _run(root, "commit", "-m", message)
+    except GitError as exc:
+        if "nothing to commit" in str(exc):
+            return False
+        raise
+    return True
+
+
+def checkout_file(root: Path, path: str) -> None:
+    """Restore ``path`` to its state in the last commit, discarding local edits."""
+    _run(root, "checkout", "--", path)
+
+
+def reset_hard_last(root: Path) -> None:
+    """Drop the last commit and its changes entirely. Irreversible past this point."""
+    _run(root, "reset", "--hard", "HEAD~1")
+
+
+def file_is_untracked(root: Path, path: str) -> bool:
+    """True if ``path`` has never been committed (a plain `checkout --` can't undo it)."""
+    porcelain = _run(root, "status", "--porcelain", "--", path)
+    return porcelain.startswith("??")
+
+
+def undo_file(root: Path, path: str) -> str:
+    """Best-effort undo of the most recent write to ``path``.
+
+    A brand-new file has nothing to check out back to, so undoing it means
+    deleting it; anything else reverts to the last commit.
+    """
+    if file_is_untracked(root, path):
+        target = root / path
+        if target.exists():
+            target.unlink()
+        return f"Deleted newly created {path} (it was never committed)."
+    checkout_file(root, path)
+    return f"Reverted {path} to its last committed version."

localgate/agent/ignore.py

@@ -0,0 +1,66 @@
+"""A minimal `.gitignore`-style pattern matcher for `.gitignore` and
+`.localgateignore`.
+
+This is a deliberate subset, not a full implementation: `*`, `**`, `?`, a leading
+`/` to anchor at the root, and a trailing `/` for directory-only patterns are all
+supported; negation (`!pattern`) is not — a negation line is simply skipped, which
+means it's ignored, and everything it would have un-ignored stays covered by
+whatever pattern matched it. That is the safe direction to be wrong in for a tool
+whose whole job is keeping secrets out of the model's hands: under-ignoring would
+leak a file, over-ignoring only costs the model a read it didn't get to make.
+
+The `.git` directory is always excluded, regardless of what's in either ignore
+file — there is no legitimate reason for the agent to read `.git/config` or
+`.git/objects`.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+_ALWAYS_IGNORED_DIRS = frozenset({".git"})
+
+
+def _pattern_to_regex(pattern: str) -> re.Pattern[str]:
+    # A trailing "/" restricts a real gitignore pattern to directories, but either
+    # way a match on a directory also covers everything under it — so the two
+    # cases only differ in a distinction (file vs. directory) this matcher
+    # doesn't track. Both are treated the same: match the entry itself, or
+    # anything nested below it.
+    body = pattern.rstrip("/")
+    anchored = body.startswith("/")
+    body = body.lstrip("/")
+
+    # Escape everything, then re-expand the glob metacharacters we support.
+    # A NUL placeholder for "**" survives re.escape and single-"*" expansion
+    # untouched, since NUL never appears in a real pattern.
+    escaped = re.escape(body).replace(r"\*\*", "\0").replace(r"\*", "[^/]*")
+    escaped = escaped.replace(r"\?", "[^/]").replace("\0", ".*")
+
+    prefix = "^" if anchored else "(^|.*/)"
+    return re.compile(prefix + escaped + "(/.*)?$")
+
+
+def load_patterns(root: Path) -> list[re.Pattern[str]]:
+    """Read `.gitignore` and `.localgateignore` from ``root``, if present."""
+    patterns: list[re.Pattern[str]] = []
+    for filename in (".gitignore", ".localgateignore"):
+        ignore_file = root / filename
+        if not ignore_file.is_file():
+            continue
+        for raw_line in ignore_file.read_text(encoding="utf-8", errors="replace").splitlines():
+            line = raw_line.strip()
+            if not line or line.startswith("#") or line.startswith("!"):
+                continue
+            patterns.append(_pattern_to_regex(line))
+    return patterns
+
+
+def is_ignored(root: Path, path: Path, patterns: list[re.Pattern[str]]) -> bool:
+    """Whether ``path`` (absolute, inside ``root``) is excluded from the agent's view."""
+    relative = path.relative_to(root)
+    if _ALWAYS_IGNORED_DIRS.intersection(relative.parts):
+        return True
+    rel_posix = relative.as_posix()
+    return any(pattern.match(rel_posix) for pattern in patterns)

localgate/agent/loop.py

@@ -0,0 +1,322 @@
+"""The agent's turn loop: ask the model, run any tool calls, feed results back, repeat.
+
+This talks to an :class:`~localgate.backends.base.InferenceBackend` directly rather
+than over HTTP — the same pattern ``cli.py`` already uses for ``localgate health``.
+That sidesteps API-key management entirely for what is, for now, a local dev tool
+running on the same machine as the backend.
+
+:class:`AgentSession` holds the conversation and runs it turn by turn, so the REPL
+can keep one session alive across many user inputs. :func:`run_agent` is a thin
+convenience wrapper around a single-turn session, used by the single-shot
+``localgate code "task"`` invocation.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import uuid
+from collections.abc import Awaitable, Callable
+from pathlib import Path
+from typing import Any
+
+from localgate.agent.tools import TOOL_SCHEMAS, ToolCallResult, execute_tool_call
+from localgate.backends.base import InferenceBackend
+
+SYSTEM_PROMPT = (
+    "You are a coding assistant working directly in the user's project directory. "
+    "Use the available tools to inspect and modify the project as needed to complete "
+    "the user's task. Prefer reading a file before overwriting it. When you are done, "
+    "reply with plain text summarizing what you did — do not call a tool in the same "
+    "turn as your final summary. If you cannot use structured tool calls, respond with "
+    'a single JSON object of the form {"name": "<tool>", "arguments": {...}} and '
+    "nothing else — no prose, no markdown fence."
+)
+
+#: Some models (observed live with qwen2.5-coder via Ollama's OpenAI-compat shim)
+#: never populate `tool_calls` at all — they print the tool call as plain-text JSON
+#: in `content` instead, despite advertising tool-calling support. `_FENCE_RE` and
+#: `_TAG_RE` strip the wrappers some other models use for the same failure mode: a
+#: markdown code fence, or some fine-tune-specific XML tag. `_TAG_RE` matches any
+#: single wrapping tag by name (`<tool_call>`, `<tool_request>`, ...) rather than
+#: one hardcoded name — the same model was observed emitting both across
+#: otherwise-identical live requests, so a fixed tag name isn't reliable.
+_FENCE_RE = re.compile(r"^```(?:json)?\s*\n?(.*?)\n?```$", re.DOTALL)
+_TAG_RE = re.compile(r"^<(\w+)>\s*(.*?)\s*</\1>$", re.DOTALL)
+
+
+def _strip_wrapper(text: str) -> str:
+    """Peel off one layer of fence and/or tag wrapping, in either order/nesting."""
+    text = text.strip()
+    for _ in range(2):  # a fence-around-a-tag or tag-around-a-fence is one pass each
+        fence_match = _FENCE_RE.match(text)
+        if fence_match:
+            text = fence_match.group(1).strip()
+            continue
+        tag_match = _TAG_RE.match(text)
+        if tag_match:
+            text = tag_match.group(2).strip()
+            continue
+        break
+    return text
+
+
+def _as_synthetic_tool_call(content: str, known_names: frozenset[str]) -> dict[str, Any] | None:
+    """If ``content`` is *only* a disguised tool call, return it in the same shape
+    a real ``tool_calls`` entry has. Otherwise return ``None`` — a final answer
+    that happens to contain JSON (e.g. showing the user a config file) must not
+    be misread as an action the model didn't actually request.
+
+    The whole-string parse is itself the main guard: JSON embedded partway
+    through prose fails ``json.loads`` on the full string and falls through here
+    to a real answer, rather than requiring separate prose-detection logic.
+    """
+    cleaned = _strip_wrapper(content)
+    try:
+        parsed = json.loads(cleaned)
+    except json.JSONDecodeError:
+        return None
+    if not isinstance(parsed, dict):
+        return None
+
+    name = parsed.get("name")
+    arguments: Any = parsed.get("arguments")
+    if not isinstance(name, str):
+        function = parsed.get("function")
+        if isinstance(function, dict):
+            name = function.get("name")
+            arguments = function.get("arguments")
+    if not isinstance(name, str) or name not in known_names:
+        return None
+
+    if isinstance(arguments, dict):
+        arguments_json = json.dumps(arguments)
+    elif isinstance(arguments, str):
+        try:
+            if not isinstance(json.loads(arguments), dict):
+                return None
+        except json.JSONDecodeError:
+            return None
+        arguments_json = arguments
+    else:
+        return None
+
+    return {
+        "id": f"synthetic-{uuid.uuid4().hex[:8]}",
+        "type": "function",
+        "function": {"name": name, "arguments": arguments_json},
+    }
+
+
+class AgentTurnLimitExceeded(RuntimeError):
+    """Raised when the model keeps calling tools without ever finishing a turn."""
+
+
+#: Called before a write_file call actually runs: (path, new_content) -> proceed?
+ConfirmWrite = Callable[[str, str], bool]
+#: Called with a short human-readable line as each tool call happens.
+OnEvent = Callable[[str], None]
+#: Called with each streamed text fragment as the model produces it.
+OnToken = Callable[[str], None]
+#: Executes one tool call. Same shape as `tools.execute_tool_call`; Phase 3's
+#: expanded tool set plugs in here without AgentSession needing to change.
+ToolExecutor = Callable[[Path, str, str, dict[str, Any]], ToolCallResult]
+#: Rewrites the outgoing message list for one payload — e.g. injecting recalled
+#: memory — without mutating the session's own history. Called fresh before every
+#: backend call, same request-scoped augmentation `chat.py` does per HTTP call.
+Augment = Callable[[list[dict[str, Any]]], Awaitable[list[dict[str, Any]]]]
+
+
+def _parse_arguments(raw: str) -> dict[str, Any]:
+    try:
+        parsed = json.loads(raw) if raw else {}
+    except json.JSONDecodeError:
+        return {}
+    return parsed if isinstance(parsed, dict) else {}
+
+
+async def _stream_completion(
+    backend: InferenceBackend, payload: dict[str, Any], on_token: OnToken
+) -> dict[str, Any]:
+    """Consume a streamed chat completion and reassemble it into one message.
+
+    OpenAI-shaped tool-call deltas arrive fragment by fragment, keyed by index —
+    the id and function name are usually whole in the first fragment, but
+    `arguments` is typically streamed character by character and must be
+    concatenated, not replaced.
+    """
+    content_parts: list[str] = []
+    tool_calls: dict[int, dict[str, Any]] = {}
+
+    async for chunk in backend.chat_stream(payload):
+        choices = chunk.get("choices") or []
+        if not choices:
+            continue
+        delta = choices[0].get("delta") or {}
+
+        text = delta.get("content")
+        if text:
+            content_parts.append(text)
+            on_token(text)
+
+        for tc_delta in delta.get("tool_calls") or []:
+            index = tc_delta.get("index", 0)
+            entry = tool_calls.setdefault(
+                index, {"id": "", "type": "function", "function": {"name": "", "arguments": ""}}
+            )
+            if tc_delta.get("id"):
+                entry["id"] = tc_delta["id"]
+            fn_delta = tc_delta.get("function") or {}
+            if fn_delta.get("name"):
+                entry["function"]["name"] += fn_delta["name"]
+            if fn_delta.get("arguments"):
+                entry["function"]["arguments"] += fn_delta["arguments"]
+
+    content = "".join(content_parts)
+    message: dict[str, Any] = {"role": "assistant", "content": content or None}
+    if tool_calls:
+        message["tool_calls"] = [tool_calls[i] for i in sorted(tool_calls)]
+    return message
+
+
+class AgentSession:
+    """One conversation with the model, across as many turns as the caller sends.
+
+    A fresh session starts with just the system prompt; each call to :meth:`send`
+    appends a user turn, runs the tool-call loop to completion, and returns the
+    model's final text. History accumulates in ``self.messages`` until :meth:`reset`.
+    """
+
+    def __init__(
+        self,
+        backend: InferenceBackend,
+        model: str,
+        root: Path,
+        *,
+        confirm_write: ConfirmWrite | None = None,
+        on_event: OnEvent | None = None,
+        on_token: OnToken | None = None,
+        max_turns: int = 20,
+        tool_schemas: list[dict[str, Any]] | None = None,
+        tool_executor: ToolExecutor | None = None,
+        augment: Augment | None = None,
+    ) -> None:
+        self.backend = backend
+        self.model = model
+        self.root = root
+        self.confirm_write = confirm_write
+        self.on_event = on_event
+        self.on_token = on_token
+        self.max_turns = max_turns
+        self.tool_schemas = tool_schemas if tool_schemas is not None else TOOL_SCHEMAS
+        self.tool_executor = tool_executor if tool_executor is not None else execute_tool_call
+        self.augment = augment
+        self._known_tool_names = frozenset(s["function"]["name"] for s in self.tool_schemas)
+        self.messages: list[dict[str, Any]] = [{"role": "system", "content": SYSTEM_PROMPT}]
+
+    def reset(self) -> None:
+        """Drop history, starting a new conversation in the same session."""
+        self.messages = [{"role": "system", "content": SYSTEM_PROMPT}]
+
+    async def send(self, user_input: str) -> str:
+        """Run one user turn to completion and return the model's final reply."""
+        self.messages.append({"role": "user", "content": user_input})
+
+        for _ in range(self.max_turns):
+            outgoing = await self.augment(self.messages) if self.augment else self.messages
+            payload = {"model": self.model, "messages": outgoing, "tools": self.tool_schemas}
+            if self.on_token is not None:
+                message = await _stream_completion(self.backend, payload, self.on_token)
+            else:
+                response = await self.backend.chat(payload)
+                message = response["choices"][0]["message"]
+
+            tool_calls = message.get("tool_calls") or []
+            if not tool_calls and message.get("content"):
+                synthetic = _as_synthetic_tool_call(message["content"], self._known_tool_names)
+                if synthetic is not None:
+                    if self.on_event is not None:
+                        self.on_event(
+                            f"(model isn't using structured tool calls — "
+                            f"parsed {synthetic['function']['name']} from plain text)"
+                        )
+                    message = {"role": "assistant", "content": None, "tool_calls": [synthetic]}
+                    tool_calls = [synthetic]
+
+            self.messages.append(message)
+
+            if not tool_calls:
+                return message.get("content") or ""
+
+            for call in tool_calls:
+                self.messages.append(await self._run_tool_call(call))
+
+        raise AgentTurnLimitExceeded(
+            f"Stopped after {self.max_turns} turns without a final answer — "
+            "the model may be looping."
+        )
+
+    async def _run_tool_call(self, call: dict[str, Any]) -> dict[str, Any]:
+        fn = call["function"]
+        name = fn["name"]
+        arguments = _parse_arguments(fn.get("arguments", ""))
+
+        if name == "write_file" and self.confirm_write is not None:
+            path = arguments.get("path", "?")
+            if not self.confirm_write(path, arguments.get("content", "")):
+                return {
+                    "role": "tool",
+                    "tool_call_id": call["id"],
+                    "name": name,
+                    "content": f"User declined to write {path}. Ask before trying again.",
+                }
+
+        if self.on_event is not None:
+            args_repr = ", ".join(f"{k}={v!r}" for k, v in _summarize(arguments).items())
+            self.on_event(f"{name}({args_repr})")
+
+        result = self.tool_executor(self.root, call["id"], name, arguments)
+        return {
+            "role": "tool",
+            "tool_call_id": result.tool_call_id,
+            "name": result.name,
+            "content": result.content,
+        }
+
+
+async def run_agent(
+    backend: InferenceBackend,
+    model: str,
+    root: Path,
+    task: str,
+    *,
+    confirm_write: ConfirmWrite | None = None,
+    on_event: OnEvent | None = None,
+    on_token: OnToken | None = None,
+    max_turns: int = 20,
+    augment: Augment | None = None,
+) -> str:
+    """Run one task to completion and return the model's final plain-text reply.
+
+    A convenience wrapper around a single-turn :class:`AgentSession`, for the
+    single-shot ``localgate code "task"`` invocation.
+    """
+    session = AgentSession(
+        backend,
+        model,
+        root,
+        confirm_write=confirm_write,
+        on_event=on_event,
+        on_token=on_token,
+        max_turns=max_turns,
+        augment=augment,
+    )
+    return await session.send(task)
+
+
+def _summarize(arguments: dict[str, Any]) -> dict[str, Any]:
+    """Truncate long values (e.g. file content) so status lines stay one line."""
+    return {
+        k: (v if not isinstance(v, str) or len(v) <= 40 else v[:37] + "...")
+        for k, v in arguments.items()
+    }

localgate/agent/memory.py

@@ -0,0 +1,149 @@
+"""Wires the coding agent into the same conversation-history and RAG-memory
+tables the HTTP `/v1/chat/completions` endpoint uses, so a coding session
+survives across `localgate code` invocations the way an API client's
+`X-Session-Id` does — retrievable later via the same `ConversationRepository`
+`GET /v1/conversations/{session_id}` reads from.
+
+The CLI talks to the backend directly, bypassing HTTP and API-key auth entirely
+(see loop.py's module docstring) — but the conversation/memory tables have a
+``NOT NULL`` ``api_key_id`` foreign key. Rather than relax that constraint for
+every caller, this module provisions one dedicated, reusable ``APIKey`` row to
+own local CLI sessions; its raw key is discarded immediately since it's never
+used to authenticate anything, only to satisfy the foreign key.
+"""
+
+from __future__ import annotations
+
+import uuid
+from pathlib import Path
+
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from localgate.backends.base import InferenceBackend
+from localgate.config import Settings
+from localgate.core.types import ChatMessage
+from localgate.db.repositories.conversations import ConversationRepository, SummaryRepository
+from localgate.db.repositories.embeddings import EmbeddingRepository
+from localgate.db.repositories.keys import APIKeyRepository
+from localgate.memory.chunker import chunk_text
+from localgate.memory.context_builder import build_augmented_messages
+from localgate.memory.embedder import embed_text
+from localgate.memory.retriever import retrieve_relevant_context
+from localgate.memory.summarizer import maybe_summarize
+
+#: The one APIKey row every local `localgate code` session's history is attributed
+#: to. Never sent anywhere as a credential.
+LOCAL_AGENT_KEY_NAME = "localgate-code (local)"
+
+_SESSION_MARKER_DIR = ".localgate"
+_SESSION_MARKER_FILE = "session_id"
+
+
+def project_session_id(root: Path) -> str:
+    """A session id for this project directory, minted once and reused.
+
+    Persisted at ``.localgate/session_id`` so re-running ``localgate code`` in the
+    same project resumes the same memory context automatically, per
+    CODING_AGENT_PLAN.md Phase 5.
+    """
+    marker = root / _SESSION_MARKER_DIR / _SESSION_MARKER_FILE
+    if marker.is_file():
+        existing = marker.read_text(encoding="utf-8").strip()
+        if existing:
+            return existing
+    session_id = str(uuid.uuid4())
+    marker.parent.mkdir(parents=True, exist_ok=True)
+    marker.write_text(session_id + "\n", encoding="utf-8")
+    return session_id
+
+
+async def get_or_create_local_agent_key_id(session: AsyncSession, settings: Settings) -> str:
+    """The ``api_key_id`` local CLI sessions are attributed to."""
+    repo = APIKeyRepository(session)
+    for key in await repo.list_all():
+        if key.name == LOCAL_AGENT_KEY_NAME:
+            return key.id
+    key, _raw_key = await repo.create(LOCAL_AGENT_KEY_NAME, settings.default_rate_limit_per_min)
+    return key.id
+
+
+class AgentMemory:
+    """Per-session memory: injects recalled context into outgoing turns, and
+    records each turn into conversation history, chunked and embedded, with
+    rolling summarization — the same three steps `chat.py` performs per request.
+    """
+
+    def __init__(
+        self,
+        session_factory: async_sessionmaker[AsyncSession],
+        backend: InferenceBackend,
+        settings: Settings,
+        session_id: str,
+        api_key_id: str,
+    ) -> None:
+        self._session_factory = session_factory
+        self._backend = backend
+        self._settings = settings
+        self.session_id = session_id
+        self._api_key_id = api_key_id
+
+    async def augment(self, messages: list[dict]) -> list[dict]:
+        """Retrieve context relevant to the latest user turn and inject it as a
+        framed system message, without mutating the caller's own history — the
+        same request-scoped augmentation `chat.py` does, applied in-process.
+        """
+        if not self._settings.memory_enabled:
+            return messages
+        last_user = next((m for m in reversed(messages) if m.get("role") == "user"), None)
+        query = last_user.get("content") if last_user else None
+        if not isinstance(query, str) or not query:
+            return messages
+
+        async with self._session_factory() as db_session:
+            retrieved = await retrieve_relevant_context(
+                db_session,
+                self._backend,
+                self.session_id,
+                query,
+                self._settings.embedding_model,
+                top_k=self._settings.max_retrieved_chunks,
+                min_score=self._settings.memory_min_score,
+            )
+            summary = await SummaryRepository(db_session).latest(self.session_id)
+
+        if not retrieved and summary is None:
+            return messages
+
+        chat_messages = [ChatMessage(**m) for m in messages]
+        augmented = build_augmented_messages(
+            chat_messages, retrieved, summary.content if summary else None
+        )
+        return [m.model_dump(exclude_none=True) for m in augmented]
+
+    async def record_turn(self, user_text: str, assistant_text: str) -> None:
+        """Persist the turn, chunk and embed it, and fold it into the rolling
+        summary once the session has grown past `summarize_after_messages`.
+        """
+        async with self._session_factory() as db_session:
+            convo = ConversationRepository(db_session)
+            await convo.add_message(self.session_id, self._api_key_id, "user", user_text)
+            if assistant_text:
+                await convo.add_message(
+                    self.session_id, self._api_key_id, "assistant", assistant_text
+                )
+
+            if not self._settings.memory_enabled:
+                return
+
+            exchange = f"User: {user_text}\nAssistant: {assistant_text}"
+            chunks = chunk_text(exchange, self._settings.chunk_size, self._settings.chunk_overlap)
+            embeddings_repo = EmbeddingRepository(db_session)
+            for chunk in chunks:
+                vector = await embed_text(self._backend, chunk, self._settings.embedding_model)
+                await embeddings_repo.add_chunk(
+                    self.session_id, self._api_key_id, chunk, vector, kind="turn"
+                )
+
+            await maybe_summarize(
+                db_session, self._backend, self._settings, self.session_id, self._api_key_id
+            )