linkgravity 1.5.13 → 1.5.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkgravity",
-  "version": "1.5.13",
+  "version": "1.5.14",
   "description": "Discord/Telegram bot bridge for the Antigravity (agy) CLI, with voice interaction support",
   "scripts": {
     "start": "node npm-scripts/run-dev.js",

package/src/cogs/general_cog.py

@@ -18,6 +18,7 @@ from config import (
     save_bot_settings,
     session_manager,
 )
+from core.agy_runner import clean_model_name
 from core.atomic_io import atomic_write_json, safe_load_json
 from utils.utils import get_default_cwd
 
@@ -35,7 +36,8 @@ def load_cached_models():
         "Claude Opus 4.6 (Thinking)",
         "GPT-OSS 120B (Medium)",
     ]
-    return safe_load_json(MODELS_CACHE_FILE, default_models, logger=logger)
+    cached = safe_load_json(MODELS_CACHE_FILE, default_models, logger=logger)
+    return [clean_model_name(m) for m in cached]
 
 
 cached_models = load_cached_models()
@@ -79,7 +81,7 @@ async def fetch_models_background():
             line = line.strip()
             line = re.sub(r"[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]", "", line).strip()
             if line and "Fetching available models" not in line:
-                models.append(line)
+                models.append(clean_model_name(line))
 
         if models:
             cached_models = models

package/src/cogs/voice_cog.py

@@ -1,5 +1,6 @@
 import asyncio
 import math
+import re
 import time
 
 import aiohttp
@@ -9,6 +10,7 @@ from discord.ext import commands, tasks
 
 from config import allowed, logger
 from messengers.registry import get_adapter_for_platform
+from services.audio_service import LANGUAGES, TTS_VOICES, default_voice_for, resolve_language
 
 from .voice.enrollment import EnrollmentManager
 from .voice.stt_session import SttSessionTracker
@@ -34,7 +36,6 @@ class VoiceCog(commands.Cog):
     def __init__(
         self,
         bot,
-        stt,
         tts,
         send_agy_response,
         agy_send,
@@ -46,8 +47,6 @@ class VoiceCog(commands.Cog):
         logger,
     ):
         self.bot = bot
-        # Unused by the voice pipeline now (STT moved to Node); kept for other callers.
-        self.stt = stt
         self.tts = tts
         self.send_agy_response = send_agy_response
         self.agy_send = agy_send
@@ -140,37 +139,36 @@ class VoiceCog(commands.Cog):
                 opts.append(app_commands.Choice(name=str(v), value=v))
         return opts
 
-    async def tts_voice_autocomplete(
+    async def language_autocomplete(
         self, interaction: discord.Interaction, current: str
     ) -> list[app_commands.Choice[str]]:
-        current_val = self.bot_settings.get("tts_voice", "en-US-AriaNeural")
-        options = [
-            "en-US-AriaNeural",
-            "en-US-GuyNeural",
-            "en-US-AnaNeural",
-            "en-US-ChristopherNeural",
-            "en-US-EricNeural",
-            "en-US-MichelleNeural",
-            "en-US-RogerNeural",
-            "en-GB-SoniaNeural",
-            "en-GB-RyanNeural",
-            "en-AU-NatashaNeural",
-            "en-AU-WilliamNeural",
-            "ko-KR-SunHiNeural",
-            "ko-KR-InJoonNeural",
-            "ja-JP-NanamiNeural",
-            "ja-JP-KeitaNeural",
-            "fr-FR-DeniseNeural",
-            "de-DE-KatjaNeural",
-            "es-ES-ElviraNeural",
-        ]
+        current_val = resolve_language()
+        query = _autocomplete_query(current).lower()
 
         choices = []
-        if current.lower() in current_val.lower() or not current:
+        if query in current_val.lower() or not query:
             choices.append(app_commands.Choice(name=f"{current_val} (current)", value=current_val))
+        for opt in LANGUAGES:
+            if query in opt.lower() and opt != current_val and len(choices) < 25:
+                choices.append(app_commands.Choice(name=opt, value=opt))
+        return choices
 
-        for opt in options:
-            if current.lower() in opt.lower() and opt != current_val and len(choices) < 25:
+    async def tts_voice_autocomplete(
+        self, interaction: discord.Interaction, current: str
+    ) -> list[app_commands.Choice[str]]:
+        # Only same-language voices - a voice from another language would read the reply
+        # with that language's pronunciation.
+        language = resolve_language()
+        current_val = self.bot_settings.get("tts_voice") or default_voice_for(language)
+        query = _autocomplete_query(current).lower()
+
+        choices = []
+        if query in current_val.lower() or not query:
+            choices.append(app_commands.Choice(name=f"{current_val} (current)", value=current_val))
+        for opt in TTS_VOICES:
+            if not opt.startswith(f"{language}-") or opt == current_val:
+                continue
+            if query in opt.lower() and len(choices) < 25:
                 choices.append(app_commands.Choice(name=opt, value=opt))
         return choices
 
@@ -325,7 +323,8 @@ class VoiceCog(commands.Cog):
         active_times="Duration in seconds the bot stays awake",
         interrupt_threshold="Mic volume that interrupts (barges into) TTS playback (1000~10000)",
         wake_sensitivity="Wake word match sensitivity (0.1~0.9, lower = easier to trigger but more false wakes)",
-        tts_voice="Select the AI TTS voice",
+        language="Language I listen and speak in (BCP-47, e.g. en-US)",
+        tts_voice="Pick a different voice within that language",
         tts_enabled="Turn Text-to-Speech ON or OFF",
         tts_speed="TTS playback speed multiplier, e.g. 1.3 for 1.3x (0.5~2.0)",
         require_wake_word="Require your wake word before I listen (default ON) - turn OFF if you use push-to-talk",
@@ -334,6 +333,7 @@ class VoiceCog(commands.Cog):
         active_times=active_times_autocomplete,
         interrupt_threshold=interrupt_threshold_autocomplete,
         wake_sensitivity=wake_sensitivity_autocomplete,
+        language=language_autocomplete,
         tts_voice=tts_voice_autocomplete,
         tts_enabled=tts_enabled_autocomplete,
         tts_speed=tts_speed_autocomplete,
@@ -346,6 +346,7 @@ class VoiceCog(commands.Cog):
         active_times: int = None,
         interrupt_threshold: int = None,
         wake_sensitivity: float = None,
+        language: str = None,
         tts_voice: str = None,
         tts_enabled: str = None,
         tts_speed: float = None,
@@ -362,6 +363,7 @@ class VoiceCog(commands.Cog):
             and active_times is None
             and interrupt_threshold is None
             and wake_sensitivity is None
+            and language is None
             and tts_voice is None
             and tts_enabled is None
             and tts_speed is None
@@ -371,7 +373,8 @@ class VoiceCog(commands.Cog):
             curr_timer = self.bot_settings.get("active_timer", 60)
             curr_interrupt_thresh = self._vad_threshold(interaction.user.id)
             curr_wake_sens = self._wake_threshold(interaction.user.id)
-            curr_tts = self.bot_settings.get("tts_voice", "en-US-AriaNeural")
+            curr_lang = resolve_language()
+            curr_tts = self.bot_settings.get("tts_voice") or default_voice_for(curr_lang)
             curr_tts_on = "ON" if self.bot_settings.get("tts_enabled", True) else "OFF"
             curr_tts_speed = self.bot_settings.get("tts_speed", 1.0)
             curr_required = self._wake_word_required(interaction.user.id)
@@ -382,6 +385,7 @@ class VoiceCog(commands.Cog):
             embed.add_field(name="⏱️ Active Time", value=f"`{curr_timer}s`", inline=False)
             embed.add_field(name="🎯 Wake Sensitivity", value=f"`{curr_wake_sens}`", inline=False)
             embed.add_field(name="🔊 Interrupt Threshold", value=f"`{curr_interrupt_thresh}`", inline=False)
+            embed.add_field(name="🌐 Language", value=f"`{curr_lang}`", inline=False)
             embed.add_field(name="🗣️ TTS Voice", value=f"`{curr_tts}`", inline=False)
             embed.add_field(name="🔊 TTS Enabled", value=f"`{curr_tts_on}`", inline=False)
             embed.add_field(name="⏩ TTS Speed", value=f"`{curr_tts_speed}x`", inline=False)
@@ -420,6 +424,13 @@ class VoiceCog(commands.Cog):
             except (aiohttp.ClientError, asyncio.TimeoutError) as e:
                 self.logger.warning(f"Node.js wake-threshold sync failed for {interaction.user.id}: {e}")
                 updated.append(f"(⚠️ Node.js Sync Failed: {e})")
+        if language is not None:
+            self.bot_settings["language"] = language
+            self.bot_settings["tts_voice"] = default_voice_for(language)
+            updated.append(
+                f"🌐 Language: `{language}` (voice set to `{self.bot_settings['tts_voice']}`; "
+                "run `lgy restart` to apply it to speech recognition)"
+            )
         if tts_voice is not None:
             self.bot_settings["tts_voice"] = tts_voice
             updated.append(f"🗣️ TTS Voice: `{tts_voice}`")
@@ -532,7 +543,6 @@ class VoiceCog(commands.Cog):
                 return
 
             import difflib
-            import re
 
             # Wake detection is Node's Rustpotter detector's job - no text-similarity fallback.
             is_waking_up = bool(data.get("wake_confirmed"))

package/src/config.py

@@ -31,6 +31,9 @@ DEFAULT_LGY_CONFIG = {
     "voice_thresholds": {},
     "active_timer": 60,
     "tts_voice": "ko-KR-SunHiNeural",
+    # BCP-47 tag driving both speech recognition and the TTS voice.
+    # Empty means derive it from tts_voice, which is how pre-1.6 configs carry their language.
+    "language": "",
     "tts_enabled": True,
     # Sticky default for /new sessions, set whenever /model succeeds.
     "default_model": "",

package/src/core/agy_runner.py

@@ -339,13 +339,18 @@ async def run_agy(
         _intentionally_stopped.discard(thread_id)
 
 
+def clean_model_name(model: str) -> str:
+    # agy models prints "<id>\t<display name>" but --model only accepts the display name.
+    return model.split("\t")[-1].strip()
+
+
 async def agy_new_conversation(
     content: str, model: str = None, stream_queue: asyncio.Queue = None, thread_id: str = None, cwd: str = None
 ) -> tuple[str, str]:
     # --print consumes the next token as the prompt, so the flag must come first.
     args = ["--dangerously-skip-permissions", "--print", content]
     if model:
-        args.extend(["--model", model])
+        args.extend(["--model", clean_model_name(model)])
     result_text = await run_agy(*args, stream_queue=stream_queue, thread_id=thread_id, cwd=cwd)
     conv_id = await _get_latest_conversation_id()
     return result_text, conv_id
@@ -361,7 +366,7 @@ async def agy_send_message(
 ) -> str:
     args = ["--dangerously-skip-permissions", "--print", content, "--conversation", conv_id]
     if model:
-        args.extend(["--model", model])
+        args.extend(["--model", clean_model_name(model)])
     return await run_agy(*args, stream_queue=stream_queue, thread_id=thread_id, cwd=cwd)
 
 

package/src/main_discord.py

@@ -1,3 +1,6 @@
+"""Discord bot setup. Runs in the same process as Telegram (see main.py),
+which starts both concurrently when both platforms are enabled."""
+
 import asyncio
 import atexit
 import os
@@ -14,7 +17,7 @@ from messengers.discord_adapter import DiscordAdapter
 from messengers.registry import register_adapter
 from services.response import send_agy_response
 from services.streaming import stream_thinking_latest
-from utils.utils import agy_new_conversation, agy_send_message, stt, tts
+from utils.utils import agy_new_conversation, agy_send_message, tts
 
 voice_process = None
 _voice_shutting_down = False
@@ -287,7 +290,6 @@ async def run_discord(stop_event: asyncio.Event) -> None:
         await bot.add_cog(
             VoiceCog(
                 bot=bot,
-                stt=stt,
                 tts=tts,
                 send_agy_response=send_agy_response,
                 agy_send=agy_send_message,

package/src/services/audio_service.py

@@ -6,9 +6,102 @@ from pathlib import Path
 
 from config import TTS_VOICE, bot_settings, logger
 
+# Verified against edge-tts's live voice list; a name that isn't in it fails at synthesis time.
+# Ordered - the first voice of a language is that language's default.
+TTS_VOICES = [
+    "en-US-AriaNeural",
+    "en-US-GuyNeural",
+    "en-US-AnaNeural",
+    "en-US-ChristopherNeural",
+    "en-US-EricNeural",
+    "en-US-MichelleNeural",
+    "en-US-RogerNeural",
+    "en-GB-SoniaNeural",
+    "en-GB-RyanNeural",
+    "en-AU-NatashaNeural",
+    "en-AU-WilliamMultilingualNeural",
+    "ko-KR-SunHiNeural",
+    "ko-KR-InJoonNeural",
+    "ja-JP-NanamiNeural",
+    "ja-JP-KeitaNeural",
+    "zh-CN-XiaoxiaoNeural",
+    "zh-CN-YunxiNeural",
+    "fr-FR-DeniseNeural",
+    "de-DE-KatjaNeural",
+    "es-ES-ElviraNeural",
+    "it-IT-ElsaNeural",
+    "pt-BR-FranciscaNeural",
+    "ru-RU-SvetlanaNeural",
+    "hi-IN-SwaraNeural",
+    "id-ID-GadisNeural",
+    "vi-VN-HoaiMyNeural",
+    "th-TH-PremwadeeNeural",
+    "tr-TR-EmelNeural",
+    "pl-PL-ZofiaNeural",
+    "nl-NL-ColetteNeural",
+    "ar-SA-ZariyahNeural",
+]
+
+LANGUAGES = list(dict.fromkeys(v.rsplit("-", 1)[0] for v in TTS_VOICES))
+
+DEFAULT_LANGUAGE = "en-US"
+
+# Ordered: the first script reaching the share threshold wins, so Hangul beats Latin in mixed
+# Korean/English text, and kana beats Han in Japanese (which is written with both).
+SCRIPT_PATTERNS = [
+    ("ko", re.compile(r"[가-힣]")),
+    ("ja", re.compile(r"[ぁ-ゖァ-ヺ]")),
+    ("ru", re.compile(r"[\u0400-\u04ff]")),
+    ("ar", re.compile(r"[\u0600-\u06ff]")),
+    ("th", re.compile(r"[\u0e00-\u0e7f]")),
+    ("hi", re.compile(r"[\u0900-\u097f]")),
+    ("zh", re.compile(r"[\u4e00-\u9fff]")),
+    ("en", re.compile(r"[a-zA-Z]")),
+]
+
+SCRIPT_SHARE = 0.3
+
+
+def detect_script(text: str) -> str | None:
+    counts = {tag: len(pattern.findall(text)) for tag, pattern in SCRIPT_PATTERNS}
+    total = sum(counts.values())
+    if not total:
+        return None
+    for tag, _ in SCRIPT_PATTERNS:
+        if counts[tag] / total >= SCRIPT_SHARE:
+            return tag
+    return max(counts, key=counts.get)
+
+
+def default_voice_for(tag: str) -> str:
+    for voice in TTS_VOICES:
+        if voice.startswith(f"{tag}-"):
+            return voice
+    if "-" in tag:
+        return default_voice_for(tag.split("-")[0])
+    return TTS_VOICES[0]
+
+
+def resolve_language() -> str:
+    # Mirrored by resolveLanguage() in voice-service/stt.js, which is what reaches Google.
+    configured = bot_settings.get("language")
+    if configured:
+        return configured
+    voice = bot_settings.get("tts_voice") or TTS_VOICE or ""
+    return voice.rsplit("-", 1)[0] if voice.count("-") >= 2 else DEFAULT_LANGUAGE
+
+
+def voice_for(text: str) -> str:
+    # Latin script covers dozens of languages, so a configured en-GB voice must survive a bare
+    # "en" detection instead of being reset to the en-US default.
+    configured = bot_settings.get("tts_voice") or TTS_VOICE
+    script = detect_script(text)
+    if script is None or configured.startswith(f"{script}-"):
+        return configured
+    return default_voice_for(script)
+
 
 async def tts(text: str, voice: str = None) -> bytes | None:
-    voice = voice or bot_settings.get("tts_voice", TTS_VOICE)
     try:
         import edge_tts
 
@@ -17,24 +110,12 @@ async def tts(text: str, voice: str = None) -> bytes | None:
         clean = re.sub(r"\n+", ". ", clean).strip()[:800]
         if not clean:
             return None
-        hangul_chars = len(re.findall(r"[가-힣]", clean))
-        alpha_chars = len(re.findall(r"[a-zA-Z]", clean))
-        total_letters = hangul_chars + alpha_chars
-        ko_voice = os.getenv("TTS_VOICE_KO", "ko-KR-SunHiNeural")
-        en_voice = os.getenv("TTS_VOICE_EN", "en-US-AriaNeural")
-
-        if total_letters == 0:
-            active_voice = TTS_VOICE
-        elif (hangul_chars / total_letters) >= 0.3:
-            active_voice = ko_voice
-        else:
-            active_voice = en_voice
 
         speed = bot_settings.get("tts_speed", 1.0)
         pct = round((speed - 1.0) * 100)
         rate = f"{'+' if pct >= 0 else ''}{pct}%"
 
-        communicate = edge_tts.Communicate(clean, active_voice, rate=rate)
+        communicate = edge_tts.Communicate(clean, voice or voice_for(clean), rate=rate)
         with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as f:
             tmp = f.name
         await communicate.save(tmp)
@@ -58,7 +139,7 @@ async def stt(audio_bytes: bytes) -> str | None:
             with sr.AudioFile(io.BytesIO(audio_bytes)) as source:
                 audio = r.record(source)
             try:
-                return r.recognize_google(audio, language="ko-KR")
+                return r.recognize_google(audio, language=resolve_language())
             except sr.UnknownValueError:
                 return None
             except sr.RequestError as e:

package/voice-service/stt.js

@@ -1,9 +1,20 @@
 const { spawn } = require('child_process');
 const ffmpegPath = require('ffmpeg-static');
+const { aglConfig } = require('./config');
 
 // Unofficial Google STT key - same default Python's SpeechRecognition (recognize_google) ships with.
 const GOOGLE_STT_KEY = 'AIzaSyBOti4mM-6x9WDnZIjIeyEU21OpBXqWBgw';
 
+// Mirrored by resolve_language() in src/services/audio_service.py. edge-tts voice names are
+// <lang>-<REGION>-<Name>, so a pre-1.6 config carries its language in tts_voice alone.
+function resolveLanguage() {
+    if (aglConfig.language) return aglConfig.language;
+    const match = /^([a-z]{2}-[A-Z]{2})-/.exec(aglConfig.tts_voice || '');
+    return match ? match[1] : 'en-US';
+}
+
+const LANGUAGE = resolveLanguage();
+
 function flacEncode(wavBuffer) {
     return new Promise((resolve, reject) => {
         const ff = spawn(ffmpegPath, [
@@ -29,7 +40,7 @@ function flacEncode(wavBuffer) {
     });
 }
 
-async function googleSTT(wavBuffer, lang = 'ko-KR') {
+async function googleSTT(wavBuffer, lang = LANGUAGE) {
     let flacBuffer;
     try {
         flacBuffer = await flacEncode(wavBuffer);
@@ -54,6 +65,7 @@ async function googleSTT(wavBuffer, lang = 'ko-KR') {
     }
 
     const raw = await res.text();
+    console.debug('[STT] raw:', raw.trim().replace(/\n/g, ' | '));
     // Response is newline-delimited JSON, one object per line.
     for (const line of raw.trim().split('\n')) {
         if (!line) continue;