@grinev/opencode-telegram-bot 0.22.0 → 0.22.2

package/.env.example

@@ -105,6 +105,18 @@ OPENCODE_MODEL_ID=big-pickle
 # raw = show assistant replies as plain text
 # MESSAGE_FORMAT_MODE=markdown
 
+# Initial runtime settings preset (optional)
+# A JSON object that seeds the bot's default /settings values on first run.
+# Keys not yet persisted in settings.json are initialised to these values;
+# any setting the user has already changed via /settings is left untouched.
+# Supported keys: ttsMode ("off"|"all"|"auto"), compactOutputMode (bool),
+#   showThinkingContent (bool), showAssistantRunFooter (bool),
+#   responseStreamingMode ("edit"|"draft"), sendDiffFileAttachments (bool)
+# The preset is validated at startup: invalid JSON, a non-object value, unknown
+# keys, or wrong value types abort startup with a clear error (fail fast).
+# Example — hide the run footer and enable compact mode by default:
+# INITIAL_SETTINGS_PRESET={"showAssistantRunFooter":false,"compactOutputMode":true}
+
 # Directory Browser Roots (optional)
 # Comma-separated list of paths that /open is allowed to browse.
 # Supports ~ for home directory. Defaults to ~ when not set.
@@ -125,11 +137,15 @@ OPENCODE_MODEL_ID=big-pickle
 # STT_API_KEY=
 # STT_MODEL=
 # STT_LANGUAGE=
+# STT request format (default: multipart)
+# multipart = standard OpenAI/Groq Whisper form-data upload
+# json      = base64 audio in an `input_audio` JSON body (e.g. OpenRouter)
+# STT_REQUEST_FORMAT=multipart
 # STT_NOTE_PROMPT="The following text is transcribed from voice. It may contain homophone or phonetic errors. Infer the intended meaning from context."
 
 # Text-to-Speech credentials (optional)
 # TTS reply behavior is controlled globally with /tts and persisted in settings.json.
-# Provider: "openai" (default), "elevenlabs", or "google".
+# Provider: "openai" (default), "elevenlabs", "google", or "edge".
 #
 # --- OpenAI-compatible (default) ---
 # Set TTS_API_URL and TTS_API_KEY to any OpenAI-compatible TTS endpoint.
@@ -155,3 +171,10 @@ OPENCODE_MODEL_ID=big-pickle
 # TTS_PROVIDER=google
 # TTS_VOICE=en-US-Studio-O
 # GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account-key.json
+#
+# --- Microsoft Edge TTS ---
+# Uses Microsoft Edge's online Read Aloud service. No API key or account
+# required; only an outbound HTTPS/WebSocket connection to
+# speech.platform.bing.com. Voice list: https://learn.microsoft.com/azure/ai-services/speech-service/language-support
+# TTS_PROVIDER=edge
+# TTS_VOICE=en-US-EmmaMultilingualNeural

package/README.md

@@ -233,11 +233,13 @@ When installed via npm, the configuration wizard handles the initial setup. The
 | `TRACK_BACKGROUND_SESSIONS`                | Track detached/non-current sessions in the current selected project/worktree and send short notifications             |    No    | `true`                   |
 | `RESPONSE_STREAM_THROTTLE_MS`              | Stream update throttle in milliseconds for assistant, thinking, and tool message edits                                |    No    | `1000`                   |
 | `MESSAGE_FORMAT_MODE`                      | Assistant reply formatting mode: `markdown` (Telegram MarkdownV2) or `raw`                                            |    No    | `markdown`               |
+| `INITIAL_SETTINGS_PRESET`                  | JSON object that seeds default `/settings` values on first run (keys not yet persisted); see [Runtime Settings](#runtime-settings) |    No    | `{}`                     |
 | `CODE_FILE_MAX_SIZE_KB`                    | Max file size (KB) to send as document                                                                                |    No    | `100`                    |
 | `STT_API_URL`                              | Whisper-compatible API base URL (enables voice/audio transcription)                                                   |    No    | —                        |
 | `STT_API_KEY`                              | API key for your STT provider                                                                                         |    No    | —                        |
 | `STT_MODEL`                                | STT model name passed to `/audio/transcriptions`                                                                      |    No    | `whisper-large-v3-turbo` |
 | `STT_LANGUAGE`                             | Optional language hint (empty = provider auto-detect)                                                                 |    No    | —                        |
+| `STT_REQUEST_FORMAT`                       | STT request format: `multipart` (standard OpenAI/Groq Whisper) or `json` (base64 `input_audio` body, e.g. OpenRouter) |    No    | `multipart`              |
 | `STT_NOTE_PROMPT`                          | Optional note prepended to the LLM prompt as `[Note: ...]` for voice transcriptions; empty / `false` / `0` disable it |    No    | —                        |
 | `TTS_PROVIDER`                             | TTS provider: `openai` for OpenAI-compatible APIs, `elevenlabs` for ElevenLabs, or `google` for Google Cloud TTS      |    No    | `openai`                 |
 | `TTS_API_URL`                              | TTS API base URL for OpenAI-compatible APIs or ElevenLabs                                                             |    No    | —                        |
@@ -258,10 +260,17 @@ Runtime preferences are changed from `/settings` and stored in `settings.json`:
 
 - Compact output mode
 - Thinking content display
+- Assistant run footer display
 - Diff file attachments
 - Response streaming mode: `edit` or `draft (experimental)`; applies only to final assistant replies, not thinking messages
 - Audio replies: `off`, `all`, or `auto` when TTS is configured
 
+You can seed the initial defaults for any of these settings without hard-coding them in your Docker image by setting `INITIAL_SETTINGS_PRESET` to a JSON object. Only keys not yet persisted in `settings.json` are affected — settings the user has already changed via `/settings` are left untouched:
+
+```env
+INITIAL_SETTINGS_PRESET={"showAssistantRunFooter":false,"compactOutputMode":true,"ttsMode":"auto"}
+```
+
 ### Reverse Proxy (Optional)
 
 For environments that block `api.telegram.org` but allow your own HTTPS endpoint (corporate networks, restricted regions), you can route Bot API traffic through a reverse proxy you control. This is an alternative to the SOCKS/HTTP forward proxy configured with `TELEGRAM_PROXY_URL`.

package/dist/app/formatters/assistant-run-footer-formatter.js

@@ -16,5 +16,5 @@ function formatDuration(elapsedMs) {
 }
 export function formatAssistantRunFooter({ agent, providerID, modelID, elapsedMs, }) {
     const agentDisplay = getAgentDisplayName(agent);
-    return `${agentDisplay} · 🤖 ${providerID}/${modelID} · 🕒 ${formatDuration(elapsedMs)}`;
+    return `${agentDisplay} · 🧠 ${providerID}/${modelID} · 🕒 ${formatDuration(elapsedMs)}`;
 }

package/dist/app/services/edge-tts.js

@@ -0,0 +1,322 @@
+import { createHash, randomBytes, randomUUID } from "crypto";
+import { WebSocket } from "ws";
+import { logger } from "../../utils/logger.js";
+/**
+ * Microsoft Edge online text-to-speech client.
+ *
+ * Speaks the same WebSocket protocol used by Microsoft Edge's Read Aloud
+ * feature (wss://speech.platform.bing.com/.../readaloud/edge/v1). No API key
+ * is required; access is authenticated through a SHA256 "Sec-MS-GEC" token
+ * derived from the current time.
+ *
+ * Ported from the Python reference implementation at
+ * https://github.com/rany2/edge-tts.
+ */
+const BASE_URL = "speech.platform.bing.com/consumer/speech/synthesize/readaloud";
+const TRUSTED_CLIENT_TOKEN = "6A5AA1D4EAFF4E9FB37E23D68491D6F4";
+const WSS_URL = `wss://${BASE_URL}/edge/v1?TrustedClientToken=${TRUSTED_CLIENT_TOKEN}`;
+const CHROMIUM_FULL_VERSION = "143.0.3650.75";
+const CHROMIUM_MAJOR_VERSION = CHROMIUM_FULL_VERSION.split(".")[0];
+export const SEC_MS_GEC_VERSION = `1-${CHROMIUM_FULL_VERSION}`;
+export const EDGE_DEFAULT_VOICE = "en-US-EmmaMultilingualNeural";
+const WIN_EPOCH_SECONDS = 11644473600;
+const TICKS_PER_SECOND = 10_000_000;
+const ROUND_SECONDS = 300;
+const WSS_HEADERS = {
+    Pragma: "no-cache",
+    "Cache-Control": "no-cache",
+    Origin: "chrome-extension://jdiccldimpdaibmpdkjnbmckianbfold",
+    "User-Agent": `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 ` +
+        `(KHTML, like Gecko) Chrome/${CHROMIUM_MAJOR_VERSION}.0.0.0 Safari/537.36 ` +
+        `Edg/${CHROMIUM_MAJOR_VERSION}.0.0.0`,
+    "Accept-Encoding": "gzip, deflate, br, zstd",
+    "Accept-Language": "en-US,en;q=0.9",
+};
+const SYNTHESIS_TIMEOUT_MS = 60_000;
+const MAX_CHUNK_BYTES = 4096;
+let clockSkewSeconds = 0;
+/**
+ * Generates the Sec-MS-GEC DRM token Microsoft requires on every request.
+ *
+ * The token is the SHA256 (uppercased hex) of `<ticks><token>` where `ticks`
+ * is the current time as Windows file time (100-ns intervals since 1601-01-01)
+ * rounded down to the nearest 5 minutes. Rounded to limit token churn; the
+ * server accepts any token valid within the current 5-minute window.
+ */
+export function generateSecMsGec(now = new Date()) {
+    let seconds = now.getTime() / 1000 + clockSkewSeconds + WIN_EPOCH_SECONDS;
+    seconds -= seconds % ROUND_SECONDS;
+    const ticks = BigInt(Math.round(seconds)) * BigInt(TICKS_PER_SECOND);
+    const strToHash = `${ticks}${TRUSTED_CLIENT_TOKEN}`;
+    return createHash("sha256").update(strToHash, "ascii").digest("hex").toUpperCase();
+}
+/** @internal Reset clock skew (for tests only). */
+export function _resetClockSkew() {
+    clockSkewSeconds = 0;
+}
+function generateMuid() {
+    return randomBytes(16).toString("hex").toUpperCase();
+}
+function connectId() {
+    return randomUUID().replace(/-/g, "");
+}
+/** Formats like JS `Date.toString()` in UTC, the X-Timestamp shape Edge sends. */
+function jsDateString(date = new Date()) {
+    // toUTCString gives "Fri, 01 Jan 2024 00:00:00 GMT"; reorder its tokens.
+    const [day, dayNum, month, year, time] = date.toUTCString().replace(",", "").split(" ");
+    return `${day} ${month} ${dayNum} ${year} ${time} GMT+0000 (Coordinated Universal Time)`;
+}
+function escapeXml(text) {
+    return text
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+/** Escapes a value for interpolation into a single-quoted XML attribute. */
+function escapeXmlAttribute(value) {
+    return escapeXml(value).replace(/'/g, "&apos;").replace(/"/g, "&quot;");
+}
+/**
+ * Replaces control characters the service rejects (0x00-0x08, 0x0B-0x0C,
+ * 0x0E-0x1F) with spaces. Common in OCR'd text; without this the service
+ * returns an error.
+ */
+function removeIncompatibleCharacters(text) {
+    // eslint-disable-next-line no-control-regex
+    return text.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F]/g, " ");
+}
+/** Moves a split point back so it does not land inside an XML entity (&amp;). */
+function adjustForXmlEntity(buf, splitAt) {
+    let result = splitAt;
+    while (result > 0) {
+        const ampersandIndex = buf.subarray(0, result).lastIndexOf("&");
+        if (ampersandIndex < 0)
+            break;
+        if (buf.subarray(ampersandIndex, result).includes(";"))
+            break;
+        result = ampersandIndex;
+    }
+    return result;
+}
+/**
+ * Splits text into chunks no larger than `byteLength` UTF-8 bytes, preferring
+ * to break at newlines or spaces and never inside a multi-byte character or
+ * XML entity. Mirrors edge-tts's split_text_by_byte_length.
+ */
+export function splitTextByByteLength(text, byteLength) {
+    if (byteLength <= 0) {
+        throw new Error("byteLength must be greater than 0");
+    }
+    let rest = Buffer.from(text, "utf-8");
+    const chunks = [];
+    while (rest.length > byteLength) {
+        let splitAt = rest.lastIndexOf(0x0a, byteLength - 1);
+        if (splitAt < 0)
+            splitAt = rest.lastIndexOf(0x20, byteLength - 1);
+        if (splitAt < 0) {
+            splitAt = byteLength;
+            // Back up while the byte at the split is a UTF-8 continuation byte
+            // (10xxxxxx) so the cut never lands inside a multi-byte character.
+            while (splitAt > 0 && (rest[splitAt] & 0xc0) === 0x80) {
+                splitAt--;
+            }
+        }
+        splitAt = adjustForXmlEntity(rest, splitAt);
+        if (splitAt <= 0)
+            splitAt = 1;
+        const chunk = rest.subarray(0, splitAt).toString("utf-8").trim();
+        if (chunk)
+            chunks.push(chunk);
+        rest = rest.subarray(splitAt);
+    }
+    const remaining = rest.toString("utf-8").trim();
+    if (remaining)
+        chunks.push(remaining);
+    return chunks;
+}
+function buildSsml(voice, rate, volume, pitch, text) {
+    return ("<speak version='1.0' xmlns='http://www.w3.org/2001/10/synthesis' xml:lang='en-US'>" +
+        `<voice name='${escapeXmlAttribute(voice)}'>` +
+        `<prosody pitch='${escapeXmlAttribute(pitch)}' rate='${escapeXmlAttribute(rate)}' ` +
+        `volume='${escapeXmlAttribute(volume)}'>` +
+        text +
+        "</prosody></voice></speak>");
+}
+function parseRfc2616Date(date) {
+    const parsed = Date.parse(date);
+    return Number.isNaN(parsed) ? null : parsed / 1000;
+}
+class EdgeHttpUpgradeError extends Error {
+    statusCode;
+    serverDate;
+    constructor(statusCode, serverDate) {
+        super(`Edge TTS WebSocket upgrade failed: HTTP ${statusCode}`);
+        this.name = "EdgeHttpUpgradeError";
+        this.statusCode = statusCode;
+        this.serverDate = serverDate;
+    }
+}
+/**
+ * Synthesizes one SSML chunk over its own WebSocket connection and resolves
+ * with that chunk's MP3 audio bytes. Retries once on HTTP 403 (clock skew) by
+ * re-deriving the token against the server's reported time.
+ *
+ * The upstream edge-tts client also opens a fresh connection per chunk; the
+ * service does not reliably accept a second SSML turn on the same socket.
+ */
+async function synthesizeChunk(chunk, params) {
+    try {
+        return await attemptSynthesis(chunk, params);
+    }
+    catch (err) {
+        if (err instanceof EdgeHttpUpgradeError && err.statusCode === 403 && err.serverDate) {
+            const serverTime = parseRfc2616Date(err.serverDate);
+            if (serverTime !== null) {
+                clockSkewSeconds = serverTime - Date.now() / 1000;
+                logger.warn(`[EdgeTTS] HTTP 403: adjusted clock skew to ${clockSkewSeconds.toFixed(1)}s, retrying`);
+                return await attemptSynthesis(chunk, params);
+            }
+        }
+        throw err;
+    }
+}
+function attemptSynthesis(chunk, params) {
+    return new Promise((resolve, reject) => {
+        const gec = generateSecMsGec();
+        const url = `${WSS_URL}&ConnectionId=${connectId()}` +
+            `&Sec-MS-GEC=${gec}&Sec-MS-GEC-Version=${SEC_MS_GEC_VERSION}`;
+        const headers = { ...WSS_HEADERS, Cookie: `muid=${generateMuid()};` };
+        const ws = new WebSocket(url, { headers });
+        const audioChunks = [];
+        let audioReceived = false;
+        let settled = false;
+        let timer = null;
+        const finish = (error, result) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            ws.removeAllListeners();
+            // Closing a still-connecting socket makes ws emit 'error' on the next
+            // tick; with no listener that is an uncaught exception, so keep a sink.
+            ws.on("error", () => { });
+            if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+                ws.close();
+            }
+            if (error)
+                reject(error);
+            else
+                resolve(result ?? Buffer.alloc(0));
+        };
+        timer = setTimeout(() => {
+            finish(new Error(`Edge TTS synthesis timed out after ${params.timeoutMs}ms`));
+        }, Math.max(0, params.deadline - Date.now()));
+        ws.on("unexpected-response", (_req, res) => {
+            const statusCode = res.statusCode ?? 0;
+            const serverDate = res.headers["date"] ?? null;
+            finish(new EdgeHttpUpgradeError(statusCode, serverDate));
+        });
+        ws.on("error", (err) => {
+            if (!settled)
+                finish(err);
+        });
+        ws.on("open", () => {
+            const configMessage = `X-Timestamp:${jsDateString()}\r\n` +
+                "Content-Type:application/json; charset=utf-8\r\n" +
+                "Path:speech.config\r\n\r\n" +
+                '{"context":{"synthesis":{"audio":{"metadataoptions":' +
+                '{"sentenceBoundaryEnabled":"true","wordBoundaryEnabled":"false"},' +
+                '"outputFormat":"audio-24khz-48kbitrate-mono-mp3"}}}}';
+            ws.send(configMessage);
+            const ssml = buildSsml(params.voice, params.rate, params.volume, params.pitch, chunk);
+            const ssmlMessage = `X-RequestId:${connectId()}\r\n` +
+                "Content-Type:application/ssml+xml\r\n" +
+                `X-Timestamp:${jsDateString()}Z\r\n` +
+                "Path:ssml\r\n\r\n" +
+                ssml;
+            ws.send(ssmlMessage);
+        });
+        ws.on("message", (data, isBinary) => {
+            if (settled)
+                return;
+            const buf = Buffer.isBuffer(data)
+                ? data
+                : Array.isArray(data)
+                    ? Buffer.concat(data)
+                    : Buffer.from(data);
+            if (isBinary) {
+                if (buf.length < 2) {
+                    finish(new Error("Edge TTS: binary message too short"));
+                    return;
+                }
+                // Binary frames: [2-byte big-endian header length][headers + \r\n][audio].
+                // The length value includes the trailing \r\n terminator, so audio
+                // starts immediately at offset 2 + headerLength.
+                const headerLength = buf.readUInt16BE(0);
+                if (2 + headerLength > buf.length) {
+                    finish(new Error("Edge TTS: binary header length exceeds message"));
+                    return;
+                }
+                const headersBlock = buf.subarray(2, 2 + headerLength).toString("utf-8");
+                if (!headersBlock.includes("Path:audio"))
+                    return;
+                const audioStart = 2 + headerLength;
+                const audio = audioStart < buf.length ? buf.subarray(audioStart) : Buffer.alloc(0);
+                if (audio.length > 0) {
+                    audioChunks.push(audio);
+                    audioReceived = true;
+                }
+                return;
+            }
+            const text = buf.toString("utf-8");
+            const sep = text.indexOf("\r\n\r\n");
+            const headerBlock = sep >= 0 ? text.slice(0, sep) : text;
+            if (!headerBlock.includes("Path:turn.end"))
+                return;
+            if (!audioReceived) {
+                finish(new Error("Edge TTS: no audio received from service"));
+            }
+            else {
+                finish(null, Buffer.concat(audioChunks));
+            }
+        });
+        // A close before turn.end means the turn never completed; partial audio
+        // must not be returned as success.
+        ws.on("close", () => {
+            if (!settled) {
+                finish(new Error("Edge TTS: connection closed before synthesis completed"));
+            }
+        });
+    });
+}
+/**
+ * Synthesizes `text` to an MP3 Buffer using Microsoft Edge's online TTS.
+ * Throws on protocol errors, timeouts, or if no audio is returned. The
+ * timeout bounds the entire synthesis, however many chunks it spans, so the
+ * caller-visible deadline matches the other TTS providers.
+ */
+export async function synthesizeWithEdgeTts(text, options) {
+    const voice = options.voice || EDGE_DEFAULT_VOICE;
+    const rate = options.rate ?? "+0%";
+    const volume = options.volume ?? "+0%";
+    const pitch = options.pitch ?? "+0Hz";
+    const timeoutMs = options.timeoutMs ?? SYNTHESIS_TIMEOUT_MS;
+    const cleaned = removeIncompatibleCharacters(text);
+    const escaped = escapeXml(cleaned);
+    const chunks = splitTextByByteLength(escaped, MAX_CHUNK_BYTES);
+    logger.debug(`[EdgeTTS] Synthesizing: voice=${voice}, chunks=${chunks.length}, chars=${text.length}`);
+    const params = {
+        voice,
+        rate,
+        volume,
+        pitch,
+        deadline: Date.now() + timeoutMs,
+        timeoutMs,
+    };
+    const buffers = [];
+    for (const chunk of chunks) {
+        buffers.push(await synthesizeChunk(chunk, params));
+    }
+    return Buffer.concat(buffers);
+}

package/dist/app/services/file-download-service.js

@@ -79,12 +79,61 @@ const APPLICATION_TEXT_MIME_TYPES = new Set([
     "application/x-yaml",
     "application/sql",
 ]);
-export function isTextMimeType(mimeType) {
+const TEXT_FILE_EXTENSIONS = new Set([
+    "svelte",
+    "vue",
+    "ts",
+    "tsx",
+    "jsx",
+    "mjs",
+    "cjs",
+    "go",
+    "rs",
+    "rb",
+    "py",
+    "java",
+    "c",
+    "cpp",
+    "h",
+    "hpp",
+    "cs",
+    "swift",
+    "kt",
+    "kts",
+    "sh",
+    "bash",
+    "yaml",
+    "yml",
+    "toml",
+    "ini",
+    "cfg",
+    "md",
+    "mdx",
+    "css",
+    "scss",
+    "less",
+    "html",
+    "htm",
+    "graphql",
+    "gql",
+    "proto",
+    "gradle",
+]);
+export function isTextMimeType(mimeType, filename) {
     if (!mimeType) {
         return false;
     }
     if (mimeType.startsWith("text/")) {
         return true;
     }
-    return APPLICATION_TEXT_MIME_TYPES.has(mimeType);
+    if (APPLICATION_TEXT_MIME_TYPES.has(mimeType)) {
+        return true;
+    }
+    if (filename) {
+        const ext = filename.split(".").pop()?.toLowerCase();
+        if (ext && TEXT_FILE_EXTENSIONS.has(ext)) {
+            return true;
+        }
+    }
+    return false;
 }

package/dist/app/services/stt-service.js

@@ -1,19 +1,35 @@
 import { config } from "../../config.js";
 import { logger } from "../../utils/logger.js";
 const STT_REQUEST_TIMEOUT_MS = 60_000;
+const AUDIO_FORMAT_BY_EXTENSION = {
+    oga: "ogg",
+    ogg: "ogg",
+    mp3: "mp3",
+    wav: "wav",
+    m4a: "m4a",
+    flac: "flac",
+    aac: "aac",
+    webm: "webm",
+};
 /**
  * Returns true if STT is configured (API URL and API key are set).
  */
 export function isSttConfigured() {
     return Boolean(config.stt.apiUrl && config.stt.apiKey);
 }
+function getAudioFormat(filename) {
+    const extension = (filename.split(".").pop() || "").toLowerCase();
+    return AUDIO_FORMAT_BY_EXTENSION[extension] || "ogg";
+}
 /**
- * Transcribes an audio buffer using a Whisper-compatible API (OpenAI / Groq / etc.).
+ * Transcribes an audio buffer using a Whisper-compatible API.
  *
- * Sends a multipart/form-data POST to `{STT_API_URL}/audio/transcriptions`.
+ * Two request formats are supported via `STT_REQUEST_FORMAT`:
+ * - `multipart` (default): standard OpenAI/Groq `multipart/form-data` upload.
+ * - `json`: base64 audio in an `input_audio` JSON body (e.g. OpenRouter).
  *
  * @param audioBuffer - Raw audio file bytes (ogg, mp3, wav, m4a, webm, etc.)
- * @param filename    - Original filename with extension (used by the API to detect format)
+ * @param filename    - Original filename with extension (used to detect format)
  * @returns Transcribed text
  * @throws Error if STT is not configured, the request fails, or the response is invalid
  */
@@ -22,23 +38,44 @@ export async function transcribeAudio(audioBuffer, filename) {
         throw new Error("STT is not configured: STT_API_URL and STT_API_KEY are required");
     }
     const url = `${config.stt.apiUrl}/audio/transcriptions`;
-    const formData = new FormData();
-    formData.append("file", new Blob([new Uint8Array(audioBuffer)]), filename);
-    formData.append("model", config.stt.model);
-    formData.append("response_format", "json");
-    if (config.stt.language) {
-        formData.append("language", config.stt.language);
+    const useJsonFormat = config.stt.requestFormat === "json";
+    const headers = {
+        Authorization: `Bearer ${config.stt.apiKey}`,
+    };
+    let body;
+    if (useJsonFormat) {
+        const payload = {
+            model: config.stt.model,
+            input_audio: {
+                data: Buffer.from(audioBuffer).toString("base64"),
+                format: getAudioFormat(filename),
+            },
+        };
+        if (config.stt.language) {
+            payload.language = config.stt.language;
+        }
+        headers["Content-Type"] = "application/json";
+        body = JSON.stringify(payload);
+        logger.debug(`[STT] Sending transcription request (json): url=${url}, model=${config.stt.model}, format=${getAudioFormat(filename)}, size=${audioBuffer.length} bytes`);
+    }
+    else {
+        const formData = new FormData();
+        formData.append("file", new Blob([new Uint8Array(audioBuffer)]), filename);
+        formData.append("model", config.stt.model);
+        formData.append("response_format", "json");
+        if (config.stt.language) {
+            formData.append("language", config.stt.language);
+        }
+        body = formData;
+        logger.debug(`[STT] Sending transcription request (multipart): url=${url}, model=${config.stt.model}, filename=${filename}, size=${audioBuffer.length} bytes`);
     }
-    logger.debug(`[STT] Sending transcription request: url=${url}, model=${config.stt.model}, filename=${filename}, size=${audioBuffer.length} bytes`);
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), STT_REQUEST_TIMEOUT_MS);
     try {
         const response = await fetch(url, {
             method: "POST",
-            headers: {
-                Authorization: `Bearer ${config.stt.apiKey}`,
-            },
-            body: formData,
+            headers,
+            body,
             signal: controller.signal,
         });
         if (!response.ok) {

package/dist/app/services/tts-service.js

@@ -1,12 +1,16 @@
 import { config } from "../../config.js";
 import { logger } from "../../utils/logger.js";
 import textToSpeech from "@google-cloud/text-to-speech";
+import { synthesizeWithEdgeTts, EDGE_DEFAULT_VOICE } from "./edge-tts.js";
 const TTS_REQUEST_TIMEOUT_MS = 60_000;
 const MAX_TTS_INPUT_CHARS = 4_000;
 export function isTtsConfigured() {
     if (config.tts.provider === "google") {
         return Boolean(process.env.GOOGLE_APPLICATION_CREDENTIALS);
     }
+    if (config.tts.provider === "edge") {
+        return true;
+    }
     return Boolean(config.tts.apiUrl && config.tts.apiKey);
 }
 /**
@@ -141,6 +145,19 @@ async function synthesizeWithElevenLabs(text) {
         clearTimeout(timeout);
     }
 }
+async function synthesizeWithEdge(text) {
+    const voice = config.tts.voice || EDGE_DEFAULT_VOICE;
+    logger.debug(`[TTS] Edge: voice=${voice}, chars=${text.length}`);
+    const buffer = await synthesizeWithEdgeTts(text, {
+        voice,
+        timeoutMs: TTS_REQUEST_TIMEOUT_MS,
+    });
+    if (buffer.length === 0) {
+        throw new Error("Edge TTS returned an empty audio response");
+    }
+    logger.debug(`[TTS] Generated Edge speech audio: ${buffer.length} bytes`);
+    return { buffer, filename: "assistant-reply.mp3", mimeType: "audio/mpeg" };
+}
 // --- Public API ---
 function getNotConfiguredMessage() {
     if (config.tts.provider === "google") {
@@ -149,6 +166,8 @@ function getNotConfiguredMessage() {
     if (config.tts.provider === "elevenlabs") {
         return "TTS is not configured: set TTS_API_URL and TTS_API_KEY for ElevenLabs";
     }
+    // No "edge" branch: isTtsConfigured() is always true for edge, so this
+    // function is unreachable for that provider.
     return "TTS is not configured: set TTS_API_URL and TTS_API_KEY";
 }
 export async function synthesizeSpeech(text) {
@@ -167,6 +186,9 @@ export async function synthesizeSpeech(text) {
         if (config.tts.provider === "elevenlabs") {
             return await synthesizeWithElevenLabs(input);
         }
+        if (config.tts.provider === "edge") {
+            return await synthesizeWithEdge(input);
+        }
         return await synthesizeWithOpenAi(input);
     }
     catch (err) {

package/dist/app/stores/settings-store.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { cloneScheduledTask } from "../types/scheduled-task.js";
+import { config } from "../../config.js";
 import { getRuntimePaths } from "../../runtime/paths.js";
 import { logger } from "../../utils/logger.js";
 function cloneScheduledTasks(tasks) {
@@ -170,6 +171,64 @@ export function __resetSettingsForTests() {
     currentSettings = {};
     settingsWriteQueue = Promise.resolve();
 }
+const VALID_TTS_MODES = ["off", "all", "auto"];
+const VALID_STREAMING_MODES = ["edit", "draft"];
+function applyInitialSettingsPreset(preset) {
+    const knownKeys = new Set([
+        "ttsMode",
+        "compactOutputMode",
+        "showThinkingContent",
+        "showAssistantRunFooter",
+        "responseStreamingMode",
+        "sendDiffFileAttachments",
+    ]);
+    for (const [key, value] of Object.entries(preset)) {
+        if (!knownKeys.has(key)) {
+            throw new Error(`INITIAL_SETTINGS_PRESET: unknown key "${key}". Supported keys: ${[...knownKeys].join(", ")}.`);
+        }
+        if (key === "ttsMode") {
+            if (typeof value !== "string" || !VALID_TTS_MODES.includes(value)) {
+                throw new Error(`INITIAL_SETTINGS_PRESET: invalid value for "ttsMode"; expected one of ${VALID_TTS_MODES.join(", ")}.`);
+            }
+            if (currentSettings.ttsMode === undefined) {
+                currentSettings.ttsMode = value;
+            }
+        }
+        else if (key === "responseStreamingMode") {
+            if (typeof value !== "string" ||
+                !VALID_STREAMING_MODES.includes(value)) {
+                throw new Error(`INITIAL_SETTINGS_PRESET: invalid value for "responseStreamingMode"; expected one of ${VALID_STREAMING_MODES.join(", ")}.`);
+            }
+            if (currentSettings.responseStreamingMode === undefined) {
+                currentSettings.responseStreamingMode = value;
+            }
+        }
+        else {
+            // Boolean settings: compactOutputMode, showThinkingContent, showAssistantRunFooter, sendDiffFileAttachments
+            if (typeof value !== "boolean") {
+                throw new Error(`INITIAL_SETTINGS_PRESET: "${key}" must be a boolean.`);
+            }
+            switch (key) {
+                case "compactOutputMode":
+                    if (currentSettings.compactOutputMode === undefined)
+                        currentSettings.compactOutputMode = value;
+                    break;
+                case "showThinkingContent":
+                    if (currentSettings.showThinkingContent === undefined)
+                        currentSettings.showThinkingContent = value;
+                    break;
+                case "showAssistantRunFooter":
+                    if (currentSettings.showAssistantRunFooter === undefined)
+                        currentSettings.showAssistantRunFooter = value;
+                    break;
+                case "sendDiffFileAttachments":
+                    if (currentSettings.sendDiffFileAttachments === undefined)
+                        currentSettings.sendDiffFileAttachments = value;
+                    break;
+            }
+        }
+    }
+}
 export async function loadSettings() {
     const loadedSettings = (await readSettingsFile());
     let requiresRewrite = false;
@@ -192,6 +251,7 @@ export async function loadSettings() {
     currentSettings.scheduledTasks = cloneScheduledTasks(loadedSettings.scheduledTasks) ?? [];
     currentSettings.scheduledTaskSessionIgnores =
         cloneScheduledTaskSessionIgnores(loadedSettings.scheduledTaskSessionIgnores) ?? [];
+    applyInitialSettingsPreset(config.bot.initialSettingsPreset);
     if (requiresRewrite) {
         void writeSettingsFile(currentSettings);
     }

package/dist/app/types/model.js

@@ -11,7 +11,7 @@ export function formatModelForButton(providerID, modelID) {
     // If model name is too long, we only truncate the model part
     const displayModelId = modelID.length > 20 ? `${modelID.substring(0, 17)}...` : modelID;
     const displayProviderId = providerID.length > 15 ? `${providerID.substring(0, 12)}...` : providerID;
-    return `🤖 ${displayProviderId}\n${displayModelId}`;
+    return `🧠 ${displayProviderId}\n${displayModelId}`;
 }
 /**
  * Format model for display in messages (full format)

package/dist/bot/callbacks/model-selection-callback-handler.js

@@ -1,6 +1,6 @@
 import { InlineKeyboard } from "grammy";
 import { getStoredAgent, resolveProjectAgent } from "../../app/services/agent-selection-service.js";
-import { searchModels, selectModel, } from "../../app/services/model-selection-service.js";
+import { searchModels, selectModel } from "../../app/services/model-selection-service.js";
 import { formatVariantForButton } from "../../app/services/variant-selection-service.js";
 import { formatModelForDisplay } from "../../app/types/model.js";
 import { interactionManager } from "../../app/managers/interaction-manager.js";
@@ -10,7 +10,28 @@ import { createMainKeyboard } from "../keyboards/main-reply-keyboard.js";
 import { keyboardManager } from "../keyboards/keyboard-manager.js";
 import { pinnedMessageManager } from "../pinned/pinned-message-manager.js";
 import { clearActiveInlineMenu, ensureActiveInlineMenu } from "../menus/inline-menu.js";
-import { MODEL_SEARCH_AGAIN_CALLBACK, MODEL_SEARCH_CALLBACK, MODEL_SEARCH_CANCEL_CALLBACK, } from "../menus/model-selection-menu.js";
+import { MODEL_LIST_CALLBACK_PREFIX, MODEL_SEARCH_AGAIN_CALLBACK, MODEL_SEARCH_CALLBACK, MODEL_SEARCH_CANCEL_CALLBACK, } from "../menus/model-selection-menu.js";
+const MODEL_SEARCH_RESULT_CALLBACK_PREFIX = "model:result:";
+function parseModelItems(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.flatMap((item) => {
+        if (typeof item !== "object" ||
+            item === null ||
+            !("providerID" in item) ||
+            !("modelID" in item)) {
+            return [];
+        }
+        const providerID = item.providerID;
+        const modelID = item.modelID;
+        if (typeof providerID !== "string" || typeof modelID !== "string") {
+            return [];
+        }
+        const variant = "variant" in item && typeof item.variant === "string" ? item.variant : "default";
+        return [{ providerID, modelID, variant }];
+    });
+}
 function parseModelSearchMetadata() {
     const state = interactionManager.getSnapshot();
     if (!state || state.kind !== "custom") {
@@ -22,7 +43,84 @@ function parseModelSearchMetadata() {
         return null;
     }
     const messageId = typeof state.metadata.messageId === "number" ? state.metadata.messageId : undefined;
-    return { flow, stage, messageId };
+    return { flow, stage, messageId, models: parseModelItems(state.metadata.models) };
+}
+function parseModelListMetadata() {
+    const state = interactionManager.getSnapshot();
+    if (!state || state.kind !== "inline" || state.metadata.menuKind !== "model") {
+        return null;
+    }
+    const modelLists = state.metadata.modelLists;
+    if (typeof modelLists !== "object" || modelLists === null) {
+        return null;
+    }
+    return {
+        favorites: parseModelItems("favorites" in modelLists ? modelLists.favorites : undefined),
+        recent: parseModelItems("recent" in modelLists ? modelLists.recent : undefined),
+    };
+}
+function parseNonNegativeIndex(value) {
+    if (!/^\d+$/.test(value)) {
+        return null;
+    }
+    const index = Number.parseInt(value, 10);
+    if (!Number.isInteger(index) || index < 0) {
+        return null;
+    }
+    return index;
+}
+function parseCallbackIndex(data, prefix) {
+    if (!data.startsWith(prefix)) {
+        return null;
+    }
+    return parseNonNegativeIndex(data.slice(prefix.length));
+}
+function resolveModelListCallback(data) {
+    if (!data.startsWith(MODEL_LIST_CALLBACK_PREFIX)) {
+        return null;
+    }
+    const parts = data.slice(MODEL_LIST_CALLBACK_PREFIX.length).split(":");
+    if (parts.length !== 2) {
+        return null;
+    }
+    const [kind, indexText] = parts;
+    const index = parseNonNegativeIndex(indexText);
+    if ((kind !== "favorites" && kind !== "recent") || index === null) {
+        return null;
+    }
+    const lists = parseModelListMetadata();
+    if (!lists) {
+        return null;
+    }
+    const model = kind === "favorites" ? lists.favorites[index] : lists.recent[index];
+    if (!model) {
+        return null;
+    }
+    return {
+        providerID: model.providerID,
+        modelID: model.modelID,
+        variant: "default",
+    };
+}
+function parseLegacyModelCallback(data) {
+    const parts = data.split(":");
+    if (parts.length < 3) {
+        return null;
+    }
+    const providerID = parts[1];
+    const modelID = parts.slice(2).join(":");
+    if (!providerID || !modelID) {
+        return null;
+    }
+    return {
+        providerID,
+        modelID,
+        variant: "default",
+    };
+}
+function isShortModelCallback(data) {
+    return (data.startsWith(MODEL_SEARCH_RESULT_CALLBACK_PREFIX) ||
+        data.startsWith(MODEL_LIST_CALLBACK_PREFIX));
 }
 /**
  * Shared logic for applying a model selection and updating UI.
@@ -75,23 +173,17 @@ export async function handleModelSelect(ctx) {
     }
     logger.debug(`[ModelHandler] Received callback: ${callbackQuery.data}`);
     try {
-        // Parse callback data: "model:providerID:modelID"
-        const parts = callbackQuery.data.split(":");
-        if (parts.length < 3) {
+        const modelInfo = resolveModelListCallback(callbackQuery.data);
+        const shouldUseLegacyFallback = !isShortModelCallback(callbackQuery.data);
+        const resolvedModelInfo = modelInfo ?? (shouldUseLegacyFallback ? parseLegacyModelCallback(callbackQuery.data) : null);
+        if (!resolvedModelInfo) {
             logger.error(`[ModelHandler] Invalid callback data format: ${callbackQuery.data}`);
             clearActiveInlineMenu("model_select_invalid_callback");
             await ctx.answerCallbackQuery({ text: t("model.change_error_callback") }).catch(() => { });
             return true;
         }
-        const providerID = parts[1];
-        const modelID = parts.slice(2).join(":"); // Handle model IDs that may contain ":"
-        const modelInfo = {
-            providerID,
-            modelID,
-            variant: "default",
-        };
         clearActiveInlineMenu("model_selected");
-        await applyModelSelectionAndNotify(ctx, modelInfo);
+        await applyModelSelectionAndNotify(ctx, resolvedModelInfo);
         return true;
     }
     catch (err) {
@@ -150,9 +242,9 @@ export async function handleModelSearchTextInput(ctx) {
     try {
         const results = await searchModels(text);
         const keyboard = new InlineKeyboard();
-        for (const model of results) {
+        for (const [index, model] of results.entries()) {
             const label = `${model.providerID}/${model.modelID}`;
-            keyboard.text(label, `model:${model.providerID}:${model.modelID}`).row();
+            keyboard.text(label, `${MODEL_SEARCH_RESULT_CALLBACK_PREFIX}${index}`).row();
         }
         keyboard.row();
         keyboard.text(t("model.search.search_again"), MODEL_SEARCH_AGAIN_CALLBACK);
@@ -168,6 +260,11 @@ export async function handleModelSearchTextInput(ctx) {
                 flow: "model-search",
                 stage: "results",
                 messageId: sent.message_id,
+                models: results.map((model) => ({
+                    providerID: model.providerID,
+                    modelID: model.modelID,
+                    variant: "default",
+                })),
             },
         });
         return true;
@@ -225,19 +322,28 @@ export async function handleModelSearchResults(ctx) {
         logger.debug("[ModelHandler] Model search prompt shown (search again)");
         return true;
     }
-    // Model selection from search results
+    const resultIndex = parseCallbackIndex(data, MODEL_SEARCH_RESULT_CALLBACK_PREFIX);
+    if (resultIndex !== null) {
+        const modelInfo = meta.models[resultIndex];
+        if (!modelInfo) {
+            await ctx.answerCallbackQuery({ text: t("model.change_error_callback") }).catch(() => { });
+            return true;
+        }
+        interactionManager.clear("model_search_selected");
+        await applyModelSelectionAndNotify(ctx, modelInfo);
+        return true;
+    }
+    // Backward compatibility for callbacks from already-rendered search result messages.
     if (data.startsWith("model:")) {
-        const parts = data.split(":");
-        if (parts.length < 3) {
+        if (isShortModelCallback(data)) {
+            logger.error(`[ModelHandler] Invalid search result callback data: ${data}`);
+            await ctx.answerCallbackQuery({ text: t("model.change_error_callback") }).catch(() => { });
+            return true;
+        }
+        const modelInfo = parseLegacyModelCallback(data);
+        if (!modelInfo) {
             return true;
         }
-        const providerID = parts[1];
-        const modelID = parts.slice(2).join(":");
-        const modelInfo = {
-            providerID,
-            modelID,
-            variant: "default",
-        };
         interactionManager.clear("model_search_selected");
         await applyModelSelectionAndNotify(ctx, modelInfo);
         return true;

package/dist/bot/callbacks/scheduled-task-callback-handler.js

@@ -100,12 +100,31 @@ function formatDateTime(dateIso, timezone) {
         return dateIso;
     }
 }
+const TASK_DETAIL_PROMPT_BYTE_BUDGET = 3400;
+function truncatePromptForDetails(prompt) {
+    if (Buffer.byteLength(prompt, "utf-8") <= TASK_DETAIL_PROMPT_BYTE_BUDGET) {
+        return prompt;
+    }
+    const budget = TASK_DETAIL_PROMPT_BYTE_BUDGET - 3;
+    let lo = 0;
+    let hi = prompt.length;
+    while (lo < hi) {
+        const mid = (lo + hi + 1) >>> 1;
+        if (Buffer.byteLength(prompt.slice(0, mid), "utf-8") <= budget) {
+            lo = mid;
+        }
+        else {
+            hi = mid - 1;
+        }
+    }
+    return `${prompt.slice(0, lo)}...`;
+}
 function formatTaskDetails(task) {
     const variant = task.model.variant ? ` (${task.model.variant})` : "";
     const model = `${task.model.providerID}/${task.model.modelID}${variant}`;
     const cronLine = task.kind === "cron" ? `${t("tasklist.details.cron", { cron: task.cron })}\n` : "";
     return t("tasklist.details", {
-        prompt: task.prompt,
+        prompt: truncatePromptForDetails(task.prompt),
         project: `${task.projectWorktree}\n${t("status.line.model", { model })}`,
         schedule: task.scheduleSummary,
         cronLine,

package/dist/bot/commands/status-command.js

@@ -38,7 +38,7 @@ export async function statusCommand(ctx) {
         message += `${t("status.line.mode", { mode: agentDisplay })}\n`;
         // Add model information
         const currentModel = fetchCurrentModel();
-        const modelDisplay = `🤖 ${currentModel.providerID}/${currentModel.modelID}`;
+        const modelDisplay = `🧠 ${currentModel.providerID}/${currentModel.modelID}`;
         message += `${t("status.line.model", { model: modelDisplay })}\n`;
         const currentProject = getCurrentProject();
         if (currentProject) {

package/dist/bot/handlers/document-handler.js

@@ -18,7 +18,7 @@ export async function handleDocumentMessage(ctx, deps) {
     const mimeType = doc.mime_type || "";
     const filename = doc.file_name || "document";
     try {
-        if (isTextMimeType(mimeType)) {
+        if (isTextMimeType(mimeType, filename)) {
             if (!isFileSizeAllowed(doc.file_size, config.files.maxFileSizeKb)) {
                 logger.warn(`[Document] Text file too large: ${filename} (${doc.file_size} bytes > ${config.files.maxFileSizeKb}KB)`);
                 await ctx.reply(t("bot.text_file_too_large", { maxSizeKb: String(config.files.maxFileSizeKb) }));

package/dist/bot/handlers/media-group-handler.js

@@ -137,7 +137,7 @@ export class MediaGroupAttachmentHandler {
             const document = item.document;
             const mimeType = document.mime_type || "";
             const filename = document.file_name || "document";
-            if (isTextMimeType(mimeType)) {
+            if (isTextMimeType(mimeType, filename)) {
                 if (!isFileSizeAllowed(document.file_size, config.files.maxFileSizeKb)) {
                     return { reason: "text_file_too_large" };
                 }

package/dist/bot/menus/inline-menu.js

@@ -71,6 +71,7 @@ export async function replyWithInlineMenu(ctx, options) {
         kind: "inline",
         expectedInput: "callback",
         metadata: {
+            ...options.metadata,
             menuKind: options.menuKind,
             messageId: message.message_id,
         },

package/dist/bot/menus/model-selection-menu.js

@@ -6,6 +6,10 @@ import { replyWithInlineMenu } from "./inline-menu.js";
 export const MODEL_SEARCH_CALLBACK = "model:search";
 export const MODEL_SEARCH_AGAIN_CALLBACK = "model:search:again";
 export const MODEL_SEARCH_CANCEL_CALLBACK = "model:search:cancel";
+export const MODEL_LIST_CALLBACK_PREFIX = "model:list:";
+export function buildModelListCallback(kind, index) {
+    return `${MODEL_LIST_CALLBACK_PREFIX}${kind}:${index}`;
+}
 function buildModelSelectionMenuText(modelLists) {
     const lines = [t("model.menu.select"), t("model.menu.favorites_title")];
     if (modelLists.favorites.length === 0) {
@@ -31,16 +35,16 @@ export async function buildModelSelectionMenu(currentModel, modelLists) {
         logger.warn("[ModelHandler] No model choices found in favorites/recent");
         return keyboard;
     }
-    const addButton = (model, prefix) => {
+    const addButton = (model, prefix, kind, index) => {
         const isActive = currentModel &&
             model.providerID === currentModel.providerID &&
             model.modelID === currentModel.modelID;
         const label = `${prefix} ${model.providerID}/${model.modelID}`;
         const labelWithCheck = isActive ? `✅ ${label}` : label;
-        keyboard.text(labelWithCheck, `model:${model.providerID}:${model.modelID}`).row();
+        keyboard.text(labelWithCheck, buildModelListCallback(kind, index)).row();
     };
-    favorites.forEach((model) => addButton(model, "⭐"));
-    recent.forEach((model) => addButton(model, "🕘"));
+    favorites.forEach((model, index) => addButton(model, "⭐", "favorites", index));
+    recent.forEach((model, index) => addButton(model, "🕘", "recent", index));
     return keyboard;
 }
 /**
@@ -57,6 +61,7 @@ export async function showModelSelectionMenu(ctx) {
             menuKind: "model",
             text,
             keyboard,
+            metadata: { modelLists },
         });
     }
     catch (err) {

package/dist/bot/message-patterns.js

@@ -1,4 +1,4 @@
 export const AGENT_MODE_BUTTON_TEXT_PATTERN = /^(📋|🛠️|💬|🔍|📝|📄|📦|🤖)\s.+\s(?:Mode|Agent)$/;
-export const MODEL_BUTTON_TEXT_PATTERN = /^🤖\s(?!.*\s(?:Mode|Agent)$)[\s\S]+$/;
+export const MODEL_BUTTON_TEXT_PATTERN = /^🧠\s(?!.*\s(?:Mode|Agent)$)[\s\S]+$/;
 // Keep support for both legacy "💭" and current "💡" prefix.
 export const VARIANT_BUTTON_TEXT_PATTERN = /^(💡|💭)\s.+$/;

package/dist/bot/streaming/compact-progress-streamer.js

@@ -26,19 +26,10 @@ export class CompactProgressStreamer {
         this.editText = editText;
     }
     updateActivity(sessionId, activity) {
-        const normalizedActivity = activity.trim();
-        if (!sessionId || !normalizedActivity) {
-            return;
-        }
-        const state = this.getOrCreateState(sessionId);
-        state.latestText = t("progress.compact.activity", {
-            header: t("progress.compact.working_header"),
-            activity: normalizedActivity,
-        });
-        this.ensureTimer(state);
+        this.updateActivityState(sessionId, activity, true);
     }
     updateThinking(sessionId) {
-        this.updateActivity(sessionId, t("progress.compact.thinking"));
+        this.updateActivityState(sessionId, t("progress.compact.thinking"), false);
     }
     updateResponding(sessionId) {
         this.updateActivity(sessionId, t("progress.compact.responding"));
@@ -105,6 +96,21 @@ export class CompactProgressStreamer {
         this.states.set(sessionId, state);
         return state;
     }
+    updateActivityState(sessionId, activity, createIfMissing) {
+        const normalizedActivity = activity.trim();
+        if (!sessionId || !normalizedActivity) {
+            return;
+        }
+        const state = createIfMissing ? this.getOrCreateState(sessionId) : this.states.get(sessionId);
+        if (!state) {
+            return;
+        }
+        state.latestText = t("progress.compact.activity", {
+            header: t("progress.compact.working_header"),
+            activity: normalizedActivity,
+        });
+        this.ensureTimer(state);
+    }
     ensureTimer(state) {
         if (state.cancelled || state.timer) {
             return;

package/dist/config.js

@@ -50,7 +50,24 @@ function getOptionalMessageFormatModeEnvVar(key, defaultValue) {
     }
     return defaultValue;
 }
-const VALID_TTS_PROVIDERS = ["openai", "google", "elevenlabs"];
+export function parseInitialSettingsPreset() {
+    const raw = getEnvVar("INITIAL_SETTINGS_PRESET", false).trim();
+    if (!raw) {
+        return {};
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("INITIAL_SETTINGS_PRESET contains invalid JSON. Fix or unset the variable.");
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error("INITIAL_SETTINGS_PRESET must be a JSON object.");
+    }
+    return parsed;
+}
+const VALID_TTS_PROVIDERS = ["openai", "google", "elevenlabs", "edge"];
 function getOptionalTtsProviderEnvVar(key, defaultValue) {
     const value = getEnvVar(key, false);
     if (!value) {
@@ -62,6 +79,18 @@ function getOptionalTtsProviderEnvVar(key, defaultValue) {
     }
     return defaultValue;
 }
+const VALID_STT_REQUEST_FORMATS = ["multipart", "json"];
+function getOptionalSttRequestFormatEnvVar(key, defaultValue) {
+    const value = getEnvVar(key, false);
+    if (!value) {
+        return defaultValue;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (VALID_STT_REQUEST_FORMATS.includes(normalized)) {
+        return normalized;
+    }
+    return defaultValue;
+}
 export function buildTelegramConfig() {
     const proxyUrl = getEnvVar("TELEGRAM_PROXY_URL", false);
     // grammY rejects an apiRoot ending with `/`, so normalize once at config
@@ -116,6 +145,7 @@ export const config = {
         locale: getOptionalLocaleEnvVar("BOT_LOCALE", "en"),
         trackBackgroundSessions: getOptionalBooleanEnvVar("TRACK_BACKGROUND_SESSIONS", true),
         messageFormatMode: getOptionalMessageFormatModeEnvVar("MESSAGE_FORMAT_MODE", "markdown"),
+        initialSettingsPreset: parseInitialSettingsPreset(),
     },
     files: {
         maxFileSizeKb: parseInt(getEnvVar("CODE_FILE_MAX_SIZE_KB", false) || "100", 10),
@@ -129,6 +159,9 @@ export const config = {
         model: getEnvVar("STT_MODEL", false) || "whisper-large-v3-turbo",
         language: getEnvVar("STT_LANGUAGE", false),
         notePrompt: getEnvVar("STT_NOTE_PROMPT", false),
+        // "multipart" (default) = standard OpenAI/Groq Whisper form-data upload.
+        // "json" = base64 audio in an `input_audio` JSON body (e.g. OpenRouter).
+        requestFormat: getOptionalSttRequestFormatEnvVar("STT_REQUEST_FORMAT", "multipart"),
     },
     tts: (() => {
         const provider = getOptionalTtsProviderEnvVar("TTS_PROVIDER", "openai");
@@ -136,7 +169,9 @@ export const config = {
             ? "en-US-Studio-O"
             : provider === "elevenlabs"
                 ? "21m00Tcm4TlvDq8ikWAM"
-                : "alloy";
+                : provider === "edge"
+                    ? "en-US-EmmaMultilingualNeural"
+                    : "alloy";
         const defaultModel = provider === "elevenlabs" ? "eleven_flash_v2_5" : "gpt-4o-mini-tts";
         return {
             apiUrl: getEnvVar("TTS_API_URL", false),

package/dist/opencode/process.js

@@ -1,4 +1,6 @@
 import { exec, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import * as path from "node:path";
 import { promisify } from "node:util";
 const execAsync = promisify(exec);
 const DEFAULT_OPENCODE_PORT = 4096;
@@ -25,13 +27,56 @@ export function resolveLocalOpencodeTarget(apiUrl) {
         return null;
     }
 }
+function resolveWindowsOpencodeExe() {
+    const pathEnv = process.env.PATH ?? "";
+    const pathEntries = pathEnv.split(path.delimiter).filter(Boolean);
+    // First pass: look for opencode.exe directly on PATH.
+    // Covers non-npm installations (install script, scoop, choco, manual download, etc.).
+    for (const entry of pathEntries) {
+        const candidateExe = path.join(entry, "opencode.exe");
+        if (existsSync(candidateExe)) {
+            return candidateExe;
+        }
+    }
+    // Second pass: look for opencode.cmd (npm global install).
+    // Derive the real exe path from the shim location.
+    for (const entry of pathEntries) {
+        const opencodeCmd = path.join(entry, "opencode.cmd");
+        if (!existsSync(opencodeCmd)) {
+            continue;
+        }
+        const candidateExe = path.join(entry, "node_modules", "opencode-ai", "bin", "opencode.exe");
+        if (existsSync(candidateExe)) {
+            return candidateExe;
+        }
+        // Found the shim but not the exe where it usually lives. Stop searching.
+        break;
+    }
+    return "";
+}
 export function createOpencodeServeSpawnCommand(target) {
     const isWindows = process.platform === "win32";
     const port = target.port.toString();
+    if (isWindows) {
+        const resolvedExe = resolveWindowsOpencodeExe();
+        if (resolvedExe) {
+            return {
+                command: resolvedExe,
+                args: ["serve", "--port", port],
+                windowsHide: true,
+            };
+        }
+        // Safe fallback: works with default npm installs where only opencode.cmd is on PATH.
+        return {
+            command: "cmd.exe",
+            args: ["/c", "opencode", "serve", "--port", port],
+            windowsHide: true,
+        };
+    }
     return {
-        command: isWindows ? "cmd.exe" : "opencode",
-        args: isWindows ? ["/c", "opencode", "serve", "--port", port] : ["serve", "--port", port],
-        windowsHide: isWindows,
+        command: "opencode",
+        args: ["serve", "--port", port],
+        windowsHide: false,
     };
 }
 export function startLocalOpencodeServer(target) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grinev/opencode-telegram-bot",
-  "version": "0.22.0",
+  "version": "0.22.2",
   "description": "Telegram bot client for OpenCode to run and monitor coding tasks from chat.",
   "type": "module",
   "main": "./dist/index.js",
@@ -63,11 +63,13 @@
     "remark-gfm": "^4.0.1",
     "remark-parse": "^11.0.0",
     "socks-proxy-agent": "^8.0.5",
-    "unified": "^11.0.5"
+    "unified": "^11.0.5",
+    "ws": "^8.21.0"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.0.8",
+    "@types/ws": "^8.18.1",
     "@typescript-eslint/eslint-plugin": "^8.53.0",
     "@typescript-eslint/parser": "^8.53.0",
     "@vitest/coverage-v8": "^3.2.4",