alvin-bot 4.4.1

package/dist/handlers/platform-message.js

@@ -0,0 +1,275 @@
+/**
+ * Generic Platform Message Handler
+ *
+ * Processes messages from any platform adapter (WhatsApp, Discord, Signal)
+ * through the AI engine and sends the response back.
+ *
+ * This is the platform-agnostic equivalent of message.ts (which is Telegram-specific).
+ */
+import fs from "fs";
+import { getSession, addToHistory, trackProviderUsage } from "../services/session.js";
+import { getRegistry } from "../engine.js";
+import { buildSystemPrompt, buildSmartSystemPrompt } from "../services/personality.js";
+import { buildSkillContext } from "../services/skills.js";
+import { touchProfile } from "../services/users.js";
+import { trackAndAdapt } from "../services/language-detect.js";
+import { transcribeAudio } from "../services/voice.js";
+import { config } from "../config.js";
+/** Platform-specific message length limits */
+const PLATFORM_LIMITS = {
+    discord: 2000,
+    telegram: 4096,
+    whatsapp: 4096,
+    signal: 6000,
+    web: 100_000,
+};
+/**
+ * Handle an incoming message from any platform adapter.
+ * Runs the AI query and sends the response back via the adapter's sendText.
+ */
+export async function handlePlatformMessage(msg, adapter) {
+    let text = msg.text?.trim();
+    // ── Voice message: transcribe first ──────────────────────────────────
+    if (msg.media?.type === "voice" && msg.media.path) {
+        if (!config.apiKeys.groq) {
+            await adapter.sendText(msg.chatId, "⚠️ Voice nicht konfiguriert (GROQ_API_KEY fehlt).");
+            return;
+        }
+        try {
+            const transcript = await transcribeAudio(msg.media.path);
+            fs.unlink(msg.media.path, () => { });
+            if (!transcript.trim()) {
+                await adapter.sendText(msg.chatId, "Could not understand the voice message. 🤷");
+                return;
+            }
+            await adapter.sendText(msg.chatId, `🎙️ _"${transcript}"_`);
+            text = transcript;
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            console.error("Voice transcription error:", errMsg);
+            await adapter.sendText(msg.chatId, `⚠️ Voice message error: ${errMsg}`);
+            if (msg.media.path)
+                fs.unlink(msg.media.path, () => { });
+            return;
+        }
+    }
+    // ── Photo with caption: describe as context ──────────────────────────
+    if (msg.media?.type === "photo" && msg.media.path) {
+        const caption = text || "Beschreibe dieses Bild.";
+        text = `[Image attached: ${msg.media.path}]\n\n${caption}`;
+    }
+    // ── Document: provide path + filename + instructions ──────────────────
+    if (msg.media?.type === "document" && msg.media.path) {
+        const fname = msg.media.fileName || "Dokument";
+        const fpath = msg.media.path;
+        const ext = fname.split(".").pop()?.toLowerCase() || "";
+        const caption = text || `Analysiere dieses Dokument: ${fname}`;
+        // Give the AI concrete instructions based on file type
+        const isArchive = ["zip", "tar", "gz", "tgz", "7z", "rar"].includes(ext);
+        const isPdf = ext === "pdf";
+        const isOffice = ["xlsx", "xls", "docx", "doc", "pptx", "csv"].includes(ext);
+        let fileHint = `[Datei empfangen: ${fpath}]\nDateiname: ${fname}\nTyp: ${msg.media.mimeType || "unbekannt"}`;
+        if (isArchive) {
+            fileHint += `\n\nDiese Datei ist ein Archiv. Entpacke sie mit: unzip "${fpath}" -d "${fpath.replace(/\.[^.]+$/, "")}" oder tar xf "${fpath}" und arbeite dann mit dem Inhalt.`;
+        }
+        else if (isPdf) {
+            fileHint += `\n\nLies den Inhalt mit: pdftotext "${fpath}" - oder python3 mit PyPDF2/pdfplumber.`;
+        }
+        else if (isOffice) {
+            fileHint += `\n\nOpen with python3 (openpyxl for xlsx, python-docx for docx, csv module for csv).`;
+        }
+        text = `${fileHint}\n\n${caption}`;
+    }
+    if (!text)
+        return;
+    // ── Basic command handling for non-Telegram platforms ──────────────
+    const cmdHandled = await handlePlatformCommand(text, msg, adapter);
+    if (cmdHandled)
+        return;
+    const userId = hashUserId(msg.userId);
+    const session = getSession(userId);
+    touchProfile(userId, msg.userName, msg.userHandle, msg.platform, text);
+    // Skip if already processing (queue up to 3)
+    if (session.isProcessing) {
+        if (session.messageQueue.length < 3) {
+            session.messageQueue.push(text);
+        }
+        return;
+    }
+    // Consume queued messages
+    let fullText = text;
+    if (session.messageQueue.length > 0) {
+        const queued = session.messageQueue.splice(0);
+        fullText = [...queued, text].join("\n\n");
+    }
+    // Add reply context
+    if (msg.replyToText) {
+        const quoted = msg.replyToText.length > 500
+            ? msg.replyToText.slice(0, 500) + "..."
+            : msg.replyToText;
+        fullText = `[Bezug auf: "${quoted}"]\n\n${fullText}`;
+    }
+    session.isProcessing = true;
+    let finalText = "";
+    // Show typing indicator
+    if (adapter.setTyping) {
+        adapter.setTyping(msg.chatId).catch(() => { });
+    }
+    // Keep typing indicator alive during long requests (refresh every 4s)
+    const typingInterval = adapter.setTyping
+        ? setInterval(() => adapter.setTyping(msg.chatId).catch(() => { }), 4000)
+        : null;
+    try {
+        session.messageCount++;
+        const adaptedLang = trackAndAdapt(Number(msg.userId) || 0, fullText, session.language);
+        if (adaptedLang !== session.language)
+            session.language = adaptedLang;
+        const registry = getRegistry();
+        const activeProvider = registry.getActive();
+        const isSDK = activeProvider.config.type === "claude-sdk";
+        const skillContext = buildSkillContext(fullText);
+        const systemPrompt = (isSDK
+            ? buildSystemPrompt(isSDK, session.language, msg.chatId)
+            : await buildSmartSystemPrompt(isSDK, session.language, fullText, msg.chatId)) + skillContext;
+        const queryOpts = {
+            prompt: fullText,
+            systemPrompt,
+            workingDir: session.workingDir,
+            effort: session.effort,
+            sessionId: isSDK ? session.sessionId : null,
+            history: !isSDK ? session.history : undefined,
+        };
+        if (!isSDK) {
+            addToHistory(userId, { role: "user", content: fullText });
+        }
+        for await (const chunk of registry.queryWithFallback(queryOpts)) {
+            switch (chunk.type) {
+                case "text":
+                    finalText = chunk.text || "";
+                    break;
+                case "done":
+                    if (chunk.sessionId)
+                        session.sessionId = chunk.sessionId;
+                    if (chunk.costUsd)
+                        session.totalCost += chunk.costUsd;
+                    trackProviderUsage(userId, registry.getActiveKey(), chunk.costUsd || 0, chunk.inputTokens, chunk.outputTokens);
+                    session.lastActivity = Date.now();
+                    break;
+                case "error":
+                    await adapter.sendText(msg.chatId, `⚠️ Error: ${chunk.error}`);
+                    return;
+            }
+        }
+        // Send response
+        if (finalText.trim()) {
+            const maxLen = PLATFORM_LIMITS[msg.platform] || 4096;
+            if (finalText.length > maxLen) {
+                const chunks = splitMessage(finalText, maxLen);
+                for (const chunk of chunks) {
+                    await adapter.sendText(msg.chatId, chunk);
+                }
+            }
+            else {
+                await adapter.sendText(msg.chatId, finalText);
+            }
+            if (!isSDK && finalText) {
+                addToHistory(userId, { role: "assistant", content: finalText });
+            }
+        }
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        console.error(`Platform message error (${msg.platform}):`, errorMsg);
+        await adapter.sendText(msg.chatId, `⚠️ Error: ${errorMsg}`);
+    }
+    finally {
+        if (typingInterval)
+            clearInterval(typingInterval);
+        session.isProcessing = false;
+    }
+}
+/**
+ * Handle basic slash commands on non-Telegram platforms.
+ * Returns true if the message was a command and was handled.
+ */
+async function handlePlatformCommand(text, msg, adapter) {
+    if (!text.startsWith("/"))
+        return false;
+    const parts = text.split(/\s+/);
+    const cmd = parts[0].toLowerCase();
+    const userId = hashUserId(msg.userId);
+    const session = getSession(userId);
+    switch (cmd) {
+        case "/new": {
+            const { resetSession } = await import("../services/session.js");
+            resetSession(userId);
+            await adapter.sendText(msg.chatId, "🔄 New chat started.");
+            return true;
+        }
+        case "/status": {
+            const { getRegistry } = await import("../engine.js");
+            const registry = getRegistry();
+            const provider = registry.getActiveKey();
+            const msgs = session.messageCount;
+            const cost = session.totalCost.toFixed(4);
+            await adapter.sendText(msg.chatId, `📊 Status\n` +
+                `Provider: ${provider}\n` +
+                `Messages: ${msgs}\n` +
+                `Cost: $${cost}\n` +
+                `Effort: ${session.effort}\n` +
+                `Platform: ${msg.platform}`);
+            return true;
+        }
+        case "/effort": {
+            const level = parts[1]?.toLowerCase();
+            if (["low", "medium", "high", "max"].includes(level)) {
+                session.effort = level;
+                await adapter.sendText(msg.chatId, `🧠 Effort: ${level}`);
+            }
+            else {
+                await adapter.sendText(msg.chatId, `🧠 Current: ${session.effort}\nOptions: /effort low|medium|high|max`);
+            }
+            return true;
+        }
+        case "/help": {
+            await adapter.sendText(msg.chatId, "🤖 Alvin Bot — Commands\n\n" +
+                "/new — New chat\n" +
+                "/status — Session info\n" +
+                "/effort <low|medium|high|max> — Thinking depth\n" +
+                "/help — This help\n\n" +
+                "For all features use the Web Dashboard or Telegram.");
+            return true;
+        }
+        default:
+            // Unknown command → treat as normal message
+            return false;
+    }
+}
+/** Hash a string userId to a numeric ID for session compatibility */
+function hashUserId(id) {
+    let hash = 0;
+    for (let i = 0; i < id.length; i++) {
+        const char = id.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash; // Convert to 32-bit int
+    }
+    return Math.abs(hash);
+}
+/** Split a message into chunks at word/newline boundaries */
+function splitMessage(text, maxLen) {
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > maxLen) {
+        let splitAt = remaining.lastIndexOf("\n", maxLen);
+        if (splitAt < maxLen * 0.5)
+            splitAt = remaining.lastIndexOf(" ", maxLen);
+        if (splitAt < maxLen * 0.5)
+            splitAt = maxLen;
+        chunks.push(remaining.slice(0, splitAt));
+        remaining = remaining.slice(splitAt).trimStart();
+    }
+    if (remaining)
+        chunks.push(remaining);
+    return chunks;
+}

package/dist/handlers/video.js

@@ -0,0 +1,237 @@
+/**
+ * Video Message Handler — Process video messages and video notes (round videos).
+ *
+ * Capabilities:
+ * - Receive video messages → extract key frames → describe/analyze
+ * - Receive video notes (round videos) → same processing
+ * - Extract audio from video → transcribe (if voice content)
+ * - Support for video files sent as documents (handled by document handler)
+ */
+import fs from "fs";
+import path from "path";
+import os from "os";
+import https from "https";
+import { execSync } from "child_process";
+import { config } from "../config.js";
+import { getSession, addToHistory } from "../services/session.js";
+import { TelegramStreamer } from "../services/telegram.js";
+import { getRegistry } from "../engine.js";
+import { transcribeAudio } from "../services/voice.js";
+import { buildSystemPrompt } from "../services/personality.js";
+const TEMP_DIR = path.join(os.tmpdir(), "alvin-bot", "video");
+if (!fs.existsSync(TEMP_DIR))
+    fs.mkdirSync(TEMP_DIR, { recursive: true });
+/** React helper */
+async function react(ctx, emoji) {
+    try {
+        await ctx.react(emoji);
+    }
+    catch { /* ignore */ }
+}
+/** Download a Telegram file */
+async function downloadFile(url, dest) {
+    return new Promise((resolve, reject) => {
+        const file = fs.createWriteStream(dest);
+        https.get(url, (response) => {
+            response.pipe(file);
+            file.on("finish", () => file.close(() => resolve()));
+        }).on("error", (err) => {
+            fs.unlink(dest, () => { });
+            reject(err);
+        });
+    });
+}
+/** Check if ffmpeg is available */
+function hasFFmpeg() {
+    try {
+        execSync("which ffmpeg", { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Extract key frames from a video (up to 4 frames, evenly spaced) */
+function extractFrames(videoPath, outputDir, maxFrames = 4) {
+    // Get video duration
+    let duration = 10;
+    try {
+        const probe = execSync(`ffprobe -v error -show_entries format=duration -of csv="p=0" "${videoPath}"`, { stdio: "pipe" }).toString().trim();
+        duration = parseFloat(probe) || 10;
+    }
+    catch { /* default duration */ }
+    const interval = Math.max(duration / (maxFrames + 1), 0.5);
+    const frames = [];
+    for (let i = 1; i <= maxFrames; i++) {
+        const timestamp = Math.min(interval * i, duration - 0.1);
+        const framePath = path.join(outputDir, `frame_${i}.jpg`);
+        try {
+            execSync(`ffmpeg -ss ${timestamp.toFixed(2)} -i "${videoPath}" -vframes 1 -q:v 3 -y "${framePath}" 2>/dev/null`, { stdio: "pipe", timeout: 10000 });
+            if (fs.existsSync(framePath) && fs.statSync(framePath).size > 0) {
+                frames.push(framePath);
+            }
+        }
+        catch { /* skip this frame */ }
+    }
+    return frames;
+}
+/** Extract audio track from video */
+function extractAudio(videoPath) {
+    const audioPath = videoPath.replace(/\.\w+$/, ".ogg");
+    try {
+        execSync(`ffmpeg -i "${videoPath}" -vn -acodec libopus -y "${audioPath}" 2>/dev/null`, { stdio: "pipe", timeout: 30000 });
+        if (fs.existsSync(audioPath) && fs.statSync(audioPath).size > 1000) {
+            return audioPath;
+        }
+    }
+    catch { /* no audio track or extraction failed */ }
+    return null;
+}
+export async function handleVideo(ctx) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const video = ctx.message?.video || ctx.message?.video_note;
+    if (!video)
+        return;
+    const userId = ctx.from.id;
+    const session = getSession(userId);
+    if (session.isProcessing) {
+        if (session.messageQueue.length < 3) {
+            session.messageQueue.push("[Video-Nachricht empfangen]");
+            await react(ctx, "📝");
+        }
+        return;
+    }
+    if (!hasFFmpeg()) {
+        await ctx.reply("❌ Video processing requires ffmpeg. Install with: `brew install ffmpeg`", { parse_mode: "Markdown" });
+        return;
+    }
+    session.isProcessing = true;
+    session.abortController = new AbortController();
+    const streamer = new TelegramStreamer(ctx.chat.id, ctx.api, ctx.message?.message_id);
+    let finalText = "";
+    const typingInterval = setInterval(() => {
+        ctx.api.sendChatAction(ctx.chat.id, "typing").catch(() => { });
+    }, 4000);
+    try {
+        await react(ctx, "👀");
+        await ctx.api.sendChatAction(ctx.chat.id, "typing");
+        // 1. Download video
+        const file = await ctx.api.getFile(video.file_id);
+        const ext = file.file_path?.split(".").pop() || "mp4";
+        const videoPath = path.join(TEMP_DIR, `video_${Date.now()}.${ext}`);
+        const fileUrl = `https://api.telegram.org/file/bot${config.botToken}/${file.file_path}`;
+        await downloadFile(fileUrl, videoPath);
+        // 2. Extract key frames
+        const frameDir = path.join(TEMP_DIR, `frames_${Date.now()}`);
+        fs.mkdirSync(frameDir, { recursive: true });
+        const frames = extractFrames(videoPath, frameDir);
+        // 3. Extract and transcribe audio (if available)
+        let transcript = "";
+        if (config.apiKeys.groq) {
+            const audioPath = extractAudio(videoPath);
+            if (audioPath) {
+                try {
+                    transcript = await transcribeAudio(audioPath);
+                    fs.unlink(audioPath, () => { });
+                }
+                catch { /* no transcription */ }
+            }
+        }
+        // 4. Build prompt with video context
+        const caption = ctx.message?.caption || "";
+        const duration = video.duration || 0;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const isVideoNote = !!ctx.message?.video_note;
+        let prompt = `[Video empfangen: ${duration}s`;
+        if (isVideoNote)
+            prompt += ", runde Videonachricht";
+        if (video.width && video.height)
+            prompt += `, ${video.width}x${video.height}`;
+        prompt += "]";
+        if (transcript) {
+            prompt += `\n\n[Audio-Transkription]: "${transcript}"`;
+        }
+        if (caption) {
+            prompt += `\n\n[Bildunterschrift]: "${caption}"`;
+        }
+        if (frames.length > 0) {
+            prompt += `\n\n[${frames.length} key frames extracted from the video]`;
+            prompt += "\n\nBitte beschreibe was im Video zu sehen ist und beantworte eventuelle Fragen.";
+        }
+        else {
+            prompt += "\n\nIch konnte keine Frames extrahieren. Basiere deine Antwort auf der Audio-Transkription.";
+        }
+        // Show what we extracted
+        const infoLines = [];
+        if (frames.length > 0)
+            infoLines.push(`🎞️ ${frames.length} frames extracted`);
+        if (transcript)
+            infoLines.push(`🎙️ "${transcript.slice(0, 100)}${transcript.length > 100 ? "..." : ""}"`);
+        if (infoLines.length > 0) {
+            await ctx.reply(infoLines.join("\n"));
+        }
+        // 5. Send to AI
+        session.messageCount++;
+        const registry = getRegistry();
+        const activeProvider = registry.getActive();
+        const isSDK = activeProvider.config.type === "claude-sdk";
+        const queryOpts = {
+            prompt,
+            systemPrompt: buildSystemPrompt(isSDK, session.language),
+            workingDir: session.workingDir,
+            effort: session.effort,
+            abortSignal: session.abortController.signal,
+            sessionId: isSDK ? session.sessionId : null,
+            history: !isSDK ? session.history : undefined,
+        };
+        if (!isSDK) {
+            addToHistory(userId, { role: "user", content: prompt });
+        }
+        for await (const chunk of registry.queryWithFallback(queryOpts)) {
+            switch (chunk.type) {
+                case "text":
+                    finalText = chunk.text || "";
+                    await streamer.update(finalText);
+                    break;
+                case "tool_use":
+                    if (chunk.toolName)
+                        session.toolUseCount++;
+                    break;
+                case "done":
+                    if (chunk.sessionId)
+                        session.sessionId = chunk.sessionId;
+                    if (chunk.costUsd)
+                        session.totalCost += chunk.costUsd;
+                    session.lastActivity = Date.now();
+                    break;
+                case "error":
+                    await ctx.reply(`Error: ${chunk.error}`);
+                    break;
+            }
+        }
+        await streamer.finalize(finalText);
+        await react(ctx, "👍");
+        if (!isSDK && finalText) {
+            addToHistory(userId, { role: "assistant", content: finalText });
+        }
+        // Cleanup
+        frames.forEach(f => fs.unlink(f, () => { }));
+        fs.rm(frameDir, { recursive: true }, () => { });
+        fs.unlink(videoPath, () => { });
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        await react(ctx, "👎");
+        if (errorMsg.includes("abort")) {
+            await ctx.reply("Anfrage abgebrochen.");
+        }
+        else {
+            await ctx.reply(`Error: ${errorMsg}`);
+        }
+    }
+    finally {
+        clearInterval(typingInterval);
+        session.isProcessing = false;
+        session.abortController = null;
+    }
+}

package/dist/handlers/voice.js

@@ -0,0 +1,148 @@
+import { InputFile } from "grammy";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import https from "https";
+/** React to a message with an emoji. Silently fails if not supported. */
+async function react(ctx, emoji) {
+    try {
+        await ctx.react(emoji);
+    }
+    catch { /* ignore */ }
+}
+import { config } from "../config.js";
+import { getSession, addToHistory } from "../services/session.js";
+import { TelegramStreamer } from "../services/telegram.js";
+import { transcribeAudio, textToSpeech } from "../services/voice.js";
+import { getRegistry } from "../engine.js";
+import { buildSystemPrompt } from "../services/personality.js";
+const TEMP_DIR = path.join(os.tmpdir(), "alvin-bot");
+if (!fs.existsSync(TEMP_DIR)) {
+    fs.mkdirSync(TEMP_DIR, { recursive: true });
+}
+async function downloadFile(url, dest) {
+    return new Promise((resolve, reject) => {
+        const file = fs.createWriteStream(dest);
+        https.get(url, (response) => {
+            response.pipe(file);
+            file.on("finish", () => file.close(() => resolve()));
+        }).on("error", (err) => {
+            fs.unlink(dest, () => { });
+            reject(err);
+        });
+    });
+}
+export async function handleVoice(ctx) {
+    const voice = ctx.message?.voice;
+    if (!voice)
+        return;
+    const userId = ctx.from.id;
+    const session = getSession(userId);
+    if (session.isProcessing) {
+        await ctx.reply("Please wait, previous request still running... (/cancel to abort)");
+        return;
+    }
+    if (!config.apiKeys.groq) {
+        await ctx.reply("Voice nicht konfiguriert (GROQ_API_KEY fehlt).");
+        return;
+    }
+    session.isProcessing = true;
+    session.abortController = new AbortController();
+    const streamer = new TelegramStreamer(ctx.chat.id, ctx.api, ctx.message?.message_id);
+    let finalText = "";
+    const typingInterval = setInterval(() => {
+        ctx.api.sendChatAction(ctx.chat.id, "typing").catch(() => { });
+    }, 4000);
+    try {
+        await react(ctx, "🎧");
+        await ctx.api.sendChatAction(ctx.chat.id, "typing");
+        // 1. Download voice message
+        const file = await ctx.api.getFile(voice.file_id);
+        const fileUrl = `https://api.telegram.org/file/bot${config.botToken}/${file.file_path}`;
+        const audioPath = path.join(TEMP_DIR, `voice_${Date.now()}.ogg`);
+        await downloadFile(fileUrl, audioPath);
+        // 2. Transcribe with Groq Whisper
+        const transcript = await transcribeAudio(audioPath);
+        fs.unlink(audioPath, () => { });
+        if (!transcript.trim()) {
+            await ctx.reply("Could not understand the voice message.");
+            return;
+        }
+        // Show what was understood
+        await ctx.reply(`"${transcript}"`);
+        // 3. Send to AI via provider system
+        session.messageCount++;
+        const registry = getRegistry();
+        const activeProvider = registry.getActive();
+        const isSDK = activeProvider.config.type === "claude-sdk";
+        const queryOpts = {
+            prompt: transcript,
+            systemPrompt: buildSystemPrompt(isSDK, session.language),
+            workingDir: session.workingDir,
+            effort: session.effort,
+            abortSignal: session.abortController.signal,
+            sessionId: isSDK ? session.sessionId : null,
+            history: !isSDK ? session.history : undefined,
+            _sessionState: isSDK ? {
+                messageCount: session.messageCount,
+                toolUseCount: session.toolUseCount,
+            } : undefined,
+        };
+        if (!isSDK) {
+            addToHistory(userId, { role: "user", content: transcript });
+        }
+        for await (const chunk of registry.queryWithFallback(queryOpts)) {
+            switch (chunk.type) {
+                case "text":
+                    finalText = chunk.text || "";
+                    await streamer.update(finalText);
+                    break;
+                case "tool_use":
+                    if (chunk.toolName)
+                        session.toolUseCount++;
+                    break;
+                case "done":
+                    if (chunk.sessionId)
+                        session.sessionId = chunk.sessionId;
+                    if (chunk.costUsd)
+                        session.totalCost += chunk.costUsd;
+                    session.lastActivity = Date.now();
+                    break;
+                case "error":
+                    await ctx.reply(`Error: ${chunk.error}`);
+                    break;
+            }
+        }
+        await streamer.finalize(finalText);
+        await react(ctx, "👍");
+        if (!isSDK && finalText) {
+            addToHistory(userId, { role: "assistant", content: finalText });
+        }
+        // 4. Send voice reply if enabled
+        if (session.voiceReply && finalText.trim()) {
+            try {
+                await ctx.api.sendChatAction(ctx.chat.id, "upload_voice");
+                const ttsPath = await textToSpeech(finalText);
+                await ctx.replyWithVoice(new InputFile(fs.readFileSync(ttsPath), "response.mp3"));
+                fs.unlink(ttsPath, () => { });
+            }
+            catch (err) {
+                console.error("TTS error:", err);
+            }
+        }
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        if (errorMsg.includes("abort")) {
+            await ctx.reply("Anfrage abgebrochen.");
+        }
+        else {
+            await ctx.reply(`Error: ${errorMsg}`);
+        }
+    }
+    finally {
+        clearInterval(typingInterval);
+        session.isProcessing = false;
+        session.abortController = null;
+    }
+}