totem-llm 0.1.0

package/server/utils/telegramBot/utils/commands/handlers/handleAbort.js

@@ -0,0 +1,15 @@
+/**
+ * /abort - Kill any ongoing LLM worker for this chat.
+ * @param {import("../index").BotContext} ctx
+ * @param {number} chatId
+ */
+async function handleAbort(ctx, chatId) {
+  const { TelegramBotService } = require("../../../index");
+  const service = new TelegramBotService();
+  const aborted = service.abortChat(chatId);
+
+  if (aborted) await ctx.bot.sendMessage(chatId, "Response aborted by user.");
+  else await ctx.bot.sendMessage(chatId, "No active response to abort.");
+}
+
+module.exports = { handleAbort };

package/server/utils/telegramBot/utils/commands/handlers/handleHelp.js

@@ -0,0 +1,15 @@
+/**
+ * /help - Show all available commands.
+ * @param {import("../index").BotContext} ctx
+ * @param {number} chatId
+ */
+async function handleHelp(ctx, chatId) {
+  const { BOT_COMMANDS } = require("../index");
+  const lines = BOT_COMMANDS.map((c) => `/${c.command} - ${c.description}`);
+  await ctx.bot.sendMessage(
+    chatId,
+    `Available commands:\n\n${lines.join("\n")}`
+  );
+}
+
+module.exports = { handleHelp };

package/server/utils/telegramBot/utils/commands/handlers/handleHistory.js

@@ -0,0 +1,80 @@
+const { Workspace } = require("../../../../../models/workspace");
+const { WorkspaceThread } = require("../../../../../models/workspaceThread");
+const { WorkspaceChats } = require("../../../../../models/workspaceChats");
+const { convertToChatHistory } = require("../../../../helpers/chat/responses");
+const { sendBatchedMessages } = require("../../../utils");
+const { escapeHTML } = require("../../format");
+
+const DEFAULT_HISTORY_COUNT = 10;
+const MAX_HISTORY_COUNT = 50;
+
+/**
+ * /history [count] - Show recent chat history.
+ * @param {import("../index").BotContext} ctx
+ * @param {number} chatId
+ * @param {string} [messageText] - Full message text to parse count from
+ */
+async function handleHistory(ctx, chatId, messageText = "") {
+  const state = ctx.getState(chatId);
+  const workspace = await Workspace.get({ slug: state.workspaceSlug });
+  if (!workspace) {
+    await ctx.bot.sendMessage(chatId, "No workspace configured.");
+    return;
+  }
+
+  const match = messageText.match(/\/history\s+(\d+)/);
+  const count = match
+    ? Math.min(parseInt(match[1], 10), MAX_HISTORY_COUNT)
+    : DEFAULT_HISTORY_COUNT;
+
+  const thread = state.threadSlug
+    ? await WorkspaceThread.get({ slug: state.threadSlug })
+    : null;
+
+  const rawChats = await WorkspaceChats.where(
+    {
+      workspaceId: workspace.id,
+      user_id: null,
+      thread_id: thread?.id || null,
+      api_session_id: null,
+      include: true,
+    },
+    count,
+    { id: "desc" }
+  );
+
+  if (!rawChats.length) {
+    await ctx.bot.sendMessage(chatId, "No messages yet in this thread.");
+    return;
+  }
+
+  const history = convertToChatHistory(rawChats.reverse());
+
+  const exchanges = [];
+  for (let i = 0; i < history.length; i++) {
+    const entry = history[i];
+    if (entry.role === "user") {
+      let block = `<b>You:</b> ${escapeHTML(entry.content || "")}`;
+      if (i + 1 < history.length && history[i + 1].role === "assistant") {
+        block += `\n\n<b>AI:</b> ${escapeHTML(history[i + 1].content || "")}`;
+        i++;
+      }
+      exchanges.push(block);
+    } else if (entry.role === "assistant") {
+      exchanges.push(`<b>AI:</b> ${escapeHTML(entry.content || "")}`);
+    }
+  }
+
+  if (!exchanges.length) return;
+
+  const threadName = thread?.name || "Default";
+  const header = `<b>${workspace.name} → ${threadName}</b>\nLast ${exchanges.length} message(s)\n\n`;
+
+  await sendBatchedMessages(ctx.bot, chatId, exchanges, {
+    header,
+    separator: "\n\n———\n\n",
+    sendOptions: { parse_mode: "HTML" },
+  });
+}
+
+module.exports = { handleHistory };

package/server/utils/telegramBot/utils/commands/handlers/handleNewThread.js

@@ -0,0 +1,35 @@
+const { Workspace } = require("../../../../../models/workspace");
+const { WorkspaceThread } = require("../../../../../models/workspaceThread");
+
+/**
+ * /new - Creates a new thread in the current workspace.
+ * @param {import("../index").BotContext} ctx
+ * @param {number} chatId
+ */
+async function handleNewThread(ctx, chatId) {
+  const state = ctx.getState(chatId);
+  const workspace = await Workspace.get({ slug: state.workspaceSlug });
+  if (!workspace) {
+    await ctx.bot.sendMessage(chatId, "No workspace configured.");
+    return;
+  }
+
+  const { thread, message: error } = await WorkspaceThread.new(
+    workspace,
+    null,
+    { name: "Telegram Thread" }
+  );
+
+  if (error || !thread) {
+    await ctx.bot.sendMessage(chatId, "Failed to create thread.");
+    return;
+  }
+
+  ctx.setState(chatId, { threadSlug: thread.slug });
+  await ctx.bot.sendMessage(
+    chatId,
+    `New thread created in "${workspace.name}". Your messages will now go here.`
+  );
+}
+
+module.exports = { handleNewThread };

package/server/utils/telegramBot/utils/commands/handlers/handleProof.js

@@ -0,0 +1,202 @@
+const { Workspace } = require("../../../../../models/workspace");
+const { WorkspaceThread } = require("../../../../../models/workspaceThread");
+const { WorkspaceChats } = require("../../../../../models/workspaceChats");
+
+const SOURCES_PER_PAGE = 6;
+
+/**
+ * Check if a source is a web source (identified by link:// prefix in chunkSource).
+ * @param {object} source
+ * @returns {boolean}
+ */
+function isWebSource(source) {
+  return source?.chunkSource?.startsWith("link://");
+}
+
+/**
+ * Get a display title for a source.
+ * @param {object} source
+ * @param {number} index
+ * @returns {string}
+ */
+function getSourceTitle(source, index) {
+  if (source.title) return source.title;
+  if (source.id) return source.id;
+  return `Source ${index + 1}`;
+}
+
+/**
+ * Truncate text to a maximum length.
+ * @param {string} text
+ * @param {number} maxLength
+ * @returns {string}
+ */
+function truncateText(text, maxLength = 30) {
+  if (!text) return "";
+  if (text.length <= maxLength) return text;
+  return text.substring(0, maxLength - 3) + "...";
+}
+
+/**
+ * Get the last assistant message for the current workspace/thread.
+ * @param {number} workspaceId
+ * @param {number|null} threadId
+ * @returns {Promise<{sources: object[], text: string}|null>}
+ */
+async function getLastAssistantMessage(workspaceId, threadId) {
+  const chat = await WorkspaceChats.get(
+    {
+      workspaceId,
+      user_id: null,
+      thread_id: threadId || null,
+      api_session_id: null,
+      include: true,
+    },
+    1,
+    { id: "desc" }
+  );
+
+  if (!chat) return null;
+
+  try {
+    const response = JSON.parse(chat.response);
+    return {
+      sources: response.sources || [],
+      text: response.text || "",
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Build the sources menu with pagination.
+ * @param {object[]} sources
+ * @param {number} page
+ * @returns {{text: string, buttons: object[][]}}
+ */
+function buildSourcesMenu(sources, page = 0) {
+  const totalPages = Math.ceil(sources.length / SOURCES_PER_PAGE);
+  const safePage = Math.max(0, Math.min(page, totalPages - 1));
+  const startIdx = safePage * SOURCES_PER_PAGE;
+  const pageSources = sources.slice(startIdx, startIdx + SOURCES_PER_PAGE);
+
+  const buttons = pageSources.map((source, idx) => {
+    const globalIdx = startIdx + idx;
+    const isWeb = isWebSource(source);
+    const emoji = isWeb ? "🌐" : "📄";
+    const title = truncateText(getSourceTitle(source, globalIdx), 28);
+    return [
+      {
+        text: `${emoji} ${title}`,
+        callback_data: `src:${globalIdx}`,
+      },
+    ];
+  });
+
+  const navRow = [];
+  if (safePage > 0) {
+    navRow.push({ text: "← Prev", callback_data: `srcpg:${safePage - 1}` });
+  }
+  if (safePage < totalPages - 1) {
+    navRow.push({ text: "Next →", callback_data: `srcpg:${safePage + 1}` });
+  }
+  if (navRow.length) buttons.push(navRow);
+
+  buttons.push([{ text: "Close", callback_data: "src:close" }]);
+
+  const text =
+    totalPages > 1
+      ? `📚 <b>Citations</b> (${safePage + 1}/${totalPages}, ${sources.length} total)\n\nSelect a source to view:`
+      : `📚 <b>Citations</b> (${sources.length} source${sources.length > 1 ? "s" : ""})\n\nSelect a source to view:`;
+
+  return { text, buttons };
+}
+
+/**
+ * Show the sources menu for the /proof command.
+ * @param {import("../index").BotContext} ctx
+ * @param {number} chatId
+ * @param {number} page
+ * @param {number|null} messageId - If provided, edits existing message
+ */
+async function showSourcesMenu(ctx, chatId, page = 0, messageId = null) {
+  const state = ctx.getState(chatId);
+  const workspace = await Workspace.get({ slug: state.workspaceSlug });
+  if (!workspace) {
+    await ctx.bot.sendMessage(chatId, "No workspace configured.");
+    return;
+  }
+
+  const thread = state.threadSlug
+    ? await WorkspaceThread.get({ slug: state.threadSlug })
+    : null;
+
+  const lastMessage = await getLastAssistantMessage(
+    workspace.id,
+    thread?.id || null
+  );
+
+  if (!lastMessage) {
+    const text = "There are no citations for the previous reply.";
+    if (messageId) {
+      await ctx.bot.editMessageText(text, {
+        chat_id: chatId,
+        message_id: messageId,
+      });
+    } else {
+      await ctx.bot.sendMessage(chatId, text);
+    }
+    return;
+  }
+
+  const { sources } = lastMessage;
+  if (!sources || sources.length === 0) {
+    const text = "The previous reply has no citations available.";
+    if (messageId) {
+      await ctx.bot.editMessageText(text, {
+        chat_id: chatId,
+        message_id: messageId,
+      });
+    } else {
+      await ctx.bot.sendMessage(chatId, text);
+    }
+    return;
+  }
+
+  // Store sources in state for callback handlers to access
+  ctx.setState(chatId, { _proofSources: sources });
+
+  const { text, buttons } = buildSourcesMenu(sources, page);
+  const opts = {
+    parse_mode: "HTML",
+    reply_markup: { inline_keyboard: buttons },
+  };
+
+  if (messageId) {
+    await ctx.bot.editMessageText(text, {
+      chat_id: chatId,
+      message_id: messageId,
+      ...opts,
+    });
+  } else {
+    await ctx.bot.sendMessage(chatId, text, opts);
+  }
+}
+
+/**
+ * /proof - Show citations from the previous assistant message.
+ * @param {import("../index").BotContext} ctx
+ * @param {number} chatId
+ */
+async function handleProof(ctx, chatId) {
+  await showSourcesMenu(ctx, chatId, 0, null);
+}
+
+module.exports = {
+  handleProof,
+  showSourcesMenu,
+  isWebSource,
+  getSourceTitle,
+  SOURCES_PER_PAGE,
+};

package/server/utils/telegramBot/utils/commands/handlers/handleReset.js

@@ -0,0 +1,32 @@
+const { Workspace } = require("../../../../../models/workspace");
+const { WorkspaceThread } = require("../../../../../models/workspaceThread");
+const { WorkspaceChats } = require("../../../../../models/workspaceChats");
+
+/**
+ * /reset - Clears LLM chat history context.
+ * @param {import("../index").BotContext} ctx
+ * @param {number} chatId
+ */
+async function handleReset(ctx, chatId) {
+  const state = ctx.getState(chatId);
+  const workspace = await Workspace.get({ slug: state.workspaceSlug });
+  if (!workspace) return;
+
+  const thread = state.threadSlug
+    ? await WorkspaceThread.get({ slug: state.threadSlug })
+    : null;
+
+  await WorkspaceChats.markThreadHistoryInvalidV2({
+    workspaceId: workspace.id,
+    user_id: null,
+    thread_id: thread?.id || null,
+    api_session_id: null,
+  });
+
+  await ctx.bot.sendMessage(
+    chatId,
+    "Chat history has been cleared for the LLM. Previous messages still appear above but won't be used as context."
+  );
+}
+
+module.exports = { handleReset };

package/server/utils/telegramBot/utils/commands/handlers/handleStart.js

@@ -0,0 +1,19 @@
+const { Workspace } = require("../../../../../models/workspace");
+
+/**
+ * /start - Welcome message with current workspace info.
+ * @param {import("../index").BotContext} ctx
+ * @param {number} chatId
+ */
+async function handleStart(ctx, chatId) {
+  const state = ctx.getState(chatId);
+  const workspace = await Workspace.get({ slug: state.workspaceSlug });
+  const name = workspace?.name || state.workspaceSlug;
+
+  await ctx.bot.sendMessage(
+    chatId,
+    `Welcome to AnythingLLM!\n\nYour messages go to the "${name}" workspace. Use /switch to change workspaces or threads, and /help to see all commands.`
+  );
+}
+
+module.exports = { handleStart };

package/server/utils/telegramBot/utils/commands/handlers/handleStatus.js

@@ -0,0 +1,80 @@
+const { Workspace } = require("../../../../../models/workspace");
+const { WorkspaceThread } = require("../../../../../models/workspaceThread");
+const {
+  resolveWorkspaceProvider,
+  sendFormattedMessage,
+} = require("../../../utils");
+
+/**
+ * /status - Show current workspace, thread, and model info.
+ * @param {import("../index").BotContext} ctx
+ * @param {number} chatId
+ */
+async function handleStatus(ctx, chatId) {
+  const state = ctx.getState(chatId);
+  const workspace = await Workspace.get({ slug: state.workspaceSlug });
+  if (!workspace) {
+    await ctx.bot.sendMessage(chatId, "No workspace configured.");
+    return;
+  }
+
+  let threadName = "Default";
+  if (state.threadSlug) {
+    const thread = await WorkspaceThread.get({ slug: state.threadSlug });
+    if (thread) threadName = thread.name;
+  }
+
+  const markdown = [];
+
+  markdown.push(`# Workspace:
+${workspace.name}
+
+# Thread:
+_${threadName}_
+--------------------------------`);
+
+  const AIbitat = require("../../../../agents/aibitat");
+  const { provider, model } = resolveWorkspaceProvider(workspace);
+  const agentConfig = { provider, model };
+  const agentProvider = new AIbitat(agentConfig).getProviderForConfig(
+    agentConfig
+  );
+  const nativeToolCalling = await agentProvider.supportsNativeToolCalling?.();
+
+  markdown.push(`# LLM Provider: 
+${provider}
+
+# LLM Model: 
+${model}
+
+# Native Tool Calling: 
+${nativeToolCalling ? "Enabled" : "Disabled"}
+
+# Chat Mode: 
+${workspace.chatMode ?? "chat"}`);
+
+  if (workspace.chatMode === "automatic" && !nativeToolCalling) {
+    markdown.unshift(
+      `<blockquote>**⚠️ Note**\nNative tool calling is unavailable for this provider/model. You can only use tools with the @agent command.</blockquote>`
+    );
+  }
+
+  if (workspace.chatMode === "chat") {
+    if (nativeToolCalling) {
+      markdown.unshift(
+        `<blockquote>**💡 Tip**\nChange this workspace's chat mode to "automatic" to use tools without the @agent command.</blockquote>`
+      );
+    } else {
+      markdown.unshift(
+        `<blockquote>**⚠️ Note**\nNative tool calling is unavailable for this provider/model. You can only use tools with the @agent command.</blockquote>`
+      );
+    }
+  }
+
+  await sendFormattedMessage(ctx.bot, chatId, markdown.join("\n"), {
+    format: true,
+    escapeHtml: false,
+  });
+}
+
+module.exports = { handleStatus };

package/server/utils/telegramBot/utils/commands/handlers/showModelMenu.js

@@ -0,0 +1,98 @@
+const { Workspace } = require("../../../../../models/workspace");
+const { resolveWorkspaceProvider } = require("../../index");
+const {
+  getCustomModels,
+  SUPPORT_CUSTOM_MODELS,
+} = require("../../../../helpers/customModels");
+const MODELS_PER_PAGE = 8;
+
+/**
+ * Show the model selection inline keyboard with pagination.
+ * @param {import("../index").BotContext} ctx
+ * @param {number} chatId
+ * @param {number} page - Current page (0-indexed)
+ * @param {number|null} messageId - If provided, edits existing message instead of sending new one
+ */
+async function showModelMenu(ctx, chatId, page = 0, messageId = null) {
+  const pageNum = typeof page === "number" && !isNaN(page) ? page : 0;
+  const state = ctx.getState(chatId);
+  const workspace = await Workspace.get({ slug: state.workspaceSlug });
+  if (!workspace) {
+    await ctx.bot.sendMessage(
+      chatId,
+      "No workspace configured. Use /switch to select a workspace."
+    );
+    return;
+  }
+
+  const { provider, model: currentModel } = resolveWorkspaceProvider(workspace);
+  if (!SUPPORT_CUSTOM_MODELS.includes(provider)) {
+    await ctx.bot.sendMessage(
+      chatId,
+      `The "${provider}" provider does not support model selection via API.`
+    );
+    return;
+  }
+
+  const { models, error } = await getCustomModels(provider);
+  if (error || !models?.length) {
+    await ctx.bot.sendMessage(
+      chatId,
+      error || `No models available for "${provider}".`
+    );
+    return;
+  }
+
+  const sortedModels = [...models].sort((a, b) => {
+    const aId = a.id || a.name;
+    const bId = b.id || b.name;
+    const aIsActive = aId === currentModel;
+    const bIsActive = bId === currentModel;
+    if (aIsActive && !bIsActive) return -1;
+    if (!aIsActive && bIsActive) return 1;
+    return 0;
+  });
+
+  const totalPages = Math.ceil(sortedModels.length / MODELS_PER_PAGE);
+  const safePage = Math.max(0, Math.min(pageNum, totalPages - 1));
+  const startIdx = safePage * MODELS_PER_PAGE;
+  const pageModels = sortedModels.slice(startIdx, startIdx + MODELS_PER_PAGE);
+
+  const buttons = pageModels.map((m) => {
+    const modelId = m.id || m.name;
+    const displayName = m.name || m.id;
+    const isActive = modelId === currentModel;
+    return [
+      {
+        text: isActive ? `🟢 ${displayName} (active)` : displayName,
+        callback_data: `mdl:${workspace.id}:${modelId.slice(0, 40)}`,
+      },
+    ];
+  });
+
+  const navRow = [];
+  if (safePage > 0) {
+    navRow.push({ text: "← Prev", callback_data: `mdlpg:${safePage - 1}` });
+  }
+  if (safePage < totalPages - 1) {
+    navRow.push({ text: "Next →", callback_data: `mdlpg:${safePage + 1}` });
+  }
+  if (navRow.length) buttons.push(navRow);
+
+  buttons.push([{ text: "✕ Cancel", callback_data: "mdl:cancel" }]);
+
+  const text = `"${workspace.name}" — Select a model (${safePage + 1}/${totalPages}, ${sortedModels.length} total):`;
+  const opts = { reply_markup: { inline_keyboard: buttons } };
+
+  if (messageId) {
+    await ctx.bot.editMessageText(text, {
+      chat_id: chatId,
+      message_id: messageId,
+      ...opts,
+    });
+  } else {
+    await ctx.bot.sendMessage(chatId, text, opts);
+  }
+}
+
+module.exports = { showModelMenu };

package/server/utils/telegramBot/utils/commands/handlers/showThreadMenu.js

@@ -0,0 +1,120 @@
+const { Workspace } = require("../../../../../models/workspace");
+const { WorkspaceChats } = require("../../../../../models/workspaceChats");
+const { WorkspaceThread } = require("../../../../../models/workspaceThread");
+const THREADS_PER_PAGE = 8;
+
+/**
+ * Show the thread selection inline keyboard for a workspace with pagination.
+ * @param {import("../index").BotContext} ctx
+ * @param {number} chatId
+ * @param {number} workspaceId - must be ID, not slug due to 64-byte limit on callback data
+ * @param {number} page - Current page (0-indexed)
+ * @param {number|null} messageId
+ */
+async function showThreadMenu(
+  ctx,
+  chatId,
+  workspaceId,
+  page = 0,
+  messageId = null
+) {
+  const pageNum = typeof page === "number" && !isNaN(page) ? page : 0;
+  const workspace = await Workspace.get({ id: workspaceId });
+  if (!workspace) return;
+
+  const threads = await WorkspaceThread.where({
+    workspace_id: workspace.id,
+  });
+
+  const state = ctx.getState(chatId);
+
+  const allItems = [];
+
+  const defaultThreadChatCount = await WorkspaceChats.count({
+    workspaceId: workspace.id,
+    thread_id: null,
+  });
+  const isDefaultActive = !state.threadSlug;
+  let defaultThreadText = isDefaultActive ? "🟢 Default (active)" : "Default";
+  if (defaultThreadChatCount > 0)
+    defaultThreadText += ` - ${defaultThreadChatCount} chats`;
+
+  allItems.push({
+    text: defaultThreadText,
+    callback_data: `th:${workspace.id}:0`,
+    isActive: isDefaultActive,
+  });
+
+  for (const thread of threads) {
+    const threadChatCount = await WorkspaceChats.count({
+      workspaceId: workspace.id,
+      thread_id: thread.id,
+    });
+
+    const isCurrent = thread.slug === state.threadSlug;
+    let threadText = isCurrent ? `🟢 ${thread.name} (active)` : thread.name;
+    if (threadChatCount > 0) threadText += ` - ${threadChatCount} chats`;
+    allItems.push({
+      text: threadText,
+      callback_data: `th:${workspace.id}:${thread.id}`,
+      isActive: isCurrent,
+    });
+  }
+
+  allItems.sort((a, b) => {
+    if (a.isActive && !b.isActive) return -1;
+    if (!a.isActive && b.isActive) return 1;
+    return 0;
+  });
+
+  const totalPages = Math.ceil(allItems.length / THREADS_PER_PAGE);
+  const safePage = Math.max(0, Math.min(pageNum, totalPages - 1));
+  const startIdx = safePage * THREADS_PER_PAGE;
+  const pageItems = allItems.slice(startIdx, startIdx + THREADS_PER_PAGE);
+
+  const buttons = pageItems.map((item) => [
+    { text: item.text, callback_data: item.callback_data },
+  ]);
+
+  const navRow = [];
+  if (safePage > 0) {
+    navRow.push({
+      text: "← Prev",
+      callback_data: `thpg:${workspaceId}:${safePage - 1}`,
+    });
+  }
+  if (safePage < totalPages - 1) {
+    navRow.push({
+      text: "Next →",
+      callback_data: `thpg:${workspaceId}:${safePage + 1}`,
+    });
+  }
+  if (navRow.length) buttons.push(navRow);
+
+  buttons.push([
+    {
+      text: "← Back to workspaces",
+      callback_data: "back:workspaces",
+    },
+  ]);
+
+  const text =
+    totalPages > 1
+      ? `"${workspace.name}" — Select a thread (${safePage + 1}/${totalPages}, ${allItems.length} total):`
+      : `"${workspace.name}" — Select a thread:`;
+  const opts = {
+    reply_markup: { inline_keyboard: buttons },
+  };
+
+  if (messageId) {
+    await ctx.bot.editMessageText(text, {
+      chat_id: chatId,
+      message_id: messageId,
+      ...opts,
+    });
+  } else {
+    await ctx.bot.sendMessage(chatId, text, opts);
+  }
+}
+
+module.exports = { showThreadMenu };