thepopebot 1.2.76-beta.2 → 1.2.76-beta.21

package/lib/channels/commands/index.js

@@ -0,0 +1,42 @@
+import { verifyCommand } from './verify.js';
+import { sessionCommand } from './session.js';
+
+const PRE_AUTH = {
+  verify: verifyCommand,
+};
+
+const POST_AUTH = {
+  session: sessionCommand,
+};
+
+function parse(text) {
+  const trimmed = (text || '').trim();
+  if (!trimmed.startsWith('/')) return null;
+  const [head, ...rest] = trimmed.slice(1).split(/\s+/);
+  return { name: head.toLowerCase(), args: rest };
+}
+
+/**
+ * Dispatch a pre-auth command. Returns { handled, reply, userId? } or null.
+ * Called when the incoming channel chat is not yet bound to a user.
+ * Only /verify runs here.
+ */
+export async function dispatchPreAuthCommand(normalized, ctx) {
+  const parsed = parse(normalized.text);
+  if (!parsed) return null;
+  const handler = PRE_AUTH[parsed.name];
+  if (!handler) return null;
+  return handler({ args: parsed.args, normalized, ctx });
+}
+
+/**
+ * Dispatch a post-auth command. Returns { handled, reply } or null.
+ * ctx must include { userId, channel, channelChatId }.
+ */
+export async function dispatchCommand(normalized, ctx) {
+  const parsed = parse(normalized.text);
+  if (!parsed) return null;
+  const handler = POST_AUTH[parsed.name];
+  if (!handler) return null;
+  return handler({ args: parsed.args, normalized, ctx });
+}

package/lib/channels/commands/session.js

@@ -0,0 +1,53 @@
+import { randomUUID } from 'crypto';
+import { setActiveThread } from '../../db/user-channels.js';
+import { getChatById, getChatsByUser } from '../../db/chats.js';
+
+function shortId(id) {
+  return id.replace(/-/g, '').slice(0, 8);
+}
+
+/**
+ * /session           → mint a new session UUID, mark it active
+ * /session list      → list the user's 10 most-recent chats
+ * /session <id|short> → switch active to an existing chat (full uuid or 8-char short id)
+ */
+export async function sessionCommand({ args, ctx }) {
+  const sub = args[0];
+
+  if (!sub) {
+    const threadId = randomUUID();
+    setActiveThread(ctx.userId, ctx.channel, threadId);
+    return {
+      handled: true,
+      reply: `New session: ${shortId(threadId)}\nSend a message to begin.`,
+    };
+  }
+
+  if (sub.toLowerCase() === 'list') {
+    const chats = getChatsByUser(ctx.userId).slice(0, 10);
+    if (!chats.length) {
+      return { handled: true, reply: 'No sessions yet. Send a message or use /session to start one.' };
+    }
+    const lines = chats.map((c) => `${shortId(c.id)}  ${c.title}`);
+    return { handled: true, reply: `Recent sessions:\n${lines.join('\n')}` };
+  }
+
+  const target = resolveChatId(sub, ctx.userId);
+  if (!target) {
+    return { handled: true, reply: `Session not found: ${sub}` };
+  }
+  setActiveThread(ctx.userId, ctx.channel, target.id);
+  return { handled: true, reply: `Switched to session: ${shortId(target.id)}\n${target.title}` };
+}
+
+function resolveChatId(input, userId) {
+  // Full UUID match first
+  const direct = getChatById(input);
+  if (direct && direct.userId === userId) return direct;
+  // Short-id match (8-char prefix of UUID minus dashes)
+  if (input.length === 8) {
+    const chats = getChatsByUser(userId);
+    return chats.find((c) => shortId(c.id) === input.toLowerCase()) || null;
+  }
+  return null;
+}

package/lib/channels/commands/verify.js

@@ -0,0 +1,18 @@
+import { redeemCode } from '../../db/user-channels.js';
+
+/**
+ * /verify <code>
+ * Pre-auth: binds the incoming channel chat to the user who issued the code.
+ */
+export async function verifyCommand({ args, ctx }) {
+  const [code] = args;
+  if (!code) {
+    return { handled: true, reply: 'Usage: /verify <code>' };
+  }
+  try {
+    const { userId } = redeemCode(ctx.channel, code, ctx.channelChatId);
+    return { handled: true, reply: 'Linked. Send a message to start chatting.', userId };
+  } catch (err) {
+    return { handled: true, reply: `Verification failed: ${err.message}` };
+  }
+}

package/lib/channels/telegram.js

@@ -4,8 +4,10 @@ import {
   downloadFile,
   reactToMessage,
   startTypingIndicator,
+  formatToolCall,
 } from '../tools/telegram.js';
-import { isWhisperEnabled, transcribeAudio } from '../tools/openai.js';
+import { isAssemblyAIEnabled, transcribeAudio } from '../tools/assemblyai.js';
+import { getConfig } from '../config.js';
 
 class TelegramAdapter extends ChannelAdapter {
   constructor(botToken) {
@@ -17,17 +19,21 @@ class TelegramAdapter extends ChannelAdapter {
    * Parse a Telegram webhook update into normalized message data.
    * Handles: text, voice/audio (transcribed), photos, documents.
    * Returns null if the update should be ignored.
+   *
+   * Does NOT authorize the chat — auth is handled downstream by resolving
+   * `channelChatId` against `user_channels`. This adapter only validates
+   * that the request came from Telegram (webhook secret) and extracts the
+   * payload.
    */
   async receive(request) {
-    const { TELEGRAM_WEBHOOK_SECRET, TELEGRAM_CHAT_ID, TELEGRAM_VERIFICATION } = process.env;
+    const webhookSecret = getConfig('TELEGRAM_WEBHOOK_SECRET');
 
-    // Validate secret token (required)
-    if (!TELEGRAM_WEBHOOK_SECRET) {
+    if (!webhookSecret) {
       console.error('[telegram] TELEGRAM_WEBHOOK_SECRET not configured — rejecting webhook');
       return null;
     }
     const headerSecret = request.headers.get('x-telegram-bot-api-secret-token');
-    if (headerSecret !== TELEGRAM_WEBHOOK_SECRET) {
+    if (headerSecret !== webhookSecret) {
       return null;
     }
 
@@ -40,31 +46,19 @@ class TelegramAdapter extends ChannelAdapter {
     let text = message.text || null;
     const attachments = [];
 
-    // Check for verification code — works even before TELEGRAM_CHAT_ID is set
-    if (TELEGRAM_VERIFICATION && text === TELEGRAM_VERIFICATION) {
-      await sendMessage(this.botToken, chatId, `Your chat ID:\n<code>${chatId}</code>`);
-      return null;
-    }
-
-    // Security: if no TELEGRAM_CHAT_ID configured, ignore all messages
-    if (!TELEGRAM_CHAT_ID) return null;
-
-    // Security: only accept messages from configured chat
-    if (chatId !== TELEGRAM_CHAT_ID) return null;
-
     // Voice messages → transcribe to text
     if (message.voice) {
-      if (!isWhisperEnabled()) {
+      if (!isAssemblyAIEnabled()) {
         await sendMessage(
           this.botToken,
           chatId,
-          'Voice messages are not supported. Please set OPENAI_API_KEY to enable transcription.'
+          'Voice messages are not supported. Please set ASSEMBLYAI_API_KEY to enable transcription.'
         );
         return null;
       }
       try {
-        const { buffer, filename } = await downloadFile(this.botToken, message.voice.file_id);
-        text = await transcribeAudio(buffer, filename);
+        const { buffer } = await downloadFile(this.botToken, message.voice.file_id);
+        text = await transcribeAudio(buffer);
       } catch (err) {
         console.error('Failed to transcribe voice:', err);
         await sendMessage(this.botToken, chatId, 'Sorry, I could not transcribe your voice message.');
@@ -74,17 +68,17 @@ class TelegramAdapter extends ChannelAdapter {
 
     // Audio messages → transcribe to text
     if (message.audio && !text) {
-      if (!isWhisperEnabled()) {
+      if (!isAssemblyAIEnabled()) {
         await sendMessage(
           this.botToken,
           chatId,
-          'Audio messages are not supported. Please set OPENAI_API_KEY to enable transcription.'
+          'Audio messages are not supported. Please set ASSEMBLYAI_API_KEY to enable transcription.'
         );
         return null;
       }
       try {
-        const { buffer, filename } = await downloadFile(this.botToken, message.audio.file_id);
-        text = await transcribeAudio(buffer, filename);
+        const { buffer } = await downloadFile(this.botToken, message.audio.file_id);
+        text = await transcribeAudio(buffer);
       } catch (err) {
         console.error('Failed to transcribe audio:', err);
         await sendMessage(this.botToken, chatId, 'Sorry, I could not transcribe your audio message.');
@@ -121,7 +115,8 @@ class TelegramAdapter extends ChannelAdapter {
     if (!text && attachments.length === 0) return null;
 
     return {
-      threadId: chatId,
+      channel: 'telegram',
+      channelChatId: chatId,
       text: text || '',
       attachments,
       metadata: { messageId: message.message_id, chatId },
@@ -136,8 +131,64 @@ class TelegramAdapter extends ChannelAdapter {
     return startTypingIndicator(this.botToken, metadata.chatId);
   }
 
-  async sendResponse(threadId, text, metadata) {
-    await sendMessage(this.botToken, threadId, text);
+  async sendResponse(channelChatId, text, metadata) {
+    await sendMessage(this.botToken, channelChatId, text);
+  }
+
+  /**
+   * Consume a chatStream() async iterable and send progressive messages.
+   * - Text chunks accumulate and flush when a tool-call arrives or stream ends.
+   * - Each tool-call sends immediately as its own message.
+   * - Tool-results react to the tool-call message with ✅ (or ❌ on error).
+   *
+   * @param {string} chatId - Telegram chat ID
+   * @param {AsyncIterable} chunks - chatStream() output
+   */
+  async streamChatResponse(chatId, chunks) {
+    let textBuffer = '';
+    // Map toolCallId → { telegramMessageId, hasCompleteArgs }
+    const toolMessages = new Map();
+
+    for await (const chunk of chunks) {
+      if (chunk.type === 'text') {
+        textBuffer += chunk.text;
+      } else if (chunk.type === 'tool-call') {
+        // Skip the first empty-args emission — wait for complete args
+        if (!chunk.args || Object.keys(chunk.args).length === 0) {
+          continue;
+        }
+
+        // Flush accumulated text before tool call
+        if (textBuffer.trim()) {
+          await sendMessage(this.botToken, chatId, textBuffer.trim());
+          textBuffer = '';
+        }
+
+        // Send tool call as its own message
+        const text = formatToolCall(chunk.toolName, chunk.args);
+        try {
+          const msg = await sendMessage(this.botToken, chatId, text);
+          toolMessages.set(chunk.toolCallId, msg.message_id);
+        } catch (err) {
+          console.error('[telegram] Failed to send tool call:', err.message);
+        }
+      } else if (chunk.type === 'tool-result') {
+        const messageId = toolMessages.get(chunk.toolCallId);
+        if (messageId) {
+          const emoji = chunk.result?.includes?.('error') || chunk.result?.includes?.('Error')
+            ? '👎'
+            : '👍';
+          reactToMessage(this.botToken, chatId, messageId, emoji).catch(() => {});
+          toolMessages.delete(chunk.toolCallId);
+        }
+      }
+      // Skip: meta, result, thinking-*, unknown
+    }
+
+    // Flush remaining text
+    if (textBuffer.trim()) {
+      await sendMessage(this.botToken, chatId, textBuffer.trim());
+    }
   }
 
   get supportsStreaming() {

package/lib/chat/CLAUDE.md

@@ -38,10 +38,10 @@ export { getRepositoriesHandler as GET } from 'thepopebot/chat/api';
 ## Chat Streaming Flow
 
 1. Client sends message via AI SDK `DefaultChatTransport` → `POST /stream/chat`
-2. Handler validates session, extracts text + file attachments from message parts
-3. Calls `chatStream()` from `lib/ai/` which handles DB persistence and LLM invocation
-4. Streams response chunks (text deltas, tool calls, tool results) via `createUIMessageStream`
-5. After first message, client calls `/chat/finalize-chat` to generate auto-title
+2. Handler validates session, extracts text + file attachments from message parts. Images and PDFs pass through as vision content; text files are inlined into the prompt.
+3. Calls `chatStream()` from `lib/ai/` which handles DB persistence and LLM invocation. Two paths: SDK adapter (in-process, e.g. Claude Agent SDK) or direct headless container (other agents).
+4. Streams response chunks (text deltas, tool calls, tool results, thinking blocks) via `createUIMessageStream`. Tool call/tool result pairs and `{ type: 'error' }` chunks are persisted as JSON message parts.
+5. After the first user message streams, the client calls `/chat/finalize-chat` to generate the auto-title (helper LLM with truncated-description fallback).
 
 ## Server Actions (actions.js)