linkgravity 1.2.2 → 1.4.0

package/src/cogs/voice_cog.py

@@ -7,6 +7,7 @@ from discord import app_commands
 from discord.ext import commands, tasks
 
 from config import allowed, logger
+from messengers.registry import get_adapter_for_platform
 
 from .voice.enrollment import EnrollmentManager
 from .voice.stt_session import SttSessionTracker
@@ -175,22 +176,19 @@ class VoiceCog(commands.Cog):
         guild_id = interaction.guild_id
 
         wake_word_map = self.bot_settings.get("wake_words") or {}
-        has_wake_word = bool(wake_word_map)
+        own_word = wake_word_map.get(str(interaction.user.id))
         active_timer = self.bot_settings.get("active_timer", 60)
 
-        if has_wake_word:
-            # dict.fromkeys dedupes while keeping first-registered order (each user has their own word).
-            ww_list = [f"`{w.strip()}`" for w in dict.fromkeys(wake_word_map.values()) if w.strip()]
-            ww_str = ", ".join(ww_list[:-1]) + f", or {ww_list[-1]}" if len(ww_list) > 1 else ww_list[0]
+        if own_word:
             msg = (
                 f"🎤 Connected to `{vc_chan.name}`.\n"
-                f"💡 Say {ww_str} to activate me. Once awake, I'll keep listening for {active_timer} seconds after each interaction.\n"
+                f"💡 Say `{own_word}` to activate me. Once awake, I'll keep listening for {active_timer} seconds after each interaction.\n"
                 f"⚙️ You can customize settings using `/sound`."
             )
         else:
             msg = (
                 f"🎤 Connected to `{vc_chan.name}`.\n"
-                f"🎙️ No wake word is set up yet, so I can't hear you yet - run `/sound wake_word:<word>` "
+                f"🎙️ You haven't set up a wake word yet, so I can't hear you - run `/sound wake_word:<word>` "
                 f"and say your chosen word a few times to register it in your voice."
             )
         await interaction.response.send_message(msg)
@@ -211,17 +209,17 @@ class VoiceCog(commands.Cog):
                 if data.get("success"):
                     self._voice_state[str(guild_id)] = interaction.channel_id
 
-                    if has_wake_word:
+                    if own_word:
                         if self.bot_settings.get("tts_enabled", True):
-                            welcome_audio = await self.tts("Yes, I am listening.")
+                            welcome_audio = await self.tts("Voice connected.")
                             if welcome_audio:
-                                await self._play_audio(str(guild_id), welcome_audio)
+                                await self._play_audio(str(guild_id), welcome_audio, suppress_active_window=True)
                     elif self.bot_settings.get("tts_enabled", True):
                         prompt_audio = await self.tts(
                             "No wake word is set up yet. Please use the sound command to set one."
                         )
                         if prompt_audio:
-                            await self._play_audio(str(guild_id), prompt_audio)
+                            await self._play_audio(str(guild_id), prompt_audio, suppress_active_window=True)
                 else:
                     await interaction.channel.send(f"⚠️ Node.js integration failed: {data.get('error')}")
         except aiohttp.ClientConnectorError:
@@ -452,9 +450,18 @@ class VoiceCog(commands.Cog):
 
             self.logger.debug(f"STT recognized: {text} -> AI: {text_to_ai}")
 
-            # A stale in-flight turn for this guild - cancel it, kill its agy process, stop playback.
+            sess = self.session_manager.get_session(str(thread_id))
+            if not sess:
+                sess = {"status": "pending", "user_id": str(user_id)}
+                self.session_manager.set_session(str(thread_id), sess)
+
+            conv_id = sess.get("conversation_id")
+            pa = self.session_manager.get_pending_approval_by_conv(conv_id) if conv_id else None
+            has_pending_approval = bool(conv_id and pa and not pa.done())
+
+            # Cancel a stale in-flight turn, unless a tool/question approval is pending (this utterance may be its answer).
             prev_task = self._active_turns.get(str(guild_id))
-            if prev_task and not prev_task.done():
+            if prev_task and not prev_task.done() and not has_pending_approval:
                 prev_task.cancel()
 
                 from core.agy_runner import stop_active_process
@@ -493,15 +500,7 @@ class VoiceCog(commands.Cog):
                         await self._play_audio(str(guild_id), audio_reply)
                 return
 
-            sess = self.session_manager.get_session(str(thread_id))
-            if not sess:
-                sess = {"status": "pending", "user_id": str(user_id)}
-                self.session_manager.set_session(str(thread_id), sess)
-
-            conv_id = sess.get("conversation_id")
-            pa = self.session_manager.get_pending_approval_by_conv(conv_id) if conv_id else None
-
-            if conv_id and pa and not pa.done():
+            if has_pending_approval:
                 app_type = self.session_manager.get_pending_approval_type_by_conv(conv_id)
                 if app_type == "ask_question":
                     pa.set_result(text)
@@ -530,7 +529,7 @@ class VoiceCog(commands.Cog):
                 self.session_manager.register_queue(str(thread.id), queue)
 
                 ctx = {"status_msg": None}
-                consume_task = asyncio.create_task(self.stream_thinking_latest(thread, ctx, queue))
+                consume_task = asyncio.create_task(self.stream_thinking_latest(thread, str(thread.id), ctx, queue))
 
                 try:
                     if is_new_session:
@@ -545,6 +544,12 @@ class VoiceCog(commands.Cog):
                         sess["status"] = "active"
                         self.session_manager.set_session(str(thread_id), sess)
                         conv_id = new_conv_id
+
+                        from utils.utils import generate_thread_title, update_agy_conversation_title
+
+                        new_title = await generate_thread_title(text_to_ai, raw_ans)
+                        await get_adapter_for_platform("discord").rename_conversation(thread, new_title)
+                        await update_agy_conversation_title(new_conv_id, new_title)
                     else:
                         logger.debug("Voice: calling agy_send...")
                         raw_ans = await self.agy_send(

package/src/config.py

@@ -7,8 +7,7 @@ WORKSPACE_DIR = Path.home() / ".gemini" / "linkgravity"
 WORKSPACE_DIR.mkdir(parents=True, exist_ok=True)
 DATA_DIR = WORKSPACE_DIR / "data"
 DATA_DIR.mkdir(parents=True, exist_ok=True)
-# Per-user wake-word recordings + built .rpw reference (see EnrollmentManager).
-# Defined early so load_bot_settings' migration below can read it.
+# Per-user wake-word recordings (see EnrollmentManager); defined early so load_bot_settings' migration below can read it.
 WAKE_REF_DIR = WORKSPACE_DIR / "wake_refs"
 WAKE_REF_DIR.mkdir(parents=True, exist_ok=True)
 
@@ -16,6 +15,8 @@ LGY_CONFIG_FILE = WORKSPACE_DIR / "lgy.json"
 
 DEFAULT_LGY_CONFIG = {
     "discord_token": "",
+    "telegram_token": "",
+    "telegram_allowed_user_ids": "",
     "session_scopes": [],
     "allowed_user_ids": "",
     # user_id (str) -> registered word, one per person (see EnrollmentManager._commit_enrollment).
@@ -74,6 +75,7 @@ logger = init_logger(WORKSPACE_DIR)
 
 
 DISCORD_TOKEN = bot_settings.get("discord_token", "")
+TELEGRAM_TOKEN = bot_settings.get("telegram_token", "")
 
 
 def _parse_session_scopes(raw_scopes) -> dict:
@@ -97,6 +99,7 @@ def _parse_session_scopes(raw_scopes) -> dict:
 
 SESSION_SCOPES = _parse_session_scopes(bot_settings.get("session_scopes"))
 ALLOWED_IDS = set(int(x) for x in bot_settings.get("allowed_user_ids", "").split(",") if x.strip())
+TELEGRAM_ALLOWED_IDS = set(int(x) for x in bot_settings.get("telegram_allowed_user_ids", "").split(",") if x.strip())
 TTS_VOICE = bot_settings.get("tts_voice", "ko-KR-SunHiNeural")
 
 
@@ -120,6 +123,7 @@ TMP_VOICE_DIR.mkdir(parents=True, exist_ok=True)
 
 MAX_EMBED_LEN = 1900
 STREAM_RATE_LIMIT_SEC = 0.5
+APPROVAL_TIMEOUT_SEC = 1800
 PERSISTENT_FILE = DATA_DIR / "persistent_tools.json"
 SESSION_FILE = DATA_DIR / "sessions.json"
 
@@ -136,5 +140,6 @@ AGY_BIN = os.getenv("AGY_BIN_PATH", str(Path.home() / ".local/bin/agy"))
 session_manager = SessionManager(DATA_DIR)
 
 
-def allowed(user_id: int) -> bool:
-    return not ALLOWED_IDS or user_id in ALLOWED_IDS
+def allowed(user_id: int, platform: str = "discord") -> bool:
+    ids = TELEGRAM_ALLOWED_IDS if platform == "telegram" else ALLOWED_IDS
+    return not ids or user_id in ids

package/src/core/agy_runner.py

@@ -118,10 +118,10 @@ async def run_agy(
         for attempt in range(max_retries):
             try:
                 env = os.environ.copy()
-                env["AGY_DISCORD_BOT"] = "1"
+                env["LGY_APPROVAL_HOOK"] = "1"
                 env["PYTHONUNBUFFERED"] = "1"
                 if thread_id:
-                    env["DISCORD_THREAD_ID"] = thread_id
+                    env["LGY_THREAD_ID"] = thread_id
 
                 libstdbuf_path = _find_libstdbuf()  # works around agy's output-truncation bug
                 if libstdbuf_path:
@@ -206,7 +206,7 @@ async def run_agy(
                 gather_task = asyncio.create_task(_gather_pipes())
                 wait_task = asyncio.create_task(proc.wait())
 
-                # Slices let the timeout pause during a pending Discord approval (up to 3600s).
+                # Slices let the timeout pause during a pending tool approval (up to 3600s).
                 from config import session_manager as _sm
 
                 poll_slice = 5.0
@@ -376,3 +376,36 @@ async def generate_thread_title(user_input: str, response: str) -> str:
     except Exception as e:
         logger.warning(f"AI thread-title generation failed, falling back to raw input: {e}")
         return fallback
+
+
+async def update_agy_conversation_title(conv_id: str, title: str) -> None:
+    """Antigravity CLI's own conversation list reads its display name from
+    conversation_summaries.db's `preview` column (the `title` column exists
+    but is unused/always empty - confirmed by inspecting the db directly).
+    Without this, agy shows its own auto-generated name while the Discord
+    thread shows ours, and the two drift apart for the same conversation."""
+    if not conv_id:
+        return
+
+    import sqlite3
+    from pathlib import Path
+
+    db_path = Path.home() / ".gemini/antigravity-cli/conversation_summaries.db"
+    if not db_path.exists():
+        return
+
+    def _update():
+        conn = sqlite3.connect(str(db_path), timeout=5)
+        try:
+            conn.execute(
+                "UPDATE conversation_summaries SET preview = ? WHERE conversation_id = ?",
+                (title, conv_id),
+            )
+            conn.commit()
+        finally:
+            conn.close()
+
+    try:
+        await asyncio.get_running_loop().run_in_executor(None, _update)
+    except Exception as e:
+        logger.warning(f"Failed to sync title into agy's conversation_summaries.db for {conv_id}: {e}")

package/src/core/session_manager.py

@@ -1,4 +1,5 @@
 import asyncio
+from datetime import datetime
 from pathlib import Path
 from typing import Any
 
@@ -79,6 +80,30 @@ class SessionManager:
     def get_active_queue_keys(self) -> list:
         return list(self.active_queues.keys())
 
+    def cleanup_stale_sessions(self, pending_max_age_days: int = 7) -> int:
+        """Only ever removes 'pending' sessions (started with /new but never actually used - no real conversation attached) older than pending_max_age_days, or with no created_at at all (pre-dates that field, safe to treat as stale). 'active' sessions are NEVER removed by age: Discord threads must stay resumable indefinitely, and Telegram's 1-chat-1-session model already overwrites its one entry on each /new, so there's nothing to accumulate there either. Returns how many were removed."""
+        now = datetime.now()
+        to_remove = []
+        for thread_id, session in self.sessions.items():
+            if session.get("status") != "pending":
+                continue
+            created_at_str = session.get("created_at")
+            if not created_at_str:
+                to_remove.append(thread_id)
+                continue
+            try:
+                age_days = (now - datetime.fromisoformat(created_at_str)).days
+            except ValueError:
+                continue
+            if age_days > pending_max_age_days:
+                to_remove.append(thread_id)
+
+        for thread_id in to_remove:
+            self.sessions.pop(thread_id, None)
+        if to_remove:
+            self.save_sessions()
+        return len(to_remove)
+
     def get_tts_task(self, thread_id: str) -> asyncio.Task | None:
         return self.active_tts_tasks.get(str(thread_id))
 

package/src/handlers/message_router.py

@@ -1,16 +1,13 @@
-import discord
-
 from config import allowed
 from handlers.thread_reply import handle_thread_reply
+from messengers.base import MessengerAdapter
 
 
-async def handle_message(bot, message: discord.Message):
-    if message.type not in (discord.MessageType.default, discord.MessageType.reply):
-        return
-    if message.author.bot:
+async def handle_message(bot, raw_event, adapter: MessengerAdapter):
+    incoming = adapter.to_incoming_message(raw_event)
+    if incoming is None:
         return
-    if not allowed(message.author.id):
+    if not allowed(incoming.author_id, incoming.platform):
         return
 
-    if isinstance(message.channel, discord.Thread):
-        await handle_thread_reply(bot, message)
+    await handle_thread_reply(bot, incoming)

package/src/handlers/thread_reply.py

@@ -2,10 +2,9 @@ import asyncio
 import time
 from datetime import datetime
 
-import discord
-
 from config import session_manager
-from messengers.registry import get_adapter
+from messengers.base import IncomingMessage
+from messengers.registry import get_adapter_for_platform
 from services.response import render_thought_process, send_agy_response
 from services.streaming import stream_thinking_latest
 from utils.utils import (
@@ -16,13 +15,19 @@ from utils.utils import (
     generate_thread_title,
     handle_image_attachments,
     stt,
+    update_agy_conversation_title,
 )
 
 
-async def handle_approval_reply(
-    message: discord.Message, thread: discord.Thread, session: dict, content: str, pa
-) -> bool:
-    adapter = get_adapter()
+async def handle_approval_reply(incoming: IncomingMessage, session: dict, content: str, pa) -> bool:
+    adapter = get_adapter_for_platform(incoming.platform)
+    thread = incoming.conversation_ref
+
+    if session_manager.get_pending_approval_type_by_conv(incoming.conversation_id) == "ask_question":
+        pa.set_result(content)
+        await adapter.send_message(thread, f'✅ *Answer Received (Write in): "{content}"*')
+        return True
+
     if content.lower() in ("yes", "y", "allow", "승인"):
         pa.set_result("allow")
         await adapter.send_message(thread, f'✅ *Answer Received (Write in): "{content}"*')
@@ -37,37 +42,42 @@ async def handle_approval_reply(
         return True
     elif content.lower() in ("clear", "reset"):
         await adapter.send_message(thread, "🧹 Conversation context cleared.")
-        old_sess = session_manager.remove_session(str(thread.id))
+        old_sess = session_manager.remove_session(incoming.conversation_id)
         if old_sess:
-            session_manager.set_session(str(thread.id), old_sess)
+            session_manager.set_session(incoming.conversation_id, old_sess)
         return True
     return False
 
 
 async def handle_pending_session(
-    bot, thread: discord.Thread, session: dict, agy_content: str, content: str, image_paths: list
+    bot, incoming: IncomingMessage, session: dict, agy_content: str, content: str, image_paths: list
 ):
-    adapter = get_adapter()
+    adapter = get_adapter_for_platform(incoming.platform)
+    thread = incoming.conversation_ref
     try:
         async with adapter.typing(thread):
             ctx = {"status_msg": None}
             start_time = time.time()
             queue = asyncio.Queue()
-            session_manager.register_queue(str(thread.id), queue)
-            stream_task = asyncio.create_task(stream_thinking_latest(bot, thread, context_dict=ctx, queue=queue))
+            session_manager.register_queue(incoming.conversation_id, queue)
+            stream_task = asyncio.create_task(
+                stream_thinking_latest(bot, thread, incoming.conversation_id, context_dict=ctx, queue=queue)
+            )
 
             cwd = session.get("cwd")
             model = session.get("model")
             result_text, new_conv_id = await agy_new_conversation(
-                agy_content, model=model, stream_queue=queue, thread_id=str(thread.id), cwd=cwd
+                agy_content, model=model, stream_queue=queue, thread_id=incoming.conversation_id, cwd=cwd
             )
 
             await queue.put(("__END__", True))
             await stream_task
 
             response_text = result_text
-            new_title = await generate_thread_title(content, response_text)
-            await adapter.rename_conversation(thread, new_title)
+            if adapter.supports_renaming:
+                new_title = await generate_thread_title(content, response_text)
+                await adapter.rename_conversation(thread, new_title)
+                await update_agy_conversation_title(new_conv_id, new_title)
 
             response_text = await render_thought_process(new_conv_id, ctx, response_text, thread)
 
@@ -82,22 +92,25 @@ async def handle_pending_session(
 
 
 async def handle_existing_session(
-    bot, thread: discord.Thread, session: dict, conv_id: str, agy_content: str, image_paths: list
+    bot, incoming: IncomingMessage, session: dict, conv_id: str, agy_content: str, image_paths: list
 ):
-    adapter = get_adapter()
+    adapter = get_adapter_for_platform(incoming.platform)
+    thread = incoming.conversation_ref
     try:
         async with adapter.typing(thread):
             ctx = {"status_msg": None}
             start_time = time.time()
             queue = asyncio.Queue()
-            session_manager.register_queue(str(thread.id), queue)
-            stream_task = asyncio.create_task(stream_thinking_latest(bot, thread, context_dict=ctx, queue=queue))
+            session_manager.register_queue(incoming.conversation_id, queue)
+            stream_task = asyncio.create_task(
+                stream_thinking_latest(bot, thread, incoming.conversation_id, context_dict=ctx, queue=queue)
+            )
             result_text = await agy_send_message(
                 conv_id,
                 agy_content,
                 model=session.get("model"),
                 stream_queue=queue,
-                thread_id=str(thread.id),
+                thread_id=incoming.conversation_id,
                 cwd=session.get("cwd"),
             )
             await queue.put(("__END__", True))
@@ -110,14 +123,14 @@ async def handle_existing_session(
         cleanup_images(image_paths)
 
 
-async def handle_thread_reply(bot, message: discord.Message):
-    thread = message.channel
-    session = session_manager.get_session(str(thread.id))
+async def handle_thread_reply(bot, incoming: IncomingMessage):
+    session = session_manager.get_session(incoming.conversation_id)
     if not session:
         return
 
-    adapter = get_adapter()
-    content = message.content.strip()
+    adapter = get_adapter_for_platform(incoming.platform)
+    thread = incoming.conversation_ref
+    content = incoming.content.strip()
     if content.startswith("/new"):
         await adapter.send_message(
             thread,
@@ -125,10 +138,11 @@ async def handle_thread_reply(bot, message: discord.Message):
         )
         return
 
-    for att in message.attachments:
+    for att in incoming.attachments:
         ct = att.content_type or ""
         if "audio" in ct or att.filename.endswith((".ogg", ".mp3", ".m4a", ".wav")):
-            await message.add_reaction("🎤")
+            if incoming.add_reaction:
+                await incoming.add_reaction("🎤")
             audio_bytes = await att.read()
             text = await stt(audio_bytes)
             if text:
@@ -136,9 +150,10 @@ async def handle_thread_reply(bot, message: discord.Message):
                 await adapter.send_message(thread, f'🎤 *Speech Recognized: "{text}"*')
             break
 
-    image_paths = await handle_image_attachments(message)
+    image_paths = await handle_image_attachments(incoming.attachments)
     if image_paths:
-        await message.add_reaction("📎")
+        if incoming.add_reaction:
+            await incoming.add_reaction("📎")
         await adapter.send_message(thread, f"📎 *{len(image_paths)} file(s) attached*")
 
     if not content and not image_paths:
@@ -151,16 +166,31 @@ async def handle_thread_reply(bot, message: discord.Message):
     pa = session_manager.get_pending_approval_by_conv(conv_id) if conv_id else None
 
     if conv_id and pa and not pa.done():
-        handled = await handle_approval_reply(message, thread, session, content, pa)
+        handled = await handle_approval_reply(incoming, session, content, pa)
         if handled:
             return
 
+    has_pending_approval = bool(conv_id and pa and not pa.done())
+    if session_manager.get_queue(incoming.conversation_id) is not None and not has_pending_approval:
+        from core.agy_runner import stop_active_process
+
+        stop_active_process(incoming.conversation_id)
+        session_manager.remove_queue(incoming.conversation_id)
+
+        prev_session = session_manager.get_session(incoming.conversation_id)
+        if prev_session:
+            session_manager.set_session(
+                incoming.conversation_id, {**prev_session, "status": "pending", "conversation_id": None}
+            )
+            session = session_manager.get_session(incoming.conversation_id)
+            conv_id = None
+
     if not conv_id:
         if session.get("status") == "pending":
-            await handle_pending_session(bot, thread, session, agy_content, content, image_paths)
+            await handle_pending_session(bot, incoming, session, agy_content, content, image_paths)
             return
         else:
             await adapter.send_message(thread, "⚠️ Session ID not found. Start a new session with `/new`.")
             return
 
-    await handle_existing_session(bot, thread, session, conv_id, agy_content, image_paths)
+    await handle_existing_session(bot, incoming, session, conv_id, agy_content, image_paths)