@superatomai/sdk-node 0.0.18 → 0.0.20

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(),
@@ -538,11 +539,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 +569,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 +599,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,10 +652,16 @@ 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()
 });
@@ -600,7 +671,9 @@ var BookmarksRequestPayloadSchema = 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()
   }).optional()
 });
 var BookmarksRequestMessageSchema = import_zod3.z.object({
@@ -2947,6 +3020,8 @@ var promptLoader = new PromptLoader({
 // src/llm.ts
 var import_sdk = __toESM(require("@anthropic-ai/sdk"));
 var import_groq_sdk = __toESM(require("groq-sdk"));
+var import_generative_ai = require("@google/generative-ai");
+var import_openai = __toESM(require("openai"));
 var import_jsonrepair = require("jsonrepair");
 var LLM = class {
   /* Get a complete text response from an LLM (Anthropic or Groq) */
@@ -2956,8 +3031,12 @@ var LLM = class {
       return this._anthropicText(messages, modelName, options);
     } else if (provider === "groq") {
       return this._groqText(messages, modelName, options);
+    } else if (provider === "gemini") {
+      return this._geminiText(messages, modelName, options);
+    } else if (provider === "openai") {
+      return this._openaiText(messages, modelName, options);
     } else {
-      throw new Error(`Unsupported provider: ${provider}. Use "anthropic" or "groq"`);
+      throw new Error(`Unsupported provider: ${provider}. Use "anthropic", "groq", "gemini", or "openai"`);
     }
   }
   /* Stream response from an LLM (Anthropic or Groq) */
@@ -2967,17 +3046,26 @@ var LLM = class {
       return this._anthropicStream(messages, modelName, options, json);
     } else if (provider === "groq") {
       return this._groqStream(messages, modelName, options, json);
+    } else if (provider === "gemini") {
+      return this._geminiStream(messages, modelName, options, json);
+    } else if (provider === "openai") {
+      return this._openaiStream(messages, modelName, options, json);
     } else {
-      throw new Error(`Unsupported provider: ${provider}. Use "anthropic" or "groq"`);
+      throw new Error(`Unsupported provider: ${provider}. Use "anthropic", "groq", "gemini", or "openai"`);
     }
   }
-  /* Stream response with tool calling support (Anthropic only for now) */
+  /* Stream response with tool calling support (Anthropic and Gemini) */
   static async streamWithTools(messages, tools, toolHandler, options = {}, maxIterations = 3) {
     const [provider, modelName] = this._parseModel(options.model);
-    if (provider !== "anthropic") {
-      throw new Error(`Tool calling is only supported for Anthropic models`);
+    if (provider === "anthropic") {
+      return this._anthropicStreamWithTools(messages, tools, toolHandler, modelName, options, maxIterations);
+    } else if (provider === "gemini") {
+      return this._geminiStreamWithTools(messages, tools, toolHandler, modelName, options, maxIterations);
+    } else if (provider === "openai") {
+      return this._openaiStreamWithTools(messages, tools, toolHandler, modelName, options, maxIterations);
+    } else {
+      throw new Error(`Tool calling is only supported for Anthropic, Gemini, and OpenAI models`);
     }
-    return this._anthropicStreamWithTools(messages, tools, toolHandler, modelName, options, maxIterations);
   }
   // ============================================================
   // PRIVATE HELPER METHODS
@@ -3311,6 +3399,298 @@ var LLM = class {
     return fullText;
   }
   // ============================================================
+  // GEMINI IMPLEMENTATION
+  // ============================================================
+  static async _geminiText(messages, modelName, options) {
+    const apiKey = options.apiKey || process.env.GEMINI_API_KEY || "";
+    const genAI = new import_generative_ai.GoogleGenerativeAI(apiKey);
+    const systemPrompt = typeof messages.sys === "string" ? messages.sys : messages.sys.map((block) => block.text).join("\n");
+    const model = genAI.getGenerativeModel({
+      model: modelName,
+      systemInstruction: systemPrompt,
+      generationConfig: {
+        maxOutputTokens: options.maxTokens || 1e3,
+        temperature: options.temperature,
+        topP: options.topP
+      }
+    });
+    const result = await model.generateContent(messages.user);
+    const response = await result.response;
+    return response.text();
+  }
+  static async _geminiStream(messages, modelName, options, json) {
+    const apiKey = options.apiKey || process.env.GEMINI_API_KEY || "";
+    const genAI = new import_generative_ai.GoogleGenerativeAI(apiKey);
+    const systemPrompt = typeof messages.sys === "string" ? messages.sys : messages.sys.map((block) => block.text).join("\n");
+    const model = genAI.getGenerativeModel({
+      model: modelName,
+      systemInstruction: systemPrompt,
+      generationConfig: {
+        maxOutputTokens: options.maxTokens || 1e3,
+        temperature: options.temperature,
+        topP: options.topP,
+        responseMimeType: json ? "application/json" : void 0
+      }
+    });
+    const result = await model.generateContentStream(messages.user);
+    let fullText = "";
+    for await (const chunk of result.stream) {
+      const text = chunk.text();
+      if (text) {
+        fullText += text;
+        if (options.partial) {
+          options.partial(text);
+        }
+      }
+    }
+    if (json) {
+      return this._parseJSON(fullText);
+    }
+    return fullText;
+  }
+  static async _geminiStreamWithTools(messages, tools, toolHandler, modelName, options, maxIterations) {
+    const apiKey = options.apiKey || process.env.GEMINI_API_KEY || "";
+    const genAI = new import_generative_ai.GoogleGenerativeAI(apiKey);
+    const systemPrompt = typeof messages.sys === "string" ? messages.sys : messages.sys.map((block) => block.text).join("\n");
+    const functionDeclarations = tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: {
+        type: import_generative_ai.SchemaType.OBJECT,
+        properties: tool.input_schema.properties,
+        required: tool.input_schema.required || []
+      }
+    }));
+    const model = genAI.getGenerativeModel({
+      model: modelName,
+      systemInstruction: systemPrompt,
+      tools: [{ functionDeclarations }],
+      generationConfig: {
+        maxOutputTokens: options.maxTokens || 4e3,
+        temperature: options.temperature,
+        topP: options.topP
+      }
+    });
+    const chat = model.startChat({
+      history: []
+    });
+    let iterations = 0;
+    let finalText = "";
+    let currentUserMessage = messages.user;
+    while (iterations < maxIterations) {
+      iterations++;
+      const result = await chat.sendMessageStream(currentUserMessage);
+      let responseText = "";
+      const functionCalls = [];
+      for await (const chunk of result.stream) {
+        const candidate = chunk.candidates?.[0];
+        if (!candidate) continue;
+        for (const part of candidate.content?.parts || []) {
+          if (part.text) {
+            responseText += part.text;
+            if (options.partial) {
+              options.partial(part.text);
+            }
+          } else if (part.functionCall) {
+            functionCalls.push({
+              name: part.functionCall.name,
+              args: part.functionCall.args
+            });
+          }
+        }
+      }
+      if (functionCalls.length === 0) {
+        finalText = responseText;
+        break;
+      }
+      const functionResponses = [];
+      for (const fc of functionCalls) {
+        try {
+          const result2 = await toolHandler(fc.name, fc.args);
+          functionResponses.push({
+            name: fc.name,
+            response: { result: typeof result2 === "string" ? result2 : JSON.stringify(result2) }
+          });
+        } catch (error) {
+          functionResponses.push({
+            name: fc.name,
+            response: { error: error instanceof Error ? error.message : String(error) }
+          });
+        }
+      }
+      const functionResponseParts = functionResponses.map((fr) => ({
+        functionResponse: {
+          name: fr.name,
+          response: fr.response
+        }
+      }));
+      currentUserMessage = functionResponseParts;
+    }
+    if (iterations >= maxIterations) {
+      throw new Error(`Max iterations (${maxIterations}) reached in tool calling loop`);
+    }
+    return finalText;
+  }
+  // ============================================================
+  // OPENAI IMPLEMENTATION
+  // ============================================================
+  static async _openaiText(messages, modelName, options) {
+    const apiKey = options.apiKey || process.env.OPENAI_API_KEY || "";
+    const openai = new import_openai.default({ apiKey });
+    const systemPrompt = typeof messages.sys === "string" ? messages.sys : messages.sys.map((block) => block.text).join("\n");
+    const response = await openai.chat.completions.create({
+      model: modelName,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: messages.user }
+      ],
+      max_tokens: options.maxTokens || 1e3,
+      temperature: options.temperature,
+      top_p: options.topP
+    });
+    return response.choices[0]?.message?.content || "";
+  }
+  static async _openaiStream(messages, modelName, options, json) {
+    const apiKey = options.apiKey || process.env.OPENAI_API_KEY || "";
+    const openai = new import_openai.default({ apiKey });
+    const systemPrompt = typeof messages.sys === "string" ? messages.sys : messages.sys.map((block) => block.text).join("\n");
+    const stream = await openai.chat.completions.create({
+      model: modelName,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: messages.user }
+      ],
+      max_tokens: options.maxTokens || 1e3,
+      temperature: options.temperature,
+      top_p: options.topP,
+      response_format: json ? { type: "json_object" } : void 0,
+      stream: true
+    });
+    let fullText = "";
+    for await (const chunk of stream) {
+      const content = chunk.choices[0]?.delta?.content || "";
+      if (content) {
+        fullText += content;
+        if (options.partial) {
+          options.partial(content);
+        }
+      }
+    }
+    if (json) {
+      return this._parseJSON(fullText);
+    }
+    return fullText;
+  }
+  static async _openaiStreamWithTools(messages, tools, toolHandler, modelName, options, maxIterations) {
+    const apiKey = options.apiKey || process.env.OPENAI_API_KEY || "";
+    const openai = new import_openai.default({ apiKey });
+    const systemPrompt = typeof messages.sys === "string" ? messages.sys : messages.sys.map((block) => block.text).join("\n");
+    const openaiTools = tools.map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: {
+          type: tool.input_schema.type,
+          properties: tool.input_schema.properties,
+          required: tool.input_schema.required || []
+        }
+      }
+    }));
+    const conversationMessages = [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: messages.user }
+    ];
+    let iterations = 0;
+    let finalText = "";
+    while (iterations < maxIterations) {
+      iterations++;
+      const stream = await openai.chat.completions.create({
+        model: modelName,
+        messages: conversationMessages,
+        max_tokens: options.maxTokens || 4e3,
+        temperature: options.temperature,
+        top_p: options.topP,
+        tools: openaiTools,
+        stream: true
+      });
+      let responseText = "";
+      const toolCalls = [];
+      const toolCallsInProgress = /* @__PURE__ */ new Map();
+      for await (const chunk of stream) {
+        const delta = chunk.choices[0]?.delta;
+        if (delta?.content) {
+          responseText += delta.content;
+          if (options.partial) {
+            options.partial(delta.content);
+          }
+        }
+        if (delta?.tool_calls) {
+          for (const toolCallDelta of delta.tool_calls) {
+            const index = toolCallDelta.index;
+            if (!toolCallsInProgress.has(index)) {
+              toolCallsInProgress.set(index, {
+                id: toolCallDelta.id || "",
+                name: toolCallDelta.function?.name || "",
+                arguments: ""
+              });
+            }
+            const tc = toolCallsInProgress.get(index);
+            if (toolCallDelta.id) {
+              tc.id = toolCallDelta.id;
+            }
+            if (toolCallDelta.function?.name) {
+              tc.name = toolCallDelta.function.name;
+            }
+            if (toolCallDelta.function?.arguments) {
+              tc.arguments += toolCallDelta.function.arguments;
+            }
+          }
+        }
+      }
+      for (const tc of toolCallsInProgress.values()) {
+        if (tc.id && tc.name) {
+          toolCalls.push(tc);
+        }
+      }
+      if (toolCalls.length === 0) {
+        finalText = responseText;
+        break;
+      }
+      conversationMessages.push({
+        role: "assistant",
+        content: responseText || null,
+        tool_calls: toolCalls.map((tc) => ({
+          id: tc.id,
+          type: "function",
+          function: {
+            name: tc.name,
+            arguments: tc.arguments
+          }
+        }))
+      });
+      for (const tc of toolCalls) {
+        let result;
+        try {
+          const args = JSON.parse(tc.arguments);
+          const toolResult = await toolHandler(tc.name, args);
+          result = typeof toolResult === "string" ? toolResult : JSON.stringify(toolResult);
+        } catch (error) {
+          result = JSON.stringify({ error: error instanceof Error ? error.message : String(error) });
+        }
+        conversationMessages.push({
+          role: "tool",
+          tool_call_id: tc.id,
+          content: result
+        });
+      }
+    }
+    if (iterations >= maxIterations) {
+      throw new Error(`Max iterations (${maxIterations}) reached in tool calling loop`);
+    }
+    return finalText;
+  }
+  // ============================================================
   // JSON PARSING HELPER
   // ============================================================
   /**
@@ -4599,18 +4979,56 @@ var AnthropicLLM = class extends BaseLLM {
 };
 var anthropicLLM = new AnthropicLLM();
 
-// src/userResponse/index.ts
+// src/userResponse/gemini.ts
 var import_dotenv3 = __toESM(require("dotenv"));
 import_dotenv3.default.config();
+var GeminiLLM = class extends BaseLLM {
+  constructor(config) {
+    super(config);
+  }
+  getDefaultModel() {
+    return "gemini/gemini-2.5-flash";
+  }
+  getDefaultApiKey() {
+    return process.env.GEMINI_API_KEY;
+  }
+  getProviderName() {
+    return "Gemini";
+  }
+};
+var geminiLLM = new GeminiLLM();
+
+// src/userResponse/openai.ts
+var import_dotenv4 = __toESM(require("dotenv"));
+import_dotenv4.default.config();
+var OpenAILLM = class extends BaseLLM {
+  constructor(config) {
+    super(config);
+  }
+  getDefaultModel() {
+    return "openai/gpt-4.1";
+  }
+  getDefaultApiKey() {
+    return process.env.OPENAI_API_KEY;
+  }
+  getProviderName() {
+    return "OpenAI";
+  }
+};
+var openaiLLM = new OpenAILLM();
+
+// src/userResponse/index.ts
+var import_dotenv5 = __toESM(require("dotenv"));
+import_dotenv5.default.config();
 function getLLMProviders() {
   const envProviders = process.env.LLM_PROVIDERS;
-  const DEFAULT_PROVIDERS = ["anthropic", "groq"];
+  const DEFAULT_PROVIDERS = ["anthropic", "gemini", "openai", "groq"];
   if (!envProviders) {
     return DEFAULT_PROVIDERS;
   }
   try {
     const providers = JSON.parse(envProviders);
-    const validProviders = providers.filter((p) => p === "anthropic" || p === "groq");
+    const validProviders = providers.filter((p) => p === "anthropic" || p === "groq" || p === "gemini" || p === "openai");
     if (validProviders.length === 0) {
       return DEFAULT_PROVIDERS;
     }
@@ -4653,10 +5071,44 @@ var useGroqMethod = async (prompt, components, apiKey, logCollector, conversatio
   logger.info(`[useGroqMethod] Successfully generated ${responseMode} using Groq`);
   return matchResult;
 };
+var useGeminiMethod = async (prompt, components, apiKey, logCollector, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
+  logger.debug("[useGeminiMethod] Initializing Gemini LLM matching method");
+  logger.debug(`[useGeminiMethod] Response mode: ${responseMode}`);
+  const msg = `Using Gemini LLM ${responseMode === "text" ? "text response" : "matching"} method...`;
+  logger.info(msg);
+  logCollector?.info(msg);
+  if (responseMode === "component" && components.length === 0) {
+    const emptyMsg = "Components not loaded in memory. Please ensure components are fetched first.";
+    logger.error("[useGeminiMethod] No components available");
+    logCollector?.error(emptyMsg);
+    return { success: false, errors: [emptyMsg] };
+  }
+  logger.debug(`[useGeminiMethod] Processing with ${components.length} components`);
+  const matchResult = await geminiLLM.handleUserRequest(prompt, components, apiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
+  logger.info(`[useGeminiMethod] Successfully generated ${responseMode} using Gemini`);
+  return matchResult;
+};
+var useOpenAIMethod = async (prompt, components, apiKey, logCollector, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
+  logger.debug("[useOpenAIMethod] Initializing OpenAI GPT matching method");
+  logger.debug(`[useOpenAIMethod] Response mode: ${responseMode}`);
+  const msg = `Using OpenAI GPT ${responseMode === "text" ? "text response" : "matching"} method...`;
+  logger.info(msg);
+  logCollector?.info(msg);
+  if (responseMode === "component" && components.length === 0) {
+    const emptyMsg = "Components not loaded in memory. Please ensure components are fetched first.";
+    logger.error("[useOpenAIMethod] No components available");
+    logCollector?.error(emptyMsg);
+    return { success: false, errors: [emptyMsg] };
+  }
+  logger.debug(`[useOpenAIMethod] Processing with ${components.length} components`);
+  const matchResult = await openaiLLM.handleUserRequest(prompt, components, apiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
+  logger.info(`[useOpenAIMethod] Successfully generated ${responseMode} using OpenAI`);
+  return matchResult;
+};
 var getUserResponseFromCache = async (prompt) => {
   return false;
 };
-var get_user_response = async (prompt, components, anthropicApiKey, groqApiKey, llmProviders, logCollector, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
+var get_user_response = async (prompt, components, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, logCollector, conversationHistory, responseMode = "component", streamCallback, collections, externalTools, userId) => {
   logger.debug(`[get_user_response] Starting user response generation for prompt: "${prompt.substring(0, 50)}..."`);
   logger.debug(`[get_user_response] Response mode: ${responseMode}`);
   logger.debug("[get_user_response] Checking cache for existing response");
@@ -4692,6 +5144,10 @@ var get_user_response = async (prompt, components, anthropicApiKey, groqApiKey,
       result = await useAnthropicMethod(prompt, components, anthropicApiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
     } else if (provider === "groq") {
       result = await useGroqMethod(prompt, components, groqApiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
+    } else if (provider === "gemini") {
+      result = await useGeminiMethod(prompt, components, geminiApiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
+    } else if (provider === "openai") {
+      result = await useOpenAIMethod(prompt, components, openaiApiKey, logCollector, conversationHistory, responseMode, streamCallback, collections, externalTools, userId);
     } else {
       logger.warn(`[get_user_response] Unknown provider: ${provider} - skipping`);
       errors.push(`Unknown provider: ${provider}`);
@@ -5036,7 +5492,7 @@ var CONTEXT_CONFIG = {
 };
 
 // src/handlers/user-prompt-request.ts
-var get_user_request = async (data, components, sendMessage, anthropicApiKey, groqApiKey, llmProviders, collections, externalTools, userId) => {
+var get_user_request = async (data, components, sendMessage, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, collections, externalTools, userId) => {
   const errors = [];
   logger.debug("[USER_PROMPT_REQ] Parsing incoming message data");
   const parseResult = UserPromptRequestMessageSchema.safeParse(data);
@@ -5111,6 +5567,8 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
     components,
     anthropicApiKey,
     groqApiKey,
+    geminiApiKey,
+    openaiApiKey,
     llmProviders,
     logCollector,
     conversationHistory,
@@ -5209,8 +5667,8 @@ var get_user_request = async (data, components, sendMessage, anthropicApiKey, gr
     wsId
   };
 };
-async function handleUserPromptRequest(data, components, sendMessage, anthropicApiKey, groqApiKey, llmProviders, collections, externalTools, userId) {
-  const response = await get_user_request(data, components, sendMessage, anthropicApiKey, groqApiKey, llmProviders, collections, externalTools, userId);
+async function handleUserPromptRequest(data, components, sendMessage, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, collections, externalTools, userId) {
+  const response = await get_user_request(data, components, sendMessage, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, collections, externalTools, userId);
   sendDataResponse4(
     response.id || data.id,
     {
@@ -5241,12 +5699,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 { prompt, limit = 5, similarityThreshold = 0.1 } = 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,
@@ -5254,7 +5713,79 @@ 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 filteredComponentSuggestions = componentSuggestions.filter(
+        (s) => (s.similarity || 0) >= similarityThreshold
+      );
+      const filteredBookmarkSuggestions = bookmarkSuggestions.filter(
+        (s) => (s.similarity || 0) >= similarityThreshold
+      );
+      const allSuggestions = [...filteredComponentSuggestions, ...filteredBookmarkSuggestions].sort((a, b) => (b.similarity || 0) - (a.similarity || 0)).slice(0, limit);
+      logger.info(`[USER_PROMPT_SUGGESTIONS_REQ ${id}] Filtered by threshold ${similarityThreshold}: ${componentSuggestions.length} -> ${filteredComponentSuggestions.length} components, ${bookmarkSuggestions.length} -> ${filteredBookmarkSuggestions.length} bookmarks`);
+      sendResponse(id, {
+        success: true,
+        data: {
+          prompt,
+          suggestions: allSuggestions,
+          count: allSuggestions.length,
+          componentCount: filteredComponentSuggestions.length,
+          bookmarkCount: filteredBookmarkSuggestions.length,
+          message: `Found ${allSuggestions.length} suggestions (${filteredComponentSuggestions.length} components, ${filteredBookmarkSuggestions.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,
@@ -5337,13 +5868,13 @@ function sendResponse(id, res, sendMessage, clientId) {
 }
 
 // src/userResponse/next-questions.ts
-async function generateNextQuestions(originalUserPrompt, component, componentData, anthropicApiKey, groqApiKey, llmProviders, logCollector, conversationHistory) {
+async function generateNextQuestions(originalUserPrompt, component, componentData, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders, logCollector, conversationHistory) {
   try {
     logger.debug("[generateNextQuestions] Starting next questions generation");
     logger.debug(`[generateNextQuestions] User prompt: "${originalUserPrompt?.substring(0, 50)}..."`);
     logger.debug(`[generateNextQuestions] Component: ${component?.name || "unknown"} (${component?.type || "unknown"})`);
     logger.debug(`[generateNextQuestions] Component data available: ${componentData ? "yes" : "no"}`);
-    const providers = llmProviders || ["anthropic"];
+    const providers = llmProviders || ["anthropic", "gemini", "openai", "groq"];
     logger.info(`[generateNextQuestions] Using LLM providers: [${providers.join(", ")}]`);
     if (conversationHistory && conversationHistory.length > 0) {
       const exchangeCount = conversationHistory.split("\n").filter((l) => l.startsWith("Q")).length;
@@ -5368,6 +5899,26 @@ async function generateNextQuestions(originalUserPrompt, component, componentDat
             logCollector,
             conversationHistory
           );
+        } else if (provider === "gemini") {
+          logger.debug("[generateNextQuestions] Using Gemini LLM for next questions");
+          result = await geminiLLM.generateNextQuestions(
+            originalUserPrompt,
+            component,
+            componentData,
+            geminiApiKey,
+            logCollector,
+            conversationHistory
+          );
+        } else if (provider === "openai") {
+          logger.debug("[generateNextQuestions] Using OpenAI LLM for next questions");
+          result = await openaiLLM.generateNextQuestions(
+            originalUserPrompt,
+            component,
+            componentData,
+            openaiApiKey,
+            logCollector,
+            conversationHistory
+          );
         } else {
           logger.debug("[generateNextQuestions] Using Anthropic LLM for next questions");
           result = await anthropicLLM.generateNextQuestions(
@@ -5418,7 +5969,7 @@ async function generateNextQuestions(originalUserPrompt, component, componentDat
 }
 
 // src/handlers/actions-request.ts
-async function handleActionsRequest(data, sendMessage, anthropicApiKey, groqApiKey, llmProviders) {
+async function handleActionsRequest(data, sendMessage, anthropicApiKey, groqApiKey, geminiApiKey, openaiApiKey, llmProviders) {
   try {
     logger.debug("[ACTIONS_REQ] Parsing incoming actions request");
     const actionsRequest = ActionsRequestMessageSchema.parse(data);
@@ -5490,6 +6041,8 @@ ${conversationHistory.substring(0, 200)}...`);
         componentData,
         anthropicApiKey,
         groqApiKey,
+        geminiApiKey,
+        openaiApiKey,
         llmProviders,
         logCollector,
         conversationHistory
@@ -5570,10 +6123,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");
@@ -5581,6 +6134,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);
@@ -5598,7 +6165,7 @@ async function handleUsersRequest(data, sendMessage) {
     const password = requestData?.password;
     const fullname = requestData?.fullname;
     const role = requestData?.role;
-    if (from.type !== "admin") {
+    if (from.type !== "admin" && operation !== "getOne" && operation !== "getAll") {
       sendResponse3(id, {
         success: false,
         error: "Unauthorized: Only admin can manage users"
@@ -5885,13 +6452,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,
@@ -5903,19 +6486,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 handleQuery(id, filters, limit, sort, executeCollection, dashboardManager2, sendMessage, from.id);
         break;
       default:
         sendResponse4(id, {
@@ -5931,7 +6517,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,
@@ -5939,21 +6525,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) {
@@ -5963,36 +6578,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) {
-    sendResponse4(id, {
-      success: false,
-      error: "Dashboard ID is required and cannot be empty"
-    }, sendMessage, clientId);
-    return;
-  }
-  if (!dashboard) {
+async function handleUpdate2(id, numericId, dashboardId, dashboard, name, description, updatedBy, executeCollection, dashboardManager2, sendMessage, clientId) {
+  if (!numericId) {
     sendResponse4(id, {
       success: false,
-      error: "Dashboard data is required"
+      error: "Dashboard ID is required"
     }, sendMessage, clientId);
     return;
   }
   try {
-    const updatedDashboard = dashboardManager2.updateDashboard(dashboardId, dashboard);
+    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(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) {
@@ -6002,65 +6637,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) {
+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(`Admin retrieved all dashboards (count: ${dashboards.length})`);
+  logger.info(`[FILE] Retrieved ${dashboards.length} dashboards`);
   sendResponse4(id, {
     success: true,
     data: {
       dashboards,
       count: dashboards.length,
-      message: `Retrieved ${dashboards.length} dashboards`
+      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 handleQuery(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);
 }
@@ -6093,13 +6817,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,
@@ -6111,19 +6851,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 handleQuery2(id, filters, limit, sort, executeCollection, reportManager2, sendMessage, from.id);
         break;
       default:
         sendResponse5(id, {
@@ -6139,7 +6882,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,
@@ -6147,21 +6890,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) {
@@ -6171,36 +6943,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) {
@@ -6210,65 +7002,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 handleQuery2(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);
 }
@@ -6288,6 +7169,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 handleQuery3(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 handleQuery3(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) => {
@@ -6304,22 +7476,24 @@ 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;
     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);
@@ -6328,82 +7502,75 @@ async function handleBookmarksRequest(data, collections, sendMessage) {
         await handleGetByThread(id, threadId, 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);
@@ -6411,23 +7578,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,
@@ -6435,15 +7602,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);
@@ -6451,14 +7618,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);
@@ -6466,7 +7633,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);
@@ -6474,7 +7641,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,
@@ -6482,7 +7649,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);
@@ -6490,7 +7657,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);
@@ -6498,7 +7665,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,
@@ -6506,13 +7673,13 @@ 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) {
+function sendResponse7(id, res, sendMessage, clientId) {
   const response = {
     id: id || "unknown",
     type: "BOOKMARKS_RES",
@@ -7364,7 +8531,10 @@ var SuperatomSDK = class {
     this.url = config.url || process.env.SA_WEBSOCKET_URL || DEFAULT_WS_URL;
     this.anthropicApiKey = config.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY || "";
     this.groqApiKey = config.GROQ_API_KEY || process.env.GROQ_API_KEY || "";
+    this.geminiApiKey = config.GEMINI_API_KEY || process.env.GEMINI_API_KEY || "";
+    this.openaiApiKey = config.OPENAI_API_KEY || process.env.OPENAI_API_KEY || "";
     this.llmProviders = config.LLM_PROVIDERS || getLLMProviders();
+    logger.info(`Initializing Superatom SDK v${SDK_VERSION} for project ${this.projectId}, llm providers: ${this.llmProviders.join(", ")}, config llm providers: ${config.LLM_PROVIDERS}`);
     this.userManager = new UserManager(this.projectId, 5e3);
     this.dashboardManager = new DashboardManager(this.projectId);
     this.reportManager = new ReportManager(this.projectId);
@@ -7449,7 +8619,9 @@ var SuperatomSDK = class {
     return new Promise((resolve, reject) => {
       try {
         const url = new URL(this.url);
-        url.searchParams.set("apiKey", this.apiKey);
+        if (this.apiKey) {
+          url.searchParams.set("apiKey", this.apiKey);
+        }
         url.searchParams.set("projectId", this.projectId);
         url.searchParams.set("userId", this.userId);
         url.searchParams.set("type", this.type);
@@ -7508,22 +8680,22 @@ var SuperatomSDK = class {
           });
           break;
         case "USER_PROMPT_REQ":
-          handleUserPromptRequest(parsed, this.components, (msg) => this.send(msg), this.anthropicApiKey, this.groqApiKey, this.llmProviders, this.collections, this.tools, this.userId).catch((error) => {
+          handleUserPromptRequest(parsed, this.components, (msg) => this.send(msg), this.anthropicApiKey, this.groqApiKey, this.geminiApiKey, this.openaiApiKey, this.llmProviders, this.collections, this.tools, this.userId).catch((error) => {
             logger.error("Failed to handle user prompt request:", error);
           });
           break;
         case "ACTIONS":
-          handleActionsRequest(parsed, (msg) => this.send(msg), this.anthropicApiKey, this.groqApiKey, this.llmProviders).catch((error) => {
+          handleActionsRequest(parsed, (msg) => this.send(msg), this.anthropicApiKey, this.groqApiKey, this.geminiApiKey, this.openaiApiKey, this.llmProviders).catch((error) => {
             logger.error("Failed to handle actions request:", error);
           });
           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;
@@ -7533,15 +8705,20 @@ var SuperatomSDK = class {
           });
           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);