@superatomai/sdk-node 0.0.19 → 0.0.21

package/dist/index.js

@@ -451,7 +451,8 @@ var UserPromptRequestMessageSchema = import_zod3.z.object({
 });
 var UserPromptSuggestionsPayloadSchema = import_zod3.z.object({
   prompt: import_zod3.z.string(),
-  limit: import_zod3.z.number().int().positive().default(5)
+  limit: import_zod3.z.number().int().positive().default(5),
+  similarityThreshold: import_zod3.z.number().min(0).max(1).default(0.4)
 });
 var UserPromptSuggestionsMessageSchema = import_zod3.z.object({
   id: import_zod3.z.string(),
@@ -494,14 +495,25 @@ var ToolSchema = import_zod3.z.object({
   params: import_zod3.z.record(import_zod3.z.string()),
   fn: import_zod3.z.function().args(import_zod3.z.any()).returns(import_zod3.z.any())
 });
+var UserQueryFiltersSchema = import_zod3.z.object({
+  username: import_zod3.z.string().optional(),
+  email: import_zod3.z.string().optional(),
+  role: import_zod3.z.string().optional(),
+  fullname: import_zod3.z.string().optional()
+});
 var UsersRequestPayloadSchema = import_zod3.z.object({
-  operation: import_zod3.z.enum(["create", "update", "delete", "getAll", "getOne"]),
+  operation: import_zod3.z.enum(["create", "update", "delete", "getAll", "getOne", "query"]),
   data: import_zod3.z.object({
+    id: import_zod3.z.number().optional(),
     username: import_zod3.z.string().optional(),
     email: import_zod3.z.string().email("Invalid email format").optional(),
     password: import_zod3.z.string().optional(),
     fullname: import_zod3.z.string().optional(),
-    role: import_zod3.z.string().optional()
+    role: import_zod3.z.string().optional(),
+    // Query operation fields
+    filters: UserQueryFiltersSchema.optional(),
+    limit: import_zod3.z.number().optional(),
+    sort: import_zod3.z.enum(["ASC", "DESC"]).optional()
   }).optional()
 });
 var UsersRequestMessageSchema = import_zod3.z.object({
@@ -538,11 +550,28 @@ var ActionsRequestMessageSchema = import_zod3.z.object({
   type: import_zod3.z.literal("ACTIONS"),
   payload: ActionsRequestPayloadSchema
 });
+var DashboardQueryFiltersSchema = import_zod3.z.object({
+  dashboardId: import_zod3.z.string().optional(),
+  projectId: import_zod3.z.string().optional(),
+  createdBy: import_zod3.z.number().optional(),
+  updatedBy: import_zod3.z.number().optional(),
+  name: import_zod3.z.string().optional()
+});
 var DashboardsRequestPayloadSchema = import_zod3.z.object({
-  operation: import_zod3.z.enum(["create", "update", "delete", "getAll", "getOne"]),
+  operation: import_zod3.z.enum(["create", "update", "delete", "getAll", "getOne", "query"]),
   data: import_zod3.z.object({
+    id: import_zod3.z.number().optional(),
     dashboardId: import_zod3.z.string().optional(),
-    dashboard: DSLRendererPropsSchema.optional()
+    projectId: import_zod3.z.string().optional(),
+    name: import_zod3.z.string().optional(),
+    description: import_zod3.z.string().optional(),
+    createdBy: import_zod3.z.number().optional(),
+    updatedBy: import_zod3.z.number().optional(),
+    dashboard: DSLRendererPropsSchema.optional(),
+    // Query operation fields
+    filters: DashboardQueryFiltersSchema.optional(),
+    limit: import_zod3.z.number().optional(),
+    sort: import_zod3.z.enum(["ASC", "DESC"]).optional()
   }).optional()
 });
 var DashboardsRequestMessageSchema = import_zod3.z.object({
@@ -551,11 +580,28 @@ var DashboardsRequestMessageSchema = import_zod3.z.object({
   type: import_zod3.z.literal("DASHBOARDS"),
   payload: DashboardsRequestPayloadSchema
 });
+var ReportQueryFiltersSchema = import_zod3.z.object({
+  reportId: import_zod3.z.string().optional(),
+  projectId: import_zod3.z.string().optional(),
+  createdBy: import_zod3.z.number().optional(),
+  updatedBy: import_zod3.z.number().optional(),
+  name: import_zod3.z.string().optional()
+});
 var ReportsRequestPayloadSchema = import_zod3.z.object({
-  operation: import_zod3.z.enum(["create", "update", "delete", "getAll", "getOne"]),
+  operation: import_zod3.z.enum(["create", "update", "delete", "getAll", "getOne", "query"]),
   data: import_zod3.z.object({
+    id: import_zod3.z.number().optional(),
     reportId: import_zod3.z.string().optional(),
-    report: DSLRendererPropsSchema2.optional()
+    projectId: import_zod3.z.string().optional(),
+    name: import_zod3.z.string().optional(),
+    description: import_zod3.z.string().optional(),
+    createdBy: import_zod3.z.number().optional(),
+    updatedBy: import_zod3.z.number().optional(),
+    report: DSLRendererPropsSchema2.optional(),
+    // Query operation fields
+    filters: ReportQueryFiltersSchema.optional(),
+    limit: import_zod3.z.number().optional(),
+    sort: import_zod3.z.enum(["ASC", "DESC"]).optional()
   }).optional()
 });
 var ReportsRequestMessageSchema = import_zod3.z.object({
@@ -564,6 +610,36 @@ var ReportsRequestMessageSchema = import_zod3.z.object({
   type: import_zod3.z.literal("REPORTS"),
   payload: ReportsRequestPayloadSchema
 });
+var UIQueryFiltersSchema = import_zod3.z.object({
+  uiId: import_zod3.z.string().optional(),
+  projectId: import_zod3.z.string().optional(),
+  createdBy: import_zod3.z.number().optional(),
+  updatedBy: import_zod3.z.number().optional(),
+  name: import_zod3.z.string().optional()
+});
+var UIsRequestPayloadSchema = import_zod3.z.object({
+  operation: import_zod3.z.enum(["create", "update", "delete", "getAll", "getOne", "query"]),
+  data: import_zod3.z.object({
+    id: import_zod3.z.number().optional(),
+    uiId: import_zod3.z.string().optional(),
+    projectId: import_zod3.z.string().optional(),
+    name: import_zod3.z.string().optional(),
+    description: import_zod3.z.string().optional(),
+    createdBy: import_zod3.z.number().optional(),
+    updatedBy: import_zod3.z.number().optional(),
+    ui: DSLRendererPropsSchema.optional(),
+    // Query operation fields
+    filters: UIQueryFiltersSchema.optional(),
+    limit: import_zod3.z.number().optional(),
+    sort: import_zod3.z.enum(["ASC", "DESC"]).optional()
+  }).optional()
+});
+var UIsRequestMessageSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  from: MessageParticipantSchema,
+  type: import_zod3.z.literal("UIS"),
+  payload: UIsRequestPayloadSchema
+});
 var UIBlockSchema = import_zod3.z.object({
   id: import_zod3.z.string().optional(),
   userQuestion: import_zod3.z.string().optional(),
@@ -587,20 +663,37 @@ var UIBlockSchema = import_zod3.z.object({
     similarity: import_zod3.z.number().optional()
   }).optional()
 });
+var DBUIBlockSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  component: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.any()).nullable(),
+  analysis: import_zod3.z.string().nullable(),
+  user_prompt: import_zod3.z.string()
+});
 var BookmarkDataSchema = import_zod3.z.object({
   id: import_zod3.z.number().optional(),
-  uiblock: import_zod3.z.any(),
-  // JSON object
+  uiblock: DBUIBlockSchema,
+  // Typed JSON object
   created_at: import_zod3.z.string().optional(),
   updated_at: import_zod3.z.string().optional()
 });
+var BookmarkQueryFiltersSchema = import_zod3.z.object({
+  userId: import_zod3.z.number().optional(),
+  threadId: import_zod3.z.string().optional(),
+  name: import_zod3.z.string().optional()
+});
 var BookmarksRequestPayloadSchema = import_zod3.z.object({
-  operation: import_zod3.z.enum(["create", "update", "delete", "getAll", "getOne", "getByUser", "getByThread"]),
+  operation: import_zod3.z.enum(["create", "update", "delete", "getAll", "getOne", "getByUser", "getByThread", "query"]),
   data: import_zod3.z.object({
     id: import_zod3.z.number().optional(),
     userId: import_zod3.z.number().optional(),
     threadId: import_zod3.z.string().optional(),
-    uiblock: import_zod3.z.any().optional()
+    name: import_zod3.z.string().optional(),
+    description: import_zod3.z.string().optional(),
+    uiblock: DBUIBlockSchema.optional(),
+    // Query operation fields
+    filters: BookmarkQueryFiltersSchema.optional(),
+    limit: import_zod3.z.number().optional(),
+    sort: import_zod3.z.enum(["ASC", "DESC"]).optional()
   }).optional()
 });
 var BookmarksRequestMessageSchema = import_zod3.z.object({
@@ -5626,12 +5719,13 @@ function sendDataResponse4(id, res, sendMessage, clientId) {
 }
 
 // src/handlers/user-prompt-suggestions.ts
-async function handleUserPromptSuggestions(data, components, sendMessage) {
+async function handleUserPromptSuggestions(data, components, sendMessage, collections, userId) {
   try {
     const request = UserPromptSuggestionsMessageSchema.parse(data);
     const { id, payload, from } = request;
     const { prompt, limit = 5 } = payload;
     const wsId = from.id;
+    logger.info(`[USER_PROMPT_SUGGESTIONS_REQ ${id}] Processing user prompt suggestions: ${prompt}`);
     if (!prompt || prompt.trim().length === 0) {
       sendResponse(id, {
         success: false,
@@ -5639,7 +5733,73 @@ async function handleUserPromptSuggestions(data, components, sendMessage) {
       }, sendMessage, wsId);
       return;
     }
+    const componentSearchHandler = collections?.["components"]?.["search"];
+    const bookmarkSearchHandler = collections?.["bookmarks"]?.["search"];
+    let componentSuggestions = [];
+    let bookmarkSuggestions = [];
+    let useEmbeddingSearch = false;
+    const searchPromises = [];
+    if (componentSearchHandler) {
+      searchPromises.push(
+        (async () => {
+          try {
+            logger.info("Using embedding-based search for components");
+            const result = await componentSearchHandler({ prompt, limit });
+            if (result.success && result.suggestions) {
+              componentSuggestions = result.suggestions.map((s) => ({
+                ...s,
+                suggestionType: "component"
+              }));
+              useEmbeddingSearch = true;
+              logger.info(`[USER_PROMPT_SUGGESTIONS_REQ ${id}] Found ${componentSuggestions.length} component suggestions`);
+            }
+          } catch (embeddingError) {
+            logger.warn("Component embedding search failed:", embeddingError);
+          }
+        })()
+      );
+    }
+    if (bookmarkSearchHandler && userId && userId !== "anonymous") {
+      searchPromises.push(
+        (async () => {
+          try {
+            logger.info(`Using embedding-based search for bookmarks (user: ${userId})`);
+            const result = await bookmarkSearchHandler({ prompt, userId, limit });
+            if (result.success && result.suggestions) {
+              bookmarkSuggestions = result.suggestions.map((s) => ({
+                ...s,
+                suggestionType: "bookmark"
+              }));
+              useEmbeddingSearch = true;
+              logger.info(`[USER_PROMPT_SUGGESTIONS_REQ ${id}] Found ${bookmarkSuggestions.length} bookmark suggestions`);
+            }
+          } catch (embeddingError) {
+            logger.warn("Bookmark embedding search failed:", embeddingError);
+          }
+        })()
+      );
+    }
+    if (searchPromises.length > 0) {
+      await Promise.all(searchPromises);
+    }
+    if (useEmbeddingSearch && (componentSuggestions.length > 0 || bookmarkSuggestions.length > 0)) {
+      const allSuggestions = [...componentSuggestions, ...bookmarkSuggestions].sort((a, b) => (b.similarity || 0) - (a.similarity || 0)).slice(0, limit);
+      logger.info(`[USER_PROMPT_SUGGESTIONS_REQ ${id}] Returning all suggestions: ${componentSuggestions.length} components, ${bookmarkSuggestions.length} bookmarks`);
+      sendResponse(id, {
+        success: true,
+        data: {
+          prompt,
+          suggestions: allSuggestions,
+          count: allSuggestions.length,
+          componentCount: componentSuggestions.length,
+          bookmarkCount: bookmarkSuggestions.length,
+          message: `Found ${allSuggestions.length} suggestions (${componentSuggestions.length} components, ${bookmarkSuggestions.length} bookmarks)`
+        }
+      }, sendMessage, wsId);
+      return;
+    }
     const displayComponents = components.filter((c) => c.isDisplayComp === true);
+    logger.info(`[USER_PROMPT_SUGGESTIONS_REQ ${id}] Using token-based approach. Display components: ${displayComponents.length}`);
     if (!displayComponents || displayComponents.length === 0) {
       sendResponse(id, {
         success: true,
@@ -5977,10 +6137,10 @@ function sendResponse2(id, res, sendMessage, clientId) {
 }
 
 // src/handlers/components-list-response.ts
-async function handleComponentListResponse(data, storeComponents) {
+async function handleComponentListResponse(data, storeComponents, collections) {
   try {
     const componentListResponse = ComponentListResponseMessageSchema.parse(data);
-    const { id, payload } = componentListResponse;
+    const { payload } = componentListResponse;
     const componentsList = payload.components;
     if (!componentsList) {
       logger.error("Components list not found in the response");
@@ -5988,6 +6148,20 @@ async function handleComponentListResponse(data, storeComponents) {
     }
     const components = ComponentsSchema.parse(componentsList);
     storeComponents(components);
+    const embedHandler = collections?.["components"]?.["embed"];
+    if (embedHandler) {
+      try {
+        logger.info("Embedding display components for semantic search...");
+        const result = await embedHandler({ components });
+        if (result.success) {
+          logger.info(`Successfully embedded ${result.count} display components`);
+        } else {
+          logger.warn("Failed to embed components:", result.error);
+        }
+      } catch (embedError) {
+        logger.warn("Failed to embed components:", embedError);
+      }
+    }
     return;
   } catch (error) {
     logger.error("Failed to handle user prompt request:", error);
@@ -5995,17 +6169,28 @@ async function handleComponentListResponse(data, storeComponents) {
 }
 
 // src/handlers/users.ts
-async function handleUsersRequest(data, sendMessage) {
+async function handleUsersRequest(data, collections, sendMessage) {
+  const executeCollection = async (collection, op, params) => {
+    const handler = collections[collection]?.[op];
+    if (!handler) {
+      return null;
+    }
+    return await handler(params);
+  };
   try {
     const request = UsersRequestMessageSchema.parse(data);
     const { id, payload, from } = request;
     const { operation, data: requestData } = payload;
+    const numericId = requestData?.id;
     const username = requestData?.username;
     const email = requestData?.email;
     const password = requestData?.password;
     const fullname = requestData?.fullname;
     const role = requestData?.role;
-    if (from.type !== "admin") {
+    const filters = requestData?.filters;
+    const limit = requestData?.limit;
+    const sort = requestData?.sort;
+    if (from.type !== "admin" && operation !== "getOne" && operation !== "getAll" && operation !== "query") {
       sendResponse3(id, {
         success: false,
         error: "Unauthorized: Only admin can manage users"
@@ -6016,19 +6201,22 @@ async function handleUsersRequest(data, sendMessage) {
     const userManager = getUserManager();
     switch (operation) {
       case "create":
-        await handleCreate(id, { username, email, password, fullname, role }, userManager, sendMessage, from.id);
+        await handleCreate(id, { username, email, password, fullname, role }, executeCollection, userManager, sendMessage, from.id);
         break;
       case "update":
-        await handleUpdate(id, { username, email, password, fullname, role }, userManager, sendMessage, from.id);
+        await handleUpdate(id, numericId, { username, email, password, fullname, role }, executeCollection, userManager, sendMessage, from.id);
         break;
       case "delete":
-        await handleDelete(id, username, userManager, sendMessage, from.id);
+        await handleDelete(id, numericId, username, executeCollection, userManager, sendMessage, from.id);
         break;
       case "getAll":
-        await handleGetAll(id, userManager, sendMessage, from.id);
+        await handleGetAll(id, executeCollection, userManager, sendMessage, from.id);
         break;
       case "getOne":
-        await handleGetOne(id, username, userManager, sendMessage, from.id);
+        await handleGetOne(id, numericId, username, executeCollection, userManager, sendMessage, from.id);
+        break;
+      case "query":
+        await handleQuery(id, filters, limit, sort, executeCollection, userManager, sendMessage, from.id);
         break;
       default:
         sendResponse3(id, {
@@ -6044,7 +6232,7 @@ async function handleUsersRequest(data, sendMessage) {
     }, sendMessage);
   }
 }
-async function handleCreate(id, userData, userManager, sendMessage, clientId) {
+async function handleCreate(id, userData, executeCollection, userManager, sendMessage, clientId) {
   const { username, email, password, fullname, role } = userData;
   if (!username || username.trim().length === 0) {
     sendResponse3(id, {
@@ -6070,52 +6258,121 @@ async function handleCreate(id, userData, userManager, sendMessage, clientId) {
       return;
     }
   }
-  if (userManager.userExists(username)) {
+  try {
+    const result = await executeCollection("users", "create", {
+      username,
+      email: email || void 0,
+      password,
+      fullname: fullname || void 0,
+      role: role || void 0
+    });
+    if (result && result.success) {
+      logger.info(`[DB] User created successfully: ${username}`);
+      sendResponse3(id, {
+        success: true,
+        data: {
+          id: result.data?.id,
+          username: result.data?.username,
+          email: result.data?.email,
+          fullname: result.data?.fullname,
+          role: result.data?.role,
+          message: `User '${username}' created successfully (DB)`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+  } catch (dbError) {
+    logger.warn(`[DB] Failed to create user, falling back to file storage: ${dbError instanceof Error ? dbError.message : "Unknown error"}`);
+  }
+  try {
+    if (userManager.userExists(username)) {
+      sendResponse3(id, {
+        success: false,
+        error: `User '${username}' already exists`
+      }, sendMessage, clientId);
+      return;
+    }
+    if (email && userManager.getUserByEmail(email)) {
+      sendResponse3(id, {
+        success: false,
+        error: `User with email '${email}' already exists`
+      }, sendMessage, clientId);
+      return;
+    }
+    const newUserData = {
+      username,
+      password
+    };
+    if (email && email.trim().length > 0) {
+      newUserData.email = email.trim();
+    }
+    if (fullname && fullname.trim().length > 0) {
+      newUserData.fullname = fullname.trim();
+    }
+    if (role && role.trim().length > 0) {
+      newUserData.role = role.trim();
+    }
+    const newUser = userManager.createUser(newUserData);
+    logger.info(`[FILE] User '${username}' created successfully`);
+    sendResponse3(id, {
+      success: true,
+      data: {
+        username: newUser.username,
+        email: newUser.email,
+        fullname: newUser.fullname,
+        role: newUser.role,
+        message: `User '${username}' created successfully (File)`
+      }
+    }, sendMessage, clientId);
+  } catch (error) {
     sendResponse3(id, {
       success: false,
-      error: `User '${username}' already exists`
+      error: error instanceof Error ? error.message : "Failed to create user"
     }, sendMessage, clientId);
-    return;
   }
-  if (email && userManager.getUserByEmail(email)) {
+}
+async function handleUpdate(id, numericId, userData, executeCollection, userManager, sendMessage, clientId) {
+  const { username, email, password, fullname, role } = userData;
+  if (!numericId && !username) {
     sendResponse3(id, {
       success: false,
-      error: `User with email '${email}' already exists`
+      error: "User ID or username is required"
     }, sendMessage, clientId);
     return;
   }
-  const newUserData = {
-    username,
-    password
-  };
-  if (email && email.trim().length > 0) {
-    newUserData.email = email.trim();
-  }
-  if (fullname && fullname.trim().length > 0) {
-    newUserData.fullname = fullname.trim();
-  }
-  if (role && role.trim().length > 0) {
-    newUserData.role = role.trim();
-  }
-  const newUser = userManager.createUser(newUserData);
-  logger.info(`User created by admin: ${username}${email ? ` (${email})` : ""}`);
-  sendResponse3(id, {
-    success: true,
-    data: {
-      username: newUser.username,
-      email: newUser.email,
-      fullname: newUser.fullname,
-      role: newUser.role,
-      message: `User '${username}' created successfully`
+  if (numericId) {
+    try {
+      const result = await executeCollection("users", "update", {
+        id: numericId,
+        username,
+        email,
+        password,
+        fullname,
+        role
+      });
+      if (result && result.success) {
+        logger.info(`[DB] User updated successfully, ID: ${numericId}`);
+        sendResponse3(id, {
+          success: true,
+          data: {
+            id: result.data?.id,
+            username: result.data?.username,
+            email: result.data?.email,
+            fullname: result.data?.fullname,
+            role: result.data?.role,
+            message: `User updated successfully (DB)`
+          }
+        }, sendMessage, clientId);
+        return;
+      }
+    } catch (dbError) {
+      logger.warn(`[DB] Failed to update user, falling back to file storage: ${dbError instanceof Error ? dbError.message : "Unknown error"}`);
     }
-  }, sendMessage, clientId);
-}
-async function handleUpdate(id, userData, userManager, sendMessage, clientId) {
-  const { username, email, password, fullname, role } = userData;
+  }
   if (!username || username.trim().length === 0) {
     sendResponse3(id, {
       success: false,
-      error: "Username is required and cannot be empty"
+      error: "Username is required for file-based storage update"
     }, sendMessage, clientId);
     return;
   }
@@ -6166,24 +6423,57 @@ async function handleUpdate(id, userData, userManager, sendMessage, clientId) {
     }, sendMessage, clientId);
     return;
   }
-  const updatedUser = userManager.updateUser(username, updates);
-  logger.info(`User updated by admin: ${username}`);
-  sendResponse3(id, {
-    success: true,
-    data: {
-      username: updatedUser.username,
-      email: updatedUser.email,
-      fullname: updatedUser.fullname,
-      role: updatedUser.role,
-      message: `User '${username}' updated successfully`
-    }
-  }, sendMessage, clientId);
+  try {
+    const updatedUser = userManager.updateUser(username, updates);
+    logger.info(`[FILE] User '${username}' updated successfully`);
+    sendResponse3(id, {
+      success: true,
+      data: {
+        username: updatedUser.username,
+        email: updatedUser.email,
+        fullname: updatedUser.fullname,
+        role: updatedUser.role,
+        message: `User '${username}' updated successfully (File)`
+      }
+    }, sendMessage, clientId);
+  } catch (error) {
+    sendResponse3(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to update user"
+    }, sendMessage, clientId);
+  }
 }
-async function handleDelete(id, username, userManager, sendMessage, clientId) {
+async function handleDelete(id, numericId, username, executeCollection, userManager, sendMessage, clientId) {
+  if (!numericId && !username) {
+    sendResponse3(id, {
+      success: false,
+      error: "User ID or username is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  if (numericId) {
+    try {
+      const result = await executeCollection("users", "delete", { id: numericId });
+      if (result && result.success) {
+        logger.info(`[DB] User deleted successfully, ID: ${numericId}`);
+        sendResponse3(id, {
+          success: true,
+          data: {
+            id: numericId,
+            username: result.data?.username,
+            message: `User deleted successfully (DB)`
+          }
+        }, sendMessage, clientId);
+        return;
+      }
+    } catch (dbError) {
+      logger.warn(`[DB] Failed to delete user, falling back to file storage: ${dbError instanceof Error ? dbError.message : "Unknown error"}`);
+    }
+  }
   if (!username || username.trim().length === 0) {
     sendResponse3(id, {
       success: false,
-      error: "Username is required and cannot be empty"
+      error: "Username is required for file-based storage delete"
     }, sendMessage, clientId);
     return;
   }
@@ -6202,16 +6492,42 @@ async function handleDelete(id, username, userManager, sendMessage, clientId) {
     }, sendMessage, clientId);
     return;
   }
-  logger.info(`User deleted by admin: ${username}`);
+  logger.info(`[FILE] User '${username}' deleted successfully`);
   sendResponse3(id, {
     success: true,
     data: {
       username,
-      message: `User '${username}' deleted successfully`
+      message: `User '${username}' deleted successfully (File)`
     }
   }, sendMessage, clientId);
 }
-async function handleGetAll(id, userManager, sendMessage, clientId) {
+async function handleGetAll(id, executeCollection, userManager, sendMessage, clientId) {
+  try {
+    const result = await executeCollection("users", "getAll", {});
+    if (result && result.success) {
+      const sanitizedUsers2 = result.data.map((user) => ({
+        id: user.id,
+        username: user.username,
+        email: user.email,
+        fullname: user.fullname,
+        role: user.role,
+        createdAt: user.createdAt,
+        updatedAt: user.updatedAt
+      }));
+      logger.info(`[DB] Retrieved ${result.count} users`);
+      sendResponse3(id, {
+        success: true,
+        data: {
+          users: sanitizedUsers2,
+          count: result.count,
+          message: `Retrieved ${result.count} users (DB)`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+  } catch (dbError) {
+    logger.warn(`[DB] Failed to get all users, falling back to file storage: ${dbError instanceof Error ? dbError.message : "Unknown error"}`);
+  }
   const users = userManager.getAllUsers();
   const sanitizedUsers = users.map((user) => ({
     username: user.username,
@@ -6220,21 +6536,55 @@ async function handleGetAll(id, userManager, sendMessage, clientId) {
     role: user.role,
     wsIds: user.wsIds || []
   }));
-  logger.info(`Admin retrieved all users (count: ${sanitizedUsers.length})`);
+  logger.info(`[FILE] Retrieved ${sanitizedUsers.length} users`);
   sendResponse3(id, {
     success: true,
     data: {
       users: sanitizedUsers,
       count: sanitizedUsers.length,
-      message: `Retrieved ${sanitizedUsers.length} users`
+      message: `Retrieved ${sanitizedUsers.length} users (File)`
     }
   }, sendMessage, clientId);
 }
-async function handleGetOne(id, username, userManager, sendMessage, clientId) {
+async function handleGetOne(id, numericId, username, executeCollection, userManager, sendMessage, clientId) {
+  if (!numericId && !username) {
+    sendResponse3(id, {
+      success: false,
+      error: "User ID or username is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  if (numericId) {
+    try {
+      const result = await executeCollection("users", "getOne", { id: numericId });
+      if (result && result.success) {
+        const sanitizedUser2 = {
+          id: result.data?.id,
+          username: result.data?.username,
+          email: result.data?.email,
+          fullname: result.data?.fullname,
+          role: result.data?.role,
+          createdAt: result.data?.createdAt,
+          updatedAt: result.data?.updatedAt
+        };
+        logger.info(`[DB] Retrieved user ID: ${numericId}`);
+        sendResponse3(id, {
+          success: true,
+          data: {
+            user: sanitizedUser2,
+            message: `Retrieved user (DB)`
+          }
+        }, sendMessage, clientId);
+        return;
+      }
+    } catch (dbError) {
+      logger.warn(`[DB] Failed to get user, falling back to file storage: ${dbError instanceof Error ? dbError.message : "Unknown error"}`);
+    }
+  }
   if (!username || username.trim().length === 0) {
     sendResponse3(id, {
       success: false,
-      error: "Username is required and cannot be empty"
+      error: "Username is required for file-based storage lookup"
     }, sendMessage, clientId);
     return;
   }
@@ -6253,12 +6603,61 @@ async function handleGetOne(id, username, userManager, sendMessage, clientId) {
     role: user.role,
     wsIds: user.wsIds || []
   };
-  logger.info(`Admin retrieved user: ${username}`);
+  logger.info(`[FILE] Retrieved user: ${username}`);
   sendResponse3(id, {
     success: true,
     data: {
       user: sanitizedUser,
-      message: `Retrieved user '${username}'`
+      message: `Retrieved user '${username}' (File)`
+    }
+  }, sendMessage, clientId);
+}
+async function handleQuery(id, filters, limit, sort, executeCollection, userManager, sendMessage, clientId) {
+  try {
+    const result = await executeCollection("users", "query", {
+      filters: filters || {},
+      limit,
+      sort
+    });
+    if (result && result.success) {
+      const sanitizedUsers2 = result.data.map((user) => ({
+        id: user.id,
+        username: user.username,
+        email: user.email,
+        fullname: user.fullname,
+        role: user.role,
+        createdAt: user.createdAt,
+        updatedAt: user.updatedAt
+      }));
+      logger.info(`[DB] Query returned ${result.count} users`);
+      sendResponse3(id, {
+        success: true,
+        data: {
+          users: sanitizedUsers2,
+          count: result.count,
+          message: `Query returned ${result.count} users (DB)`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+  } catch (dbError) {
+    logger.warn(`[DB] Failed to query users: ${dbError instanceof Error ? dbError.message : "Unknown error"}`);
+  }
+  const users = userManager.getAllUsers();
+  const sanitizedUsers = users.map((user) => ({
+    username: user.username,
+    email: user.email,
+    fullname: user.fullname,
+    role: user.role,
+    wsIds: user.wsIds || []
+  }));
+  logger.info(`[FILE] Retrieved ${sanitizedUsers.length} users (all - no query filter)`);
+  sendResponse3(id, {
+    success: true,
+    data: {
+      users: sanitizedUsers,
+      count: sanitizedUsers.length,
+      message: `Retrieved ${sanitizedUsers.length} users (File - no query filter)`
     }
   }, sendMessage, clientId);
 }
@@ -6292,13 +6691,29 @@ function getDashboardManager() {
 }
 
 // src/handlers/dashboards.ts
-async function handleDashboardsRequest(data, sendMessage) {
+async function handleDashboardsRequest(data, collections, sendMessage) {
+  const executeCollection = async (collection, op, params) => {
+    const handler = collections[collection]?.[op];
+    if (!handler) {
+      return null;
+    }
+    return await handler(params);
+  };
   try {
     const request = DashboardsRequestMessageSchema.parse(data);
     const { id, payload, from } = request;
     const { operation, data: requestData } = payload;
     const dashboardId = requestData?.dashboardId;
     const dashboard = requestData?.dashboard;
+    const projectId = requestData?.projectId;
+    const name = requestData?.name;
+    const description = requestData?.description;
+    const createdBy = requestData?.createdBy;
+    const updatedBy = requestData?.updatedBy;
+    const numericId = requestData?.id;
+    const filters = requestData?.filters;
+    const limit = requestData?.limit;
+    const sort = requestData?.sort;
     if (from.type !== "admin") {
       sendResponse4(id, {
         success: false,
@@ -6310,19 +6725,22 @@ async function handleDashboardsRequest(data, sendMessage) {
     const dashboardManager2 = getDashboardManager();
     switch (operation) {
       case "create":
-        await handleCreate2(id, dashboardId, dashboard, dashboardManager2, sendMessage, from.id);
+        await handleCreate2(id, dashboardId, dashboard, projectId, name, description, createdBy, executeCollection, dashboardManager2, sendMessage, from.id);
         break;
       case "update":
-        await handleUpdate2(id, dashboardId, dashboard, dashboardManager2, sendMessage, from.id);
+        await handleUpdate2(id, numericId, dashboardId, dashboard, name, description, updatedBy, executeCollection, dashboardManager2, sendMessage, from.id);
         break;
       case "delete":
-        await handleDelete2(id, dashboardId, dashboardManager2, sendMessage, from.id);
+        await handleDelete2(id, numericId, dashboardId, executeCollection, dashboardManager2, sendMessage, from.id);
         break;
       case "getAll":
-        await handleGetAll2(id, dashboardManager2, sendMessage, from.id);
+        await handleGetAll2(id, executeCollection, dashboardManager2, sendMessage, from.id);
         break;
       case "getOne":
-        await handleGetOne2(id, dashboardId, dashboardManager2, sendMessage, from.id);
+        await handleGetOne2(id, numericId, dashboardId, executeCollection, dashboardManager2, sendMessage, from.id);
+        break;
+      case "query":
+        await handleQuery2(id, filters, limit, sort, executeCollection, dashboardManager2, sendMessage, from.id);
         break;
       default:
         sendResponse4(id, {
@@ -6338,7 +6756,7 @@ async function handleDashboardsRequest(data, sendMessage) {
     }, sendMessage);
   }
 }
-async function handleCreate2(id, dashboardId, dashboard, dashboardManager2, sendMessage, clientId) {
+async function handleCreate2(id, dashboardId, dashboard, projectId, name, description, createdBy, executeCollection, dashboardManager2, sendMessage, clientId) {
   if (!dashboardId || dashboardId.trim().length === 0) {
     sendResponse4(id, {
       success: false,
@@ -6346,21 +6764,50 @@ async function handleCreate2(id, dashboardId, dashboard, dashboardManager2, send
     }, sendMessage, clientId);
     return;
   }
-  if (!dashboard) {
+  if (!projectId) {
     sendResponse4(id, {
       success: false,
-      error: "Dashboard data is required"
+      error: "Project ID is required"
     }, sendMessage, clientId);
     return;
   }
   try {
+    const result = await executeCollection("dashboards", "create", {
+      dashboardId,
+      projectId,
+      name: name || "",
+      description,
+      dashboard,
+      createdBy
+    });
+    if (result && result.success) {
+      logger.info(`[DB] Dashboard created successfully, ID: ${result.data?.id}`);
+      sendResponse4(id, {
+        success: true,
+        data: {
+          id: result.data?.id,
+          dashboardId: result.data?.dashboardId,
+          dashboard: result.data?.dashboard || dashboard,
+          message: `Dashboard created successfully (DB)`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+  } catch (dbError) {
+    logger.warn(`[DB] Failed to create dashboard, falling back to file storage: ${dbError instanceof Error ? dbError.message : "Unknown error"}`);
+  }
+  try {
+    if (!dashboard) {
+      dashboard = {};
+    }
     const createdDashboard = dashboardManager2.createDashboard(dashboardId, dashboard);
+    logger.info(`[FILE] Dashboard '${dashboardId}' created successfully`);
     sendResponse4(id, {
       success: true,
       data: {
         dashboardId,
         dashboard: createdDashboard,
-        message: `Dashboard '${dashboardId}' created successfully`
+        message: `Dashboard '${dashboardId}' created successfully (File)`
       }
     }, sendMessage, clientId);
   } catch (error) {
@@ -6370,36 +6817,56 @@ async function handleCreate2(id, dashboardId, dashboard, dashboardManager2, send
     }, sendMessage, clientId);
   }
 }
-async function handleUpdate2(id, dashboardId, dashboard, dashboardManager2, sendMessage, clientId) {
-  if (!dashboardId || dashboardId.trim().length === 0) {
+async function handleUpdate2(id, numericId, dashboardId, dashboard, name, description, updatedBy, executeCollection, dashboardManager2, sendMessage, clientId) {
+  if (!numericId) {
     sendResponse4(id, {
       success: false,
-      error: "Dashboard ID is required and cannot be empty"
+      error: "Dashboard ID is required"
     }, sendMessage, clientId);
     return;
   }
-  if (!dashboard) {
-    sendResponse4(id, {
-      success: false,
-      error: "Dashboard data is required"
-    }, sendMessage, clientId);
-    return;
+  try {
+    const result = await executeCollection("dashboards", "update", {
+      id: numericId,
+      name,
+      description,
+      dashboard,
+      updatedBy
+    });
+    if (result && result.success) {
+      logger.info(`[DB] Dashboard updated successfully, ID: ${numericId}`);
+      sendResponse4(id, {
+        success: true,
+        data: {
+          id: numericId,
+          dashboardId: result.data?.dashboardId,
+          dashboard: result.data?.dashboard || dashboard,
+          message: `Dashboard updated successfully (DB)`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+  } catch (dbError) {
+    logger.warn(`[DB] Failed to update dashboard, falling back to file storage: ${dbError instanceof Error ? dbError.message : "Unknown error"}`);
   }
+  const fileStorageId = dashboardId || String(numericId);
   try {
-    const updatedDashboard = dashboardManager2.updateDashboard(dashboardId, dashboard);
+    const updatedDashboard = dashboardManager2.updateDashboard(fileStorageId, dashboard);
     if (!updatedDashboard) {
       sendResponse4(id, {
         success: false,
-        error: `Dashboard '${dashboardId}' not found`
+        error: `Dashboard '${fileStorageId}' not found`
       }, sendMessage, clientId);
       return;
     }
+    logger.info(`[FILE] Dashboard '${fileStorageId}' updated successfully`);
     sendResponse4(id, {
       success: true,
       data: {
-        dashboardId,
+        id: numericId,
+        dashboardId: fileStorageId,
         dashboard: updatedDashboard,
-        message: `Dashboard '${dashboardId}' updated successfully`
+        message: `Dashboard '${fileStorageId}' updated successfully (File)`
       }
     }, sendMessage, clientId);
   } catch (error) {
@@ -6409,65 +6876,154 @@ async function handleUpdate2(id, dashboardId, dashboard, dashboardManager2, send
     }, sendMessage, clientId);
   }
 }
-async function handleDelete2(id, dashboardId, dashboardManager2, sendMessage, clientId) {
-  if (!dashboardId || dashboardId.trim().length === 0) {
+async function handleDelete2(id, numericId, dashboardId, executeCollection, dashboardManager2, sendMessage, clientId) {
+  if (!numericId) {
     sendResponse4(id, {
       success: false,
-      error: "Dashboard ID is required and cannot be empty"
+      error: "Dashboard ID is required"
     }, sendMessage, clientId);
     return;
   }
-  const deleted = dashboardManager2.deleteDashboard(dashboardId);
+  try {
+    const result = await executeCollection("dashboards", "delete", { id: numericId });
+    if (result && result.success) {
+      logger.info(`[DB] Dashboard deleted successfully, ID: ${numericId}`);
+      sendResponse4(id, {
+        success: true,
+        data: {
+          id: numericId,
+          message: `Dashboard deleted successfully (DB)`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+  } catch (dbError) {
+    logger.warn(`[DB] Failed to delete dashboard, falling back to file storage: ${dbError instanceof Error ? dbError.message : "Unknown error"}`);
+  }
+  const fileStorageId = dashboardId || String(numericId);
+  const deleted = dashboardManager2.deleteDashboard(fileStorageId);
   if (!deleted) {
     sendResponse4(id, {
       success: false,
-      error: `Dashboard '${dashboardId}' not found`
+      error: `Dashboard '${fileStorageId}' not found`
     }, sendMessage, clientId);
     return;
   }
+  logger.info(`[FILE] Dashboard '${fileStorageId}' deleted successfully`);
   sendResponse4(id, {
     success: true,
     data: {
-      dashboardId,
-      message: `Dashboard '${dashboardId}' deleted successfully`
+      id: numericId,
+      dashboardId: fileStorageId,
+      message: `Dashboard '${fileStorageId}' deleted successfully (File)`
     }
   }, sendMessage, clientId);
 }
-async function handleGetAll2(id, dashboardManager2, sendMessage, clientId) {
-  const dashboards = dashboardManager2.getAllDashboards();
-  logger.info(`Admin retrieved all dashboards (count: ${dashboards.length})`);
-  sendResponse4(id, {
-    success: true,
-    data: {
-      dashboards,
-      count: dashboards.length,
-      message: `Retrieved ${dashboards.length} dashboards`
-    }
+async function handleGetAll2(id, executeCollection, dashboardManager2, sendMessage, clientId) {
+  try {
+    const result = await executeCollection("dashboards", "getAll", {});
+    if (result && result.success) {
+      logger.info(`[DB] Retrieved ${result.count} dashboards`);
+      sendResponse4(id, {
+        success: true,
+        data: {
+          dashboards: result.data,
+          count: result.count,
+          message: `Retrieved ${result.count} dashboards (DB)`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+  } catch (dbError) {
+    logger.warn(`[DB] Failed to get all dashboards, falling back to file storage: ${dbError instanceof Error ? dbError.message : "Unknown error"}`);
+  }
+  const dashboards = dashboardManager2.getAllDashboards();
+  logger.info(`[FILE] Retrieved ${dashboards.length} dashboards`);
+  sendResponse4(id, {
+    success: true,
+    data: {
+      dashboards,
+      count: dashboards.length,
+      message: `Retrieved ${dashboards.length} dashboards (File)`
+    }
   }, sendMessage, clientId);
 }
-async function handleGetOne2(id, dashboardId, dashboardManager2, sendMessage, clientId) {
-  if (!dashboardId || dashboardId.trim().length === 0) {
+async function handleGetOne2(id, numericId, dashboardId, executeCollection, dashboardManager2, sendMessage, clientId) {
+  if (!numericId) {
     sendResponse4(id, {
       success: false,
-      error: "Dashboard ID is required and cannot be empty"
+      error: "Dashboard ID is required"
     }, sendMessage, clientId);
     return;
   }
-  const dashboard = dashboardManager2.getDashboard(dashboardId);
+  try {
+    const result = await executeCollection("dashboards", "getOne", { id: numericId });
+    if (result && result.success) {
+      logger.info(`[DB] Retrieved dashboard ID: ${numericId}`);
+      sendResponse4(id, {
+        success: true,
+        data: {
+          id: numericId,
+          dashboardId: result.data?.dashboardId,
+          dashboard: result.data?.dashboard || result.data,
+          message: `Retrieved dashboard (DB)`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+  } catch (dbError) {
+    logger.warn(`[DB] Failed to get dashboard, falling back to file storage: ${dbError instanceof Error ? dbError.message : "Unknown error"}`);
+  }
+  const fileStorageId = dashboardId || String(numericId);
+  const dashboard = dashboardManager2.getDashboard(fileStorageId);
   if (!dashboard) {
     sendResponse4(id, {
       success: false,
-      error: `Dashboard '${dashboardId}' not found`
+      error: `Dashboard '${fileStorageId}' not found`
     }, sendMessage, clientId);
     return;
   }
-  logger.info(`Admin retrieved dashboard: ${dashboardId}`);
+  logger.info(`[FILE] Retrieved dashboard: ${fileStorageId}`);
   sendResponse4(id, {
     success: true,
     data: {
-      dashboardId,
+      id: numericId,
+      dashboardId: fileStorageId,
       dashboard,
-      message: `Retrieved dashboard '${dashboardId}'`
+      message: `Retrieved dashboard '${fileStorageId}' (File)`
+    }
+  }, sendMessage, clientId);
+}
+async function handleQuery2(id, filters, limit, sort, executeCollection, dashboardManager2, sendMessage, clientId) {
+  try {
+    const result = await executeCollection("dashboards", "query", {
+      filters: filters || {},
+      limit,
+      sort
+    });
+    if (result && result.success) {
+      logger.info(`[DB] Query returned ${result.count} dashboards`);
+      sendResponse4(id, {
+        success: true,
+        data: {
+          dashboards: result.data,
+          count: result.count,
+          message: `Query returned ${result.count} dashboards (DB)`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+  } catch (dbError) {
+    logger.warn(`[DB] Failed to query dashboards: ${dbError instanceof Error ? dbError.message : "Unknown error"}`);
+  }
+  const dashboards = dashboardManager2.getAllDashboards();
+  logger.info(`[FILE] Retrieved ${dashboards.length} dashboards (all - no query filter)`);
+  sendResponse4(id, {
+    success: true,
+    data: {
+      dashboards,
+      count: dashboards.length,
+      message: `Retrieved ${dashboards.length} dashboards (File - no query filter)`
     }
   }, sendMessage, clientId);
 }
@@ -6500,13 +7056,29 @@ function setReportManager(manager) {
 }
 
 // src/handlers/reports.ts
-async function handleReportsRequest(data, sendMessage) {
+async function handleReportsRequest(data, collections, sendMessage) {
+  const executeCollection = async (collection, op, params) => {
+    const handler = collections[collection]?.[op];
+    if (!handler) {
+      return null;
+    }
+    return await handler(params);
+  };
   try {
     const request = ReportsRequestMessageSchema.parse(data);
     const { id, payload, from } = request;
     const { operation, data: requestData } = payload;
     const reportId = requestData?.reportId;
     const report = requestData?.report;
+    const projectId = requestData?.projectId;
+    const name = requestData?.name;
+    const description = requestData?.description;
+    const createdBy = requestData?.createdBy;
+    const updatedBy = requestData?.updatedBy;
+    const numericId = requestData?.id;
+    const filters = requestData?.filters;
+    const limit = requestData?.limit;
+    const sort = requestData?.sort;
     if (from.type !== "admin") {
       sendResponse5(id, {
         success: false,
@@ -6518,19 +7090,22 @@ async function handleReportsRequest(data, sendMessage) {
     const reportManager2 = getReportManager();
     switch (operation) {
       case "create":
-        await handleCreate3(id, reportId, report, reportManager2, sendMessage, from.id);
+        await handleCreate3(id, reportId, report, projectId, name, description, createdBy, executeCollection, reportManager2, sendMessage, from.id);
         break;
       case "update":
-        await handleUpdate3(id, reportId, report, reportManager2, sendMessage, from.id);
+        await handleUpdate3(id, numericId, reportId, report, name, description, updatedBy, executeCollection, reportManager2, sendMessage, from.id);
         break;
       case "delete":
-        await handleDelete3(id, reportId, reportManager2, sendMessage, from.id);
+        await handleDelete3(id, numericId, reportId, executeCollection, reportManager2, sendMessage, from.id);
         break;
       case "getAll":
-        await handleGetAll3(id, reportManager2, sendMessage, from.id);
+        await handleGetAll3(id, executeCollection, reportManager2, sendMessage, from.id);
         break;
       case "getOne":
-        await handleGetOne3(id, reportId, reportManager2, sendMessage, from.id);
+        await handleGetOne3(id, numericId, reportId, executeCollection, reportManager2, sendMessage, from.id);
+        break;
+      case "query":
+        await handleQuery3(id, filters, limit, sort, executeCollection, reportManager2, sendMessage, from.id);
         break;
       default:
         sendResponse5(id, {
@@ -6546,7 +7121,7 @@ async function handleReportsRequest(data, sendMessage) {
     }, sendMessage);
   }
 }
-async function handleCreate3(id, reportId, report, reportManager2, sendMessage, clientId) {
+async function handleCreate3(id, reportId, report, projectId, name, description, createdBy, executeCollection, reportManager2, sendMessage, clientId) {
   if (!reportId || reportId.trim().length === 0) {
     sendResponse5(id, {
       success: false,
@@ -6554,21 +7129,50 @@ async function handleCreate3(id, reportId, report, reportManager2, sendMessage,
     }, sendMessage, clientId);
     return;
   }
-  if (!report) {
+  if (!projectId) {
     sendResponse5(id, {
       success: false,
-      error: "Report data is required"
+      error: "Project ID is required"
     }, sendMessage, clientId);
     return;
   }
   try {
+    const result = await executeCollection("reports", "create", {
+      reportId,
+      projectId,
+      name: name || "",
+      description,
+      report,
+      createdBy
+    });
+    if (result && result.success) {
+      logger.info(`[DB] Report created successfully, ID: ${result.data?.id}`);
+      sendResponse5(id, {
+        success: true,
+        data: {
+          id: result.data?.id,
+          reportId: result.data?.reportId,
+          report: result.data?.report || report,
+          message: `Report created successfully (DB)`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+  } catch (dbError) {
+    logger.warn(`[DB] Failed to create report, falling back to file storage: ${dbError instanceof Error ? dbError.message : "Unknown error"}`);
+  }
+  try {
+    if (!report) {
+      report = {};
+    }
     const createdReport = reportManager2.createReport(reportId, report);
+    logger.info(`[FILE] Report '${reportId}' created successfully`);
     sendResponse5(id, {
       success: true,
       data: {
         reportId,
         report: createdReport,
-        message: `Report '${reportId}' created successfully`
+        message: `Report '${reportId}' created successfully (File)`
       }
     }, sendMessage, clientId);
   } catch (error) {
@@ -6578,36 +7182,56 @@ async function handleCreate3(id, reportId, report, reportManager2, sendMessage,
     }, sendMessage, clientId);
   }
 }
-async function handleUpdate3(id, reportId, report, reportManager2, sendMessage, clientId) {
-  if (!reportId || reportId.trim().length === 0) {
+async function handleUpdate3(id, numericId, reportId, report, name, description, updatedBy, executeCollection, reportManager2, sendMessage, clientId) {
+  if (!numericId) {
     sendResponse5(id, {
       success: false,
-      error: "Report ID is required and cannot be empty"
+      error: "Report ID is required"
     }, sendMessage, clientId);
     return;
   }
-  if (!report) {
-    sendResponse5(id, {
-      success: false,
-      error: "Report data is required"
-    }, sendMessage, clientId);
-    return;
+  try {
+    const result = await executeCollection("reports", "update", {
+      id: numericId,
+      name,
+      description,
+      report,
+      updatedBy
+    });
+    if (result && result.success) {
+      logger.info(`[DB] Report updated successfully, ID: ${numericId}`);
+      sendResponse5(id, {
+        success: true,
+        data: {
+          id: numericId,
+          reportId: result.data?.reportId,
+          report: result.data?.report || report,
+          message: `Report updated successfully (DB)`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+  } catch (dbError) {
+    logger.warn(`[DB] Failed to update report, falling back to file storage: ${dbError instanceof Error ? dbError.message : "Unknown error"}`);
   }
+  const fileStorageId = reportId || String(numericId);
   try {
-    const updatedReport = reportManager2.updateReport(reportId, report);
+    const updatedReport = reportManager2.updateReport(fileStorageId, report);
     if (!updatedReport) {
       sendResponse5(id, {
         success: false,
-        error: `Report '${reportId}' not found`
+        error: `Report '${fileStorageId}' not found`
       }, sendMessage, clientId);
       return;
     }
+    logger.info(`[FILE] Report '${fileStorageId}' updated successfully`);
     sendResponse5(id, {
       success: true,
       data: {
-        reportId,
+        id: numericId,
+        reportId: fileStorageId,
         report: updatedReport,
-        message: `Report '${reportId}' updated successfully`
+        message: `Report '${fileStorageId}' updated successfully (File)`
       }
     }, sendMessage, clientId);
   } catch (error) {
@@ -6617,65 +7241,154 @@ async function handleUpdate3(id, reportId, report, reportManager2, sendMessage,
     }, sendMessage, clientId);
   }
 }
-async function handleDelete3(id, reportId, reportManager2, sendMessage, clientId) {
-  if (!reportId || reportId.trim().length === 0) {
+async function handleDelete3(id, numericId, reportId, executeCollection, reportManager2, sendMessage, clientId) {
+  if (!numericId) {
     sendResponse5(id, {
       success: false,
-      error: "Report ID is required and cannot be empty"
+      error: "Report ID is required"
     }, sendMessage, clientId);
     return;
   }
-  const deleted = reportManager2.deleteReport(reportId);
+  try {
+    const result = await executeCollection("reports", "delete", { id: numericId });
+    if (result && result.success) {
+      logger.info(`[DB] Report deleted successfully, ID: ${numericId}`);
+      sendResponse5(id, {
+        success: true,
+        data: {
+          id: numericId,
+          message: `Report deleted successfully (DB)`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+  } catch (dbError) {
+    logger.warn(`[DB] Failed to delete report, falling back to file storage: ${dbError instanceof Error ? dbError.message : "Unknown error"}`);
+  }
+  const fileStorageId = reportId || String(numericId);
+  const deleted = reportManager2.deleteReport(fileStorageId);
   if (!deleted) {
     sendResponse5(id, {
       success: false,
-      error: `Report '${reportId}' not found`
+      error: `Report '${fileStorageId}' not found`
     }, sendMessage, clientId);
     return;
   }
+  logger.info(`[FILE] Report '${fileStorageId}' deleted successfully`);
   sendResponse5(id, {
     success: true,
     data: {
-      reportId,
-      message: `Report '${reportId}' deleted successfully`
+      id: numericId,
+      reportId: fileStorageId,
+      message: `Report '${fileStorageId}' deleted successfully (File)`
     }
   }, sendMessage, clientId);
 }
-async function handleGetAll3(id, reportManager2, sendMessage, clientId) {
+async function handleGetAll3(id, executeCollection, reportManager2, sendMessage, clientId) {
+  try {
+    const result = await executeCollection("reports", "getAll", {});
+    if (result && result.success) {
+      logger.info(`[DB] Retrieved ${result.count} reports`);
+      sendResponse5(id, {
+        success: true,
+        data: {
+          reports: result.data,
+          count: result.count,
+          message: `Retrieved ${result.count} reports (DB)`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+  } catch (dbError) {
+    logger.warn(`[DB] Failed to get all reports, falling back to file storage: ${dbError instanceof Error ? dbError.message : "Unknown error"}`);
+  }
   const reports = reportManager2.getAllReports();
-  logger.info(`Admin retrieved all reports (count: ${reports.length})`);
+  logger.info(`[FILE] Retrieved ${reports.length} reports`);
   sendResponse5(id, {
     success: true,
     data: {
       reports,
       count: reports.length,
-      message: `Retrieved ${reports.length} reports`
+      message: `Retrieved ${reports.length} reports (File)`
     }
   }, sendMessage, clientId);
 }
-async function handleGetOne3(id, reportId, reportManager2, sendMessage, clientId) {
-  if (!reportId || reportId.trim().length === 0) {
+async function handleGetOne3(id, numericId, reportId, executeCollection, reportManager2, sendMessage, clientId) {
+  if (!numericId) {
     sendResponse5(id, {
       success: false,
-      error: "Report ID is required and cannot be empty"
+      error: "Report ID is required"
     }, sendMessage, clientId);
     return;
   }
-  const report = reportManager2.getReport(reportId);
+  try {
+    const result = await executeCollection("reports", "getOne", { id: numericId });
+    if (result && result.success) {
+      logger.info(`[DB] Retrieved report ID: ${numericId}`);
+      sendResponse5(id, {
+        success: true,
+        data: {
+          id: numericId,
+          reportId: result.data?.reportId,
+          report: result.data?.report || result.data,
+          message: `Retrieved report (DB)`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+  } catch (dbError) {
+    logger.warn(`[DB] Failed to get report, falling back to file storage: ${dbError instanceof Error ? dbError.message : "Unknown error"}`);
+  }
+  const fileStorageId = reportId || String(numericId);
+  const report = reportManager2.getReport(fileStorageId);
   if (!report) {
     sendResponse5(id, {
       success: false,
-      error: `Report '${reportId}' not found`
+      error: `Report '${fileStorageId}' not found`
     }, sendMessage, clientId);
     return;
   }
-  logger.info(`Admin retrieved report: ${reportId}`);
+  logger.info(`[FILE] Retrieved report: ${fileStorageId}`);
   sendResponse5(id, {
     success: true,
     data: {
-      reportId,
+      id: numericId,
+      reportId: fileStorageId,
       report,
-      message: `Retrieved report '${reportId}'`
+      message: `Retrieved report '${fileStorageId}' (File)`
+    }
+  }, sendMessage, clientId);
+}
+async function handleQuery3(id, filters, limit, sort, executeCollection, reportManager2, sendMessage, clientId) {
+  try {
+    const result = await executeCollection("reports", "query", {
+      filters: filters || {},
+      limit,
+      sort
+    });
+    if (result && result.success) {
+      logger.info(`[DB] Query returned ${result.count} reports`);
+      sendResponse5(id, {
+        success: true,
+        data: {
+          reports: result.data,
+          count: result.count,
+          message: `Query returned ${result.count} reports (DB)`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+  } catch (dbError) {
+    logger.warn(`[DB] Failed to query reports: ${dbError instanceof Error ? dbError.message : "Unknown error"}`);
+  }
+  const reports = reportManager2.getAllReports();
+  logger.info(`[FILE] Retrieved ${reports.length} reports (all - no query filter)`);
+  sendResponse5(id, {
+    success: true,
+    data: {
+      reports,
+      count: reports.length,
+      message: `Retrieved ${reports.length} reports (File - no query filter)`
     }
   }, sendMessage, clientId);
 }
@@ -6695,6 +7408,297 @@ function sendResponse5(id, res, sendMessage, clientId) {
   sendMessage(response);
 }
 
+// src/handlers/uis.ts
+async function handleUIsRequest(data, collections, sendMessage) {
+  const executeCollection = async (collection, op, params) => {
+    const handler = collections[collection]?.[op];
+    if (!handler) {
+      throw new Error(`Collection handler not found: ${collection}.${op}`);
+    }
+    return await handler(params);
+  };
+  try {
+    const request = UIsRequestMessageSchema.parse(data);
+    const { id, payload, from } = request;
+    const { operation, data: requestData } = payload;
+    const uiId = requestData?.uiId;
+    const ui = requestData?.ui;
+    const projectId = requestData?.projectId;
+    const name = requestData?.name;
+    const description = requestData?.description;
+    const createdBy = requestData?.createdBy;
+    const updatedBy = requestData?.updatedBy;
+    const numericId = requestData?.id;
+    const filters = requestData?.filters;
+    const limit = requestData?.limit;
+    const sort = requestData?.sort;
+    if (from.type !== "admin") {
+      sendResponse6(id, {
+        success: false,
+        error: "Unauthorized: Only admin can manage UIs"
+      }, sendMessage, from.id);
+      logger.warn(`Unauthorized UI management attempt from: ${from.type}`);
+      return;
+    }
+    switch (operation) {
+      case "create":
+        await handleCreate4(id, uiId, ui, projectId, name, description, createdBy, executeCollection, sendMessage, from.id);
+        break;
+      case "update":
+        await handleUpdate4(id, numericId, ui, name, description, updatedBy, executeCollection, sendMessage, from.id);
+        break;
+      case "delete":
+        await handleDelete4(id, numericId, executeCollection, sendMessage, from.id);
+        break;
+      case "getAll":
+        await handleGetAll4(id, executeCollection, sendMessage, from.id);
+        break;
+      case "getOne":
+        await handleGetOne4(id, numericId, executeCollection, sendMessage, from.id);
+        break;
+      case "query":
+        await handleQuery4(id, filters, limit, sort, executeCollection, sendMessage, from.id);
+        break;
+      default:
+        sendResponse6(id, {
+          success: false,
+          error: `Unknown operation: ${operation}`
+        }, sendMessage, from.id);
+    }
+  } catch (error) {
+    logger.error("Failed to handle UIs request:", error);
+    sendResponse6(null, {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error occurred"
+    }, sendMessage);
+  }
+}
+async function handleCreate4(id, uiId, ui, projectId, name, description, createdBy, executeCollection, sendMessage, clientId) {
+  if (!uiId || uiId.trim().length === 0) {
+    sendResponse6(id, {
+      success: false,
+      error: "UI ID is required and cannot be empty"
+    }, sendMessage, clientId);
+    return;
+  }
+  if (!projectId || projectId.trim().length === 0) {
+    sendResponse6(id, {
+      success: false,
+      error: "Project ID is required and cannot be empty"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("uis", "create", {
+      uiId,
+      projectId,
+      name: name || uiId,
+      description,
+      ui,
+      createdBy
+    });
+    if (result && result.success) {
+      logger.info(`UI created successfully, ID: ${result.data?.id}`);
+      sendResponse6(id, {
+        success: true,
+        data: {
+          id: result.data?.id,
+          uiId: result.data?.uiId || uiId,
+          ui: result.data?.ui || ui,
+          message: `UI created successfully`
+        }
+      }, sendMessage, clientId);
+    } else {
+      sendResponse6(id, {
+        success: false,
+        error: "Failed to create UI"
+      }, sendMessage, clientId);
+    }
+  } catch (error) {
+    sendResponse6(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to create UI"
+    }, sendMessage, clientId);
+  }
+}
+async function handleUpdate4(id, numericId, ui, name, description, updatedBy, executeCollection, sendMessage, clientId) {
+  if (!numericId) {
+    sendResponse6(id, {
+      success: false,
+      error: "UI ID is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("uis", "update", {
+      id: numericId,
+      name,
+      description,
+      ui,
+      updatedBy
+    });
+    if (result && result.success) {
+      logger.info(`UI updated successfully, ID: ${numericId}`);
+      sendResponse6(id, {
+        success: true,
+        data: {
+          id: numericId,
+          uiId: result.data?.uiId,
+          ui: result.data?.ui || ui,
+          message: `UI updated successfully`
+        }
+      }, sendMessage, clientId);
+    } else {
+      sendResponse6(id, {
+        success: false,
+        error: "Failed to update UI"
+      }, sendMessage, clientId);
+    }
+  } catch (error) {
+    sendResponse6(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to update UI"
+    }, sendMessage, clientId);
+  }
+}
+async function handleDelete4(id, numericId, executeCollection, sendMessage, clientId) {
+  if (!numericId) {
+    sendResponse6(id, {
+      success: false,
+      error: "UI ID is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("uis", "delete", { id: numericId });
+    if (result && result.success) {
+      logger.info(`UI deleted successfully, ID: ${numericId}`);
+      sendResponse6(id, {
+        success: true,
+        data: {
+          id: numericId,
+          message: `UI deleted successfully`
+        }
+      }, sendMessage, clientId);
+    } else {
+      sendResponse6(id, {
+        success: false,
+        error: "Failed to delete UI"
+      }, sendMessage, clientId);
+    }
+  } catch (error) {
+    sendResponse6(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to delete UI"
+    }, sendMessage, clientId);
+  }
+}
+async function handleGetAll4(id, executeCollection, sendMessage, clientId) {
+  try {
+    const result = await executeCollection("uis", "getAll", {});
+    if (result && result.success) {
+      logger.info(`Retrieved ${result.count} UIs`);
+      sendResponse6(id, {
+        success: true,
+        data: {
+          uis: result.data,
+          count: result.count,
+          message: `Retrieved ${result.count} UIs`
+        }
+      }, sendMessage, clientId);
+    } else {
+      sendResponse6(id, {
+        success: false,
+        error: "Failed to get UIs"
+      }, sendMessage, clientId);
+    }
+  } catch (error) {
+    sendResponse6(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to get UIs"
+    }, sendMessage, clientId);
+  }
+}
+async function handleGetOne4(id, numericId, executeCollection, sendMessage, clientId) {
+  if (!numericId) {
+    sendResponse6(id, {
+      success: false,
+      error: "UI ID is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("uis", "getOne", { id: numericId });
+    if (result && result.success) {
+      logger.info(`Retrieved UI ID: ${numericId}`);
+      sendResponse6(id, {
+        success: true,
+        data: {
+          id: numericId,
+          uiId: result.data?.uiId,
+          ui: result.data?.ui || result.data,
+          message: `Retrieved UI`
+        }
+      }, sendMessage, clientId);
+    } else {
+      sendResponse6(id, {
+        success: false,
+        error: `UI not found`
+      }, sendMessage, clientId);
+    }
+  } catch (error) {
+    sendResponse6(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to get UI"
+    }, sendMessage, clientId);
+  }
+}
+async function handleQuery4(id, filters, limit, sort, executeCollection, sendMessage, clientId) {
+  try {
+    const result = await executeCollection("uis", "query", {
+      filters: filters || {},
+      limit,
+      sort
+    });
+    if (result && result.success) {
+      logger.info(`Query returned ${result.count} UIs`);
+      sendResponse6(id, {
+        success: true,
+        data: {
+          uis: result.data,
+          count: result.count,
+          message: `Query returned ${result.count} UIs`
+        }
+      }, sendMessage, clientId);
+    } else {
+      sendResponse6(id, {
+        success: false,
+        error: "Failed to query UIs"
+      }, sendMessage, clientId);
+    }
+  } catch (error) {
+    sendResponse6(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to query UIs"
+    }, sendMessage, clientId);
+  }
+}
+function sendResponse6(id, res, sendMessage, clientId) {
+  const response = {
+    id: id || "unknown",
+    type: "UIS_RES",
+    from: { type: "data-agent" },
+    to: {
+      type: "admin",
+      id: clientId
+    },
+    payload: {
+      ...res
+    }
+  };
+  sendMessage(response);
+}
+
 // src/handlers/bookmarks.ts
 async function handleBookmarksRequest(data, collections, sendMessage) {
   const executeCollection = async (collection, op, params) => {
@@ -6711,22 +7715,27 @@ async function handleBookmarksRequest(data, collections, sendMessage) {
     const bookmarkId = requestData?.id;
     const userId = requestData?.userId;
     const threadId = requestData?.threadId;
+    const name = requestData?.name;
+    const description = requestData?.description;
     const uiblock = requestData?.uiblock;
+    const filters = requestData?.filters;
+    const limit = requestData?.limit;
+    const sort = requestData?.sort;
     switch (operation) {
       case "create":
-        await handleCreate4(id, userId, threadId, uiblock, executeCollection, sendMessage, from.id);
+        await handleCreate5(id, userId, threadId, name, description, uiblock, executeCollection, sendMessage, from.id);
         break;
       case "update":
-        await handleUpdate4(id, bookmarkId, threadId, uiblock, executeCollection, sendMessage, from.id);
+        await handleUpdate5(id, bookmarkId, threadId, name, description, uiblock, executeCollection, sendMessage, from.id);
         break;
       case "delete":
-        await handleDelete4(id, bookmarkId, executeCollection, sendMessage, from.id);
+        await handleDelete5(id, bookmarkId, executeCollection, sendMessage, from.id);
         break;
       case "getAll":
-        await handleGetAll4(id, executeCollection, sendMessage, from.id);
+        await handleGetAll5(id, executeCollection, sendMessage, from.id);
         break;
       case "getOne":
-        await handleGetOne4(id, bookmarkId, executeCollection, sendMessage, from.id);
+        await handleGetOne5(id, bookmarkId, executeCollection, sendMessage, from.id);
         break;
       case "getByUser":
         await handleGetByUser(id, userId, threadId, executeCollection, sendMessage, from.id);
@@ -6734,83 +7743,79 @@ async function handleBookmarksRequest(data, collections, sendMessage) {
       case "getByThread":
         await handleGetByThread(id, threadId, executeCollection, sendMessage, from.id);
         break;
+      case "query":
+        await handleQuery5(id, filters, limit, sort, executeCollection, sendMessage, from.id);
+        break;
       default:
-        sendResponse6(id, {
+        sendResponse7(id, {
           success: false,
           error: `Unknown operation: ${operation}`
         }, sendMessage, from.id);
     }
   } catch (error) {
     logger.error("Failed to handle bookmarks request:", error);
-    sendResponse6(null, {
+    sendResponse7(null, {
       success: false,
       error: error instanceof Error ? error.message : "Unknown error occurred"
     }, sendMessage);
   }
 }
-async function handleCreate4(id, userId, threadId, uiblock, executeCollection, sendMessage, clientId) {
+async function handleCreate5(id, userId, threadId, name, description, uiblock, executeCollection, sendMessage, clientId) {
   if (!userId) {
-    sendResponse6(id, {
+    sendResponse7(id, {
       success: false,
       error: "userId is required"
     }, sendMessage, clientId);
     return;
   }
   if (!uiblock) {
-    sendResponse6(id, {
+    sendResponse7(id, {
       success: false,
       error: "UIBlock data is required"
     }, sendMessage, clientId);
     return;
   }
   try {
-    const result = await executeCollection("bookmarks", "create", { userId, threadId, uiblock });
-    sendResponse6(id, {
+    const result = await executeCollection("bookmarks", "create", { userId, threadId, name, description, uiblock });
+    sendResponse7(id, {
       success: true,
       data: result.data,
       message: "Bookmark created successfully"
     }, sendMessage, clientId);
     logger.info(`Bookmark created: ID ${result.data.id}`);
   } catch (error) {
-    sendResponse6(id, {
+    sendResponse7(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to create bookmark"
     }, sendMessage, clientId);
   }
 }
-async function handleUpdate4(id, bookmarkId, threadId, uiblock, executeCollection, sendMessage, clientId) {
+async function handleUpdate5(id, bookmarkId, threadId, name, description, uiblock, executeCollection, sendMessage, clientId) {
   if (!bookmarkId) {
-    sendResponse6(id, {
+    sendResponse7(id, {
       success: false,
       error: "Bookmark ID is required"
     }, sendMessage, clientId);
     return;
   }
-  if (!uiblock) {
-    sendResponse6(id, {
-      success: false,
-      error: "UIBlock data is required"
-    }, sendMessage, clientId);
-    return;
-  }
   try {
-    const result = await executeCollection("bookmarks", "update", { id: bookmarkId, threadId, uiblock });
-    sendResponse6(id, {
+    const result = await executeCollection("bookmarks", "update", { id: bookmarkId, threadId, name, description, uiblock });
+    sendResponse7(id, {
       success: true,
       data: result.data,
       message: "Bookmark updated successfully"
     }, sendMessage, clientId);
     logger.info(`Bookmark updated: ID ${bookmarkId}`);
   } catch (error) {
-    sendResponse6(id, {
+    sendResponse7(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to update bookmark"
     }, sendMessage, clientId);
   }
 }
-async function handleDelete4(id, bookmarkId, executeCollection, sendMessage, clientId) {
+async function handleDelete5(id, bookmarkId, executeCollection, sendMessage, clientId) {
   if (!bookmarkId) {
-    sendResponse6(id, {
+    sendResponse7(id, {
       success: false,
       error: "Bookmark ID is required"
     }, sendMessage, clientId);
@@ -6818,23 +7823,23 @@ async function handleDelete4(id, bookmarkId, executeCollection, sendMessage, cli
   }
   try {
     const result = await executeCollection("bookmarks", "delete", { id: bookmarkId });
-    sendResponse6(id, {
+    sendResponse7(id, {
       success: true,
       data: result.data,
       message: "Bookmark deleted successfully"
     }, sendMessage, clientId);
     logger.info(`Bookmark deleted: ID ${bookmarkId}`);
   } catch (error) {
-    sendResponse6(id, {
+    sendResponse7(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to delete bookmark"
     }, sendMessage, clientId);
   }
 }
-async function handleGetAll4(id, executeCollection, sendMessage, clientId) {
+async function handleGetAll5(id, executeCollection, sendMessage, clientId) {
   try {
     const result = await executeCollection("bookmarks", "getAll", {});
-    sendResponse6(id, {
+    sendResponse7(id, {
       success: true,
       data: result.data,
       count: result.count,
@@ -6842,15 +7847,15 @@ async function handleGetAll4(id, executeCollection, sendMessage, clientId) {
     }, sendMessage, clientId);
     logger.info(`Retrieved all bookmarks (count: ${result.count})`);
   } catch (error) {
-    sendResponse6(id, {
+    sendResponse7(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to get bookmarks"
     }, sendMessage, clientId);
   }
 }
-async function handleGetOne4(id, bookmarkId, executeCollection, sendMessage, clientId) {
+async function handleGetOne5(id, bookmarkId, executeCollection, sendMessage, clientId) {
   if (!bookmarkId) {
-    sendResponse6(id, {
+    sendResponse7(id, {
       success: false,
       error: "Bookmark ID is required"
     }, sendMessage, clientId);
@@ -6858,14 +7863,14 @@ async function handleGetOne4(id, bookmarkId, executeCollection, sendMessage, cli
   }
   try {
     const result = await executeCollection("bookmarks", "getOne", { id: bookmarkId });
-    sendResponse6(id, {
+    sendResponse7(id, {
       success: true,
       data: result.data,
       message: `Retrieved bookmark ID ${bookmarkId}`
     }, sendMessage, clientId);
     logger.info(`Retrieved bookmark: ID ${bookmarkId}`);
   } catch (error) {
-    sendResponse6(id, {
+    sendResponse7(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to get bookmark"
     }, sendMessage, clientId);
@@ -6873,7 +7878,7 @@ async function handleGetOne4(id, bookmarkId, executeCollection, sendMessage, cli
 }
 async function handleGetByUser(id, userId, threadId, executeCollection, sendMessage, clientId) {
   if (!userId) {
-    sendResponse6(id, {
+    sendResponse7(id, {
       success: false,
       error: "userId is required"
     }, sendMessage, clientId);
@@ -6881,7 +7886,7 @@ async function handleGetByUser(id, userId, threadId, executeCollection, sendMess
   }
   try {
     const result = await executeCollection("bookmarks", "getByUser", { userId, threadId });
-    sendResponse6(id, {
+    sendResponse7(id, {
       success: true,
       data: result.data,
       count: result.count,
@@ -6889,7 +7894,7 @@ async function handleGetByUser(id, userId, threadId, executeCollection, sendMess
     }, sendMessage, clientId);
     logger.info(`Retrieved bookmarks for user ${userId} (count: ${result.count})`);
   } catch (error) {
-    sendResponse6(id, {
+    sendResponse7(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to get bookmarks by user"
     }, sendMessage, clientId);
@@ -6897,7 +7902,7 @@ async function handleGetByUser(id, userId, threadId, executeCollection, sendMess
 }
 async function handleGetByThread(id, threadId, executeCollection, sendMessage, clientId) {
   if (!threadId) {
-    sendResponse6(id, {
+    sendResponse7(id, {
       success: false,
       error: "threadId is required"
     }, sendMessage, clientId);
@@ -6905,7 +7910,7 @@ async function handleGetByThread(id, threadId, executeCollection, sendMessage, c
   }
   try {
     const result = await executeCollection("bookmarks", "getByThread", { threadId });
-    sendResponse6(id, {
+    sendResponse7(id, {
       success: true,
       data: result.data,
       count: result.count,
@@ -6913,13 +7918,34 @@ async function handleGetByThread(id, threadId, executeCollection, sendMessage, c
     }, sendMessage, clientId);
     logger.info(`Retrieved bookmarks for thread ${threadId} (count: ${result.count})`);
   } catch (error) {
-    sendResponse6(id, {
+    sendResponse7(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to get bookmarks by thread"
     }, sendMessage, clientId);
   }
 }
-function sendResponse6(id, res, sendMessage, clientId) {
+async function handleQuery5(id, filters, limit, sort, executeCollection, sendMessage, clientId) {
+  try {
+    const result = await executeCollection("bookmarks", "query", {
+      filters: filters || {},
+      limit,
+      sort
+    });
+    sendResponse7(id, {
+      success: true,
+      data: result.data,
+      count: result.count,
+      message: `Query returned ${result.count} bookmarks`
+    }, sendMessage, clientId);
+    logger.info(`Query returned ${result.count} bookmarks`);
+  } catch (error) {
+    sendResponse7(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to query bookmarks"
+    }, sendMessage, clientId);
+  }
+}
+function sendResponse7(id, res, sendMessage, clientId) {
   const response = {
     id: id || "unknown",
     type: "BOOKMARKS_RES",
@@ -7930,30 +8956,35 @@ var SuperatomSDK = class {
           });
           break;
         case "USER_PROMPT_SUGGESTIONS_REQ":
-          handleUserPromptSuggestions(parsed, this.components, (msg) => this.send(msg)).catch((error) => {
+          handleUserPromptSuggestions(parsed, this.components, (msg) => this.send(msg), this.collections, this.userId).catch((error) => {
             logger.error("Failed to handle user prompt suggestions request:", error);
           });
           break;
         case "COMPONENT_LIST_RES":
-          handleComponentListResponse(parsed, (com) => this.storeComponents(com)).catch((error) => {
+          handleComponentListResponse(parsed, (com) => this.storeComponents(com), this.collections).catch((error) => {
             logger.error("Failed to handle component list request:", error);
           });
           break;
         case "USERS":
-          handleUsersRequest(parsed, (msg) => this.send(msg)).catch((error) => {
+          handleUsersRequest(parsed, this.collections, (msg) => this.send(msg)).catch((error) => {
             logger.error("Failed to handle users request:", error);
           });
           break;
         case "DASHBOARDS":
-          handleDashboardsRequest(parsed, (msg) => this.send(msg)).catch((error) => {
+          handleDashboardsRequest(parsed, this.collections, (msg) => this.send(msg)).catch((error) => {
             logger.error("Failed to handle dashboards request:", error);
           });
           break;
         case "REPORTS":
-          handleReportsRequest(parsed, (msg) => this.send(msg)).catch((error) => {
+          handleReportsRequest(parsed, this.collections, (msg) => this.send(msg)).catch((error) => {
             logger.error("Failed to handle reports request:", error);
           });
           break;
+        case "UIS":
+          handleUIsRequest(parsed, this.collections, (msg) => this.send(msg)).catch((error) => {
+            logger.error("Failed to handle UIs request:", error);
+          });
+          break;
         case "BOOKMARKS":
           handleBookmarksRequest(parsed, this.collections, (msg) => this.send(msg)).catch((error) => {
             logger.error("Failed to handle bookmarks request:", error);