@grinev/opencode-telegram-bot 0.16.1 → 0.18.0

package/dist/bot/handlers/prompt.js

@@ -18,6 +18,8 @@ import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
 import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
 import { assistantRunState } from "../assistant-run-state.js";
+import { attachToSession, detachAttachedSession, markAttachedSessionBusy, markAttachedSessionIdle, } from "../../attach/service.js";
+import { externalUserInputSuppressionManager } from "../../external-input/suppression.js";
 /** Module-level references for async callbacks that don't have ctx. */
 let botInstance = null;
 let chatIdInstance = null;
@@ -59,6 +61,7 @@ async function isSessionBusy(sessionId, directory) {
     }
 }
 async function resetMismatchedSessionContext() {
+    detachAttachedSession("session_mismatch_reset");
     stopEventListening();
     summaryAggregator.clear();
     foregroundSessionState.clearAll("session_mismatch_reset");
@@ -96,13 +99,8 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
     }
     botInstance = bot;
     chatIdInstance = ctx.chat.id;
-    // Initialize pinned message manager if not already
-    if (!pinnedMessageManager.isInitialized()) {
-        pinnedMessageManager.initialize(bot.api, ctx.chat.id);
-    }
-    // Initialize keyboard manager if not already
-    keyboardManager.initialize(bot.api, ctx.chat.id);
     let currentSession = getCurrentSession();
+    let createdNewSession = false;
     if (currentSession && currentSession.directory !== currentProject.worktree) {
         logger.warn(`[Bot] Session/project mismatch detected. sessionDirectory=${currentSession.directory}, projectDirectory=${currentProject.worktree}. Resetting session context.`);
         await resetMismatchedSessionContext();
@@ -126,38 +124,28 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
         };
         setCurrentSession(currentSession);
         await ingestSessionInfoForCache(session);
-        // Create pinned message for new session
-        try {
-            await pinnedMessageManager.onSessionChange(session.id, session.title);
-        }
-        catch (err) {
-            logger.error("[Bot] Error creating pinned message for new session:", err);
-        }
+        createdNewSession = true;
+    }
+    else {
+        logger.info(`[Bot] Using existing session: id=${currentSession.id}, title="${currentSession.title}"`);
+    }
+    await attachToSession({
+        bot,
+        chatId: ctx.chat.id,
+        session: currentSession,
+        ensureEventSubscription,
+    });
+    if (createdNewSession) {
         const currentAgent = await resolveProjectAgent(getStoredAgent());
         const currentModel = getStoredModel();
-        const contextInfo = pinnedMessageManager.getContextInfo();
-        const variantName = formatVariantForButton(currentModel.variant || "default");
         keyboardManager.updateAgent(currentAgent);
+        const contextInfo = keyboardManager.getContextInfo();
+        const variantName = formatVariantForButton(currentModel.variant || "default");
         const keyboard = createMainKeyboard(currentAgent, currentModel, contextInfo ?? undefined, variantName);
-        await ctx.reply(t("bot.session_created", { title: session.title }), {
+        await ctx.reply(t("bot.session_created", { title: currentSession.title }), {
             reply_markup: keyboard,
         });
     }
-    else {
-        logger.info(`[Bot] Using existing session: id=${currentSession.id}, title="${currentSession.title}"`);
-        // Ensure pinned message exists for existing session
-        if (!pinnedMessageManager.getState().messageId) {
-            try {
-                await pinnedMessageManager.onSessionChange(currentSession.id, currentSession.title);
-            }
-            catch (err) {
-                logger.error("[Bot] Error creating pinned message for existing session:", err);
-            }
-        }
-    }
-    await ensureEventSubscription(currentSession.directory);
-    summaryAggregator.setSession(currentSession.id);
-    summaryAggregator.setBotAndChatId(bot, ctx.chat.id);
     const sessionIsBusy = await isSessionBusy(currentSession.id, currentSession.directory);
     if (sessionIsBusy) {
         logger.info(`[Bot] Ignoring new prompt: session ${currentSession.id} is busy`);
@@ -211,6 +199,7 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
         };
         logger.info(`[Bot] Calling session.prompt (fire-and-forget) with agent=${currentAgent}, fileCount=${fileParts.length}...`);
         foregroundSessionState.markBusy(currentSession.id);
+        await markAttachedSessionBusy(currentSession.id);
         assistantRunState.startRun(currentSession.id, {
             startedAt: Date.now(),
             configuredAgent: currentAgent,
@@ -218,6 +207,9 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
             configuredModelID: storedModel.modelID,
         });
         setPromptResponseMode(currentSession.id, responseMode);
+        if (text.trim().length > 0) {
+            externalUserInputSuppressionManager.register(currentSession.id, text);
+        }
         // CRITICAL: DO NOT wait for session.prompt to complete.
         // If we wait, the handler will not finish and grammY will not call getUpdates,
         // which blocks receiving button callback_query updates.
@@ -228,6 +220,7 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
             onSuccess: ({ error }) => {
                 if (error) {
                     foregroundSessionState.markIdle(currentSession.id);
+                    void markAttachedSessionIdle(currentSession.id);
                     assistantRunState.clearRun(currentSession.id, "session_prompt_api_error");
                     clearPromptResponseMode(currentSession.id);
                     const details = formatErrorDetails(error, 6000);
@@ -242,6 +235,7 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
             },
             onError: (error) => {
                 foregroundSessionState.markIdle(currentSession.id);
+                void markAttachedSessionIdle(currentSession.id);
                 assistantRunState.clearRun(currentSession.id, "session_prompt_background_error");
                 clearPromptResponseMode(currentSession.id);
                 const details = formatErrorDetails(error, 6000);
@@ -256,6 +250,7 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
     catch (err) {
         if (currentSession) {
             foregroundSessionState.markIdle(currentSession.id);
+            await markAttachedSessionIdle(currentSession.id);
             assistantRunState.clearRun(currentSession.id, "session_prompt_handler_error");
         }
         logger.error("Error in prompt handler:", err);

package/dist/bot/handlers/voice.js

@@ -156,8 +156,15 @@ export async function handleVoiceMessage(ctx, deps) {
             logger.warn("[Voice] Failed to edit status message with recognized text:", editError);
         }
         logger.info(`[Voice] Transcribed audio: ${recognizedText.length} chars`);
+        let textForLLM = recognizedText;
+        const notePrompt = config.stt.notePrompt.trim();
+        if (notePrompt && notePrompt.toLowerCase() !== "false" && notePrompt !== "0") {
+            const llmNote = `[Note: ${notePrompt}]`;
+            logger.debug(`[Voice] Added STT note to LLM prompt: ${llmNote}`);
+            textForLLM = `${llmNote}\n${recognizedText}`;
+        }
         // Process the recognized text as a prompt
-        await processPrompt(ctx, recognizedText, deps);
+        await processPrompt(ctx, textForLLM, deps);
     }
     catch (err) {
         const errorMessage = err instanceof Error ? err.message : "unknown error";

package/dist/bot/index.js

@@ -16,6 +16,7 @@ import { AGENT_MODE_BUTTON_TEXT_PATTERN, MODEL_BUTTON_TEXT_PATTERN, VARIANT_BUTT
 import { sessionsCommand, handleSessionSelect } from "./commands/sessions.js";
 import { newCommand } from "./commands/new.js";
 import { projectsCommand, handleProjectSelect } from "./commands/projects.js";
+import { worktreeCommand, handleWorktreeCallback } from "./commands/worktree.js";
 import { openCommand, handleOpenCallback, clearOpenPathIndex } from "./commands/open.js";
 import { abortCommand } from "./commands/abort.js";
 import { opencodeStartCommand } from "./commands/opencode-start.js";
@@ -24,6 +25,7 @@ import { renameCommand, handleRenameCancel, handleRenameTextAnswer } from "./com
 import { handleTaskCallback, handleTaskTextInput, taskCommand } from "./commands/task.js";
 import { handleTaskListCallback, taskListCommand } from "./commands/tasklist.js";
 import { commandsCommand, handleCommandsCallback, handleCommandTextArguments, } from "./commands/commands.js";
+import { skillsCommand, handleSkillsCallback, handleSkillTextArguments, } from "./commands/skills.js";
 import { ttsCommand } from "./commands/tts.js";
 import { handleQuestionCallback, showCurrentQuestion, handleQuestionTextAnswer, } from "./handlers/question.js";
 import { handlePermissionCallback, showPermissionRequest } from "./handlers/permission.js";
@@ -64,7 +66,11 @@ import { scheduledTaskRuntime } from "../scheduled-task/runtime.js";
 import { assistantRunState } from "./assistant-run-state.js";
 import { ResponseStreamer } from "./streaming/response-streamer.js";
 import { ToolCallStreamer } from "./streaming/tool-call-streamer.js";
+import { attachManager } from "../attach/manager.js";
+import { markAttachedSessionBusy, markAttachedSessionIdle, restoreAttachedCurrentSession, } from "../attach/service.js";
+import { externalUserInputSuppressionManager } from "../external-input/suppression.js";
 import { prepareAssistantFinalStreamingPayload, prepareAssistantStreamingPayload, renderAssistantFinalPartsSafe, } from "./utils/assistant-rendering.js";
+import { deliverExternalUserInputNotification } from "./utils/external-user-input.js";
 let botInstance = null;
 let chatIdInstance = null;
 let commandsInitialized = false;
@@ -261,6 +267,27 @@ function getToolStreamKey(tool) {
     }
     return "default";
 }
+function getEventSessionId(event) {
+    const properties = event.properties;
+    return properties.sessionID || properties.info?.sessionID || properties.part?.sessionID || null;
+}
+function shouldMarkAttachedBusyFromEvent(event) {
+    switch (event.type) {
+        case "session.status":
+            return event.properties.status?.type === "busy";
+        case "message.updated": {
+            const info = event.properties.info;
+            return info?.role === "assistant" && !info.time?.completed;
+        }
+        case "message.part.updated":
+        case "message.part.delta":
+        case "question.asked":
+        case "permission.asked":
+            return true;
+        default:
+            return false;
+    }
+}
 async function ensureCommandsInitialized(ctx, next) {
     if (commandsInitialized || !ctx.from || ctx.from.id !== config.telegram.allowedUserId) {
         await next();
@@ -386,6 +413,26 @@ async function ensureEventSubscription(directory) {
             }
         });
     });
+    summaryAggregator.setOnExternalUserInput(async (sessionId, _messageId, messageText) => {
+        void enqueueSessionCompletionTask(sessionId, async () => {
+            if (!botInstance || !chatIdInstance) {
+                return;
+            }
+            try {
+                await deliverExternalUserInputNotification({
+                    api: botInstance.api,
+                    chatId: chatIdInstance,
+                    currentSessionId: getCurrentSession()?.id ?? null,
+                    sessionId,
+                    text: messageText,
+                    consumeSuppressedInput: (incomingSessionId, incomingText) => externalUserInputSuppressionManager.consume(incomingSessionId, incomingText),
+                });
+            }
+            catch (err) {
+                logger.error("[Bot] Failed to deliver external user input to Telegram:", err);
+            }
+        });
+    });
     summaryAggregator.setOnTool(async (toolInfo) => {
         if (!botInstance || !chatIdInstance) {
             logger.error("Bot or chat ID not available for sending tool notification");
@@ -459,18 +506,19 @@ async function ensureEventSubscription(directory) {
             logger.error("Failed to send file to Telegram:", err);
         }
     });
-    summaryAggregator.setOnQuestion(async (questions, requestID) => {
+    summaryAggregator.setOnQuestion(async (questions, requestID, sessionId) => {
         if (!botInstance || !chatIdInstance) {
             logger.error("Bot or chat ID not available for showing questions");
             return;
         }
         const currentSession = getCurrentSession();
-        if (currentSession) {
-            await Promise.all([
-                toolMessageBatcher.flushSession(currentSession.id, "question_asked"),
-                toolCallStreamer.flushSession(currentSession.id, "question_asked"),
-            ]);
+        if (!currentSession || currentSession.id !== sessionId) {
+            return;
         }
+        await Promise.all([
+            toolMessageBatcher.flushSession(currentSession.id, "question_asked"),
+            toolCallStreamer.flushSession(currentSession.id, "question_asked"),
+        ]);
         if (questionManager.isActive()) {
             logger.warn("[Bot] Replacing active poll with a new one");
             const previousMessageIds = questionManager.getMessageIds();
@@ -501,6 +549,10 @@ async function ensureEventSubscription(directory) {
             logger.error("Bot or chat ID not available for showing permission request");
             return;
         }
+        const currentSession = getCurrentSession();
+        if (!currentSession || currentSession.id !== request.sessionID) {
+            return;
+        }
         await Promise.all([
             toolMessageBatcher.flushSession(request.sessionID, "permission_asked"),
             toolCallStreamer.flushSession(request.sessionID, "permission_asked"),
@@ -581,6 +633,7 @@ async function ensureEventSubscription(directory) {
         }
     });
     summaryAggregator.setOnSessionIdle(async (sessionId) => {
+        await markAttachedSessionIdle(sessionId);
         await sessionCompletionTasks.get(sessionId)?.catch(() => undefined);
         const completedRun = assistantRunState.finishRun(sessionId, "session_idle");
         clearPromptResponseMode(sessionId);
@@ -625,6 +678,7 @@ async function ensureEventSubscription(directory) {
         }
     });
     summaryAggregator.setOnSessionError(async (sessionId, message) => {
+        await markAttachedSessionIdle(sessionId);
         if (!botInstance || !chatIdInstance) {
             clearPromptResponseMode(sessionId);
             assistantRunState.clearRun(sessionId, "session_error_no_bot_context");
@@ -704,6 +758,11 @@ async function ensureEventSubscription(directory) {
     });
     logger.info(`[Bot] Subscribing to OpenCode events for project: ${directory}`);
     subscribeToEvents(directory, (event) => {
+        const attached = attachManager.getSnapshot();
+        const eventSessionId = getEventSessionId(event);
+        if (attached && eventSessionId === attached.sessionId && shouldMarkAttachedBusyFromEvent(event)) {
+            void markAttachedSessionBusy(attached.sessionId);
+        }
         if (event.type === "session.created" || event.type === "session.updated") {
             const info = event.properties.info;
             if (info?.directory) {
@@ -721,6 +780,7 @@ async function ensureEventSubscription(directory) {
 export function createBot() {
     clearAllInteractionState("bot_startup");
     sessionCompletionTasks.clear();
+    attachManager.clear("bot_startup");
     assistantRunState.clearAll("bot_startup");
     if (heartbeatTimer) {
         clearInterval(heartbeatTimer);
@@ -746,6 +806,8 @@ export function createBot() {
         };
     }
     const bot = new Bot(config.telegram.token, botOptions);
+    botInstance = bot;
+    chatIdInstance = config.telegram.allowedUserId;
     // Heartbeat for diagnostics: verify the event loop is not blocked
     let heartbeatCounter = 0;
     heartbeatTimer = setInterval(() => {
@@ -801,14 +863,16 @@ export function createBot() {
     bot.command("opencode_start", opencodeStartCommand);
     bot.command("opencode_stop", opencodeStopCommand);
     bot.command("projects", projectsCommand);
+    bot.command("worktree", worktreeCommand);
     bot.command("open", openCommand);
     bot.command("sessions", sessionsCommand);
-    bot.command("new", newCommand);
+    bot.command("new", (ctx) => newCommand(ctx, { bot, ensureEventSubscription }));
     bot.command("abort", abortCommand);
     bot.command("task", taskCommand);
     bot.command("tasklist", taskListCommand);
     bot.command("rename", renameCommand);
     bot.command("commands", commandsCommand);
+    bot.command("skills", skillsCommand);
     bot.on("message:text", unknownCommandMiddleware);
     bot.on("callback_query:data", async (ctx) => {
         logger.debug(`[Bot] Received callback_query:data: ${ctx.callbackQuery?.data}`);
@@ -823,8 +887,9 @@ export function createBot() {
                 // Clean up path index when the open-directory menu is cancelled
                 clearOpenPathIndex();
             }
-            const handledSession = await handleSessionSelect(ctx);
+            const handledSession = await handleSessionSelect(ctx, { bot, ensureEventSubscription });
             const handledProject = await handleProjectSelect(ctx);
+            const handledWorktree = await handleWorktreeCallback(ctx);
             const handledOpen = await handleOpenCallback(ctx);
             const handledQuestion = await handleQuestionCallback(ctx);
             const handledPermission = await handlePermissionCallback(ctx);
@@ -836,10 +901,12 @@ export function createBot() {
             const handledTaskList = await handleTaskListCallback(ctx);
             const handledRenameCancel = await handleRenameCancel(ctx);
             const handledCommands = await handleCommandsCallback(ctx, { bot, ensureEventSubscription });
-            logger.debug(`[Bot] Callback handled: inlineCancel=${handledInlineCancel}, session=${handledSession}, project=${handledProject}, open=${handledOpen}, question=${handledQuestion}, permission=${handledPermission}, agent=${handledAgent}, model=${handledModel}, variant=${handledVariant}, compactConfirm=${handledCompactConfirm}, task=${handledTask}, taskList=${handledTaskList}, rename=${handledRenameCancel}, commands=${handledCommands}`);
+            const handledSkills = await handleSkillsCallback(ctx, { bot, ensureEventSubscription });
+            logger.debug(`[Bot] Callback handled: inlineCancel=${handledInlineCancel}, session=${handledSession}, project=${handledProject}, worktree=${handledWorktree}, open=${handledOpen}, question=${handledQuestion}, permission=${handledPermission}, agent=${handledAgent}, model=${handledModel}, variant=${handledVariant}, compactConfirm=${handledCompactConfirm}, task=${handledTask}, taskList=${handledTaskList}, rename=${handledRenameCancel}, commands=${handledCommands}, skills=${handledSkills}`);
             if (!handledInlineCancel &&
                 !handledSession &&
                 !handledProject &&
+                !handledWorktree &&
                 !handledOpen &&
                 !handledQuestion &&
                 !handledPermission &&
@@ -850,7 +917,8 @@ export function createBot() {
                 !handledTask &&
                 !handledTaskList &&
                 !handledRenameCancel &&
-                !handledCommands) {
+                !handledCommands &&
+                !handledSkills) {
                 logger.debug("Unknown callback query:", ctx.callbackQuery?.data);
                 await ctx.answerCallbackQuery({ text: t("callback.unknown_command") });
             }
@@ -952,6 +1020,14 @@ export function createBot() {
     });
     // Voice and audio message handlers (STT transcription -> prompt)
     const voicePromptDeps = { bot, ensureEventSubscription };
+    safeBackgroundTask({
+        taskName: "bot.restoreFollowedSession",
+        task: () => restoreAttachedCurrentSession({
+            bot,
+            chatId: config.telegram.allowedUserId,
+            ensureEventSubscription,
+        }),
+    });
     bot.on("message:voice", async (ctx) => {
         logger.debug(`[Bot] Received voice message, chatId=${ctx.chat.id}`);
         botInstance = bot;
@@ -1049,6 +1125,10 @@ export function createBot() {
         if (handledCommandArgs) {
             return;
         }
+        const handledSkillArgs = await handleSkillTextArguments(ctx, promptDeps);
+        if (handledSkillArgs) {
+            return;
+        }
         await processUserPrompt(ctx, text, promptDeps);
         logger.debug("[Bot] message:text handler completed (prompt sent in background)");
     });

package/dist/bot/middleware/interaction-guard.js

@@ -80,7 +80,7 @@ export async function interactionGuardMiddleware(ctx, next) {
     const message = decision.busy
         ? decision.state?.kind === "question" || decision.state?.kind === "permission"
             ? getInteractionBlockedMessage(decision.reason, decision.state.kind)
-            : t("interaction.blocked.finish_current")
+            : t("bot.session_busy")
         : getInteractionBlockedMessage(decision.reason, decision.state?.kind);
     logger.debug(`[InteractionGuard] Blocked input: interactionKind=${decision.state?.kind || "none"}, inputType=${decision.inputType}, reason=${decision.reason || "unknown"}, command=${decision.command || "-"}, busy=${decision.busy ? "yes" : "no"}`);
     if (ctx.callbackQuery) {

package/dist/bot/utils/busy-guard.js

@@ -1,10 +1,11 @@
 import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
+import { attachManager } from "../../attach/manager.js";
 import { t } from "../../i18n/index.js";
 export function isForegroundBusy() {
-    return foregroundSessionState.isBusy();
+    return foregroundSessionState.isBusy() || attachManager.isBusy();
 }
 export async function replyBusyBlocked(ctx) {
-    const message = t("interaction.blocked.finish_current");
+    const message = t("bot.session_busy");
     if (ctx.callbackQuery) {
         await ctx.answerCallbackQuery({ text: message }).catch(() => { });
         return;

package/dist/bot/utils/external-user-input.js

@@ -0,0 +1,46 @@
+import { t } from "../../i18n/index.js";
+import { escapePlainTextForTelegramMarkdownV2 } from "../../summary/formatter.js";
+import { sendBotText } from "./telegram-text.js";
+function normalizeExternalUserInputText(text) {
+    return text.replace(/\r\n/g, "\n").trim();
+}
+function buildQuotedPlainText(text) {
+    return text
+        .split("\n")
+        .map((line) => (line.length > 0 ? `> ${line}` : ">"))
+        .join("\n");
+}
+function buildQuotedMarkdownText(text) {
+    return text
+        .split("\n")
+        .map((line) => line.length > 0 ? `> ${escapePlainTextForTelegramMarkdownV2(line)}` : ">")
+        .join("\n");
+}
+export function buildExternalUserInputNotification(text) {
+    const normalizedText = normalizeExternalUserInputText(text);
+    if (!normalizedText) {
+        return null;
+    }
+    const title = `👤 ${t("bot.external_user_input")}`;
+    return {
+        text: `${escapePlainTextForTelegramMarkdownV2(title)}\n\n${buildQuotedMarkdownText(normalizedText)}`,
+        rawFallbackText: `${title}\n\n${buildQuotedPlainText(normalizedText)}`,
+    };
+}
+export async function deliverExternalUserInputNotification({ api, chatId, currentSessionId, sessionId, text, consumeSuppressedInput, }) {
+    const notification = buildExternalUserInputNotification(text);
+    if (!notification || currentSessionId !== sessionId) {
+        return false;
+    }
+    if (consumeSuppressedInput(sessionId, text)) {
+        return false;
+    }
+    await sendBotText({
+        api,
+        chatId,
+        text: notification.text,
+        rawFallbackText: notification.rawFallbackText,
+        format: "markdown_v2",
+    });
+    return true;
+}

package/dist/bot/utils/switch-project.js

@@ -3,6 +3,7 @@ import { clearSession } from "../../session/manager.js";
 import { summaryAggregator } from "../../summary/aggregator.js";
 import { pinnedMessageManager } from "../../pinned/manager.js";
 import { keyboardManager } from "../../keyboard/manager.js";
+import { detachAttachedSession } from "../../attach/service.js";
 import { getStoredAgent, resolveProjectAgent } from "../../agent/manager.js";
 import { getStoredModel } from "../../model/manager.js";
 import { formatVariantForButton } from "../../variant/manager.js";
@@ -23,6 +24,7 @@ import { logger } from "../../utils/logger.js";
  * @param reason    short tag for `clearAllInteractionState` (e.g. "project_switched")
  */
 export async function switchToProject(ctx, project, reason) {
+    detachAttachedSession(reason);
     setCurrentProject(project);
     clearSession();
     summaryAggregator.clear();

package/dist/config.js

@@ -73,6 +73,7 @@ export const config = {
         projectsListLimit: getOptionalPositiveIntEnvVar("PROJECTS_LIST_LIMIT", 10),
         commandsListLimit: getOptionalPositiveIntEnvVar("COMMANDS_LIST_LIMIT", 10),
         taskLimit: getOptionalPositiveIntEnvVar("TASK_LIMIT", 10),
+        scheduledTaskExecutionTimeoutMinutes: getOptionalPositiveIntEnvVar("SCHEDULED_TASK_EXECUTION_TIMEOUT_MINUTES", 120),
         responseStreamThrottleMs: getOptionalPositiveIntEnvVar("RESPONSE_STREAM_THROTTLE_MS", 500),
         bashToolDisplayMaxLength: getOptionalPositiveIntEnvVar("BASH_TOOL_DISPLAY_MAX_LENGTH", 128),
         locale: getOptionalLocaleEnvVar("BOT_LOCALE", "en"),
@@ -92,6 +93,7 @@ export const config = {
         apiKey: getEnvVar("STT_API_KEY", false),
         model: getEnvVar("STT_MODEL", false) || "whisper-large-v3-turbo",
         language: getEnvVar("STT_LANGUAGE", false),
+        notePrompt: getEnvVar("STT_NOTE_PROMPT", false),
     },
     tts: {
         apiUrl: getEnvVar("TTS_API_URL", false),

package/dist/external-input/suppression.js

@@ -0,0 +1,54 @@
+const SUPPRESSION_TTL_MS = 60_000;
+function normalizeExternalUserInputText(text) {
+    return text.replace(/\r\n/g, "\n").trim();
+}
+class ExternalUserInputSuppressionManager {
+    entriesBySession = new Map();
+    register(sessionId, text, now = Date.now()) {
+        const normalizedText = normalizeExternalUserInputText(text);
+        if (!sessionId || !normalizedText) {
+            return;
+        }
+        this.prune(now);
+        const sessionEntries = this.entriesBySession.get(sessionId) ?? [];
+        sessionEntries.push({ text: normalizedText, createdAt: now });
+        this.entriesBySession.set(sessionId, sessionEntries);
+    }
+    consume(sessionId, text, now = Date.now()) {
+        const normalizedText = normalizeExternalUserInputText(text);
+        if (!sessionId || !normalizedText) {
+            return false;
+        }
+        this.prune(now);
+        const sessionEntries = this.entriesBySession.get(sessionId);
+        if (!sessionEntries?.length) {
+            return false;
+        }
+        const entryIndex = sessionEntries.findIndex((entry) => entry.text === normalizedText);
+        if (entryIndex < 0) {
+            return false;
+        }
+        sessionEntries.splice(entryIndex, 1);
+        if (sessionEntries.length === 0) {
+            this.entriesBySession.delete(sessionId);
+        }
+        return true;
+    }
+    clearAll() {
+        this.entriesBySession.clear();
+    }
+    __resetForTests() {
+        this.clearAll();
+    }
+    prune(now) {
+        for (const [sessionId, sessionEntries] of this.entriesBySession.entries()) {
+            const activeEntries = sessionEntries.filter((entry) => now - entry.createdAt <= SUPPRESSION_TTL_MS);
+            if (activeEntries.length === 0) {
+                this.entriesBySession.delete(sessionId);
+                continue;
+            }
+            this.entriesBySession.set(sessionId, activeEntries);
+        }
+    }
+}
+export const externalUserInputSuppressionManager = new ExternalUserInputSuppressionManager();