totem-llm 0.1.0

package/server/endpoints/mobile/index.js

@@ -0,0 +1,160 @@
+const { validatedRequest } = require("../../utils/middleware/validatedRequest");
+const { MobileDevice } = require("../../models/mobileDevice");
+const { handleMobileCommand } = require("./utils");
+const { validDeviceToken, validRegistrationToken } = require("./middleware");
+const { reqBody } = require("../../utils/http");
+const {
+  flexUserRoleValid,
+  ROLES,
+} = require("../../utils/middleware/multiUserProtected");
+
+function mobileEndpoints(app) {
+  if (!app) return;
+
+  /**
+   * Gets all the devices from the database.
+   * @param {import("express").Request} request
+   * @param {import("express").Response} response
+   */
+  app.get(
+    "/mobile/devices",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (_request, response) => {
+      try {
+        const devices = await MobileDevice.where({}, null, null, {
+          user: { select: { id: true, username: true } },
+        });
+        return response.status(200).json({ devices });
+      } catch (e) {
+        console.error(e);
+        response.sendStatus(500).end();
+      }
+    }
+  );
+
+  /**
+   * Updates the device status via an updates object.
+   * @param {import("express").Request} request
+   * @param {import("express").Response} response
+   */
+  app.post(
+    "/mobile/update/:id",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (request, response) => {
+      try {
+        const body = reqBody(request);
+        const updates = await MobileDevice.update(
+          Number(request.params.id),
+          body
+        );
+        if (updates.error)
+          return response.status(400).json({ error: updates.error });
+        return response.status(200).json({ updates });
+      } catch (e) {
+        console.error(e);
+        response.sendStatus(500).end();
+      }
+    }
+  );
+
+  /**
+   * Deletes a device from the database.
+   * @param {import("express").Request} request
+   * @param {import("express").Response} response
+   */
+  app.delete(
+    "/mobile/:id",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (request, response) => {
+      try {
+        const device = await MobileDevice.get({
+          id: Number(request.params.id),
+        });
+        if (!device)
+          return response.status(404).json({ error: "Device not found" });
+        await MobileDevice.delete(device.id);
+        return response.status(200).json({ message: "Device deleted" });
+      } catch (e) {
+        console.error(e);
+        response.sendStatus(500).end();
+      }
+    }
+  );
+
+  app.get(
+    "/mobile/connect-info",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (_request, response) => {
+      try {
+        return response.status(200).json({
+          connectionUrl: MobileDevice.connectionURL(response.locals?.user),
+        });
+      } catch (e) {
+        console.error(e);
+        response.sendStatus(500).end();
+      }
+    }
+  );
+
+  /**
+   * Checks if the device auth token is valid
+   * against approved devices.
+   */
+  app.get("/mobile/auth", [validDeviceToken], async (_, response) => {
+    try {
+      return response
+        .status(200)
+        .json({ success: true, message: "Device authenticated" });
+    } catch (e) {
+      console.error(e);
+      response.sendStatus(500).end();
+    }
+  });
+
+  /**
+   * Registers a new device (is open so that the mobile app can register itself)
+   * Will create a new device in the database but requires approval by the user
+   * before it can be used.
+   * @param {import("express").Request} request
+   * @param {import("express").Response} response
+   */
+  app.post(
+    "/mobile/register",
+    [validRegistrationToken],
+    async (request, response) => {
+      try {
+        const body = reqBody(request);
+        const result = await MobileDevice.create({
+          deviceOs: body.deviceOs,
+          deviceName: body.deviceName,
+          userId: response.locals?.user?.id,
+        });
+
+        if (result.error)
+          return response.status(400).json({ error: result.error });
+        return response.status(200).json({
+          token: result.device.token,
+          platform: MobileDevice.platform,
+        });
+      } catch (e) {
+        console.error(e);
+        response.sendStatus(500).end();
+      }
+    }
+  );
+
+  app.post(
+    "/mobile/send/:command",
+    [validDeviceToken],
+    async (request, response) => {
+      try {
+        return handleMobileCommand(request, response);
+      } catch (e) {
+        console.error(e);
+        response.sendStatus(500).end();
+      }
+    }
+  );
+}
+
+module.exports = { mobileEndpoints };

package/server/endpoints/mobile/middleware/index.js

@@ -0,0 +1,97 @@
+const { MobileDevice } = require("../../../models/mobileDevice");
+const { SystemSettings } = require("../../../models/systemSettings");
+const { User } = require("../../../models/user");
+
+/**
+ * Validates the device id from the request headers by checking if the device
+ * exists in the database and is approved.
+ * @param {import("express").Request} request
+ * @param {import("express").Response} response
+ * @param {import("express").NextFunction} next
+ */
+async function validDeviceToken(request, response, next) {
+  try {
+    const token = request.header("x-anythingllm-mobile-device-token");
+    if (!token)
+      return response.status(400).json({ error: "Device token is required" });
+
+    const device = await MobileDevice.get(
+      { token: String(token) },
+      { user: true }
+    );
+    if (!device)
+      return response.status(400).json({ error: "Device not found" });
+    if (!device.approved)
+      return response.status(400).json({ error: "Device not approved" });
+
+    // If the device is associated with a user then we can associate it with the locals
+    // so we can reuse it later.
+    if (device.user) {
+      if (device.user.suspended)
+        return response.status(400).json({ error: "User is suspended." });
+      response.locals.user = device.user;
+    }
+
+    delete device.user;
+    response.locals.device = device;
+    next();
+  } catch (error) {
+    console.error("validDeviceToken", error);
+    response.status(500).json({ error: "Invalid middleware response" });
+  }
+}
+
+/**
+ * Validates a temporary registration token that is passed in the request
+ * and associates the user with the token (if valid). Temporary token is consumed
+ * and cannot be used again after this middleware is called.
+ * @param {*} request
+ * @param {*} response
+ * @param {*} next
+ */
+async function validRegistrationToken(request, response, next) {
+  try {
+    const authHeader = request.header("Authorization");
+    const tempToken = authHeader ? authHeader.split(" ")[1] : null;
+    if (!tempToken)
+      return response
+        .status(400)
+        .json({ error: "Registration token is required" });
+
+    const tempTokenData = MobileDevice.tempToken(tempToken);
+    if (!tempTokenData)
+      return response
+        .status(400)
+        .json({ error: "Invalid or expired registration token" });
+
+    // If in multi-user mode, we need to validate the user id
+    // associated exists, is not banned and then associate with locals so we can reuse it later.
+    // If not in multi-user mode then simply having a valid token is enough.
+    const multiUserMode = await SystemSettings.isMultiUserMode();
+    if (multiUserMode) {
+      if (!tempTokenData.userId)
+        return response
+          .status(400)
+          .json({ error: "User id not found in registration token" });
+      const user = await User.get({ id: Number(tempTokenData.userId) });
+      if (!user) return response.status(400).json({ error: "User not found" });
+      if (user.suspended)
+        return response
+          .status(400)
+          .json({ error: "User is suspended - cannot register device" });
+      response.locals.user = user;
+    }
+
+    next();
+  } catch (error) {
+    console.error("validRegistrationToken:error", error);
+    response.status(500).json({
+      error: "Invalid middleware response from validRegistrationToken",
+    });
+  }
+}
+
+module.exports = {
+  validDeviceToken,
+  validRegistrationToken,
+};

package/server/endpoints/mobile/utils/index.js

@@ -0,0 +1,195 @@
+const { Workspace } = require("../../../models/workspace");
+const { WorkspaceChats } = require("../../../models/workspaceChats");
+const { WorkspaceThread } = require("../../../models/workspaceThread");
+const { ApiChatHandler } = require("../../../utils/chats/apiChatHandler");
+const { reqBody } = require("../../../utils/http");
+const prisma = require("../../../utils/prisma");
+const { getModelTag } = require("../../utils");
+const { MobileDevice } = require("../../../models/mobileDevice");
+
+/**
+ *
+ * @param {import("express").Request} request
+ * @param {import("express").Response} response
+ * @returns
+ */
+async function handleMobileCommand(request, response) {
+  const { command } = request.params;
+  const user = response.locals.user ?? null;
+  const body = reqBody(request);
+
+  if (command === "workspaces") {
+    const workspaces = user
+      ? await Workspace.whereWithUser(user, {})
+      : await Workspace.where({});
+    for (const workspace of workspaces) {
+      const [threadCount, chatCount] = await Promise.all([
+        prisma.workspace_threads.count({
+          where: {
+            workspace_id: workspace.id,
+            ...(user ? { user_id: user.id } : {}),
+          },
+        }),
+        prisma.workspace_chats.count({
+          where: {
+            workspaceId: workspace.id,
+            include: true,
+            ...(user ? { user_id: user.id } : {}),
+          },
+        }),
+      ]);
+      workspace.threadCount = threadCount;
+      workspace.chatCount = chatCount;
+      workspace.platform = MobileDevice.platform;
+    }
+    return response.status(200).json({ workspaces });
+  }
+
+  if (command === "workspace-content") {
+    const workspace = user
+      ? await Workspace.getWithUser(user, { slug: String(body.workspaceSlug) })
+      : await Workspace.get({ slug: String(body.workspaceSlug) });
+
+    if (!workspace)
+      return response.status(400).json({ error: "Workspace not found" });
+    const threads = [
+      {
+        id: 0,
+        name: "Default Thread",
+        slug: "default-thread",
+        workspace_id: workspace.id,
+        createdAt: new Date(),
+        lastUpdatedAt: new Date(),
+      },
+      ...(await prisma.workspace_threads.findMany({
+        where: {
+          workspace_id: workspace.id,
+          ...(user ? { user_id: user.id } : {}),
+        },
+      })),
+    ];
+    const chats = (
+      await prisma.workspace_chats.findMany({
+        where: {
+          workspaceId: workspace.id,
+          include: true,
+          ...(user ? { user_id: user.id } : {}),
+        },
+      })
+    ).map((chat) => ({
+      ...chat,
+      // Create a dummy thread_id for the default thread so the chats can be mapped correctly.
+      ...(chat.thread_id === null ? { thread_id: 0 } : {}),
+      createdAt: chat.createdAt.toISOString(),
+      lastUpdatedAt: chat.lastUpdatedAt.toISOString(),
+    }));
+    return response.status(200).json({ threads, chats });
+  }
+
+  // Get the model for this workspace (workspace -> system)
+  if (command === "model-tag") {
+    const { workspaceSlug } = body;
+    const workspace = user
+      ? await Workspace.getWithUser(user, { slug: String(workspaceSlug) })
+      : await Workspace.get({ slug: String(workspaceSlug) });
+
+    if (!workspace)
+      return response.status(400).json({ error: "Workspace not found" });
+    if (workspace.chatModel)
+      return response.status(200).json({ model: workspace.chatModel });
+    else return response.status(200).json({ model: getModelTag() });
+  }
+
+  if (command === "reset-chat") {
+    const { workspaceSlug, threadSlug } = body;
+    const workspace = user
+      ? await Workspace.getWithUser(user, { slug: String(workspaceSlug) })
+      : await Workspace.get({ slug: String(workspaceSlug) });
+
+    if (!workspace)
+      return response.status(400).json({ error: "Workspace not found" });
+    const threadId = threadSlug
+      ? await prisma.workspace_threads.findFirst({
+          where: {
+            workspace_id: workspace.id,
+            slug: String(threadSlug),
+            ...(user ? { user_id: user.id } : {}),
+          },
+        })?.id
+      : null;
+
+    await WorkspaceChats.markThreadHistoryInvalidV2({
+      workspaceId: workspace.id,
+      ...(user ? { user_id: user.id } : {}),
+      thread_id: threadId, // if threadId is null, this will reset the default thread.
+    });
+    return response.status(200).json({ success: true });
+  }
+
+  if (command === "new-thread") {
+    const { workspaceSlug } = body;
+    const workspace = user
+      ? await Workspace.getWithUser(user, { slug: String(workspaceSlug) })
+      : await Workspace.get({ slug: String(workspaceSlug) });
+
+    if (!workspace)
+      return response.status(400).json({ error: "Workspace not found" });
+    const { thread } = await WorkspaceThread.new(workspace, user?.id);
+    return response.status(200).json({ thread });
+  }
+
+  if (command === "stream-chat") {
+    const { workspaceSlug = null, threadSlug = null, message } = body;
+    if (!workspaceSlug)
+      return response.status(400).json({ error: "Workspace ID is required" });
+    else if (!message)
+      return response.status(400).json({ error: "Message is required" });
+
+    const workspace = user
+      ? await Workspace.getWithUser(user, { slug: String(workspaceSlug) })
+      : await Workspace.get({ slug: String(workspaceSlug) });
+
+    if (!workspace)
+      return response.status(400).json({ error: "Workspace not found" });
+    const thread = threadSlug
+      ? await prisma.workspace_threads.findFirst({
+          where: {
+            workspace_id: workspace.id,
+            slug: String(threadSlug),
+            ...(user ? { user_id: user.id } : {}),
+          },
+        })
+      : null;
+
+    response.setHeader("Cache-Control", "no-cache");
+    response.setHeader("Content-Type", "text/event-stream");
+    response.setHeader("Access-Control-Allow-Origin", "*");
+    response.setHeader("Connection", "keep-alive");
+    response.flushHeaders();
+    await ApiChatHandler.streamChat({
+      response,
+      workspace,
+      thread,
+      message,
+      mode: "chat",
+      user: user,
+      sessionId: null,
+      attachments: [],
+      reset: false,
+    });
+    return response.end();
+  }
+
+  if (command === "unregister-device") {
+    if (!response.locals.device)
+      return response.status(200).json({ success: true });
+    await MobileDevice.delete(response.locals.device.id);
+    return response.status(200).json({ success: true });
+  }
+
+  return response.status(400).json({ error: "Invalid command" });
+}
+
+module.exports = {
+  handleMobileCommand,
+};

package/server/endpoints/modelRouter.js

@@ -0,0 +1,205 @@
+const { ModelRouter } = require("../models/modelRouter");
+const { ModelRouterRule } = require("../models/modelRouterRule");
+const { ModelRouterService } = require("../utils/router");
+const { reqBody, userFromSession } = require("../utils/http");
+const {
+  flexUserRoleValid,
+  ROLES,
+} = require("../utils/middleware/multiUserProtected");
+const { validatedRequest } = require("../utils/middleware/validatedRequest");
+const { requireFeature } = require("../utils/middleware/requireFeature");
+
+function modelRouterEndpoints(app) {
+  if (!app) return;
+
+  // Gate all model router routes based on the active build profile
+  app.use("/model-routers", requireFeature("modelRouter"));
+
+  app.get(
+    "/model-routers",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (_request, response) => {
+      try {
+        const routers = await ModelRouter.getAllWithCounts();
+        response.status(200).json({ routers });
+      } catch (e) {
+        console.error(e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  app.get(
+    "/model-routers/:id",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (request, response) => {
+      try {
+        const { id } = request.params;
+        const router = await ModelRouter.getWithRulesAndCount({
+          id: Number(id),
+        });
+        if (!router) {
+          response
+            .status(404)
+            .json({ router: null, error: "Router not found." });
+          return;
+        }
+        response.status(200).json({ router });
+      } catch (e) {
+        console.error(e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  app.post(
+    "/model-routers/new",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (request, response) => {
+      try {
+        const user = await userFromSession(request, response);
+        const data = reqBody(request);
+        const { router, error } = await ModelRouter.create(
+          data,
+          user?.id || null
+        );
+
+        if (error) return response.status(400).json({ router, error });
+        return response.status(200).json({ router });
+      } catch (e) {
+        console.error(e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  app.put(
+    "/model-routers/:id",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (request, response) => {
+      try {
+        const { id } = request.params;
+        const data = reqBody(request);
+        const { router, error } = await ModelRouter.update(Number(id), data);
+        if (error) return response.status(400).json({ router, error });
+        ModelRouterService.invalidateRouter(Number(id));
+        return response.status(200).json({ router });
+      } catch (e) {
+        console.error(e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  app.delete(
+    "/model-routers/:id",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (request, response) => {
+      try {
+        const { id } = request.params;
+        const success = await ModelRouter.delete(Number(id));
+        if (!success)
+          return response
+            .status(400)
+            .json({ success: false, error: "Failed to delete router." });
+        ModelRouterService.invalidateRouter(Number(id));
+        return response.status(200).json({ success: true });
+      } catch (e) {
+        console.error(e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  app.post(
+    "/model-routers/:id/rules/new",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (request, response) => {
+      try {
+        const { id } = request.params;
+        const user = await userFromSession(request, response);
+        const data = reqBody(request);
+        const routerId = Number(id);
+        const { rule, error } = await ModelRouterRule.create(
+          routerId,
+          data,
+          user?.id || null
+        );
+        if (error) return response.status(400).json({ rule, error });
+
+        ModelRouterService.invalidateRouter(routerId);
+        return response.status(200).json({ rule });
+      } catch (e) {
+        console.error(e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  app.put(
+    "/model-routers/:id/rules/reorder",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (request, response) => {
+      try {
+        const { id } = request.params;
+        const { ruleUpdates } = reqBody(request);
+        if (!Array.isArray(ruleUpdates))
+          return response
+            .status(400)
+            .json({ success: false, error: "ruleUpdates must be an array." });
+
+        const { success, error } =
+          await ModelRouterRule.reorderRules(ruleUpdates);
+        if (error) return response.status(400).json({ success, error });
+        ModelRouterService.invalidateRouter(Number(id));
+        return response.status(200).json({ success });
+      } catch (e) {
+        console.error(e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  app.put(
+    "/model-routers/:id/rules/:ruleId",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (request, response) => {
+      try {
+        const { id, ruleId } = request.params;
+        const data = reqBody(request);
+        const { rule, error } = await ModelRouterRule.update(
+          Number(ruleId),
+          data
+        );
+        if (error) return response.status(400).json({ rule, error });
+        ModelRouterService.invalidateRouter(Number(id));
+        return response.status(200).json({ rule });
+      } catch (e) {
+        console.error(e);
+        response.sendStatus(500);
+      }
+    }
+  );
+
+  app.delete(
+    "/model-routers/:id/rules/:ruleId",
+    [validatedRequest, flexUserRoleValid([ROLES.admin])],
+    async (request, response) => {
+      try {
+        const { id, ruleId } = request.params;
+        const success = await ModelRouterRule.delete(Number(ruleId));
+        if (!success)
+          return response
+            .status(400)
+            .json({ success: false, error: "Failed to delete rule." });
+        ModelRouterService.invalidateRouter(Number(id));
+        return response.status(200).json({ success: true });
+      } catch (e) {
+        console.error(e);
+        response.sendStatus(500);
+      }
+    }
+  );
+}
+
+module.exports = { modelRouterEndpoints };