totem-llm 0.1.0

package/server/utils/agents/aibitat/plugins/web-scraping.js

@@ -0,0 +1,158 @@
+const { CollectorApi } = require("../../../collectorApi");
+const Provider = require("../providers/ai-provider");
+const { summarizeContent } = require("../utils/summarize");
+
+const webScraping = {
+  name: "web-scraping",
+  startupConfig: {
+    params: {},
+  },
+  plugin: function () {
+    return {
+      name: this.name,
+      setup(aibitat) {
+        aibitat.function({
+          super: aibitat,
+          name: this.name,
+          controller: new AbortController(),
+          description:
+            "Read and extract content from a specific webpage URL. Fetch the text from a website, get the contents of a link, or visit a URL to see what it says. Use when you have a specific web address to read.",
+          examples: [
+            {
+              prompt: "Read that URL for me",
+              call: JSON.stringify({ url: "https://example.com" }),
+            },
+            {
+              prompt: "What is anythingllm.com about?",
+              call: JSON.stringify({ url: "https://anythingllm.com" }),
+            },
+            {
+              prompt: "Scrape https://example.com",
+              call: JSON.stringify({ url: "https://example.com" }),
+            },
+          ],
+          parameters: {
+            $schema: "http://json-schema.org/draft-07/schema#",
+            type: "object",
+            properties: {
+              url: {
+                type: "string",
+                format: "uri",
+                description:
+                  "A complete web address URL including protocol. Assumes https if not provided.",
+              },
+            },
+            additionalProperties: false,
+          },
+          handler: async function ({ url }) {
+            try {
+              if (url) return await this.scrape(url);
+              return "There is nothing we can do. This function call returns no information.";
+            } catch (error) {
+              const errorMessage = error?.message ?? JSON.stringify(error);
+              this.super.handlerProps.log(
+                `Web Scraping Error: ${errorMessage}`
+              );
+              this.super.introspect(
+                `${this.caller}: Web Scraping Error: ${errorMessage}`
+              );
+              return `There was an error while calling the function. No data or response was found. Let the user know this was the error: ${errorMessage}`;
+            }
+          },
+
+          /**
+           * Report a URL citation to be displayed in the chat UI.
+           * @param {string} url - The URL that was accessed
+           * @param {string} content - The content retrieved from the URL
+           */
+          reportUrlCitation: function (url, content) {
+            try {
+              const urlObj = new URL(url);
+              this.super.addCitation?.({
+                id: url,
+                title: urlObj.hostname + urlObj.pathname,
+                text: content,
+                chunkSource: `link://${url}`,
+                score: null,
+              });
+            } catch {
+              // URL parsing failed, still add citation without parsed title
+              this.super.addCitation?.({
+                id: url,
+                title: url,
+                text: content,
+                chunkSource: `link://${url}`,
+                score: null,
+              });
+            }
+          },
+
+          /**
+           * Scrape a website and summarize the content based on objective if the content is too large.
+           * Objective is the original objective & task that user give to the agent, url is the url of the website to be scraped.
+           * Here we can leverage the document collector to get raw website text quickly.
+           *
+           * @param url
+           * @returns
+           */
+          scrape: async function (url) {
+            this.super.introspect(
+              `${this.caller}: Scraping the content of ${url}`
+            );
+            const { success, content } =
+              await new CollectorApi().getLinkContent(url);
+
+            if (!success) {
+              this.super.introspect(
+                `${this.caller}: could not scrape ${url}. I can't use this page's content.`
+              );
+              throw new Error(
+                `URL could not be scraped and no content was found.`
+              );
+            }
+
+            if (!content || content?.length === 0) {
+              throw new Error("There was no content to be collected or read.");
+            }
+
+            this.reportUrlCitation(url, content);
+            const { TokenManager } = require("../../../helpers/tiktoken");
+            const tokenEstimate = new TokenManager(
+              this.super.model
+            ).countFromString(content);
+            if (
+              tokenEstimate <
+              Provider.contextLimit(this.super.provider, this.super.model)
+            ) {
+              this.super.introspect(
+                `${this.caller}: Looking over the content of the page. ~${tokenEstimate} tokens.`
+              );
+              return content;
+            }
+
+            this.super.introspect(
+              `${this.caller}: This page's content exceeds the model's context limit. Summarizing it right now.`
+            );
+            this.super.onAbort(() => {
+              this.super.handlerProps.log(
+                "Abort was triggered, exiting summarization early."
+              );
+              this.controller.abort();
+            });
+
+            return summarizeContent({
+              provider: this.super.provider,
+              model: this.super.model,
+              controllerSignal: this.controller.signal,
+              content,
+            });
+          },
+        });
+      },
+    };
+  },
+};
+
+module.exports = {
+  webScraping,
+};

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

@@ -0,0 +1,361 @@
+const chalk = require("chalk");
+const { v4: uuidv4 } = require("uuid");
+const { safeJsonParse } = require("../../../http");
+const { skillIsAutoApproved } = require("../../../helpers/agents");
+const SOCKET_TIMEOUT_MS = 300 * 1_000; // 5 mins
+const TOOL_APPROVAL_TIMEOUT_MS = 120 * 1_000; // 2 mins for tool approval
+const CLARIFICATION_DEFAULT_TIMEOUT_MS = 120 * 1_000; // 2 mins for clarifying questions
+
+/**
+ * Websocket Interface plugin. It prints the messages on the console and asks for feedback
+ * while the conversation is running in the background.
+ */
+
+// export interface AIbitatWebSocket extends ServerWebSocket<unknown> {
+//   askForFeedback?: any
+//   awaitResponse?: any
+//   handleFeedback?: (message: string) => void;
+//   handleToolApproval?: (message: string) => void;
+//   handleClarificationResponse?: (message: string) => void;
+// }
+
+const WEBSOCKET_BAIL_COMMANDS = [
+  "exit",
+  "/exit",
+  "stop",
+  "/stop",
+  "halt",
+  "/halt",
+  "/reset", // Will not reset but will bail. Powerusers always do this and the LLM responds.
+];
+const websocket = {
+  name: "websocket",
+  startupConfig: {
+    params: {
+      socket: {
+        required: true,
+      },
+      muteUserReply: {
+        required: false,
+        default: true,
+      },
+      introspection: {
+        required: false,
+        default: true,
+      },
+    },
+  },
+  plugin: function ({
+    socket, // @type AIbitatWebSocket
+    muteUserReply = true, // Do not post messages to "USER" back to frontend.
+    introspection = false, // when enabled will attach socket to Aibitat object with .introspect method which reports status updates to frontend.
+    userId = null, // User ID for multi-user mode whitelist lookups
+  }) {
+    return {
+      name: this.name,
+      setup(aibitat) {
+        aibitat.onError(async (error) => {
+          let errorMessage =
+            error?.message || "An error occurred while running the agent.";
+          console.error(chalk.red(`   error: ${errorMessage}`), error);
+          aibitat.introspect(
+            `Error encountered while running: ${errorMessage}`
+          );
+          socket.send(
+            JSON.stringify({ type: "wssFailure", content: errorMessage })
+          );
+          aibitat.terminate();
+        });
+
+        aibitat.introspect = (messageText) => {
+          if (!introspection) return; // Dump thoughts when not wanted.
+          socket.send(
+            JSON.stringify({
+              type: "statusResponse",
+              content: messageText,
+              animate: true,
+            })
+          );
+        };
+
+        // expose function for sockets across aibitat
+        // type param must be set or else msg will not be shown or handled in UI.
+        aibitat.socket = {
+          send: (type = "__unhandled", content = "") => {
+            socket.send(JSON.stringify({ type, content }));
+          },
+        };
+
+        /**
+         * Request user approval before executing a tool/skill.
+         * This sends a request to the frontend and blocks until the user responds.
+         * If the skill is whitelisted, approval is granted automatically.
+         *
+         * @param {Object} options - The approval request options
+         * @param {string} options.skillName - The name of the skill/tool requesting approval
+         * @param {Object} [options.payload={}] - Optional payload data to display to the user
+         * @param {string} [options.description] - Optional description of what the skill will do
+         * @returns {Promise<{approved: boolean, message: string}>} - The approval result
+         */
+        aibitat.requestToolApproval = async function ({
+          skillName,
+          payload = {},
+          description = null,
+        }) {
+          if (skillIsAutoApproved({ skillName })) {
+            return {
+              approved: true,
+              message: "Skill is auto-approved.",
+            };
+          }
+
+          const {
+            AgentSkillWhitelist,
+          } = require("../../../../models/agentSkillWhitelist");
+          const isWhitelisted = await AgentSkillWhitelist.isWhitelisted(
+            skillName,
+            userId
+          );
+          if (isWhitelisted) {
+            console.log(
+              chalk.green(
+                userId
+                  ? `User ${userId} - `
+                  : "" + `Skill ${skillName} is whitelisted - auto-approved.`
+              )
+            );
+            return {
+              approved: true,
+              message: "Skill is whitelisted - auto-approved.",
+            };
+          }
+
+          const requestId = uuidv4();
+          return new Promise((resolve) => {
+            let timeoutId = null;
+
+            socket.handleToolApproval = (message) => {
+              try {
+                const data = safeJsonParse(message, {});
+                if (
+                  data?.type !== "toolApprovalResponse" ||
+                  data?.requestId !== requestId
+                )
+                  return;
+
+                delete socket.handleToolApproval;
+                clearTimeout(timeoutId);
+
+                if (data.approved) {
+                  return resolve({
+                    approved: true,
+                    message: "User approved the tool execution.",
+                  });
+                }
+
+                return resolve({
+                  approved: false,
+                  message: "Tool call was rejected by the user.",
+                });
+              } catch (e) {
+                console.error("Error handling tool approval response:", e);
+              }
+            };
+
+            socket.send(
+              JSON.stringify({
+                type: "toolApprovalRequest",
+                requestId,
+                skillName,
+                payload,
+                description,
+                timeoutMs: TOOL_APPROVAL_TIMEOUT_MS,
+              })
+            );
+
+            timeoutId = setTimeout(() => {
+              delete socket.handleToolApproval;
+              console.log(
+                chalk.yellow(
+                  `Tool approval request timed out after ${TOOL_APPROVAL_TIMEOUT_MS}ms`
+                )
+              );
+              resolve({
+                approved: false,
+                message:
+                  "Tool approval request timed out. User did not respond in time.",
+              });
+            }, TOOL_APPROVAL_TIMEOUT_MS);
+          });
+        };
+
+        /**
+         * Ask the user one or more clarifying questions in a single card and
+         * wait for their answers. With more than one question the card
+         * paginates; with exactly one it renders a simple form. Sends one
+         * websocket request and resolves when the user submits the whole set,
+         * skips, or the timeout elapses.
+         *
+         * @param {Object} options
+         * @param {Array<Object>} options.questions - Question objects, each with shape:
+         *   { kind: "input"|"choice", question: string, ... per-kind fields }
+         * @param {boolean} [options.allowSkip=true] - Whether the user can skip individual questions
+         * @param {number} [options.timeoutMs] - Override timeout (ms)
+         * @returns {Promise<{ skipped: boolean, timedOut: boolean, answers: Array<{skipped: boolean, answer: any}> }>}
+         */
+        aibitat.requestUserClarification = async function ({
+          questions = [],
+          allowSkip = true,
+          timeoutMs = CLARIFICATION_DEFAULT_TIMEOUT_MS,
+        }) {
+          const requestId = uuidv4();
+          return new Promise((resolve) => {
+            let timeoutId = null;
+
+            socket.handleClarificationResponse = (message) => {
+              try {
+                const data = safeJsonParse(message, {});
+                if (
+                  data?.type !== "clarificationResponse" ||
+                  data?.requestId !== requestId
+                )
+                  return;
+
+                delete socket.handleClarificationResponse;
+                clearTimeout(timeoutId);
+
+                if (data.skipped) {
+                  return resolve({
+                    skipped: true,
+                    timedOut: false,
+                    answers: questions.map(() => ({
+                      skipped: true,
+                      answer: null,
+                    })),
+                  });
+                }
+
+                const answers = Array.isArray(data.answers) ? data.answers : [];
+                const normalized = questions.map((_, i) => {
+                  const a = answers[i] || {};
+                  return {
+                    skipped: !!a.skipped,
+                    answer: a.answer ?? null,
+                  };
+                });
+                return resolve({
+                  skipped: false,
+                  timedOut: false,
+                  answers: normalized,
+                });
+              } catch (e) {
+                console.error("Error handling clarification response:", e);
+              }
+            };
+
+            socket.send(
+              JSON.stringify({
+                type: "clarificationRequest",
+                requestId,
+                questions,
+                allowSkip,
+                timeoutMs,
+              })
+            );
+
+            timeoutId = setTimeout(() => {
+              delete socket.handleClarificationResponse;
+              console.log(
+                chalk.yellow(
+                  `Clarification request timed out after ${timeoutMs}ms`
+                )
+              );
+              resolve({
+                skipped: false,
+                timedOut: true,
+                answers: questions.map(() => ({ skipped: true, answer: null })),
+              });
+            }, timeoutMs);
+          });
+        };
+
+        // aibitat.onStart(() => {
+        //   console.log("🚀 starting chat ...");
+        // });
+
+        aibitat.onMessage((message) => {
+          if (message.from !== "USER")
+          if (message.from === "USER" && muteUserReply) return;
+          socket.send(JSON.stringify(message));
+        });
+
+        aibitat.onTerminate(() => {
+          // console.log("🚀 chat finished");
+          socket.close();
+        });
+
+        aibitat.onInterrupt(async (node) => {
+          const { feedback, attachments } = await socket.askForFeedback(
+            socket,
+            node
+          );
+          if (WEBSOCKET_BAIL_COMMANDS.includes(feedback)) {
+            socket.close();
+            return;
+          }
+
+          await aibitat.continue(feedback, attachments);
+        });
+
+        /**
+         * Socket wait for feedback on socket
+         *
+         * @param socket The content to summarize. // AIbitatWebSocket & { receive: any, echo: any }
+         * @param node The chat node // { from: string; to: string }
+         * @returns {{ feedback: string, attachments: Array }} The feedback and any attachments.
+         */
+        socket.askForFeedback = (socket, node) => {
+          socket.awaitResponse = (question = "waiting...") => {
+            socket.send(JSON.stringify({ type: "WAITING_ON_INPUT", question }));
+
+            return new Promise(function (resolve) {
+              let socketTimeout = null;
+              socket.handleFeedback = (message) => {
+                const data = JSON.parse(message);
+                if (data.type !== "awaitingFeedback") return;
+                delete socket.handleFeedback;
+                clearTimeout(socketTimeout);
+                resolve({
+                  feedback: data.feedback,
+                  attachments: data.attachments || [],
+                });
+                return;
+              };
+
+              socketTimeout = setTimeout(() => {
+                console.log(
+                  chalk.red(
+                    `Client took too long to respond, chat thread is dead after ${SOCKET_TIMEOUT_MS}ms`
+                  )
+                );
+                resolve({ feedback: "exit", attachments: [] });
+                return;
+              }, SOCKET_TIMEOUT_MS);
+            });
+          };
+
+          return socket.awaitResponse(`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: \n`);
+        };
+        // console.log("🚀 WS plugin is complete.");
+      },
+    };
+  },
+};
+
+module.exports = {
+  websocket,
+  WEBSOCKET_BAIL_COMMANDS,
+};