linkgravity 1.2.0 → 1.2.2

package/README.md

@@ -1,33 +1,32 @@
-# LinkGravity (lgy)
+# LinkGravity
 
-A Discord bot interface for the Antigravity (agy) agentic AI system. It translates Antigravity CLI prompts into Discord UI components and provides voice interaction capabilities.
+A Discord bot interface for the Antigravity agentic AI system. It translates Antigravity CLI prompts into Discord UI components and provides voice interaction capabilities.
 
 ## Features
 
 - **Environment Sync:** Automatically syncs with the host's `~/.gemini` configuration.
-- **Voice Interaction:** Supports voice channels with adaptive VAD (Voice Activity Detection) to segment speech and filter environmental noise, plus live "listening..." feedback while you're still talking.
+- **Voice Interaction:** Supports voice channels with adaptive voice activity detection to segment speech and filter environmental noise, plus live "listening..." feedback while you're still talking.
 - **Wake Word Recognition:** Uses phoneme-level similarity to detect wake words and activate voice commands.
-- **CLI Prompt Interception:** Converts CLI prompts (`ask_question`, `run_command` approvals) into interactive Discord buttons.
-- **Command Security:** Parses chained shell commands (`&&`, `||`, `;`) and requires individual approval for each command. Supports prefix-based scope whitelisting.
-- **Multi-Modal Input:** Attach any file (not just images) for the AI to read; audio attachments (`.ogg`/`.mp3`/`.m4a`/`.wav`) are transcribed to text automatically.
+- **Approval Flow:** Command and tool-call approvals become interactive Discord buttons. Chained shell commands are approved individually, and any approval can be scoped to auto-allow that command or tool going forward - something plain `agy` doesn't do.
+- **Multi-Modal Input:** Attach files for the AI to read, including audio, which gets transcribed to text automatically.
 
-## Prerequisites
+## Requirements
 
 - Node.js >= 18
 - Python >= 3.10
-- `agy` (Antigravity CLI) installed on this machine
-- `ffmpeg` on your PATH (needed for TTS/voice playback)
-- A Discord bot token, and at least one server/channel to allow it in
+- Antigravity CLI installed on this machine
+- A messenger bot token, and at least one server/channel to allow it in
+  - **Discord** - currently the only one supported
 
 ### Creating the Discord bot
 
 In the [Discord Developer Portal](https://discord.com/developers/applications), create an application and bot, then:
 
-- Under **Bot**, enable the **Message Content** privileged intent (required - the bot reads message text/attachments).
+- Under **Bot**, enable the **Message Content** privileged intent - required, since the bot reads message text/attachments.
 - Under **OAuth2 → URL Generator**, select the **bot** and **applications.commands** scopes, then these bot permissions:
   - Send Messages, Send Messages in Threads, Create Public Threads
   - Read Message History, Attach Files, Embed Links, Add Reactions
-  - Connect, Speak (for voice channel support)
+  - Connect, Speak - for voice channel support
 - Use the generated URL to invite the bot to your server.
 
 ## Installation
@@ -36,7 +35,7 @@ In the [Discord Developer Portal](https://discord.com/developers/applications),
 npm install -g linkgravity
 ```
 
-This runs a postinstall step that creates a Python virtual environment at `~/.gemini/linkgravity/venv/` (kept outside the package install location on purpose - see `npm-scripts/venv-paths.js`) and installs `requirements.txt` into it - no manual `pip install` needed.
+Sets up its own Python environment automatically - no manual `pip install` needed.
 
 ## Setup
 
@@ -46,11 +45,11 @@ Run the configuration wizard once to set your bot token, allowed servers/channel
 lgy setup
 ```
 
-This writes to `~/.gemini/linkgravity/lgy.json` (outside the package directory, so `npm update`/reinstall never touches it). You can re-run `lgy setup` any time to change settings later - each field keeps its current value if you leave it empty.
+This writes to `~/.gemini/linkgravity/lgy.json`, outside the package directory, so `npm update`/reinstall never touches it. You can re-run `lgy setup` any time to change settings later - each field keeps its current value if you leave it empty.
 
 During setup you'll be asked for one or more Discord servers to allow, and optionally specific channels within each:
 
-- Leave the channel list empty for a server → **the whole server** is allowed (any channel can start a session).
+- Leave the channel list empty for a server → **the whole server** is allowed - any channel can start a session.
 - List specific channel IDs for a server → **only those channels** in that server are allowed.
 
 A new session is only ever started with the **`/new`** slash command in Discord - never just by typing a message. `/new` works both in a regular channel and from inside an existing thread.
@@ -58,57 +57,35 @@ A new session is only ever started with the **`/new`** slash command in Discord
 ## Usage
 
 ```bash
-lgy start      # Start the bot as a background daemon (via PM2)
+lgy start      # Start the bot as a background daemon via PM2
 lgy stop       # Stop it
 lgy restart    # Restart it
-lgy logs       # View live logs (add -f to follow, --tail N for more lines)
+lgy logs       # View live logs - add -f to follow, --tail N for more lines
 lgy enable     # Register the bot to auto-start on system boot
 lgy disable    # Remove it from system boot
-lgy            # Interactive menu (same commands, picked from a list)
+lgy            # Interactive menu - same commands, picked from a list
 ```
 
 ## Development
 
-This project uses [Ruff](https://docs.astral.sh/ruff/) for Python linting/formatting and [Prettier](https://prettier.io/) for the Node.js side. `npm install` sets both up automatically (installs `requirements-dev.txt` into the venv at `~/.gemini/linkgravity/venv/`, registers git hooks) - manual install is only needed if you want to run them yourself outside of a commit. The venv lives outside this checkout (see `npm-scripts/venv-paths.js` for why), so on macOS/Linux:
-
 ```bash
-~/.gemini/linkgravity/venv/bin/ruff check src/    # lint
-~/.gemini/linkgravity/venv/bin/ruff format src/   # format
-
-npm run format:check        # check JS formatting
-npm run format              # format JS
+npm i
 ```
 
-(On Windows, replace `venv/bin/ruff` with `venv\Scripts\ruff.exe` under the same `~/.gemini/linkgravity/` directory.)
-
-Git hooks (via [pre-commit](https://pre-commit.com/), config in `.pre-commit-config.yaml`) run automatically once you `npm install`:
-
-- **pre-commit**: runs `ruff` (lint + format) and `prettier` on staged files, auto-fixing what it can.
-- **commit-msg**: enforces [Conventional Commits](https://www.conventionalcommits.org/) (e.g. `fix: ...`, `feat: ...`, `docs: ...`) via [conventional-pre-commit](https://github.com/compilerla/conventional-pre-commit).
-
-If a hook doesn't seem to be running, check `git config --get core.hooksPath` - it should be unset (or point at `.git/hooks`, pre-commit's default). A leftover `.husky` value from an older checkout will silently make git skip pre-commit's hooks entirely; `git config --unset core.hooksPath` fixes it.
+That's it - it wires up [Ruff](https://docs.astral.sh/ruff/) for Python and [Prettier](https://prettier.io/) for Node, plus git hooks that lint/format on commit and enforce [Conventional Commits](https://www.conventionalcommits.org/) commit messages.
 
 ## Debugging
 
-Set `LOG_LEVEL=DEBUG` in your shell before `lgy restart` for verbose logs, including agy's raw stdout for each turn (`lgy` passes your shell's environment through to the daemon on restart). Defaults to `INFO`. Use `lgy logs -t` (or `--timestamp`) to include timestamps - they're stripped by default.
-
-## Known Issues
-
-**Wake word false positives on short words** (e.g. "시리", "잼민이"): Rustpotter's phoneme matching carries less signal for 1-2 syllable words, so genuine-match and unrelated-speech score distributions overlap - no single threshold cleanly separates them. Current mitigations in `voice-service/index.js`'s `getDetectorForUser` and `cogs/voice_cog.py`'s `handle_stt_input`:
-
-- `score_mode: Max` (each of the 5 enrollment samples can cover a different natural tone/pace, instead of requiring all 5 to be delivered consistently like `Median` did)
-- `min_scores: 4` (requires a candidate to keep winning across several frames, compensating for `Max` being more permissive per-frame)
-- The STT-based text cross-check is tightened specifically for short wake words (similarity floor 0.55, vs. 0.35 for longer ones) - this is currently doing most of the real work of rejecting false positives
-
-This isn't fully solved. If issues persist after real-world use, prefer these over further threshold guessing:
+```bash
+LOG_LEVEL=DEBUG lgy start
+```
 
-1. Encourage re-enrolling with a longer/more distinctive wake word (a 1-2 syllable word is close to a hard ceiling for this approach, regardless of tuning)
-2. Log `bestWakeScore` + outcome (no raw audio) during a trial period and re-tune the constants above against that data instead of guessing
+Use `lgy logs -t` to include timestamps.
 
 ## Security Warning
 
 This bot gives an AI agent broad access to the machine it runs on - **that's inherent to what it does, so don't expose it publicly or run it somewhere you don't fully trust its users.**
 
-- `allowed_user_ids` (set via `lgy setup`) is your primary access control - always set it.
-- Tool calls (including shell commands) go through an approval flow in Discord by default; treat anyone in `allowed_user_ids` as having effectively full control of this machine.
+- `allowed_user_ids`, set via `lgy setup`, is your primary access control - always set it.
+- Tool calls, including shell commands, go through an approval flow in Discord by default; treat anyone in `allowed_user_ids` as having effectively full control of this machine.
 - Your Discord token and other settings live in `~/.gemini/linkgravity/lgy.json`, outside this repo/package directory - never commit or share that file.

package/bin/cli.js

@@ -14,6 +14,7 @@ const color = {
     green: '\x1b[32m',
     cyan: '\x1b[36m',
     yellow: '\x1b[33m',
+    red: '\x1b[31m',
     dim: '\x1b[2m',
 };
 
@@ -76,31 +77,71 @@ function runPm2(args, silent = true) {
 // Only strips the FIRST bracket group if present, so aiohttp's second
 // "[INFO ]" bracket (not a timestamp) is left alone.
 const TIMESTAMP_PREFIX = /^\[?\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}\]?\s*/;
+// loguru's colorize=True puts an ANSI code before the timestamp digits, breaking the '^' anchor above.
+// eslint-disable-next-line no-control-regex
+const ANSI_ESCAPE = /\x1b\[[0-9;]*m/g;
+
+const LEVEL_COLOR = {
+    DEBUG: color.dim,
+    INFO: color.cyan,
+    WARNING: color.yellow,
+    ERROR: color.red,
+    CRITICAL: color.red,
+};
+
+// Recolors the level word ourselves so Python (loguru) and Node (plain console.log) lines match.
+function colorizeLevel(line) {
+    return line.replace(/\b(DEBUG|INFO|WARNING|ERROR|CRITICAL)\b/, (match) => {
+        const c = LEVEL_COLOR[match];
+        return c ? `${c}${match}${color.reset}` : match;
+    });
+}
 
 function runPm2LogsClean(args, showStamps = false) {
     const cp = spawn('npx', ['-y', 'pm2', ...args], { cwd: path.join(__dirname, '..') });
 
-    const filterAndPrint = (data) => {
-        const lines = data.toString().split('\n');
-        for (const line of lines) {
-            if (line.trim().length === 0) continue;
-            if (
-                line.includes('In-memory PM2') ||
-                line.includes('pm2 update') ||
-                line.includes('[TAILING]') ||
-                line.includes('.pm2/logs/lgy') ||
-                line.includes('In memory PM2 version') ||
-                line.includes('Local PM2 version') ||
-                line.match(/^>+ /)
-            ) {
-                continue;
-            }
-            console.log(showStamps ? line : line.replace(TIMESTAMP_PREFIX, ''));
+    const printLine = (line) => {
+        if (line.trim().length === 0) return;
+        if (
+            line.includes('In-memory PM2') ||
+            line.includes('pm2 update') ||
+            line.includes('[TAILING]') ||
+            line.includes('.pm2/logs/lgy') ||
+            line.includes('In memory PM2 version') ||
+            line.includes('Local PM2 version') ||
+            line.match(/^>+ /)
+        ) {
+            return;
         }
+        const clean = line.replace(ANSI_ESCAPE, '');
+        const displayLine = colorizeLevel(showStamps ? clean : clean.replace(TIMESTAMP_PREFIX, ''));
+        console.log(displayLine);
     };
 
-    cp.stdout.on('data', filterAndPrint);
-    cp.stderr.on('data', filterAndPrint);
+    // A line can arrive split across two 'data' events, so buffer until '\n' is seen.
+    function makeChunkHandler() {
+        let buffer = '';
+        const handler = (data) => {
+            buffer += data.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop(); // last element: '' if buffer ended in '\n', else the incomplete tail
+            for (const line of lines) printLine(line);
+        };
+        handler.flush = () => {
+            if (buffer) printLine(buffer);
+            buffer = '';
+        };
+        return handler;
+    }
+
+    const stdoutHandler = makeChunkHandler();
+    const stderrHandler = makeChunkHandler();
+    cp.stdout.on('data', stdoutHandler);
+    cp.stderr.on('data', stderrHandler);
+    cp.on('close', () => {
+        stdoutHandler.flush();
+        stderrHandler.flush();
+    });
 }
 
 function verifyStartup() {
@@ -168,7 +209,14 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
     runPm2(['restart', 'lgy', '--update-env']);
     verifyStartup();
 } else if (cmd === 'logs') {
-    let args = process.argv.slice(3);
+    const SHORT_FLAGS = ['-f', '-n', '-t'];
+    let args = process.argv.slice(3).flatMap((arg) => {
+        // Only split bare combined short flags (e.g. "-fn" -> "-f", "-n"), not "--long" flags.
+        if (!/^-[a-z]{2,}$/.test(arg)) return [arg];
+        const chars = arg.slice(1).split('');
+        if (!chars.every((c) => SHORT_FLAGS.includes(`-${c}`))) return [arg];
+        return chars.map((c) => `-${c}`);
+    });
     let pm2Args = ['logs', 'lgy'];
     let isFollow = false;
     let showStamps = false;
@@ -265,8 +313,7 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
     if (restartResult.status === 0) {
         verifyStartup();
     } else if ((restartResult.stderr || '').toString().includes('not found')) {
-        // Daemon wasn't running before the update - start it fresh instead
-        // of reporting a restart that never had anything to restart.
+        // Wasn't running before the update - start fresh instead of a false "restarted".
         info("Daemon wasn't running - starting it fresh...");
         runPm2(['start', botPath, '--interpreter', pythonExe, '--name', 'lgy']);
         verifyStartup();

package/bin/setup.js

@@ -278,9 +278,7 @@ async function runSetup() {
     } else {
         const stderr = (restartResult.stderr || '').toString();
         if (stderr.includes('not found')) {
-            // Nothing to restart yet (first-ever setup, or pm2's process list was
-            // reset e.g. after a reboot without `pm2 save`) - start it instead of
-            // reporting a false "restarted" success.
+            // Nothing to restart yet - start it instead of a false "restarted".
             const botPath = path.join(__dirname, '..', 'src', 'main.py');
             const startResult = spawnSync(
                 'npx',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkgravity",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Discord bot bridge for the Antigravity (agy) CLI, with voice interaction support",
   "scripts": {
     "postinstall": "node npm-scripts/postinstall.js",

package/src/cogs/general_cog.py

@@ -273,10 +273,7 @@ class GeneralCog(commands.Cog):
                 prev_tts.cancel()
                 session_manager.remove_tts_task(thread_id)
 
-            # A killed turn leaves the conversation in an unknown state -
-            # reusing conv_id risks silently hanging on the next message.
-            # conversation_id must be cleared too, not just status: the
-            # text path only treats a session as pending when both are unset.
+            # Must clear conversation_id too, not just status - pending requires both unset.
             session_manager.set_session(thread_id, {**session, "status": "pending", "conversation_id": None})
 
         from core.agy_runner import stop_active_process

package/src/cogs/voice/enrollment.py

@@ -337,7 +337,7 @@ class EnrollmentManager:
             except aiohttp.ClientError as e:
                 self.logger.warning(f"Failed to invalidate cached detector for {user_id}: {e}")
 
-        self.bot_settings["wake_words"] = session["word"]
+        self.bot_settings.setdefault("wake_words", {})[user_id] = session["word"]
         self.save_bot_settings(self.bot_settings)
 
         del self._enrollment[user_id]

package/src/cogs/voice_cog.py

@@ -44,8 +44,7 @@ class VoiceCog(commands.Cog):
         self.save_bot_settings = save_bot_settings
         self.logger = logger
         self._voice_state = {}
-        # guild_id -> in-flight handle_stt_input task, if any. A new
-        # utterance cancels the previous one so replies can't race out of order.
+        # guild_id -> in-flight handle_stt_input task; a new utterance cancels the previous one.
         self._active_turns = {}
         self.enrollment = EnrollmentManager(
             bot, self._voice_state, self._play_audio, self.bot_settings, self.save_bot_settings, self.logger
@@ -175,12 +174,13 @@ class VoiceCog(commands.Cog):
         vc_chan = interaction.user.voice.channel
         guild_id = interaction.guild_id
 
-        has_wake_word = bool(self.bot_settings.get("wake_words"))
+        wake_word_map = self.bot_settings.get("wake_words") or {}
+        has_wake_word = bool(wake_word_map)
         active_timer = self.bot_settings.get("active_timer", 60)
 
         if has_wake_word:
-            wake_words_raw = self.bot_settings["wake_words"]
-            ww_list = [f"`{w.strip()}`" for w in wake_words_raw.split(",") if w.strip()]
+            # 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]
             msg = (
                 f"🎤 Connected to `{vc_chan.name}`.\n"
@@ -275,7 +275,7 @@ class VoiceCog(commands.Cog):
             and tts_voice is None
             and tts_enabled is None
         ):
-            curr_wake = self.bot_settings.get("wake_words", "None")
+            curr_wake = (self.bot_settings.get("wake_words") or {}).get(str(interaction.user.id), "None")
             curr_timer = self.bot_settings.get("active_timer", 60)
             curr_thresh = self.bot_settings.get("voice_threshold", 3000)
             curr_tts = self.bot_settings.get("tts_voice", "en-US-AriaNeural")
@@ -292,8 +292,7 @@ class VoiceCog(commands.Cog):
         updated = []
         wake_word_pending = False
         if wake_word is not None:
-            # Deferred: wake_words only gets set once 5 samples are
-            # recorded and confirmed (see EnrollmentManager), not here.
+            # Deferred - wake_words is set later once 5 samples are recorded (see EnrollmentManager).
             wake_word_pending = True
         if active_times is not None:
             self.bot_settings["active_timer"] = active_times
@@ -383,8 +382,7 @@ class VoiceCog(commands.Cog):
                 await self.stt_session.clear_partial_msg(str(guild_id))
                 return
 
-            # Node runs STT itself before calling this endpoint, so this is
-            # already-recognized text, not raw audio - keeps STT off every VAD hit.
+            # Node runs STT itself before this call, so 'text' is already-recognized, not raw audio.
             text = data.get("text")
 
             thread_id = self._voice_state.get(str(guild_id))
@@ -407,10 +405,7 @@ class VoiceCog(commands.Cog):
             import difflib
             import re
 
-            # Wake detection is Node's audio-based Rustpotter detector's job.
-            # No text-similarity fallback: an unenrolled user (or a failed
-            # .rpw build - see EnrollmentManager._build_rustpotter_reference)
-            # just can't wake the bot until that's fixed.
+            # Wake detection is Node's Rustpotter detector's job - no text-similarity fallback.
             is_waking_up = bool(data.get("wake_confirmed"))
             matched_wake_word = data.get("matched_wake_word")
             is_active = self.stt_session.is_active(str(guild_id))
@@ -444,8 +439,7 @@ class VoiceCog(commands.Cog):
                         if prefix_similarity >= 0.6:
                             text_to_ai = " ".join(words[wake_word_count:]).strip()
 
-            # No text resemblance at all + short wake word (less acoustic
-            # signal, more false-wakes) -> require a closer match to trust it.
+            # Short wake words have less acoustic signal (more false-wakes) -> need a closer match.
             wake_syllables = len(re.sub(r"[^\w가-힣]", "", matched_wake_word or ""))
             min_prefix_similarity = 0.55 if wake_syllables <= 2 else 0.35
             if is_waking_up and prefix_similarity is not None and prefix_similarity < min_prefix_similarity:
@@ -458,9 +452,7 @@ class VoiceCog(commands.Cog):
 
             self.logger.debug(f"STT recognized: {text} -> AI: {text_to_ai}")
 
-            # A previous in-flight turn for this guild is now stale - cancel
-            # it, kill its agy process (like /stop), and stop its playback,
-            # rather than letting two turns race to completion.
+            # A stale in-flight turn for this guild - cancel it, kill its agy process, stop playback.
             prev_task = self._active_turns.get(str(guild_id))
             if prev_task and not prev_task.done():
                 prev_task.cancel()

package/src/config.py

@@ -7,6 +7,10 @@ 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.
+WAKE_REF_DIR = WORKSPACE_DIR / "wake_refs"
+WAKE_REF_DIR.mkdir(parents=True, exist_ok=True)
 
 LGY_CONFIG_FILE = WORKSPACE_DIR / "lgy.json"
 
@@ -14,13 +18,13 @@ DEFAULT_LGY_CONFIG = {
     "discord_token": "",
     "session_scopes": [],
     "allowed_user_ids": "",
-    "wake_words": "Jarvis",
+    # user_id (str) -> registered word, one per person (see EnrollmentManager._commit_enrollment).
+    "wake_words": {},
     "active_timer": 60,
     "voice_threshold": 3000,
     "tts_voice": "ko-KR-SunHiNeural",
     "tts_enabled": True,
-    # Sticky default for new /new sessions - set whenever /model succeeds,
-    # so a new thread doesn't fall back to agy's own settings.json model.
+    # Sticky default for /new sessions, set whenever /model succeeds.
     "default_model": "",
 }
 
@@ -34,10 +38,26 @@ class _PrintLogger:
         print(f"[config] {msg}")
 
 
+def _migrate_legacy_wake_words():
+    """Pre-1.3, wake_words was one global string shared by everyone and
+    overwritten by each /sound call. The .rpw files were always saved per
+    user_id though, so rebuild the real per-user mapping from those."""
+    migrated = {}
+    for user_dir in WAKE_REF_DIR.iterdir():
+        if not user_dir.is_dir():
+            continue
+        rpw = next(user_dir.glob("*.rpw"), None)
+        if rpw:
+            migrated[user_dir.name] = rpw.stem.replace("_", " ")
+    return migrated
+
+
 def load_bot_settings():
     data = safe_load_json(LGY_CONFIG_FILE, DEFAULT_LGY_CONFIG.copy(), logger=_PrintLogger())
     for k, v in DEFAULT_LGY_CONFIG.items():
         data.setdefault(k, v)
+    if isinstance(data.get("wake_words"), str):
+        data["wake_words"] = _migrate_legacy_wake_words()
     return data
 
 
@@ -94,15 +114,9 @@ def is_allowed_session_channel(channel) -> bool:
 
 TMP_FILE_DIR = WORKSPACE_DIR / "tmp-files"
 TMP_VOICE_DIR = WORKSPACE_DIR / "tmp-voice"
-# Per-user wake-word recordings + built .rpw reference (see
-# EnrollmentManager in cogs/voice/enrollment.py). No folder/.rpw yet means
-# "not enrolled" - falls back to transcribing everything and matching
-# bot_settings["wake_words"] as text.
-WAKE_REF_DIR = WORKSPACE_DIR / "wake_refs"
 
 TMP_FILE_DIR.mkdir(parents=True, exist_ok=True)
 TMP_VOICE_DIR.mkdir(parents=True, exist_ok=True)
-WAKE_REF_DIR.mkdir(parents=True, exist_ok=True)
 
 MAX_EMBED_LEN = 1900
 STREAM_RATE_LIMIT_SEC = 0.5