@superatomai/sdk-node 0.0.55 → 0.0.57

package/dist/index.mjs

@@ -2359,10 +2359,30 @@ var BookmarksRequestMessageSchema = z3.object({
   type: z3.literal("BOOKMARKS"),
   payload: BookmarksRequestPayloadSchema
 });
+var ArtifactsRequestPayloadSchema = z3.object({
+  operation: z3.enum(["create", "update", "delete", "getAll", "getOne"]),
+  data: z3.object({
+    id: z3.number().optional(),
+    name: z3.string().optional(),
+    createdBy: z3.number().optional(),
+    dsl: z3.record(z3.any()).optional(),
+    status: z3.string().optional(),
+    deleted: z3.boolean().optional(),
+    limit: z3.number().optional()
+  }).optional()
+});
+var ArtifactsRequestMessageSchema = z3.object({
+  id: z3.string(),
+  from: MessageParticipantSchema,
+  type: z3.literal("ARTIFACTS"),
+  payload: ArtifactsRequestPayloadSchema
+});
+var KbNodeTypeSchema = z3.enum(["global", "user", "query"]);
 var KbNodesQueryFiltersSchema = z3.object({
   query: z3.string().optional(),
   category: z3.string().optional(),
   tags: z3.array(z3.string()).optional(),
+  type: KbNodeTypeSchema.optional(),
   createdBy: z3.number().optional()
 });
 var KbNodesRequestPayloadSchema = z3.object({
@@ -2373,6 +2393,7 @@ var KbNodesRequestPayloadSchema = z3.object({
     content: z3.string().optional(),
     category: z3.string().optional(),
     tags: z3.array(z3.string()).optional(),
+    type: KbNodeTypeSchema.optional(),
     createdBy: z3.number().optional(),
     updatedBy: z3.number().optional(),
     userId: z3.number().optional(),
@@ -5386,7 +5407,7 @@ var getKnowledgeBase = async ({
       topK
     });
     if (!result || !result.content) {
-      logger.error("[KnowledgeBase] No knowledge base results returned");
+      logger.info("[KnowledgeBase] No knowledge base results returned");
       return "";
     }
     logger.info(`[KnowledgeBase] Retrieved knowledge base context (${result.content.length} chars)`);
@@ -5400,8 +5421,101 @@ var getKnowledgeBase = async ({
     return "";
   }
 };
+var getGlobalKnowledgeBase = async ({
+  collections,
+  limit = 100
+}) => {
+  try {
+    if (!collections || !collections["knowledge-base"] || !collections["knowledge-base"]["getGlobal"]) {
+      logger.info("[KnowledgeBase] knowledge-base.getGlobal collection not registered, skipping");
+      return "";
+    }
+    logger.info("[KnowledgeBase] Fetching global knowledge base nodes...");
+    const result = await collections["knowledge-base"]["getGlobal"]({ limit });
+    if (!result || !result.content) {
+      logger.info("[KnowledgeBase] No global knowledge base nodes found");
+      return "";
+    }
+    logger.info(`[KnowledgeBase] Retrieved ${result.count || 0} global knowledge base nodes`);
+    return result.content;
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    logger.warn(`[KnowledgeBase] Error fetching global knowledge base: ${errorMsg}`);
+    return "";
+  }
+};
+var getUserKnowledgeBase = async ({
+  collections,
+  userId,
+  limit = 100
+}) => {
+  try {
+    if (!userId) {
+      logger.info("[KnowledgeBase] No userId provided, skipping user knowledge base");
+      return "";
+    }
+    if (!collections || !collections["knowledge-base"] || !collections["knowledge-base"]["getByUser"]) {
+      logger.info("[KnowledgeBase] knowledge-base.getByUser collection not registered, skipping");
+      return "";
+    }
+    logger.info(`[KnowledgeBase] Fetching user knowledge base nodes for userId: ${userId}...`);
+    const result = await collections["knowledge-base"]["getByUser"]({
+      userId: Number(userId),
+      limit
+    });
+    if (!result || !result.content) {
+      logger.info(`[KnowledgeBase] No user knowledge base nodes found for userId: ${userId}`);
+      return "";
+    }
+    logger.info(`[KnowledgeBase] Retrieved ${result.count || 0} user knowledge base nodes for userId: ${userId}`);
+    return result.content;
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    logger.warn(`[KnowledgeBase] Error fetching user knowledge base: ${errorMsg}`);
+    return "";
+  }
+};
+var getAllKnowledgeBase = async ({
+  prompt,
+  collections,
+  userId,
+  topK = 3
+}) => {
+  logger.info("[KnowledgeBase] Fetching all knowledge base contexts...");
+  const [globalContext, userContext, queryContext] = await Promise.all([
+    getGlobalKnowledgeBase({ collections }),
+    getUserKnowledgeBase({ collections, userId }),
+    getKnowledgeBase({ prompt, collections, topK })
+  ]);
+  let combinedContext = "";
+  if (globalContext) {
+    combinedContext += "## Global Knowledge Base\n";
+    combinedContext += "The following information applies to all queries:\n\n";
+    combinedContext += globalContext + "\n\n";
+  }
+  if (userContext) {
+    combinedContext += "## User-Specific Knowledge Base\n";
+    combinedContext += "The following information is specific to this user:\n\n";
+    combinedContext += userContext + "\n\n";
+  }
+  if (queryContext) {
+    combinedContext += "## Relevant Knowledge Base (Query-Matched)\n";
+    combinedContext += "The following information is semantically relevant to the current query:\n\n";
+    combinedContext += queryContext + "\n\n";
+  }
+  logger.info(`[KnowledgeBase] Combined knowledge base context: global=${globalContext.length} chars, user=${userContext.length} chars, query=${queryContext.length} chars`);
+  return {
+    globalContext,
+    userContext,
+    queryContext,
+    combinedContext: combinedContext.trim()
+  };
+};
 var KB = {
-  getKnowledgeBase
+  getKnowledgeBase,
+  getGlobalKnowledgeBase,
+  getUserKnowledgeBase,
+  getAllKnowledgeBase
 };
 var knowledge_base_default = KB;
 
@@ -6264,8 +6378,9 @@ ${executedToolsText}`);
    * @param components - Optional list of available components for matching suggestions
    * @param externalTools - Optional array of external tools (email, calendar, etc.) that can be called
    * @param category - Question category ('data_analysis' | 'data_modification' | 'general'). For data_modification, answer component streaming is skipped. For general, component generation is skipped entirely.
+   * @param userId - Optional user ID for fetching user-specific knowledge base nodes
    */
-  async generateTextResponse(userPrompt, apiKey, logCollector, conversationHistory, streamCallback, collections, components, externalTools, category) {
+  async generateTextResponse(userPrompt, apiKey, logCollector, conversationHistory, streamCallback, collections, components, externalTools, category, userId) {
     const errors = [];
     logger.debug(`[${this.getProviderName()}] Starting text response generation`);
     logger.debug(`[${this.getProviderName()}] User prompt: "${userPrompt.substring(0, 50)}..."`);
@@ -6314,11 +6429,13 @@ ${executedToolsText}`);
       }
       const schemaDoc = schema.generateSchemaDocumentation();
       const databaseRules = await promptLoader.loadDatabaseRules();
-      const knowledgeBaseContext = await knowledge_base_default.getKnowledgeBase({
+      const kbResult = await knowledge_base_default.getAllKnowledgeBase({
         prompt: userPrompt,
         collections,
-        topK: 1
+        userId,
+        topK: 3
       });
+      const knowledgeBaseContext = kbResult.combinedContext;
       const prompts = await promptLoader.loadPrompts("text-response", {
         USER_PROMPT: userPrompt,
         CONVERSATION_HISTORY: conversationHistory || "No previous conversation",
@@ -6444,10 +6561,58 @@ ${executedToolsText}`);
       const executedToolsList = [];
       let maxAttemptsReached = false;
       let fullStreamedText = "";
+      let streamBuffer = "";
+      let flushTimer = null;
+      const FLUSH_INTERVAL = 50;
+      const flushStreamBuffer = () => {
+        if (streamBuffer && streamCallback) {
+          streamCallback(streamBuffer);
+          streamBuffer = "";
+        }
+        flushTimer = null;
+      };
       const wrappedStreamCallback = streamCallback ? (chunk) => {
         fullStreamedText += chunk;
-        streamCallback(chunk);
+        streamBuffer += chunk;
+        if (chunk.includes("\n") || chunk.length > 100) {
+          if (flushTimer) {
+            clearTimeout(flushTimer);
+            flushTimer = null;
+          }
+          flushStreamBuffer();
+        } else if (!flushTimer) {
+          flushTimer = setTimeout(flushStreamBuffer, FLUSH_INTERVAL);
+        }
       } : void 0;
+      const flushStream = () => {
+        if (flushTimer) {
+          clearTimeout(flushTimer);
+          flushTimer = null;
+        }
+        flushStreamBuffer();
+      };
+      const streamDelay = (ms = 50) => new Promise((resolve) => setTimeout(resolve, ms));
+      const withProgressHeartbeat = async (operation, progressMessage, intervalMs = 1e3) => {
+        if (!wrappedStreamCallback) {
+          return operation();
+        }
+        const startTime = Date.now();
+        await streamDelay(30);
+        wrappedStreamCallback(`\u23F3 ${progressMessage}`);
+        const heartbeatInterval = setInterval(() => {
+          const elapsedSeconds = Math.floor((Date.now() - startTime) / 1e3);
+          if (elapsedSeconds >= 1) {
+            wrappedStreamCallback(` (${elapsedSeconds}s)`);
+          }
+        }, intervalMs);
+        try {
+          const result2 = await operation();
+          return result2;
+        } finally {
+          clearInterval(heartbeatInterval);
+          wrappedStreamCallback("\n\n");
+        }
+      };
       const toolHandler = async (toolName, toolInput) => {
         if (toolName === "execute_query") {
           let sql = toolInput.sql;
@@ -6482,6 +6647,7 @@ Please try rephrasing your question or simplifying your request.
             throw new Error(errorMsg);
           }
           try {
+            flushStream();
             if (wrappedStreamCallback) {
               const paramsDisplay = Object.keys(params).length > 0 ? `
 **Parameters:** ${JSON.stringify(params)}` : "";
@@ -6491,10 +6657,12 @@ Please try rephrasing your question or simplifying your request.
 \u{1F50D} **Analyzing your question...**
 
 `);
+                await streamDelay(50);
                 if (reasoning) {
                   wrappedStreamCallback(`\u{1F4AD} ${reasoning}
 
 `);
+                  await streamDelay(50);
                 }
                 wrappedStreamCallback(`\u{1F4DD} **Generated SQL Query:**
 \`\`\`sql
@@ -6502,19 +6670,19 @@ ${sql}
 \`\`\`${paramsDisplay}
 
 `);
-                wrappedStreamCallback(`\u26A1 **Executing query...**
-
-`);
+                await streamDelay(50);
               } else {
                 wrappedStreamCallback(`
 
 \u{1F504} **Retrying with corrected query (attempt ${attempts}/${MAX_QUERY_ATTEMPTS})...**
 
 `);
+                await streamDelay(50);
                 if (reasoning) {
                   wrappedStreamCallback(`\u{1F4AD} ${reasoning}
 
 `);
+                  await streamDelay(50);
                 }
                 wrappedStreamCallback(`\u{1F4DD} **Corrected SQL Query:**
 \`\`\`sql
@@ -6522,9 +6690,7 @@ ${sql}
 \`\`\`${paramsDisplay}
 
 `);
-                wrappedStreamCallback(`\u26A1 **Executing query...**
-
-`);
+                await streamDelay(50);
               }
             }
             logCollector?.logQuery(
@@ -6536,15 +6702,22 @@ ${sql}
               throw new Error("Database collection not registered. Please register database.execute collection to execute queries.");
             }
             const queryPayload = Object.keys(params).length > 0 ? { sql: JSON.stringify({ sql, values: params }) } : { sql };
-            const result2 = await collections["database"]["execute"](queryPayload);
+            const result2 = await withProgressHeartbeat(
+              () => collections["database"]["execute"](queryPayload),
+              "Executing database query",
+              800
+              // Send heartbeat every 800ms for responsive feedback
+            );
             const data = result2?.data || result2;
             const rowCount = result2?.count ?? (Array.isArray(data) ? data.length : "N/A");
             logger.info(`[${this.getProviderName()}] Query executed successfully, rows returned: ${rowCount}`);
             logCollector?.info(`Query successful, returned ${rowCount} rows`);
             if (wrappedStreamCallback) {
-              wrappedStreamCallback(`\u2705 **Query executed successfully!**
+              wrappedStreamCallback(`
+\u2705 **Query executed successfully!**
 
 `);
+              await streamDelay(50);
               if (Array.isArray(data) && data.length > 0) {
                 const firstRow = data[0];
                 const columns = Object.keys(firstRow);
@@ -6553,18 +6726,22 @@ ${sql}
                   wrappedStreamCallback(`**Result:** ${value}
 
 `);
+                  await streamDelay(50);
                 } else if (data.length > 0) {
                   wrappedStreamCallback(`**Retrieved ${rowCount} rows**
 
 `);
+                  await streamDelay(50);
                   wrappedStreamCallback(`<DataTable>${JSON.stringify(data)}</DataTable>
 
 `);
+                  await streamDelay(50);
                 }
               } else if (Array.isArray(data) && data.length === 0) {
                 wrappedStreamCallback(`**No rows returned.**
 
 `);
+                await streamDelay(50);
               }
               wrappedStreamCallback(`\u{1F4CA} **Analyzing results...**
 
@@ -6614,6 +6791,7 @@ Please try rephrasing your request or contact support.
               throw new Error(errorMsg);
             }
             try {
+              flushStream();
               if (wrappedStreamCallback) {
                 if (attempts === 1) {
                   wrappedStreamCallback(`
@@ -6628,8 +6806,14 @@ Please try rephrasing your request or contact support.
 
 `);
                 }
+                await streamDelay(50);
               }
-              const result2 = await externalTool.fn(toolInput);
+              const result2 = await withProgressHeartbeat(
+                () => externalTool.fn(toolInput),
+                `Running ${externalTool.name}`,
+                800
+                // Send heartbeat every 800ms
+              );
               logger.info(`[${this.getProviderName()}] External tool ${externalTool.name} executed successfully`);
               logCollector?.info(`\u2713 ${externalTool.name} executed successfully`);
               if (!executedToolsList.find((t) => t.id === externalTool.id)) {
@@ -6662,6 +6846,7 @@ Please try rephrasing your request or contact support.
                 wrappedStreamCallback(`\u2705 **${externalTool.name} completed successfully**
 
 `);
+                await streamDelay(50);
               }
               return JSON.stringify(result2, null, 2);
             } catch (error) {
@@ -6730,7 +6915,9 @@ ${errorMsg}
           textLength: textResponse.length
         }
       );
+      flushStream();
       if (wrappedStreamCallback && components && components.length > 0 && category !== "general") {
+        wrappedStreamCallback("\n\n\u{1F4CA} **Generating visualization components...**\n\n");
         wrappedStreamCallback("__TEXT_COMPLETE__COMPONENT_GENERATION_START__");
       }
       let matchedComponents = [];
@@ -7040,7 +7227,8 @@ ${errorMsg}
         collections,
         components,
         toolsToUse,
-        categoryClassification.category
+        categoryClassification.category,
+        userId
       );
       const elapsedTime = Date.now() - startTime;
       logger.info(`[${this.getProviderName()}] Total time taken: ${elapsedTime}ms (${(elapsedTime / 1e3).toFixed(2)}s)`);
@@ -10113,6 +10301,182 @@ function sendResponse7(id, res, sendMessage, clientId) {
   sendMessage(response);
 }
 
+// src/handlers/artifacts.ts
+init_logger();
+async function handleArtifactsRequest(data, collections, sendMessage) {
+  const executeCollection = async (collection, op, params) => {
+    const handler = collections[collection]?.[op];
+    if (!handler) {
+      throw new Error(`Collection operation ${collection}.${op} not found`);
+    }
+    return await handler(params);
+  };
+  try {
+    const request = ArtifactsRequestMessageSchema.parse(data);
+    const { id, payload, from } = request;
+    const { operation, data: requestData } = payload;
+    const artifactId = requestData?.id;
+    const name = requestData?.name;
+    const createdBy = requestData?.createdBy;
+    const dsl = requestData?.dsl;
+    const status = requestData?.status;
+    const deleted = requestData?.deleted;
+    const limit = requestData?.limit;
+    switch (operation) {
+      case "create":
+        await handleCreate6(id, name, createdBy, dsl, status, executeCollection, sendMessage, from.id);
+        break;
+      case "update":
+        await handleUpdate6(id, artifactId, name, dsl, status, deleted, executeCollection, sendMessage, from.id);
+        break;
+      case "delete":
+        await handleDelete6(id, artifactId, executeCollection, sendMessage, from.id);
+        break;
+      case "getAll":
+        await handleGetAll6(id, limit, executeCollection, sendMessage, from.id);
+        break;
+      case "getOne":
+        await handleGetOne6(id, artifactId, executeCollection, sendMessage, from.id);
+        break;
+      default:
+        sendResponse8(id, {
+          success: false,
+          error: `Unknown operation: ${operation}`
+        }, sendMessage, from.id);
+    }
+  } catch (error) {
+    logger.error("Failed to handle artifacts request:", error);
+    sendResponse8(null, {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error occurred"
+    }, sendMessage);
+  }
+}
+async function handleCreate6(id, name, createdBy, dsl, status, executeCollection, sendMessage, clientId) {
+  if (!name) {
+    sendResponse8(id, {
+      success: false,
+      error: "name is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("artifacts", "create", { name, createdBy, dsl, status });
+    sendResponse8(id, {
+      success: true,
+      data: result.data,
+      message: "Artifact created successfully"
+    }, sendMessage, clientId);
+    logger.info(`Artifact created: ID ${result.data.id}`);
+  } catch (error) {
+    sendResponse8(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to create artifact"
+    }, sendMessage, clientId);
+  }
+}
+async function handleUpdate6(id, artifactId, name, dsl, status, deleted, executeCollection, sendMessage, clientId) {
+  if (!artifactId) {
+    sendResponse8(id, {
+      success: false,
+      error: "Artifact ID is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("artifacts", "update", { id: artifactId, name, dsl, status, deleted });
+    sendResponse8(id, {
+      success: true,
+      data: result.data,
+      message: "Artifact updated successfully"
+    }, sendMessage, clientId);
+    logger.info(`Artifact updated: ID ${artifactId}`);
+  } catch (error) {
+    sendResponse8(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to update artifact"
+    }, sendMessage, clientId);
+  }
+}
+async function handleDelete6(id, artifactId, executeCollection, sendMessage, clientId) {
+  if (!artifactId) {
+    sendResponse8(id, {
+      success: false,
+      error: "Artifact ID is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("artifacts", "delete", { id: artifactId });
+    sendResponse8(id, {
+      success: true,
+      data: result.data,
+      message: "Artifact deleted successfully"
+    }, sendMessage, clientId);
+    logger.info(`Artifact deleted: ID ${artifactId}`);
+  } catch (error) {
+    sendResponse8(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to delete artifact"
+    }, sendMessage, clientId);
+  }
+}
+async function handleGetAll6(id, limit, executeCollection, sendMessage, clientId) {
+  try {
+    const result = await executeCollection("artifacts", "getAll", { limit });
+    sendResponse8(id, {
+      success: true,
+      data: result.data,
+      count: result.count,
+      message: `Retrieved ${result.count} artifacts`
+    }, sendMessage, clientId);
+    logger.info(`Retrieved all artifacts (count: ${result.count})`);
+  } catch (error) {
+    sendResponse8(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to get artifacts"
+    }, sendMessage, clientId);
+  }
+}
+async function handleGetOne6(id, artifactId, executeCollection, sendMessage, clientId) {
+  if (!artifactId) {
+    sendResponse8(id, {
+      success: false,
+      error: "Artifact ID is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("artifacts", "getOne", { id: artifactId });
+    sendResponse8(id, {
+      success: true,
+      data: result.data,
+      message: `Retrieved artifact ID ${artifactId}`
+    }, sendMessage, clientId);
+    logger.info(`Retrieved artifact: ID ${artifactId}`);
+  } catch (error) {
+    sendResponse8(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to get artifact"
+    }, sendMessage, clientId);
+  }
+}
+function sendResponse8(id, res, sendMessage, clientId) {
+  const response = {
+    id: id || "unknown",
+    type: "ARTIFACTS_RES",
+    from: { type: "data-agent" },
+    to: {
+      type: "user",
+      id: clientId
+    },
+    payload: {
+      ...res
+    }
+  };
+  sendMessage(response);
+}
+
 // src/handlers/kb-nodes.ts
 init_logger();
 async function handleKbNodesRequest(data, collections, sendMessage) {
@@ -10132,6 +10496,7 @@ async function handleKbNodesRequest(data, collections, sendMessage) {
     const content = requestData?.content;
     const category = requestData?.category;
     const tags = requestData?.tags;
+    const type = requestData?.type;
     const createdBy = requestData?.createdBy;
     const updatedBy = requestData?.updatedBy;
     const userId = requestData?.userId;
@@ -10141,22 +10506,22 @@ async function handleKbNodesRequest(data, collections, sendMessage) {
     const offset = requestData?.offset;
     switch (operation) {
       case "create":
-        await handleCreate6(id, { title, content, category, tags, createdBy }, executeCollection, sendMessage, from.id);
+        await handleCreate7(id, { title, content, category, tags, type, createdBy }, executeCollection, sendMessage, from.id);
         break;
       case "update":
-        await handleUpdate6(id, nodeId, { title, content, category, tags, updatedBy }, executeCollection, sendMessage, from.id);
+        await handleUpdate7(id, nodeId, { title, content, category, tags, type, updatedBy }, executeCollection, sendMessage, from.id);
         break;
       case "delete":
-        await handleDelete6(id, nodeId, executeCollection, sendMessage, from.id);
+        await handleDelete7(id, nodeId, executeCollection, sendMessage, from.id);
         break;
       case "getAll":
-        await handleGetAll6(id, limit, offset, executeCollection, sendMessage, from.id);
+        await handleGetAll7(id, limit, offset, executeCollection, sendMessage, from.id);
         break;
       case "getOne":
-        await handleGetOne6(id, nodeId, executeCollection, sendMessage, from.id);
+        await handleGetOne7(id, nodeId, executeCollection, sendMessage, from.id);
         break;
       case "search":
-        await handleSearch(id, { query, category, tags, createdBy, limit, offset }, executeCollection, sendMessage, from.id);
+        await handleSearch(id, { query, category, tags, type, createdBy, limit, offset }, executeCollection, sendMessage, from.id);
         break;
       case "getByCategory":
         await handleGetByCategory(id, category, limit, offset, executeCollection, sendMessage, from.id);
@@ -10171,37 +10536,37 @@ async function handleKbNodesRequest(data, collections, sendMessage) {
         await handleGetTags(id, executeCollection, sendMessage, from.id);
         break;
       default:
-        sendResponse8(id, {
+        sendResponse9(id, {
           success: false,
           error: `Unknown operation: ${operation}`
         }, sendMessage, from.id);
     }
   } catch (error) {
     logger.error("Failed to handle KB nodes request:", error);
-    sendResponse8(null, {
+    sendResponse9(null, {
       success: false,
       error: error instanceof Error ? error.message : "Unknown error occurred"
     }, sendMessage);
   }
 }
-async function handleCreate6(id, nodeData, executeCollection, sendMessage, clientId) {
-  const { title, content, category, tags, createdBy } = nodeData;
+async function handleCreate7(id, nodeData, executeCollection, sendMessage, clientId) {
+  const { title, content, category, tags, type, createdBy } = nodeData;
   if (!title || title.trim().length === 0) {
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: "Title is required and cannot be empty"
     }, sendMessage, clientId);
     return;
   }
   if (!content || content.trim().length === 0) {
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: "Content is required and cannot be empty"
     }, sendMessage, clientId);
     return;
   }
   if (!createdBy) {
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: "createdBy (user ID) is required"
     }, sendMessage, clientId);
@@ -10213,11 +10578,12 @@ async function handleCreate6(id, nodeData, executeCollection, sendMessage, clien
       content,
       category: category || void 0,
       tags: tags || void 0,
+      type: type || "query",
       createdBy
     });
     if (result && result.success) {
       logger.info(`[DB] KB node created successfully: ${title}`);
-      sendResponse8(id, {
+      sendResponse9(id, {
         success: true,
         data: {
           ...result.data,
@@ -10226,29 +10592,29 @@ async function handleCreate6(id, nodeData, executeCollection, sendMessage, clien
       }, sendMessage, clientId);
       return;
     }
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: "Failed to create knowledge node"
     }, sendMessage, clientId);
   } catch (error) {
     logger.error("[DB] Failed to create KB node:", error);
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to create knowledge node"
     }, sendMessage, clientId);
   }
 }
-async function handleUpdate6(id, nodeId, nodeData, executeCollection, sendMessage, clientId) {
-  const { title, content, category, tags, updatedBy } = nodeData;
+async function handleUpdate7(id, nodeId, nodeData, executeCollection, sendMessage, clientId) {
+  const { title, content, category, tags, type, updatedBy } = nodeData;
   if (!nodeId) {
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: "Knowledge node ID is required"
     }, sendMessage, clientId);
     return;
   }
   if (!updatedBy) {
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: "updatedBy (user ID) is required"
     }, sendMessage, clientId);
@@ -10261,11 +10627,12 @@ async function handleUpdate6(id, nodeId, nodeData, executeCollection, sendMessag
       content,
       category,
       tags,
+      type,
       updatedBy
     });
     if (result && result.success) {
       logger.info(`[DB] KB node updated successfully, ID: ${nodeId}`);
-      sendResponse8(id, {
+      sendResponse9(id, {
         success: true,
         data: {
           ...result.data,
@@ -10274,21 +10641,21 @@ async function handleUpdate6(id, nodeId, nodeData, executeCollection, sendMessag
       }, sendMessage, clientId);
       return;
     }
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: "Failed to update knowledge node"
     }, sendMessage, clientId);
   } catch (error) {
     logger.error("[DB] Failed to update KB node:", error);
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to update knowledge node"
     }, sendMessage, clientId);
   }
 }
-async function handleDelete6(id, nodeId, executeCollection, sendMessage, clientId) {
+async function handleDelete7(id, nodeId, executeCollection, sendMessage, clientId) {
   if (!nodeId) {
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: "Knowledge node ID is required"
     }, sendMessage, clientId);
@@ -10298,7 +10665,7 @@ async function handleDelete6(id, nodeId, executeCollection, sendMessage, clientI
     const result = await executeCollection("kbNodes", "delete", { id: nodeId });
     if (result && result.success) {
       logger.info(`[DB] KB node deleted successfully, ID: ${nodeId}`);
-      sendResponse8(id, {
+      sendResponse9(id, {
         success: true,
         data: {
           id: nodeId,
@@ -10308,19 +10675,19 @@ async function handleDelete6(id, nodeId, executeCollection, sendMessage, clientI
       }, sendMessage, clientId);
       return;
     }
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: "Failed to delete knowledge node"
     }, sendMessage, clientId);
   } catch (error) {
     logger.error("[DB] Failed to delete KB node:", error);
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to delete knowledge node"
     }, sendMessage, clientId);
   }
 }
-async function handleGetAll6(id, limit, offset, executeCollection, sendMessage, clientId) {
+async function handleGetAll7(id, limit, offset, executeCollection, sendMessage, clientId) {
   try {
     const result = await executeCollection("kbNodes", "getAll", {
       limit: limit || 100,
@@ -10328,7 +10695,7 @@ async function handleGetAll6(id, limit, offset, executeCollection, sendMessage,
     });
     if (result && result.success) {
       logger.info(`[DB] Retrieved ${result.count} KB nodes`);
-      sendResponse8(id, {
+      sendResponse9(id, {
         success: true,
         data: {
           nodes: result.data,
@@ -10338,21 +10705,21 @@ async function handleGetAll6(id, limit, offset, executeCollection, sendMessage,
       }, sendMessage, clientId);
       return;
     }
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: "Failed to retrieve knowledge nodes"
     }, sendMessage, clientId);
   } catch (error) {
     logger.error("[DB] Failed to get all KB nodes:", error);
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to retrieve knowledge nodes"
     }, sendMessage, clientId);
   }
 }
-async function handleGetOne6(id, nodeId, executeCollection, sendMessage, clientId) {
+async function handleGetOne7(id, nodeId, executeCollection, sendMessage, clientId) {
   if (!nodeId) {
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: "Knowledge node ID is required"
     }, sendMessage, clientId);
@@ -10362,7 +10729,7 @@ async function handleGetOne6(id, nodeId, executeCollection, sendMessage, clientI
     const result = await executeCollection("kbNodes", "getOne", { id: nodeId });
     if (result && result.success) {
       logger.info(`[DB] Retrieved KB node ID: ${nodeId}`);
-      sendResponse8(id, {
+      sendResponse9(id, {
         success: true,
         data: {
           node: result.data,
@@ -10371,32 +10738,33 @@ async function handleGetOne6(id, nodeId, executeCollection, sendMessage, clientI
       }, sendMessage, clientId);
       return;
     }
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: "Failed to retrieve knowledge node"
     }, sendMessage, clientId);
   } catch (error) {
     logger.error("[DB] Failed to get KB node:", error);
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to retrieve knowledge node"
     }, sendMessage, clientId);
   }
 }
 async function handleSearch(id, searchParams, executeCollection, sendMessage, clientId) {
-  const { query, category, tags, createdBy, limit, offset } = searchParams;
+  const { query, category, tags, type, createdBy, limit, offset } = searchParams;
   try {
     const result = await executeCollection("kbNodes", "search", {
       query,
       category,
       tags,
+      type,
       createdBy,
       limit: limit || 50,
       offset: offset || 0
     });
     if (result && result.success) {
       logger.info(`[DB] Search returned ${result.count} KB nodes`);
-      sendResponse8(id, {
+      sendResponse9(id, {
         success: true,
         data: {
           nodes: result.data,
@@ -10406,13 +10774,13 @@ async function handleSearch(id, searchParams, executeCollection, sendMessage, cl
       }, sendMessage, clientId);
       return;
     }
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: "Failed to search knowledge nodes"
     }, sendMessage, clientId);
   } catch (error) {
     logger.error("[DB] Failed to search KB nodes:", error);
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to search knowledge nodes"
     }, sendMessage, clientId);
@@ -10420,7 +10788,7 @@ async function handleSearch(id, searchParams, executeCollection, sendMessage, cl
 }
 async function handleGetByCategory(id, category, limit, offset, executeCollection, sendMessage, clientId) {
   if (!category) {
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: "Category is required"
     }, sendMessage, clientId);
@@ -10434,7 +10802,7 @@ async function handleGetByCategory(id, category, limit, offset, executeCollectio
     });
     if (result && result.success) {
       logger.info(`[DB] Retrieved ${result.count} KB nodes for category: ${category}`);
-      sendResponse8(id, {
+      sendResponse9(id, {
         success: true,
         data: {
           nodes: result.data,
@@ -10445,13 +10813,13 @@ async function handleGetByCategory(id, category, limit, offset, executeCollectio
       }, sendMessage, clientId);
       return;
     }
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: "Failed to retrieve knowledge nodes by category"
     }, sendMessage, clientId);
   } catch (error) {
     logger.error("[DB] Failed to get KB nodes by category:", error);
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to retrieve knowledge nodes by category"
     }, sendMessage, clientId);
@@ -10459,7 +10827,7 @@ async function handleGetByCategory(id, category, limit, offset, executeCollectio
 }
 async function handleGetByUser(id, userId, limit, offset, executeCollection, sendMessage, clientId) {
   if (!userId) {
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: "User ID is required"
     }, sendMessage, clientId);
@@ -10473,7 +10841,7 @@ async function handleGetByUser(id, userId, limit, offset, executeCollection, sen
     });
     if (result && result.success) {
       logger.info(`[DB] Retrieved ${result.count} KB nodes for user: ${userId}`);
-      sendResponse8(id, {
+      sendResponse9(id, {
         success: true,
         data: {
           nodes: result.data,
@@ -10484,13 +10852,13 @@ async function handleGetByUser(id, userId, limit, offset, executeCollection, sen
       }, sendMessage, clientId);
       return;
     }
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: "Failed to retrieve knowledge nodes by user"
     }, sendMessage, clientId);
   } catch (error) {
     logger.error("[DB] Failed to get KB nodes by user:", error);
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to retrieve knowledge nodes by user"
     }, sendMessage, clientId);
@@ -10501,7 +10869,7 @@ async function handleGetCategories(id, executeCollection, sendMessage, clientId)
     const result = await executeCollection("kbNodes", "getCategories", {});
     if (result && result.success) {
       logger.info(`[DB] Retrieved ${result.count} categories`);
-      sendResponse8(id, {
+      sendResponse9(id, {
         success: true,
         data: {
           categories: result.data,
@@ -10511,13 +10879,13 @@ async function handleGetCategories(id, executeCollection, sendMessage, clientId)
       }, sendMessage, clientId);
       return;
     }
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: "Failed to retrieve categories"
     }, sendMessage, clientId);
   } catch (error) {
     logger.error("[DB] Failed to get categories:", error);
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to retrieve categories"
     }, sendMessage, clientId);
@@ -10528,7 +10896,7 @@ async function handleGetTags(id, executeCollection, sendMessage, clientId) {
     const result = await executeCollection("kbNodes", "getTags", {});
     if (result && result.success) {
       logger.info(`[DB] Retrieved ${result.count} tags`);
-      sendResponse8(id, {
+      sendResponse9(id, {
         success: true,
         data: {
           tags: result.data,
@@ -10538,19 +10906,19 @@ async function handleGetTags(id, executeCollection, sendMessage, clientId) {
       }, sendMessage, clientId);
       return;
     }
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: "Failed to retrieve tags"
     }, sendMessage, clientId);
   } catch (error) {
     logger.error("[DB] Failed to get tags:", error);
-    sendResponse8(id, {
+    sendResponse9(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to retrieve tags"
     }, sendMessage, clientId);
   }
 }
-function sendResponse8(id, res, sendMessage, clientId) {
+function sendResponse9(id, res, sendMessage, clientId) {
   const response = {
     id: id || "unknown",
     type: "KB_NODES_RES",
@@ -10595,19 +10963,19 @@ async function handleMenusRequest(data, collections, sendMessage) {
     const items = requestData?.items;
     switch (operation) {
       case "create":
-        await handleCreate7(id, name, componentName, icon, userMessage, parentId, sortOrder, props, isActive, executeCollection, sendMessage, from.id);
+        await handleCreate8(id, name, componentName, icon, userMessage, parentId, sortOrder, props, isActive, executeCollection, sendMessage, from.id);
         break;
       case "update":
-        await handleUpdate7(id, menuId, name, componentName, icon, userMessage, parentId, sortOrder, props, isActive, executeCollection, sendMessage, from.id);
+        await handleUpdate8(id, menuId, name, componentName, icon, userMessage, parentId, sortOrder, props, isActive, executeCollection, sendMessage, from.id);
         break;
       case "delete":
-        await handleDelete7(id, menuId, executeCollection, sendMessage, from.id);
+        await handleDelete8(id, menuId, executeCollection, sendMessage, from.id);
         break;
       case "getAll":
-        await handleGetAll7(id, executeCollection, sendMessage, from.id);
+        await handleGetAll8(id, executeCollection, sendMessage, from.id);
         break;
       case "getOne":
-        await handleGetOne7(id, menuId, executeCollection, sendMessage, from.id);
+        await handleGetOne8(id, menuId, executeCollection, sendMessage, from.id);
         break;
       case "getRootMenus":
         await handleGetRootMenus(id, executeCollection, sendMessage, from.id);
@@ -10625,29 +10993,29 @@ async function handleMenusRequest(data, collections, sendMessage) {
         await handleReorder(id, items, executeCollection, sendMessage, from.id);
         break;
       default:
-        sendResponse9(id, {
+        sendResponse10(id, {
           success: false,
           error: `Unknown operation: ${operation}`
         }, sendMessage, from.id);
     }
   } catch (error) {
     logger.error("Failed to handle menus request:", error);
-    sendResponse9(null, {
+    sendResponse10(null, {
       success: false,
       error: error instanceof Error ? error.message : "Unknown error occurred"
     }, sendMessage);
   }
 }
-async function handleCreate7(id, name, componentName, icon, userMessage, parentId, sortOrder, props, isActive, executeCollection, sendMessage, clientId) {
+async function handleCreate8(id, name, componentName, icon, userMessage, parentId, sortOrder, props, isActive, executeCollection, sendMessage, clientId) {
   if (!name) {
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: false,
       error: "name is required"
     }, sendMessage, clientId);
     return;
   }
   if (!componentName) {
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: false,
       error: "componentName is required"
     }, sendMessage, clientId);
@@ -10664,22 +11032,22 @@ async function handleCreate7(id, name, componentName, icon, userMessage, parentI
       props,
       isActive
     });
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: true,
       data: result.data,
       message: "Menu created successfully"
     }, sendMessage, clientId);
     logger.info(`Menu created: ID ${result.data?.id}`);
   } catch (error) {
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to create menu"
     }, sendMessage, clientId);
   }
 }
-async function handleUpdate7(id, menuId, name, componentName, icon, userMessage, parentId, sortOrder, props, isActive, executeCollection, sendMessage, clientId) {
+async function handleUpdate8(id, menuId, name, componentName, icon, userMessage, parentId, sortOrder, props, isActive, executeCollection, sendMessage, clientId) {
   if (!menuId) {
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: false,
       error: "Menu ID is required"
     }, sendMessage, clientId);
@@ -10697,22 +11065,22 @@ async function handleUpdate7(id, menuId, name, componentName, icon, userMessage,
       props,
       isActive
     });
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: true,
       data: result.data,
       message: "Menu updated successfully"
     }, sendMessage, clientId);
     logger.info(`Menu updated: ID ${menuId}`);
   } catch (error) {
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to update menu"
     }, sendMessage, clientId);
   }
 }
-async function handleDelete7(id, menuId, executeCollection, sendMessage, clientId) {
+async function handleDelete8(id, menuId, executeCollection, sendMessage, clientId) {
   if (!menuId) {
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: false,
       error: "Menu ID is required"
     }, sendMessage, clientId);
@@ -10720,23 +11088,23 @@ async function handleDelete7(id, menuId, executeCollection, sendMessage, clientI
   }
   try {
     const result = await executeCollection("menus", "delete", { id: menuId });
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: true,
       data: result.data,
       message: "Menu deleted successfully"
     }, sendMessage, clientId);
     logger.info(`Menu deleted: ID ${menuId}`);
   } catch (error) {
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to delete menu"
     }, sendMessage, clientId);
   }
 }
-async function handleGetAll7(id, executeCollection, sendMessage, clientId) {
+async function handleGetAll8(id, executeCollection, sendMessage, clientId) {
   try {
     const result = await executeCollection("menus", "getAll", {});
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: true,
       data: result.data,
       count: result.count,
@@ -10744,15 +11112,15 @@ async function handleGetAll7(id, executeCollection, sendMessage, clientId) {
     }, sendMessage, clientId);
     logger.info(`Retrieved all menus (count: ${result.count})`);
   } catch (error) {
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to get menus"
     }, sendMessage, clientId);
   }
 }
-async function handleGetOne7(id, menuId, executeCollection, sendMessage, clientId) {
+async function handleGetOne8(id, menuId, executeCollection, sendMessage, clientId) {
   if (!menuId) {
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: false,
       error: "Menu ID is required"
     }, sendMessage, clientId);
@@ -10760,14 +11128,14 @@ async function handleGetOne7(id, menuId, executeCollection, sendMessage, clientI
   }
   try {
     const result = await executeCollection("menus", "getOne", { id: menuId });
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: true,
       data: result.data,
       message: `Retrieved menu ID ${menuId}`
     }, sendMessage, clientId);
     logger.info(`Retrieved menu: ID ${menuId}`);
   } catch (error) {
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to get menu"
     }, sendMessage, clientId);
@@ -10776,7 +11144,7 @@ async function handleGetOne7(id, menuId, executeCollection, sendMessage, clientI
 async function handleGetRootMenus(id, executeCollection, sendMessage, clientId) {
   try {
     const result = await executeCollection("menus", "getRootMenus", {});
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: true,
       data: result.data,
       count: result.count,
@@ -10784,7 +11152,7 @@ async function handleGetRootMenus(id, executeCollection, sendMessage, clientId)
     }, sendMessage, clientId);
     logger.info(`Retrieved root menus (count: ${result.count})`);
   } catch (error) {
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to get root menus"
     }, sendMessage, clientId);
@@ -10792,7 +11160,7 @@ async function handleGetRootMenus(id, executeCollection, sendMessage, clientId)
 }
 async function handleGetChildMenus(id, parentId, executeCollection, sendMessage, clientId) {
   if (parentId === void 0 || parentId === null) {
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: false,
       error: "parentId is required"
     }, sendMessage, clientId);
@@ -10800,7 +11168,7 @@ async function handleGetChildMenus(id, parentId, executeCollection, sendMessage,
   }
   try {
     const result = await executeCollection("menus", "getChildMenus", { parentId });
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: true,
       data: result.data,
       count: result.count,
@@ -10808,7 +11176,7 @@ async function handleGetChildMenus(id, parentId, executeCollection, sendMessage,
     }, sendMessage, clientId);
     logger.info(`Retrieved child menus for parent ${parentId} (count: ${result.count})`);
   } catch (error) {
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to get child menus"
     }, sendMessage, clientId);
@@ -10817,7 +11185,7 @@ async function handleGetChildMenus(id, parentId, executeCollection, sendMessage,
 async function handleGetHierarchy(id, executeCollection, sendMessage, clientId) {
   try {
     const result = await executeCollection("menus", "getHierarchy", {});
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: true,
       data: result.data,
       count: result.count,
@@ -10825,7 +11193,7 @@ async function handleGetHierarchy(id, executeCollection, sendMessage, clientId)
     }, sendMessage, clientId);
     logger.info(`Retrieved menus hierarchy (root count: ${result.count})`);
   } catch (error) {
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to get menus hierarchy"
     }, sendMessage, clientId);
@@ -10838,7 +11206,7 @@ async function handleQuery6(id, filters, limit, sort, executeCollection, sendMes
       limit,
       sort
     });
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: true,
       data: result.data,
       count: result.count,
@@ -10846,7 +11214,7 @@ async function handleQuery6(id, filters, limit, sort, executeCollection, sendMes
     }, sendMessage, clientId);
     logger.info(`Query returned ${result.count} menus`);
   } catch (error) {
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to query menus"
     }, sendMessage, clientId);
@@ -10854,7 +11222,7 @@ async function handleQuery6(id, filters, limit, sort, executeCollection, sendMes
 }
 async function handleReorder(id, items, executeCollection, sendMessage, clientId) {
   if (!items || !Array.isArray(items) || items.length === 0) {
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: false,
       error: "items array is required"
     }, sendMessage, clientId);
@@ -10862,20 +11230,20 @@ async function handleReorder(id, items, executeCollection, sendMessage, clientId
   }
   try {
     const result = await executeCollection("menus", "reorder", { items });
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: true,
       data: result.data,
       message: `Reordered ${items.length} menus successfully`
     }, sendMessage, clientId);
     logger.info(`Reordered ${items.length} menus`);
   } catch (error) {
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: false,
       error: error instanceof Error ? error.message : "Failed to reorder menus"
     }, sendMessage, clientId);
   }
 }
-function sendResponse9(id, res, sendMessage, clientId) {
+function sendResponse10(id, res, sendMessage, clientId) {
   const response = {
     id: id || "unknown",
     type: "MENUS_RES",
@@ -12407,6 +12775,11 @@ var SuperatomSDK = class {
             logger.error("Failed to handle bookmarks request:", error);
           });
           break;
+        case "ARTIFACTS":
+          handleArtifactsRequest(parsed, this.collections, (msg) => this.send(msg)).catch((error) => {
+            logger.error("Failed to handle artifacts request:", error);
+          });
+          break;
         case "KB_NODES":
           handleKbNodesRequest(parsed, this.collections, (msg) => this.send(msg)).catch((error) => {
             logger.error("Failed to handle KB nodes request:", error);