totem-llm 0.1.0

package/server/utils/agents/aibitat/plugins/chat-history.js

@@ -0,0 +1,210 @@
+const { WorkspaceChats } = require("../../../../models/workspaceChats");
+const { WorkspaceThread } = require("../../../../models/workspaceThread");
+
+/**
+ * Plugin to save chat history to AnythingLLM DB.
+ */
+const chatHistory = {
+  name: "chat-history",
+  startupConfig: {
+    params: {},
+  },
+  plugin: function () {
+    return {
+      name: this.name,
+      setup: function (aibitat) {
+        // If the agent is aborted (e.g. user sent /reset mid-response), skip
+        // the pending save so a completing in-flight response doesn't reappear.
+        aibitat.onAbort(() => {
+          aibitat._aborted = true;
+        });
+
+        // pre-register a workspace chat ID to secure it in the DB
+        aibitat.onMessage(async (message) => {
+          if (message.from !== "USER") return;
+
+          /**
+           * If we don't have a tracked chat ID, we need to create a new one so we can upsert the response later.
+           * Normally, if this was a totally fresh chat from the user, we can assume that the message from the socket is
+           * the message we want to store for the prompt. However, if this is a regeneration of a previous message and that message
+           * called tools the history could include intermediate messages so need to search backwards to find the most recent user message
+           * as that is actually the prompt.
+           */
+          if (!aibitat.trackedChatId) {
+            let userMessage = message.content;
+            if (userMessage.startsWith("@agent:")) {
+              const lastUserMsgIndex = aibitat._chats.findLastIndex(
+                (c) => c.from === "USER" && !c.content.startsWith("@agent:")
+              );
+
+              // When regenerating a message, we need to use the last user message as the prompt.
+              // Also prune the chats array to only include the messages before target prompt to re-run
+              // or else tool call results from the previous run will be included in the history and the model will not re-call tools
+              // that previously worked for the to-be-regenerated prompt.
+              if (lastUserMsgIndex !== -1) {
+                userMessage = aibitat._chats[lastUserMsgIndex].content;
+                aibitat._chats = aibitat._chats.slice(0, lastUserMsgIndex + 1);
+              }
+            }
+
+            const { chat } = await WorkspaceChats.new({
+              workspaceId: Number(aibitat.handlerProps.invocation.workspace_id),
+              user: { id: aibitat.handlerProps.invocation.user_id || null },
+              threadId: aibitat.handlerProps.invocation.thread_id || null,
+              include: false,
+              prompt: userMessage,
+              response: {},
+            });
+            if (chat) aibitat.registerChatId(chat.id);
+          }
+        });
+
+        aibitat.onMessage(async () => {
+          try {
+            if (aibitat._aborted) return;
+            const lastResponses = aibitat.chats.slice(-2);
+            if (lastResponses.length !== 2) return;
+            const [prev, last] = lastResponses;
+
+            // We need a full conversation reply with prev being from
+            // the USER and the last being from anyone other than the user.
+            if (prev.from !== "USER" || last.from === "USER") return;
+
+            // Extract attachments from user message if present
+            const attachments = prev.attachments || [];
+
+            // If we have a post-reply flow we should save the chat using this special flow
+            // so that post save cleanup and other unique properties can be run as opposed to regular chat.
+            if (aibitat.hasOwnProperty("_replySpecialAttributes")) {
+              await this._storeSpecial(aibitat, {
+                prompt: prev.content,
+                response: last.content,
+                attachments,
+                options: aibitat._replySpecialAttributes,
+              });
+              delete aibitat._replySpecialAttributes;
+              return;
+            }
+
+            await this._store(aibitat, {
+              prompt: prev.content,
+              response: last.content,
+              attachments,
+            });
+          } catch {}
+        });
+      },
+      _store: async function (
+        aibitat,
+        { prompt, response, attachments = [] } = {}
+      ) {
+        const invocation = aibitat.handlerProps.invocation;
+        const metrics = aibitat.providerInstance?.getUsage?.() ?? {};
+        const citations = aibitat._pendingCitations ?? [];
+        const outputs = aibitat._pendingOutputs ?? [];
+        const clarifyingQuestions =
+          aibitat._pendingClarifyingQuestionSurveys ?? [];
+        await WorkspaceChats.upsert(aibitat.trackedChatId, {
+          workspaceId: Number(invocation.workspace_id),
+          prompt,
+          response: {
+            text: response,
+            sources: citations,
+            type: "chat",
+            attachments,
+            metrics,
+            ...(outputs.length > 0 ? { outputs } : {}),
+            ...(clarifyingQuestions.length > 0 ? { clarifyingQuestions } : {}),
+          },
+          user: { id: invocation?.user_id || null },
+          threadId: invocation?.thread_id || null,
+          include: true,
+        });
+
+        if (!aibitat._threadRenamed) {
+          aibitat._threadRenamed = await this._autoRenameThread(
+            aibitat,
+            prompt
+          );
+        }
+        this._cleanup(aibitat);
+      },
+      _storeSpecial: async function (
+        aibitat,
+        { prompt, response, attachments = [], options = {} } = {}
+      ) {
+        const invocation = aibitat.handlerProps.invocation;
+        const metrics = aibitat.providerInstance?.getUsage?.() ?? {};
+        const citations = aibitat._pendingCitations ?? [];
+        const outputs = aibitat._pendingOutputs ?? [];
+        const clarifyingQuestions =
+          aibitat._pendingClarifyingQuestionSurveys ?? [];
+        const existingSources = options?.sources ?? [];
+        await WorkspaceChats.upsert(aibitat.trackedChatId, {
+          workspaceId: Number(invocation.workspace_id),
+          prompt,
+          response: {
+            sources: [...existingSources, ...citations],
+            // when we have a _storeSpecial called the options param can include a storedResponse() function
+            // that will override the text property to store extra information in, depending on the special type of chat.
+            text: options.hasOwnProperty("storedResponse")
+              ? options.storedResponse(response)
+              : response,
+            type: options?.saveAsType ?? "chat",
+            attachments,
+            metrics,
+            ...(outputs.length > 0 ? { outputs } : {}),
+            ...(clarifyingQuestions.length > 0 ? { clarifyingQuestions } : {}),
+          },
+          user: { id: invocation?.user_id || null },
+          threadId: invocation?.thread_id || null,
+          include: true,
+        });
+
+        if (!aibitat._threadRenamed) {
+          aibitat._threadRenamed = await this._autoRenameThread(
+            aibitat,
+            prompt
+          );
+        }
+        options?.postSave();
+        this._cleanup(aibitat);
+      },
+
+      _autoRenameThread: async function (aibitat, prompt) {
+        const invocation = aibitat.handlerProps.invocation;
+        if (!invocation?.thread_id) return true;
+
+        const thread = await WorkspaceThread.get({ id: invocation.thread_id });
+        if (!thread) return true;
+
+        const { Workspace } = require("../../../../models/workspace");
+        const workspace = await Workspace.get({ id: invocation.workspace_id });
+        if (!workspace) return true;
+
+        await WorkspaceThread.autoRenameThread({
+          thread,
+          workspace,
+          user: invocation.user_id ? { id: invocation.user_id } : null,
+          prompt,
+          onRename: (updatedThread) => {
+            aibitat.socket?.send("rename_thread", {
+              slug: updatedThread.slug,
+              name: updatedThread.name,
+            });
+          },
+        });
+        return true;
+      },
+
+      _cleanup: function (aibitat) {
+        aibitat.clearCitations?.();
+        aibitat._pendingOutputs = [];
+        aibitat.clearClarifyingQuestionSurveys?.();
+        aibitat.clearTrackedChatId();
+      },
+    };
+  },
+};
+
+module.exports = { chatHistory };

package/server/utils/agents/aibitat/plugins/cli.js

@@ -0,0 +1,134 @@
+// Plugin CAN ONLY BE USE IN DEVELOPMENT.
+const { input } = require("@inquirer/prompts");
+const chalk = require("chalk");
+
+/**
+ * Command-line Interface plugin. It prints the messages on the console and asks for feedback
+ * while the conversation is running in the background.
+ */
+const cli = {
+  name: "cli",
+  startupConfig: {
+    params: {},
+  },
+  plugin: function ({ simulateStream = true } = {}) {
+    return {
+      name: this.name,
+      setup(aibitat) {
+        let printing = [];
+
+        aibitat.onError(async (error) => {
+          let errorMessage =
+            error?.message || "An error occurred while running the agent.";
+          console.error(chalk.red(`   error: ${errorMessage}`), error);
+        });
+
+        aibitat.onStart(() => {
+          console.log();
+          console.log("🚀 starting chat ...\n");
+          printing = [Promise.resolve()];
+        });
+
+        aibitat.onMessage(async (message) => {
+          const next = new Promise(async (resolve) => {
+            await Promise.all(printing);
+            await this.print(message, simulateStream);
+            resolve();
+          });
+          printing.push(next);
+        });
+
+        aibitat.onTerminate(async () => {
+          await Promise.all(printing);
+          console.log("🚀 chat finished");
+        });
+
+        aibitat.onInterrupt(async (node) => {
+          await Promise.all(printing);
+          const feedback = await this.askForFeedback(node);
+          // Add an extra line after the message
+          console.log();
+
+          if (feedback === "exit") {
+            console.log("🚀 chat finished");
+            return process.exit(0);
+          }
+
+          await aibitat.continue(feedback);
+        });
+      },
+
+      /**
+   * Print a message on the terminal
+   *
+   * @param message
+   * // message Type { from: string; to: string; content?: string } & {
+      state: 'loading' | 'error' | 'success' | 'interrupt'
+    }
+   * @param simulateStream
+   */
+      print: async function (message = {}, simulateStream = true) {
+        const replying = chalk.dim(`(to ${message.to})`);
+        const reference = `${chalk.magenta("✎")} ${chalk.bold(
+          message.from
+        )} ${replying}:`;
+
+        if (!simulateStream) {
+          console.log(reference);
+          console.log(message.content);
+          // Add an extra line after the message
+          console.log();
+          return;
+        }
+
+        process.stdout.write(`${reference}\n`);
+
+        // Emulate streaming by breaking the cached response into chunks
+        const chunks = message.content?.split(" ") || [];
+        const stream = new ReadableStream({
+          async start(controller) {
+            for (const chunk of chunks) {
+              const bytes = new TextEncoder().encode(chunk + " ");
+              controller.enqueue(bytes);
+              await new Promise((r) =>
+                setTimeout(
+                  r,
+                  // get a random number between 10ms and 50ms to simulate a random delay
+                  Math.floor(Math.random() * 40) + 10
+                )
+              );
+            }
+            controller.close();
+          },
+        });
+
+        // Stream the response to the chat
+        for await (const chunk of stream) {
+          process.stdout.write(new TextDecoder().decode(chunk));
+        }
+
+        // Add an extra line after the message
+        console.log();
+        console.log();
+      },
+
+      /**
+       * Ask for feedback to the user using the terminal
+       *
+       * @param node //{ from: string; to: string }
+       * @returns
+       */
+      askForFeedback: function (node = {}) {
+        return input({
+          message: `Provide feedback to ${chalk.yellow(
+            node.to
+          )} as ${chalk.yellow(
+            node.from
+          )}. Press enter to skip and use auto-reply, or type 'exit' to end the conversation: `,
+        });
+      },
+    };
+  },
+};
+
+module.exports = { cli };

package/server/utils/agents/aibitat/plugins/create-files/docx/create-docx-file.js

@@ -0,0 +1,301 @@
+const {
+  getDeploymentVersion,
+} = require("../../../../../../endpoints/utils.js");
+const createFilesLib = require("../lib.js");
+const {
+  getTheme,
+  getMargins,
+  loadLibraries,
+  htmlToDocxElements,
+  createCoverPageSection,
+  createRunningHeader,
+  createRunningFooter,
+  DEFAULT_NUMBERING_CONFIG,
+} = require("./utils.js");
+
+module.exports.CreateDocxFile = {
+  name: "create-docx-file",
+  plugin: function () {
+    return {
+      name: "create-docx-file",
+      setup(aibitat) {
+        aibitat.function({
+          super: aibitat,
+          name: this.name,
+          description:
+            "Create a Microsoft Word document (.docx) from markdown or plain text content. Supports professional styling with color themes, title pages, and running headers/footers.",
+          examples: [
+            {
+              prompt: "Create a Word document with meeting notes",
+              call: JSON.stringify({
+                filename: "meeting-notes.docx",
+                content:
+                  "# Meeting Notes - Q1 Planning\n\n## Attendees\n- John Smith\n- Sarah Johnson\n- Mike Chen\n\n## Agenda\n1. Review Q4 results\n2. Set Q1 goals\n3. Assign tasks\n\n## Action Items\n| Person | Task | Due Date |\n|--------|------|----------|\n| John | Prepare budget report | Jan 15 |\n| Sarah | Draft marketing plan | Jan 20 |\n| Mike | Schedule follow-up | Jan 10 |",
+              }),
+            },
+            {
+              prompt:
+                "Create a professional project proposal with a title page",
+              call: JSON.stringify({
+                filename: "project-proposal.docx",
+                title: "Project Alpha Proposal",
+                subtitle: "Strategic Initiative for Q2 2024",
+                author: "Product Team",
+                theme: "blue",
+                includeTitlePage: true,
+                content:
+                  "## Executive Summary\nThis proposal outlines the development of **Project Alpha**, a next-generation platform.\n\n## Objectives\n- Increase efficiency by 40%\n- Reduce costs by $50,000 annually\n- Improve user satisfaction\n\n## Timeline\n| Phase | Duration | Deliverables |\n|-------|----------|-------------|\n| Phase 1 | 4 weeks | Requirements |\n| Phase 2 | 8 weeks | Development |\n| Phase 3 | 2 weeks | Testing |\n\n## Budget\nTotal estimated budget: **$150,000**",
+              }),
+            },
+            {
+              prompt: "Create technical documentation with warm theme",
+              call: JSON.stringify({
+                filename: "api-documentation.docx",
+                title: "API Documentation",
+                theme: "warm",
+                margins: "narrow",
+                content:
+                  "# API Documentation\n\n## Authentication\nAll API requests require a Bearer token in the Authorization header.\n\n```javascript\nconst headers = {\n  'Authorization': 'Bearer YOUR_TOKEN',\n  'Content-Type': 'application/json'\n};\n```\n\n## Endpoints\n\n### GET /users\nReturns a list of all users.\n\n### POST /users\nCreates a new user.\n\n> **Note:** Rate limiting applies to all endpoints.",
+              }),
+            },
+          ],
+          parameters: {
+            $schema: "http://json-schema.org/draft-07/schema#",
+            type: "object",
+            properties: {
+              filename: {
+                type: "string",
+                description:
+                  "The filename for the Word document. Will automatically add .docx extension if not present.",
+              },
+              title: {
+                type: "string",
+                description:
+                  "Document title for metadata and title page. If not provided, will be extracted from content or use filename.",
+              },
+              subtitle: {
+                type: "string",
+                description:
+                  "Optional subtitle displayed on the title page below the main title.",
+              },
+              author: {
+                type: "string",
+                description:
+                  "Optional author name displayed on the title page.",
+              },
+              content: {
+                type: "string",
+                description:
+                  "The content to convert to a Word document. Fully supports markdown formatting.",
+              },
+              theme: {
+                type: "string",
+                enum: ["neutral", "blue", "warm"],
+                description:
+                  "Color theme for the document. 'neutral' (slate/grey), 'blue' (corporate blue), or 'warm' (earthy tones). Defaults to neutral.",
+              },
+              margins: {
+                type: "string",
+                enum: ["normal", "narrow", "wide"],
+                description:
+                  "Page margin preset. 'normal' (standard), 'narrow' (data-heavy docs), or 'wide' (letters/memos). Defaults to normal.",
+              },
+              includeTitlePage: {
+                type: "boolean",
+                description:
+                  "Include a professional title page with centered title, subtitle, author, and date. Content starts on page 2 with running headers/footers.",
+              },
+            },
+            required: ["filename", "content"],
+            additionalProperties: false,
+          },
+          handler: async function ({
+            filename = "document.docx",
+            title = null,
+            subtitle = null,
+            author = null,
+            content = "",
+            theme = "neutral",
+            margins = "normal",
+            includeTitlePage = false,
+          }) {
+            try {
+              this.super.handlerProps.log(`Using the create-docx-file tool.`);
+
+              const hasExtension = /\.docx$/i.test(filename);
+              if (!hasExtension) filename = `${filename}.docx`;
+              const displayFilename = filename.split("/").pop();
+
+              const documentTitle =
+                title ||
+                content.match(/^#\s+(.+)$/m)?.[1] ||
+                displayFilename.replace(/\.docx$/i, "");
+
+              if (this.super.requestToolApproval) {
+                const approval = await this.super.requestToolApproval({
+                  skillName: this.name,
+                  payload: { filename: displayFilename, title: documentTitle },
+                  description: `Create Word document "${displayFilename}"`,
+                });
+                if (!approval.approved) {
+                  this.super.introspect(
+                    `${this.caller}: User rejected the ${this.name} request.`
+                  );
+                  return approval.message;
+                }
+              }
+
+              this.super.introspect(
+                `${this.caller}: Creating Word document "${displayFilename}"${includeTitlePage ? " with title page" : ""}`
+              );
+
+              const libs = await loadLibraries();
+              const { marked, docx } = libs;
+              const { Document, Packer, Paragraph, TextRun } = docx;
+              marked.setOptions({
+                gfm: true,
+                breaks: true,
+              });
+
+              const themeColors = getTheme(theme);
+              const marginConfig = getMargins(margins);
+
+              const html = marked.parse(content);
+              this.super.handlerProps.log(
+                `create-docx-file: Parsed markdown to HTML (${html.length} chars), theme: ${theme}, margins: ${margins}`
+              );
+
+              const logoBuffer = createFilesLib.getLogo({
+                forDarkBackground: false,
+                format: "buffer",
+              });
+
+              const docElements = await htmlToDocxElements(
+                html,
+                libs,
+                this.super.handlerProps.log,
+                themeColors
+              );
+
+              if (docElements.length === 0) {
+                docElements.push(
+                  new Paragraph({
+                    children: [new TextRun({ text: content })],
+                  })
+                );
+              }
+
+              const sections = [];
+
+              if (includeTitlePage) {
+                const currentDate = new Date().toLocaleDateString("en-US", {
+                  year: "numeric",
+                  month: "long",
+                  day: "numeric",
+                });
+
+                sections.push(
+                  createCoverPageSection(docx, {
+                    title: documentTitle,
+                    subtitle,
+                    author,
+                    date: currentDate,
+                    theme: themeColors,
+                    margins: marginConfig,
+                    logoBuffer,
+                  })
+                );
+
+                sections.push({
+                  properties: {
+                    page: {
+                      margin: marginConfig,
+                    },
+                  },
+                  children: docElements,
+                  headers: {
+                    default: createRunningHeader(
+                      docx,
+                      documentTitle,
+                      themeColors
+                    ),
+                  },
+                  footers: {
+                    default: createRunningFooter(docx, logoBuffer, themeColors),
+                  },
+                });
+              } else {
+                sections.push({
+                  properties: {
+                    page: {
+                      margin: marginConfig,
+                    },
+                  },
+                  children: docElements,
+                  footers: {
+                    default: createRunningFooter(docx, logoBuffer, themeColors),
+                  },
+                });
+              }
+
+              const doc = new Document({
+                title: documentTitle,
+                creator: `AnythingLLM ${getDeploymentVersion()}`,
+                description: `Word Document generated by AnythingLLM ${getDeploymentVersion()}`,
+                numbering: DEFAULT_NUMBERING_CONFIG,
+                sections,
+              });
+
+              const buffer = await Packer.toBuffer(doc);
+              const bufferSizeKB = (buffer.length / 1024).toFixed(2);
+
+              this.super.handlerProps.log(
+                `create-docx-file: Generated buffer - size: ${bufferSizeKB}KB, title: "${documentTitle}", theme: ${theme}`
+              );
+
+              const savedFile = await createFilesLib.saveGeneratedFile({
+                fileType: "docx",
+                extension: "docx",
+                buffer,
+                displayFilename,
+              });
+
+              this.super.socket.send("fileDownloadCard", {
+                filename: savedFile.displayFilename,
+                storageFilename: savedFile.filename,
+                fileSize: savedFile.fileSize,
+              });
+
+              createFilesLib.registerOutput(this.super, "DocxFileDownload", {
+                filename: savedFile.displayFilename,
+                storageFilename: savedFile.filename,
+                fileSize: savedFile.fileSize,
+              });
+
+              this.super.introspect(
+                `${this.caller}: Successfully created Word document "${displayFilename}"`
+              );
+
+              const styleInfo = [
+                theme !== "neutral" ? `${theme} theme` : null,
+                margins !== "normal" ? `${margins} margins` : null,
+                includeTitlePage ? "title page" : null,
+              ].filter(Boolean);
+
+              const styleDesc =
+                styleInfo.length > 0 ? ` with ${styleInfo.join(", ")}` : "";
+
+              return `Successfully created Word document "${displayFilename}" (${bufferSizeKB}KB)${styleDesc}. The document includes formatted content with tables, images, Page X of Y footer, and professional styling.`;
+            } catch (e) {
+              this.super.handlerProps.log(
+                `create-docx-file error: ${e.message}`
+              );
+              this.super.introspect(`Error: ${e.message}`);
+              return `Error creating Word document: ${e.message}`;
+            }
+          },
+        });
+      },
+    };
+  },
+};