synapse-cli-agent 0.1.13__py3-none-any.whl

synapse/sessions/cancel_repair.py

@@ -0,0 +1,208 @@
+"""Keep multi-turn context continuous after user cancel (ESC).
+
+Hard-stopping astream can leave the LangGraph checkpoint with:
+- AIMessage.tool_calls without matching ToolMessage
+- pending ``next`` nodes (e.g. tools / model)
+
+The next user turn then fails or loses consistency. This module seals the
+cancelled turn so prior messages remain usable.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def _msg_type(msg: Any) -> str:
+    t = getattr(msg, "type", None)
+    if t:
+        return str(t).lower()
+    return type(msg).__name__.lower()
+
+
+def _is_tool_msg(msg: Any) -> bool:
+    return _msg_type(msg) in {"tool", "toolmessage"}
+
+
+def _is_ai_msg(msg: Any) -> bool:
+    return _msg_type(msg) in {"ai", "assistant", "aimessage"}
+
+
+def _is_human_msg(msg: Any) -> bool:
+    return _msg_type(msg) in {"human", "user", "humanmessage"}
+
+
+def _tool_call_id(call: Any) -> str | None:
+    if isinstance(call, dict):
+        cid = call.get("id")
+    else:
+        cid = getattr(call, "id", None)
+    return str(cid) if cid else None
+
+
+def _tool_call_name(call: Any) -> str:
+    if isinstance(call, dict):
+        name = call.get("name")
+    else:
+        name = getattr(call, "name", None)
+    return str(name or "tool")
+
+
+def _graph_nodes(agent: Any) -> set[str]:
+    nodes = getattr(agent, "nodes", None) or {}
+    try:
+        return set(nodes.keys())
+    except Exception:  # noqa: BLE001
+        return set()
+
+
+def _pick_tools_node(nodes: set[str], next_nodes: tuple[str, ...]) -> str | None:
+    for n in next_nodes:
+        if "tool" in n.lower():
+            return n
+    if "tools" in nodes:
+        return "tools"
+    for n in nodes:
+        if "tool" in n.lower() and not n.startswith("__"):
+            return n
+    return None
+
+
+def _pick_model_node(nodes: set[str], next_nodes: tuple[str, ...]) -> str | None:
+    for n in next_nodes:
+        low = n.lower()
+        if "tool" not in low and not n.startswith("__"):
+            return n
+    for preferred in ("model", "agent"):
+        if preferred in nodes:
+            return preferred
+    for n in nodes:
+        if not n.startswith("__") and "tool" not in n.lower() and "middleware" not in n.lower():
+            return n
+    return None
+
+
+def _answered_tool_ids(messages: list[Any]) -> set[str]:
+    done: set[str] = set()
+    for msg in messages:
+        if not _is_tool_msg(msg):
+            continue
+        tid = getattr(msg, "tool_call_id", None)
+        if tid:
+            done.add(str(tid))
+    return done
+
+
+def _pending_tool_seals(messages: list[Any]) -> list[Any]:
+    from langchain_core.messages import ToolMessage
+
+    answered = _answered_tool_ids(messages)
+    seals: list[Any] = []
+    for msg in messages:
+        for call in getattr(msg, "tool_calls", None) or []:
+            cid = _tool_call_id(call)
+            if not cid or cid in answered:
+                continue
+            seals.append(
+                ToolMessage(
+                    content="[cancelled by user]",
+                    tool_call_id=cid,
+                    name=_tool_call_name(call),
+                    status="error",
+                )
+            )
+            answered.add(cid)
+    return seals
+
+
+def _needs_cancel_note(messages: list[Any]) -> bool:
+    if not messages:
+        return False
+    last = messages[-1]
+    content = str(getattr(last, "content", "") or "")
+    low = content.casefold()
+    if _is_ai_msg(last) and not (getattr(last, "tool_calls", None) or []):
+        if "cancelled" in low or "终止" in content:
+            return False
+        # Plain AI reply already closed the turn.
+        if content.strip():
+            return False
+        return True
+    # Human without answer, tool without follow-up AI, or AI with open tools
+    # (tools should already be sealed before this check).
+    return True
+
+
+def repair_thread_after_cancel(agent: Any, config: dict[str, Any]) -> list[str]:
+    """Seal a cancelled turn so the same thread_id remains continuous.
+
+    Returns short status notes for logs/UI (never raises).
+    """
+    notes: list[str] = []
+    get_state = getattr(agent, "get_state", None)
+    update_state = getattr(agent, "update_state", None)
+    if not callable(get_state) or not callable(update_state):
+        return ["cancel seal skipped: agent has no get_state/update_state"]
+
+    try:
+        snap = get_state(config)
+    except Exception as exc:  # noqa: BLE001
+        return [f"cancel seal skipped: get_state failed: {exc}"]
+
+    values = getattr(snap, "values", None) or {}
+    messages = list(values.get("messages") or [])
+    if not messages:
+        return ["cancel seal: empty thread (nothing to preserve)"]
+
+    nodes = _graph_nodes(agent)
+    next_nodes = tuple(str(x) for x in (getattr(snap, "next", None) or ()))
+
+    try:
+        seals = _pending_tool_seals(messages)
+        if seals:
+            tools_node = _pick_tools_node(nodes, next_nodes)
+            if tools_node:
+                update_state(config, {"messages": seals}, as_node=tools_node)
+                notes.append(f"sealed {len(seals)} open tool call(s) as_node={tools_node}")
+            else:
+                update_state(config, {"messages": seals})
+                notes.append(f"sealed {len(seals)} open tool call(s)")
+            snap = get_state(config)
+            values = getattr(snap, "values", None) or {}
+            messages = list(values.get("messages") or [])
+            next_nodes = tuple(str(x) for x in (getattr(snap, "next", None) or ()))
+
+        if _needs_cancel_note(messages):
+            from langchain_core.messages import AIMessage
+
+            note = AIMessage(content="[本轮已由用户终止，上下文已保留]")
+            model_node = _pick_model_node(nodes, next_nodes)
+            if model_node and next_nodes:
+                try:
+                    update_state(config, {"messages": [note]}, as_node=model_node)
+                    notes.append(f"cancel note as_node={model_node}")
+                except Exception:  # noqa: BLE001
+                    update_state(config, {"messages": [note]})
+                    notes.append("cancel note appended")
+            else:
+                # No pending graph step: still append a boundary note when the
+                # last message is human/tool so the next model call is clean.
+                last = messages[-1]
+                if _is_human_msg(last) or _is_tool_msg(last) or (
+                    _is_ai_msg(last) and (getattr(last, "tool_calls", None) or [])
+                ):
+                    update_state(config, {"messages": [note]})
+                    notes.append("cancel note appended")
+
+        snap = get_state(config)
+        values = getattr(snap, "values", None) or {}
+        messages = list(values.get("messages") or [])
+        next_nodes = tuple(str(x) for x in (getattr(snap, "next", None) or ()))
+        notes.append(f"messages={len(messages)}")
+        if next_nodes:
+            notes.append(f"pending next={next_nodes}")
+        else:
+            notes.append("checkpoint ready for next turn")
+    except Exception as exc:  # noqa: BLE001
+        notes.append(f"cancel seal error: {exc}")
+    return notes

synapse/sessions/session_recap.py

@@ -0,0 +1,174 @@
+"""Session recap (away summary) — one-line progress when idle.
+
+Inspired by Claude Code Session Recap: after a completed turn, if the
+session sits idle long enough, surface a single-line summary so the user
+can resume without scrolling. No slash command — auto-only.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+DEFAULT_IDLE_SECONDS = 180.0
+DEFAULT_MIN_TURNS = 3
+MAX_LINE_CHARS = 120
+MAX_FRAGMENT_CHARS = 48
+
+
+def _one_line(text: str, *, limit: int = MAX_FRAGMENT_CHARS) -> str:
+    body = " ".join((text or "").split())
+    if not body:
+        return ""
+    if len(body) <= limit:
+        return body
+    return body[: max(0, limit - 1)] + "…"
+
+
+def build_recap_line(
+    *,
+    user_text: str = "",
+    tool_summary: str = "",
+    answer_excerpt: str = "",
+    max_chars: int = MAX_LINE_CHARS,
+) -> str:
+    """Compose a single dim UI line from the latest turn snapshot."""
+    parts: list[str] = []
+    user = _one_line(user_text)
+    tools = _one_line(tool_summary, limit=40)
+    answer = _one_line(answer_excerpt, limit=56)
+    if user:
+        parts.append(f"任务 {user}")
+    if tools:
+        parts.append(f"工具 {tools}")
+    if answer:
+        parts.append(f"进展 {answer}")
+    if not parts:
+        parts.append("会话空闲；可继续输入")
+    body = "；".join(parts)
+    line = f"recap: {body}"
+    if len(line) > max_chars:
+        line = line[: max(0, max_chars - 1)] + "…"
+    return line
+
+
+def snapshot_from_turn(
+    *,
+    user_text: str = "",
+    tool_items: list[Any] | None = None,
+    tool_summary: str = "",
+    answer_text: str = "",
+) -> dict[str, str]:
+    """Normalize turn facts into a plain dict for recap generation."""
+    summary = (tool_summary or "").strip()
+    if not summary and tool_items:
+        names: list[str] = []
+        for it in tool_items:
+            name = getattr(it, "name", None) or getattr(it, "label", None) or ""
+            name = str(name).strip()
+            if name and name not in names:
+                names.append(name)
+            if len(names) >= 4:
+                break
+        if names:
+            summary = ", ".join(names)
+    return {
+        "user_text": (user_text or "").strip(),
+        "tool_summary": summary,
+        "answer_excerpt": (answer_text or "").strip(),
+    }
+
+
+@dataclass
+class SessionRecapController:
+    """Track eligibility for an automatic one-line recap after idle."""
+
+    enabled: bool = True
+    idle_seconds: float = DEFAULT_IDLE_SECONDS
+    min_turns: int = DEFAULT_MIN_TURNS
+    turn_count: int = 0
+    last_turn_done_at: float | None = None
+    last_snapshot: dict[str, str] = field(default_factory=dict)
+    # After a recap is shown, require a new completed turn before next fire.
+    needs_fresh_turn: bool = False
+
+    def reset(self) -> None:
+        self.turn_count = 0
+        self.last_turn_done_at = None
+        self.last_snapshot = {}
+        self.needs_fresh_turn = False
+
+    def note_turn_done(
+        self,
+        now: float,
+        *,
+        user_text: str = "",
+        tool_summary: str = "",
+        tool_items: list[Any] | None = None,
+        answer_text: str = "",
+        turn_count: int | None = None,
+    ) -> None:
+        """Record a completed agent turn as the recap source."""
+        if turn_count is not None:
+            self.turn_count = max(0, int(turn_count))
+        else:
+            self.turn_count += 1
+        self.last_turn_done_at = float(now)
+        self.last_snapshot = snapshot_from_turn(
+            user_text=user_text,
+            tool_items=tool_items,
+            tool_summary=tool_summary,
+            answer_text=answer_text,
+        )
+        self.needs_fresh_turn = False
+
+    def eligible(
+        self,
+        now: float,
+        *,
+        busy: bool = False,
+        draft_nonempty: bool = False,
+    ) -> bool:
+        """Whether an idle recap should fire now."""
+        if not self.enabled:
+            return False
+        if busy or draft_nonempty:
+            return False
+        if self.needs_fresh_turn:
+            return False
+        if self.turn_count < max(1, int(self.min_turns)):
+            return False
+        if self.last_turn_done_at is None:
+            return False
+        idle_for = float(now) - float(self.last_turn_done_at)
+        if idle_for < max(0.0, float(self.idle_seconds)):
+            return False
+        return True
+
+    def try_fire(
+        self,
+        now: float,
+        *,
+        busy: bool = False,
+        draft_nonempty: bool = False,
+    ) -> str | None:
+        """If eligible, return the recap line and mark as shown.
+
+        Long idle must never re-generate: after a successful fire, arm
+        ``needs_fresh_turn`` and clear the idle clock until a new turn.
+        """
+        if not self.eligible(
+            now,
+            busy=busy,
+            draft_nonempty=draft_nonempty,
+        ):
+            return None
+        line = build_recap_line(
+            user_text=self.last_snapshot.get("user_text", ""),
+            tool_summary=self.last_snapshot.get("tool_summary", ""),
+            answer_excerpt=self.last_snapshot.get("answer_excerpt", ""),
+        )
+        # One-shot per completed turn. Further idle ticks stay silent.
+        self.needs_fresh_turn = True
+        self.last_turn_done_at = None
+        return line