d15c61b5dc
hermes_state.py 17,220 -> 6,442 LOC. Behavior-neutral: every moved body is AST-identical to the original, verified per extraction. SessionDB core - _write_sql / _write_rowcount / _read_one / _read_all replace ~120 copies of the `def _do(conn): conn.execute(...)` + `_execute_write(_do)` and `with self._read_ctx() as conn: row = conn.execute(...).fetchone()` shapes. - _set_lineage_column replaces four copies of the recursive compression-lineage UPDATE (archived / pinned / hidden / last_read_at). - _read_session_number unifies the three compression counter readers. - Dead (zero refs repo-wide): restore_rewound, delete_gateway_routing_entries, _is_duplicate_replayed_user_message, SessionPortabilityMixin.get_first_assistant_text. New mixins bound onto SessionDB via the MRO (logger name stays "hermes_state"): hermes_state_messages SessionMessagesMixin 48 methods hermes_state_compression SessionCompressionMixin 30 hermes_state_gateway SessionGatewayMixin 26 hermes_state_maintenance SessionMaintenanceMixin 13 hermes_state_usage SessionUsageMixin 12 hermes_state_titles SessionTitlesMixin 13 hermes_state_telegram SessionTelegramTopicsMixin 11 Origin-internal symbols resolve through a lazy `from hermes_state import ...` inside the few methods that need them (no import cycle). New free-function modules, every name re-imported into hermes_state so `hermes_state.<name>` (and test monkeypatches on it) keep working; intra-module calls to patched helpers go through the lazy origin import: hermes_state_repair repair/backup/preflight (43 defs) hermes_state_wal journal-mode / PRAGMA policy (33 defs) hermes_state_dbfile header probes, zeroed-db quarantine, stats, holders (21 defs) Existing mixins: search — shared FTS MATCH/LIKE builders, unified rebuild status/step/finish engines, state_meta helpers; schema — one legacy/v23 FTS init branch, shared _live_pk_columns, Row/tuple dual access dropped; portability — shared _PREVIEW_RAW_SUBQUERY_SQL and _rich_row; common — single stat_db_file_identity (was 3 copies), AUTO_VACUUM_MIN_FREELIST_RATIO. Docstrings/comments hand-compacted (AST-identical) keeping every invariant, ordering rule, failure mode and WHY. Schema SQL, migration order and PRAGMAs untouched. test_repair_path_has_no_bare_connects repointed to hermes_state_repair.
530 lines
21 KiB
Python
530 lines
21 KiB
Python
"""Telegram DM topic-mode mixin for :class:`hermes_state.SessionDB`."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
import sqlite3
|
|
import time
|
|
from typing import Any, Dict, List, Optional
|
|
|
|
from hermes_state_common import (
|
|
_PREVIEW_ELIGIBLE_SQL,
|
|
_PREVIEW_RAW_SELECT,
|
|
_shape_preview,
|
|
_sql_session_last_active,
|
|
)
|
|
|
|
# caplog tests pin the "hermes_state" logger name.
|
|
logger = logging.getLogger("hermes_state")
|
|
|
|
|
|
def _normalize_telegram_topic_profile_name(profile_name: Optional[str] = None) -> str:
|
|
"""Empty/missing → ``"default"`` (single namespace for non-multiplexed
|
|
gateways). Multiplexed callers must pass the *routed* profile
|
|
(``source.profile``), never the process-global active profile."""
|
|
name = str(profile_name or "").strip()
|
|
return name if name else "default"
|
|
|
|
|
|
class SessionTelegramTopicsMixin:
|
|
"""Telegram DM topic-mode tables, bindings and lookups."""
|
|
|
|
def apply_telegram_topic_migration(self) -> None:
|
|
"""Create Telegram DM topic-mode tables on explicit /topic opt-in.
|
|
|
|
Deliberately NOT part of startup reconciliation: operators can upgrade
|
|
and keep the old bot behavior until a user runs /topic.
|
|
|
|
Schema versions: v1 initial; v2 session_id FK ON DELETE CASCADE (pruning
|
|
clears bindings); v3 ``profile_name`` on both tables so multiplexed
|
|
gateways sharing one state.db isolate topic state per profile.
|
|
"""
|
|
# (table, column list, DDL body). profile_name leads the PK: a private
|
|
# chat_id is the user id, identical across bots sharing one state.db.
|
|
tables = (
|
|
(
|
|
"telegram_dm_topic_mode",
|
|
"profile_name, chat_id, user_id, enabled, activated_at, updated_at, "
|
|
"has_topics_enabled, allows_users_to_create_topics, "
|
|
"capability_checked_at, intro_message_id, pinned_message_id",
|
|
"""
|
|
profile_name TEXT NOT NULL DEFAULT 'default',
|
|
chat_id TEXT NOT NULL,
|
|
user_id TEXT NOT NULL,
|
|
enabled INTEGER NOT NULL DEFAULT 1,
|
|
activated_at REAL NOT NULL,
|
|
updated_at REAL NOT NULL,
|
|
has_topics_enabled INTEGER,
|
|
allows_users_to_create_topics INTEGER,
|
|
capability_checked_at REAL,
|
|
intro_message_id TEXT,
|
|
pinned_message_id TEXT,
|
|
PRIMARY KEY (profile_name, chat_id)
|
|
""",
|
|
),
|
|
(
|
|
"telegram_dm_topic_bindings",
|
|
"profile_name, chat_id, thread_id, user_id, session_key, "
|
|
"session_id, managed_mode, linked_at, updated_at",
|
|
"""
|
|
profile_name TEXT NOT NULL DEFAULT 'default',
|
|
chat_id TEXT NOT NULL,
|
|
thread_id TEXT NOT NULL,
|
|
user_id TEXT NOT NULL,
|
|
session_key TEXT NOT NULL,
|
|
session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
|
|
managed_mode TEXT NOT NULL DEFAULT 'auto',
|
|
linked_at REAL NOT NULL,
|
|
updated_at REAL NOT NULL,
|
|
PRIMARY KEY (profile_name, chat_id, thread_id)
|
|
""",
|
|
),
|
|
)
|
|
|
|
def _do(conn):
|
|
for table, columns, ddl in tables:
|
|
conn.execute(f"CREATE TABLE IF NOT EXISTS {table} ({ddl})")
|
|
have = {row[1] for row in conn.execute(f"PRAGMA table_info('{table}')")}
|
|
if "profile_name" in have:
|
|
continue
|
|
# v1/v2 → v3. SQLite can't ALTER a PK or FK, so rebuild (this
|
|
# also supplies v2's ON DELETE CASCADE). Legacy rows land in
|
|
# "default" only, never replicated across profiles.
|
|
legacy_columns = columns.replace("profile_name, ", "", 1)
|
|
conn.executescript(
|
|
f"""
|
|
CREATE TABLE {table}_new ({ddl});
|
|
INSERT INTO {table}_new ({columns})
|
|
SELECT 'default', {legacy_columns} FROM {table};
|
|
DROP TABLE {table};
|
|
ALTER TABLE {table}_new RENAME TO {table};
|
|
"""
|
|
)
|
|
|
|
# Indexes after any rebuild: the user index needs profile_name.
|
|
conn.executescript(
|
|
"""
|
|
CREATE UNIQUE INDEX IF NOT EXISTS idx_telegram_dm_topic_bindings_session
|
|
ON telegram_dm_topic_bindings(session_id);
|
|
|
|
CREATE INDEX IF NOT EXISTS idx_telegram_dm_topic_bindings_user
|
|
ON telegram_dm_topic_bindings(profile_name, user_id, chat_id);
|
|
"""
|
|
)
|
|
|
|
conn.execute(
|
|
"INSERT INTO state_meta (key, value) VALUES (?, ?) "
|
|
"ON CONFLICT(key) DO UPDATE SET value = excluded.value",
|
|
("telegram_dm_topic_schema_version", "3"),
|
|
)
|
|
self._execute_write(_do)
|
|
|
|
def enable_telegram_topic_mode(
|
|
self,
|
|
*,
|
|
chat_id: str,
|
|
user_id: str,
|
|
profile_name: str = "default",
|
|
has_topics_enabled: Optional[bool] = None,
|
|
allows_users_to_create_topics: Optional[bool] = None,
|
|
) -> None:
|
|
"""Enable Telegram DM topic mode for one private chat/user.
|
|
|
|
Owns the explicit topic migration; SessionDB startup must not create
|
|
these tables. Multiplexed callers pass the routed ``source.profile``,
|
|
not the process-global active profile.
|
|
"""
|
|
self.apply_telegram_topic_migration()
|
|
now = time.time()
|
|
profile_name = _normalize_telegram_topic_profile_name(profile_name)
|
|
|
|
def _to_int(value: Optional[bool]) -> Optional[int]:
|
|
if value is None:
|
|
return None
|
|
return 1 if value else 0
|
|
|
|
self._write_sql(
|
|
"""
|
|
INSERT INTO telegram_dm_topic_mode (
|
|
profile_name, chat_id, user_id, enabled, activated_at, updated_at,
|
|
has_topics_enabled, allows_users_to_create_topics,
|
|
capability_checked_at
|
|
) VALUES (?, ?, ?, 1, ?, ?, ?, ?, ?)
|
|
ON CONFLICT(profile_name, chat_id) DO UPDATE SET
|
|
user_id = excluded.user_id,
|
|
enabled = 1,
|
|
updated_at = excluded.updated_at,
|
|
has_topics_enabled = excluded.has_topics_enabled,
|
|
allows_users_to_create_topics = excluded.allows_users_to_create_topics,
|
|
capability_checked_at = excluded.capability_checked_at
|
|
""",
|
|
(
|
|
profile_name,
|
|
str(chat_id),
|
|
str(user_id),
|
|
now,
|
|
now,
|
|
_to_int(has_topics_enabled),
|
|
_to_int(allows_users_to_create_topics),
|
|
now,
|
|
),
|
|
)
|
|
|
|
def disable_telegram_topic_mode(
|
|
self,
|
|
*,
|
|
chat_id: str,
|
|
profile_name: str = "default",
|
|
clear_bindings: bool = True,
|
|
) -> None:
|
|
"""Disable Telegram DM topic mode for one private chat.
|
|
|
|
``clear_bindings`` also drops the chat's bindings so a later re-enable
|
|
starts clean. Never creates the tables; absent tables are a no-op.
|
|
"""
|
|
profile_name = _normalize_telegram_topic_profile_name(profile_name)
|
|
|
|
def _do(conn):
|
|
try:
|
|
conn.execute(
|
|
"UPDATE telegram_dm_topic_mode SET enabled = 0, updated_at = ? "
|
|
"WHERE profile_name = ? AND chat_id = ?",
|
|
(time.time(), profile_name, str(chat_id)),
|
|
)
|
|
if clear_bindings:
|
|
conn.execute(
|
|
"DELETE FROM telegram_dm_topic_bindings "
|
|
"WHERE profile_name = ? AND chat_id = ?",
|
|
(profile_name, str(chat_id)),
|
|
)
|
|
except sqlite3.OperationalError:
|
|
return
|
|
self._execute_write(_do)
|
|
|
|
def is_telegram_topic_mode_enabled(
|
|
self,
|
|
*,
|
|
chat_id: str,
|
|
user_id: str,
|
|
profile_name: str = "default",
|
|
) -> bool:
|
|
"""Return whether Telegram DM topic mode is enabled for this chat/user."""
|
|
profile_name = _normalize_telegram_topic_profile_name(profile_name)
|
|
with self._read_ctx() as conn:
|
|
try:
|
|
row = conn.execute(
|
|
"""
|
|
SELECT enabled FROM telegram_dm_topic_mode
|
|
WHERE profile_name = ? AND chat_id = ? AND user_id = ?
|
|
""",
|
|
(profile_name, str(chat_id), str(user_id)),
|
|
).fetchone()
|
|
except sqlite3.OperationalError:
|
|
return False
|
|
if row is None:
|
|
return False
|
|
enabled = row[0]
|
|
return bool(enabled)
|
|
|
|
def get_telegram_topic_binding(
|
|
self,
|
|
*,
|
|
chat_id: str,
|
|
thread_id: str,
|
|
profile_name: str = "default",
|
|
) -> Optional[Dict[str, Any]]:
|
|
"""Return the session binding for a Telegram DM topic, if present."""
|
|
profile_name = _normalize_telegram_topic_profile_name(profile_name)
|
|
with self._read_ctx() as conn:
|
|
try:
|
|
row = conn.execute(
|
|
"""
|
|
SELECT * FROM telegram_dm_topic_bindings
|
|
WHERE profile_name = ? AND chat_id = ? AND thread_id = ?
|
|
""",
|
|
(profile_name, str(chat_id), str(thread_id)),
|
|
).fetchone()
|
|
except sqlite3.OperationalError:
|
|
return None
|
|
return dict(row) if row else None
|
|
|
|
def list_telegram_topic_bindings_for_chat(
|
|
self,
|
|
*,
|
|
chat_id: str,
|
|
profile_name: str = "default",
|
|
) -> List[Dict[str, Any]]:
|
|
"""All bindings for one chat, newest first. Read-only: [] when the
|
|
table is absent (never triggers the migration)."""
|
|
profile_name = _normalize_telegram_topic_profile_name(profile_name)
|
|
with self._read_ctx() as conn:
|
|
try:
|
|
rows = conn.execute(
|
|
"SELECT * FROM telegram_dm_topic_bindings "
|
|
"WHERE profile_name = ? AND chat_id = ? "
|
|
"ORDER BY updated_at DESC",
|
|
(profile_name, str(chat_id)),
|
|
).fetchall()
|
|
except sqlite3.OperationalError:
|
|
return []
|
|
return [dict(row) for row in rows]
|
|
|
|
def get_telegram_topic_binding_by_session(
|
|
self,
|
|
*,
|
|
session_id: str,
|
|
) -> Optional[Dict[str, Any]]:
|
|
"""Reverse lookup via the UNIQUE INDEX on session_id; None when
|
|
unbound or the table is absent."""
|
|
with self._read_ctx() as conn:
|
|
try:
|
|
row = conn.execute(
|
|
"""
|
|
SELECT * FROM telegram_dm_topic_bindings
|
|
WHERE session_id = ?
|
|
""",
|
|
(str(session_id),),
|
|
).fetchone()
|
|
except sqlite3.OperationalError:
|
|
return None
|
|
return dict(row) if row else None
|
|
|
|
def delete_telegram_topic_binding(
|
|
self,
|
|
*,
|
|
chat_id: str,
|
|
thread_id: str,
|
|
profile_name: str = "default",
|
|
) -> int:
|
|
"""Remove the binding row for one (chat, thread) pair.
|
|
|
|
Called when the Bot API confirms a topic was deleted externally
|
|
(``Thread not found`` after the same-thread retry failed); otherwise
|
|
``gateway.run._recover_telegram_topic_thread_id`` keeps redirecting
|
|
inbound messages to the dead topic.
|
|
|
|
If this removes the chat's *last* binding, ``telegram_dm_topic_mode``
|
|
is flipped to ``enabled = 0`` in the same transaction; otherwise the
|
|
chat stays in topic mode with zero lanes and a user who disabled topics
|
|
in the Telegram client (not via ``/topic off``) stays stuck.
|
|
|
|
Returns the number of rows deleted; absent binding or unmigrated tables
|
|
are silent no-ops (never raise from a cleanup hot path).
|
|
"""
|
|
chat_id = str(chat_id)
|
|
thread_id = str(thread_id)
|
|
profile_name = _normalize_telegram_topic_profile_name(profile_name)
|
|
deleted = {"count": 0}
|
|
|
|
def _do(conn):
|
|
try:
|
|
cursor = conn.execute(
|
|
"""
|
|
DELETE FROM telegram_dm_topic_bindings
|
|
WHERE profile_name = ? AND chat_id = ? AND thread_id = ?
|
|
""",
|
|
(profile_name, chat_id, thread_id),
|
|
)
|
|
deleted["count"] = cursor.rowcount or 0
|
|
except sqlite3.OperationalError:
|
|
deleted["count"] = 0
|
|
return
|
|
if not deleted["count"]:
|
|
return
|
|
# Last binding gone → disable topic mode. Same transaction, so no
|
|
# read-after-prune race.
|
|
try:
|
|
remaining = conn.execute(
|
|
"""
|
|
SELECT 1 FROM telegram_dm_topic_bindings
|
|
WHERE profile_name = ? AND chat_id = ? LIMIT 1
|
|
""",
|
|
(profile_name, chat_id),
|
|
).fetchone()
|
|
if remaining is None:
|
|
conn.execute(
|
|
"UPDATE telegram_dm_topic_mode "
|
|
"SET enabled = 0, updated_at = ? "
|
|
"WHERE profile_name = ? AND chat_id = ?",
|
|
(time.time(), profile_name, chat_id),
|
|
)
|
|
except sqlite3.OperationalError:
|
|
# telegram_dm_topic_mode absent — binding prune still stands.
|
|
pass
|
|
|
|
self._execute_write(_do)
|
|
return deleted["count"]
|
|
|
|
def bind_telegram_topic(
|
|
self,
|
|
*,
|
|
chat_id: str,
|
|
thread_id: str,
|
|
user_id: str,
|
|
session_key: str,
|
|
session_id: str,
|
|
managed_mode: str = "auto",
|
|
profile_name: str = "default",
|
|
) -> None:
|
|
"""Bind one Telegram DM topic thread to one Hermes session.
|
|
|
|
A session may be linked to only one topic: rebinding the same pair is
|
|
idempotent; linking the session to a different topic raises ValueError.
|
|
"""
|
|
self.apply_telegram_topic_migration()
|
|
now = time.time()
|
|
chat_id = str(chat_id)
|
|
thread_id = str(thread_id)
|
|
user_id = str(user_id)
|
|
session_key = str(session_key)
|
|
session_id = str(session_id)
|
|
profile_name = _normalize_telegram_topic_profile_name(profile_name)
|
|
|
|
def _do(conn):
|
|
existing_session = conn.execute(
|
|
"""
|
|
SELECT profile_name, chat_id, thread_id
|
|
FROM telegram_dm_topic_bindings
|
|
WHERE session_id = ?
|
|
""",
|
|
(session_id,),
|
|
).fetchone()
|
|
if existing_session is not None:
|
|
if isinstance(existing_session, sqlite3.Row):
|
|
linked_profile = existing_session["profile_name"]
|
|
linked_chat = existing_session["chat_id"]
|
|
linked_thread = existing_session["thread_id"]
|
|
else:
|
|
linked_profile, linked_chat, linked_thread = existing_session
|
|
if (
|
|
str(linked_profile) != profile_name
|
|
or str(linked_chat) != chat_id
|
|
or str(linked_thread) != thread_id
|
|
):
|
|
raise ValueError("session is already linked to another Telegram topic")
|
|
|
|
conn.execute(
|
|
"""
|
|
INSERT INTO telegram_dm_topic_bindings (
|
|
profile_name, chat_id, thread_id, user_id, session_key, session_id,
|
|
managed_mode, linked_at, updated_at
|
|
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
ON CONFLICT(profile_name, chat_id, thread_id) DO UPDATE SET
|
|
user_id = excluded.user_id,
|
|
session_key = excluded.session_key,
|
|
session_id = excluded.session_id,
|
|
managed_mode = excluded.managed_mode,
|
|
updated_at = excluded.updated_at
|
|
""",
|
|
(
|
|
profile_name,
|
|
chat_id,
|
|
thread_id,
|
|
user_id,
|
|
session_key,
|
|
session_id,
|
|
managed_mode,
|
|
now,
|
|
now,
|
|
),
|
|
)
|
|
self._execute_write(_do)
|
|
|
|
def is_telegram_session_linked_to_topic(self, *, session_id: str) -> bool:
|
|
"""True if the session is bound to any Telegram DM topic. Read-only:
|
|
absent tables (nobody ran ``/topic``) mean unbound → False."""
|
|
with self._read_ctx() as conn:
|
|
try:
|
|
row = conn.execute(
|
|
"""
|
|
SELECT 1 FROM telegram_dm_topic_bindings
|
|
WHERE session_id = ?
|
|
LIMIT 1
|
|
""",
|
|
(str(session_id),),
|
|
).fetchone()
|
|
except sqlite3.OperationalError:
|
|
return False
|
|
return row is not None
|
|
|
|
def list_unlinked_telegram_sessions_for_user(
|
|
self,
|
|
*,
|
|
chat_id: str,
|
|
user_id: str,
|
|
profile_name: str = "default",
|
|
limit: int = 10,
|
|
) -> List[Dict[str, Any]]:
|
|
"""This user's Telegram sessions not bound to a topic.
|
|
|
|
Read-only: if the bindings table is absent, every session is unlinked
|
|
and a simpler query is used. Scoped by ``profile_name`` so multiplexed
|
|
profiles do not surface each other's sessions.
|
|
"""
|
|
profile_name = _normalize_telegram_topic_profile_name(profile_name)
|
|
# sessions.profile_name is NULL/empty for legacy rows → treat as default.
|
|
profile_clause = "AND COALESCE(NULLIF(TRIM(s.profile_name), ''), 'default') = ?"
|
|
with self._read_ctx() as conn:
|
|
try:
|
|
rows = conn.execute(
|
|
f"""
|
|
SELECT s.*,
|
|
COALESCE(sp.prompt, s.system_prompt)
|
|
AS _system_prompt_resolved,
|
|
COALESCE(
|
|
(SELECT {_PREVIEW_RAW_SELECT}
|
|
FROM messages m
|
|
WHERE m.session_id = s.id AND m.role = 'user' AND m.content IS NOT NULL
|
|
AND {_PREVIEW_ELIGIBLE_SQL}
|
|
ORDER BY m.timestamp, m.id LIMIT 1),
|
|
''
|
|
) AS _preview_raw,
|
|
{_sql_session_last_active("s")} AS last_active
|
|
FROM sessions s
|
|
LEFT JOIN system_prompts sp
|
|
ON sp.hash = s.system_prompt_hash
|
|
WHERE s.source = 'telegram'
|
|
AND s.user_id = ?
|
|
{profile_clause}
|
|
AND NOT EXISTS (
|
|
SELECT 1 FROM telegram_dm_topic_bindings b
|
|
WHERE b.session_id = s.id
|
|
)
|
|
ORDER BY last_active DESC, s.started_at DESC
|
|
LIMIT ?
|
|
""",
|
|
(str(user_id), profile_name, int(limit)),
|
|
).fetchall()
|
|
except sqlite3.OperationalError:
|
|
rows = conn.execute(
|
|
f"""
|
|
SELECT s.*,
|
|
COALESCE(sp.prompt, s.system_prompt)
|
|
AS _system_prompt_resolved,
|
|
COALESCE(
|
|
(SELECT {_PREVIEW_RAW_SELECT}
|
|
FROM messages m
|
|
WHERE m.session_id = s.id AND m.role = 'user' AND m.content IS NOT NULL
|
|
AND {_PREVIEW_ELIGIBLE_SQL}
|
|
ORDER BY m.timestamp, m.id LIMIT 1),
|
|
''
|
|
) AS _preview_raw,
|
|
{_sql_session_last_active("s")} AS last_active
|
|
FROM sessions s
|
|
LEFT JOIN system_prompts sp
|
|
ON sp.hash = s.system_prompt_hash
|
|
WHERE s.source = 'telegram'
|
|
AND s.user_id = ?
|
|
ORDER BY last_active DESC, s.started_at DESC
|
|
LIMIT ?
|
|
""",
|
|
(str(user_id), int(limit)),
|
|
).fetchall()
|
|
|
|
sessions: List[Dict[str, Any]] = []
|
|
for row in rows:
|
|
session = self._session_row_dict(row)
|
|
session["preview"] = _shape_preview(session.pop("_preview_raw", ""))
|
|
sessions.append(session)
|
|
return sessions
|