totem-llm 0.1.0

package/server/utils/agents/aibitat/plugins/outlook/search/outlook-get-inbox.js

@@ -0,0 +1,75 @@
+const outlookLib = require("../lib.js");
+const { formatMessageSummary, handleSkillError } = outlookLib;
+
+module.exports.OutlookGetInbox = {
+  name: "outlook-get-inbox",
+  plugin: function () {
+    return {
+      name: "outlook-get-inbox",
+      setup(aibitat) {
+        aibitat.function({
+          super: aibitat,
+          name: this.name,
+          description:
+            "Get recent emails from the Outlook inbox. " +
+            "Returns a list of recent messages with subject, sender, date, and read status. " +
+            "Use this to quickly see what's in the inbox.",
+          examples: [
+            {
+              prompt: "Show me my recent emails",
+              call: JSON.stringify({ limit: 10 }),
+            },
+            {
+              prompt: "What's in my inbox?",
+              call: JSON.stringify({ limit: 25 }),
+            },
+          ],
+          parameters: {
+            $schema: "http://json-schema.org/draft-07/schema#",
+            type: "object",
+            properties: {
+              limit: {
+                type: "number",
+                description:
+                  "Maximum number of messages to return (1-50). Defaults to 25.",
+                default: 25,
+              },
+            },
+            additionalProperties: false,
+          },
+          handler: async function ({ limit = 25 }) {
+            try {
+              this.super.handlerProps.log(`Using the outlook-get-inbox tool.`);
+              this.super.introspect(
+                `${this.caller}: Fetching Outlook inbox...`
+              );
+
+              const result = await outlookLib.getInbox(limit);
+
+              if (!result.success) {
+                this.super.introspect(
+                  `${this.caller}: Failed to get inbox - ${result.error}`
+                );
+                return `Error getting Outlook inbox: ${result.error}`;
+              }
+
+              const { messages, resultCount } = result.data;
+              this.super.introspect(
+                `${this.caller}: Found ${resultCount} messages in inbox`
+              );
+
+              if (resultCount === 0) {
+                return "No messages found in inbox.";
+              }
+
+              const summary = formatMessageSummary(messages);
+              return `Found ${resultCount} messages in inbox:\n\n${summary}\n\nAlways include the conversation ID in the response. Use the conversation ID with outlook-read-thread to read the full conversation.`;
+            } catch (e) {
+              return handleSkillError(this, "outlook-get-inbox", e);
+            }
+          },
+        });
+      },
+    };
+  },
+};

package/server/utils/agents/aibitat/plugins/outlook/search/outlook-read-thread.js

@@ -0,0 +1,131 @@
+const outlookLib = require("../lib.js");
+const { handleAttachments, handleSkillError } = outlookLib;
+
+module.exports.OutlookReadThread = {
+  name: "outlook-read-thread",
+  plugin: function () {
+    return {
+      name: "outlook-read-thread",
+      setup(aibitat) {
+        aibitat.function({
+          super: aibitat,
+          name: this.name,
+          description:
+            "Read a full email conversation thread by its conversation ID. " +
+            "Returns all messages in the thread including sender, recipients, subject, body, date, and attachment information. " +
+            "Use this after searching to read the full conversation.",
+          examples: [
+            {
+              prompt: "Read the email thread with conversation ID AAQkAGI2...",
+              call: JSON.stringify({
+                conversationId: "AAQkAGI2...",
+              }),
+            },
+          ],
+          parameters: {
+            $schema: "http://json-schema.org/draft-07/schema#",
+            type: "object",
+            properties: {
+              conversationId: {
+                type: "string",
+                description: "The Outlook conversation ID to read.",
+              },
+            },
+            required: ["conversationId"],
+            additionalProperties: false,
+          },
+          handler: async function ({ conversationId }) {
+            try {
+              this.super.handlerProps.log(
+                `Using the outlook-read-thread tool.`
+              );
+
+              if (!conversationId) {
+                return "Error: conversationId is required.";
+              }
+
+              this.super.introspect(
+                `${this.caller}: Reading Outlook conversation...`
+              );
+
+              const result = await outlookLib.readThread(conversationId);
+
+              if (!result.success) {
+                this.super.introspect(
+                  `${this.caller}: Failed to read thread - ${result.error}`
+                );
+                return `Error reading Outlook thread: ${result.error}`;
+              }
+
+              const thread = result.data;
+
+              const { allAttachments, parsedContent: parsedAttachmentContent } =
+                await handleAttachments(this, thread.messages);
+
+              const messagesFormatted = thread.messages
+                .map((msg, i) => {
+                  let attachmentInfo = "";
+                  if (msg.attachments?.length > 0) {
+                    attachmentInfo = `\n   Attachments: ${msg.attachments.map((a) => `${a.name} (${a.contentType}, ${(a.size / 1024).toFixed(1)}KB)`).join(", ")}`;
+                  }
+
+                  const bodyContent =
+                    msg.bodyType === "html"
+                      ? msg.body
+                          .replace(/<[^>]*>/g, " ")
+                          .replace(/\s+/g, " ")
+                          .trim()
+                      : msg.body;
+
+                  return (
+                    `--- Message ${i + 1} ---\n` +
+                    `From: ${msg.fromName} <${msg.from}>\n` +
+                    `To: ${msg.to}\n` +
+                    (msg.cc ? `CC: ${msg.cc}\n` : "") +
+                    `Date: ${new Date(msg.date).toLocaleString()}\n` +
+                    `Subject: ${msg.subject}\n` +
+                    `Status: ${msg.isRead ? "READ" : "UNREAD"}\n` +
+                    `\n${bodyContent}` +
+                    attachmentInfo
+                  );
+                })
+                .join("\n\n");
+
+              this.super.introspect(
+                `${this.caller}: Successfully read thread with ${thread.messageCount} messages`
+              );
+
+              // Report citation for the thread (without attachments)
+              this.super.addCitation?.({
+                id: `outlook-thread-${thread.conversationId}`,
+                title: thread.subject,
+                text: `Subject: "${thread.subject}"\n\n${messagesFormatted}`,
+                chunkSource: `outlook-thread://${this._generatePermalink(thread.conversationId)}`,
+                score: null,
+              });
+
+              return (
+                `Thread: "${thread.subject}"\n` +
+                `Conversation ID: ${thread.conversationId}\n` +
+                `Messages: ${thread.messageCount}\n` +
+                `Total Attachments: ${allAttachments.length}\n\n` +
+                messagesFormatted +
+                parsedAttachmentContent
+              );
+            } catch (e) {
+              return handleSkillError(this, "outlook-read-thread", e);
+            }
+          },
+          _generatePermalink: function (conversationId) {
+            if (!conversationId) return null;
+            let encodedId = encodeURIComponent(conversationId);
+            // For outlook, this needs to be specifically encoded
+            // as the webpage does not respect it like traditional URL encoding
+            encodedId = encodedId.replace(/-/g, "%2F");
+            return `https://outlook.live.com/mail/inbox/id/${encodedId}`;
+          },
+        });
+      },
+    };
+  },
+};

package/server/utils/agents/aibitat/plugins/outlook/search/outlook-search.js

@@ -0,0 +1,101 @@
+const outlookLib = require("../lib.js");
+const { formatMessageSummary, handleSkillError } = outlookLib;
+
+module.exports.OutlookSearch = {
+  name: "outlook-search",
+  plugin: function () {
+    return {
+      name: "outlook-search",
+      setup(aibitat) {
+        aibitat.function({
+          super: aibitat,
+          name: this.name,
+          description:
+            "Search emails in Outlook using Microsoft Search syntax. " +
+            "Supports searching by keywords, sender, subject, and more. " +
+            "Common search terms: 'from:email', 'subject:word', 'hasAttachments:true'. " +
+            "Returns message summaries with ID, subject, date, and read status.",
+          examples: [
+            {
+              prompt: "Search for emails about the project",
+              call: JSON.stringify({
+                query: "project update",
+                limit: 10,
+              }),
+            },
+            {
+              prompt: "Find emails from john@example.com",
+              call: JSON.stringify({
+                query: "from:john@example.com",
+                limit: 20,
+              }),
+            },
+            {
+              prompt: "Search for emails with attachments about invoices",
+              call: JSON.stringify({
+                query: "hasAttachments:true invoice",
+                limit: 15,
+              }),
+            },
+          ],
+          parameters: {
+            $schema: "http://json-schema.org/draft-07/schema#",
+            type: "object",
+            properties: {
+              query: {
+                type: "string",
+                description:
+                  "Search query. Use Microsoft Search syntax like 'from:email', 'subject:keyword', etc.",
+              },
+              limit: {
+                type: "number",
+                description:
+                  "Maximum number of results to return (1-50). Defaults to 10.",
+                default: 10,
+              },
+              skip: {
+                type: "number",
+                description:
+                  "Number of results to skip for pagination. Defaults to 0.",
+                default: 0,
+              },
+            },
+            required: ["query"],
+            additionalProperties: false,
+          },
+          handler: async function ({ query, limit = 10, skip = 0 }) {
+            try {
+              this.super.handlerProps.log(`Using the outlook-search tool.`);
+              this.super.introspect(
+                `${this.caller}: Searching Outlook with query "${query}"`
+              );
+
+              const result = await outlookLib.search(query, limit, skip);
+
+              if (!result.success) {
+                this.super.introspect(
+                  `${this.caller}: Outlook search failed - ${result.error}`
+                );
+                return `Error searching Outlook: ${result.error}`;
+              }
+
+              const { messages, resultCount } = result.data;
+              this.super.introspect(
+                `${this.caller}: Found ${resultCount} messages matching query`
+              );
+
+              if (resultCount === 0) {
+                return `No emails found matching query "${query}".`;
+              }
+
+              const summary = formatMessageSummary(messages);
+              return `Found ${resultCount} messages:\n\n${summary}\n\nAlways include the conversation ID in the response. Use the conversation ID with outlook-read-thread to read the full conversation.`;
+            } catch (e) {
+              return handleSkillError(this, "outlook-search", e);
+            }
+          },
+        });
+      },
+    };
+  },
+};

package/server/utils/agents/aibitat/plugins/outlook/send/outlook-send-email.js

@@ -0,0 +1,222 @@
+const outlookLib = require("../lib.js");
+const { prepareAttachmentsWithValidation, handleSkillError } = outlookLib;
+
+module.exports.OutlookSendEmail = {
+  name: "outlook-send-email",
+  plugin: function () {
+    return {
+      name: "outlook-send-email",
+      setup(aibitat) {
+        aibitat.function({
+          super: aibitat,
+          name: this.name,
+          description:
+            "Send an email immediately through Outlook. " +
+            "This action sends the email right away and cannot be undone. " +
+            "Can also reply to an existing message by providing replyToMessageId. " +
+            "For composing emails that need review before sending, use outlook-create-draft instead.",
+          examples: [
+            {
+              prompt: "Send an email to john@example.com about the project",
+              call: JSON.stringify({
+                to: "john@example.com",
+                subject: "Project Update",
+                body: "Hi John,\n\nHere's the latest update on the project.\n\nBest regards",
+              }),
+            },
+            {
+              prompt: "Reply to message AAMkAGI2...",
+              call: JSON.stringify({
+                replyToMessageId: "AAMkAGI2...",
+                body: "Thanks for the update. I'll review and get back to you.",
+              }),
+            },
+            {
+              prompt: "Reply all to message AAMkAGI2...",
+              call: JSON.stringify({
+                replyToMessageId: "AAMkAGI2...",
+                body: "Thanks everyone for your input.",
+                replyAll: true,
+              }),
+            },
+          ],
+          parameters: {
+            $schema: "http://json-schema.org/draft-07/schema#",
+            type: "object",
+            properties: {
+              replyToMessageId: {
+                type: "string",
+                description:
+                  "Message ID to reply to. If provided, sends a reply instead of a new email. " +
+                  "When replying, 'to' and 'subject' are optional (inherited from original).",
+              },
+              replyAll: {
+                type: "boolean",
+                description:
+                  "When replying, whether to reply to all recipients. Defaults to false.",
+                default: false,
+              },
+              to: {
+                type: "string",
+                description:
+                  "Recipient email address(es). Required for new emails, optional for replies.",
+              },
+              subject: {
+                type: "string",
+                description:
+                  "Email subject line. Required for new emails, optional for replies.",
+              },
+              body: {
+                type: "string",
+                description: "Email body content.",
+              },
+              cc: {
+                type: "string",
+                description: "CC recipient email address(es). Optional.",
+              },
+              bcc: {
+                type: "string",
+                description: "BCC recipient email address(es). Optional.",
+              },
+              isHtml: {
+                type: "boolean",
+                description:
+                  "Whether the body is HTML content. Defaults to false.",
+                default: false,
+              },
+              attachments: {
+                type: "array",
+                items: { type: "string" },
+                description:
+                  "Array of absolute file paths to attach to the email.",
+              },
+            },
+            required: ["body"],
+            additionalProperties: false,
+          },
+          handler: async function ({
+            replyToMessageId,
+            replyAll = false,
+            to,
+            subject,
+            body,
+            cc,
+            bcc,
+            isHtml,
+            attachments,
+          }) {
+            try {
+              this.super.handlerProps.log(`Using the outlook-send-email tool.`);
+
+              const isReply = !!replyToMessageId;
+
+              if (!isReply && (!to || !subject)) {
+                return "Error: 'to' and 'subject' are required for new emails. For replies, provide 'replyToMessageId'.";
+              }
+
+              if (!body) {
+                return "Error: 'body' is required.";
+              }
+
+              const attachmentResult = await prepareAttachmentsWithValidation(
+                this,
+                attachments,
+                { requireApprovalPerFile: true, recipientInfo: to }
+              );
+              if (!attachmentResult.success) {
+                return `Error with attachment: ${attachmentResult.error}`;
+              }
+              const {
+                attachments: preparedAttachments,
+                summaries: attachmentSummaries,
+              } = attachmentResult;
+
+              if (this.super.requestToolApproval) {
+                const attachmentNote =
+                  preparedAttachments.length > 0
+                    ? ` with ${preparedAttachments.length} attachment(s): ${attachmentSummaries.join(", ")}`
+                    : "";
+                const description = isReply
+                  ? `Send ${replyAll ? "reply-all" : "reply"} to message ${replyToMessageId}${attachmentNote}? This will send immediately.`
+                  : `Send email to "${to}" with subject "${subject}"${attachmentNote} - This will send immediately`;
+                const approval = await this.super.requestToolApproval({
+                  skillName: this.name,
+                  payload: isReply
+                    ? { replyToMessageId, replyAll }
+                    : {
+                        to,
+                        subject,
+                        attachmentCount: preparedAttachments.length,
+                      },
+                  description,
+                });
+                if (!approval.approved) {
+                  this.super.introspect(
+                    `${this.caller}: User rejected the ${this.name} request.`
+                  );
+                  return approval.message;
+                }
+              }
+
+              let result;
+              if (isReply) {
+                this.super.introspect(
+                  `${this.caller}: Sending ${replyAll ? "reply-all" : "reply"} to message...`
+                );
+                result = await outlookLib.replyToMessage(
+                  replyToMessageId,
+                  body,
+                  replyAll
+                );
+              } else {
+                this.super.introspect(
+                  `${this.caller}: Sending email to ${to}${preparedAttachments.length > 0 ? ` with ${preparedAttachments.length} attachment(s)` : ""}`
+                );
+
+                const options = { isHtml };
+                if (cc) options.cc = cc;
+                if (bcc) options.bcc = bcc;
+                if (preparedAttachments.length > 0) {
+                  options.attachments = preparedAttachments;
+                }
+
+                result = await outlookLib.sendEmail(to, subject, body, options);
+              }
+
+              if (!result.success) {
+                this.super.introspect(
+                  `${this.caller}: Failed to send - ${result.error}`
+                );
+                return `Error sending: ${result.error}`;
+              }
+
+              if (isReply) {
+                this.super.introspect(
+                  `${this.caller}: Successfully sent ${replyAll ? "reply-all" : "reply"}`
+                );
+                return `Successfully sent ${replyAll ? "reply-all" : "reply"} to message (ID: ${replyToMessageId}). The reply has been delivered.`;
+              }
+
+              this.super.introspect(
+                `${this.caller}: Successfully sent email to ${to}`
+              );
+
+              return (
+                `Successfully sent email:\n` +
+                `To: ${to}\n` +
+                `Subject: ${subject}\n` +
+                (cc ? `CC: ${cc}\n` : "") +
+                (preparedAttachments.length > 0
+                  ? `Attachments: ${attachmentSummaries.join(", ")}\n`
+                  : "") +
+                `\nThe email has been sent.`
+              );
+            } catch (e) {
+              return handleSkillError(this, "outlook-send-email", e);
+            }
+          },
+        });
+      },
+    };
+  },
+};

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

@@ -0,0 +1,114 @@
+const { safeJsonParse } = require("../../../http");
+const { Deduplicator } = require("../utils/dedupe");
+
+const rechart = {
+  name: "create-chart",
+  startupConfig: {
+    params: {},
+  },
+  plugin: function () {
+    return {
+      name: this.name,
+      setup(aibitat) {
+        // Scrape a website and summarize the content based on objective if the content is too large.',
+        aibitat.function({
+          super: aibitat,
+          name: this.name,
+          tracker: new Deduplicator(),
+          description:
+            "Create a chart, graph, or data visualization. Generate bar charts, line graphs, pie charts, area charts, or scatter plots to visualize data, statistics, trends, or results. Use to display numbers and data visually.",
+          examples: [
+            { prompt: "Create a chart from that data" },
+            { prompt: "Make a bar graph of the results" },
+            { prompt: "Visualize these numbers" },
+          ],
+          parameters: {
+            $schema: "http://json-schema.org/draft-07/schema#",
+            type: "object",
+            properties: {
+              type: {
+                type: "string",
+                enum: [
+                  "area",
+                  "bar",
+                  "line",
+                  "composed",
+                  "scatter",
+                  "pie",
+                  "radar",
+                  "radialBar",
+                  "treemap",
+                  "funnel",
+                ],
+                description: "The type of chart to be generated.",
+              },
+              title: {
+                type: "string",
+                description:
+                  "Title of the chart. There MUST always be a title. Do not leave it blank.",
+              },
+              dataset: {
+                type: "string",
+                description: `Valid JSON in which each element is an object for Recharts API for the 'type' of chart defined WITHOUT new line characters. Strictly using this FORMAT and naming:
+{ "name": "a", "value": 12 }].
+Make sure field "name" always stays named "name". Instead of naming value field value in JSON, name it based on user metric and make it the same across every item.
+Make sure the format use double quotes and property names are string literals. Provide JSON data only.`,
+              },
+            },
+            additionalProperties: false,
+          },
+          required: ["type", "title", "dataset"],
+          handler: async function ({ type, dataset, title }) {
+            try {
+              if (this.tracker.isMarkedUnique(this.name)) {
+                this.super.handlerProps.log(
+                  `${this.name} has been called for this chat response already. It can only be called once per chat.`
+                );
+                return "The chart was generated and returned to the user. This function completed successfully. Do not call this function again.";
+              }
+
+              const data = safeJsonParse(dataset, null);
+              if (data === null) {
+                this.super.introspect(
+                  `${this.caller}: ${this.name} provided invalid JSON data - so we cant make a ${type} chart.`
+                );
+                return "Invalid JSON provided. Please only provide valid RechartJS JSON to generate a chart.";
+              }
+
+              this.super.introspect(`${this.caller}: Rendering ${type} chart.`);
+              this.super.socket.send("rechartVisualize", {
+                type,
+                dataset,
+                title,
+              });
+
+              this.super._replySpecialAttributes = {
+                saveAsType: "rechartVisualize",
+                storedResponse: (additionalText = "") =>
+                  JSON.stringify({
+                    type,
+                    dataset,
+                    title,
+                    caption: additionalText,
+                  }),
+                postSave: () => this.tracker.removeUniqueConstraint(this.name),
+              };
+
+              this.tracker.markUnique(this.name);
+              return "The chart was generated and returned to the user. This function completed successfully. Do not make another chart.";
+            } catch (error) {
+              this.super.handlerProps.log(
+                `create-chart raised an error. ${error.message}`
+              );
+              return `Let the user know this action was not successful. An error was raised while generating the chart. ${error.message}`;
+            }
+          },
+        });
+      },
+    };
+  },
+};
+
+module.exports = {
+  rechart,
+};