@superatomai/sdk-node 0.0.56 → 0.0.58

package/dist/index.js

@@ -2409,10 +2409,39 @@ var BookmarksRequestMessageSchema = import_zod3.z.object({
   type: import_zod3.z.literal("BOOKMARKS"),
   payload: BookmarksRequestPayloadSchema
 });
+var ArtifactsQueryFiltersSchema = import_zod3.z.object({
+  createdBy: import_zod3.z.number().optional(),
+  status: import_zod3.z.string().optional(),
+  name: import_zod3.z.string().optional(),
+  deleted: import_zod3.z.boolean().optional()
+});
+var ArtifactsRequestPayloadSchema = 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(),
+    name: import_zod3.z.string().optional(),
+    createdBy: import_zod3.z.number().optional(),
+    dsl: import_zod3.z.record(import_zod3.z.any()).optional(),
+    status: import_zod3.z.string().optional(),
+    deleted: import_zod3.z.boolean().optional(),
+    limit: import_zod3.z.number().optional(),
+    // Query operation fields
+    filters: ArtifactsQueryFiltersSchema.optional(),
+    sort: import_zod3.z.enum(["ASC", "DESC"]).optional()
+  }).optional()
+});
+var ArtifactsRequestMessageSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  from: MessageParticipantSchema,
+  type: import_zod3.z.literal("ARTIFACTS"),
+  payload: ArtifactsRequestPayloadSchema
+});
+var KbNodeTypeSchema = import_zod3.z.enum(["global", "user", "query"]);
 var KbNodesQueryFiltersSchema = import_zod3.z.object({
   query: import_zod3.z.string().optional(),
   category: import_zod3.z.string().optional(),
   tags: import_zod3.z.array(import_zod3.z.string()).optional(),
+  type: KbNodeTypeSchema.optional(),
   createdBy: import_zod3.z.number().optional()
 });
 var KbNodesRequestPayloadSchema = import_zod3.z.object({
@@ -2423,6 +2452,7 @@ var KbNodesRequestPayloadSchema = import_zod3.z.object({
     content: import_zod3.z.string().optional(),
     category: import_zod3.z.string().optional(),
     tags: import_zod3.z.array(import_zod3.z.string()).optional(),
+    type: KbNodeTypeSchema.optional(),
     createdBy: import_zod3.z.number().optional(),
     updatedBy: import_zod3.z.number().optional(),
     userId: import_zod3.z.number().optional(),
@@ -5436,7 +5466,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)`);
@@ -5450,8 +5480,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;
 
@@ -5833,6 +5956,9 @@ var BaseLLM = class {
    * @returns Object containing matched components, layout title/description, and follow-up actions
    */
   async matchComponentsFromAnalysis(analysisContent, components, apiKey, logCollector, componentStreamCallback, deferredTools, executedTools) {
+    const methodStartTime = Date.now();
+    const methodName = "matchComponentsFromAnalysis";
+    logger.info(`[${this.getProviderName()}] [TIMING] START ${methodName} | model: ${this.getModelForTask("complex")}`);
     try {
       logger.debug(`[${this.getProviderName()}] Starting component matching from text response`);
       let availableComponentsText = "No components available";
@@ -6139,6 +6265,8 @@ ${executedToolsText}`);
           }
         };
       }).filter(Boolean);
+      const methodDuration = Date.now() - methodStartTime;
+      logger.info(`[${this.getProviderName()}] [TIMING] DONE ${methodName} in ${methodDuration}ms | components: ${finalComponents.length} | actions: ${actions.length}`);
       return {
         components: finalComponents,
         layoutTitle,
@@ -6146,8 +6274,9 @@ ${executedToolsText}`);
         actions
       };
     } catch (error) {
+      const methodDuration = Date.now() - methodStartTime;
       const errorMsg = error instanceof Error ? error.message : String(error);
-      logger.error(`[${this.getProviderName()}] Error matching components: ${errorMsg}`);
+      logger.error(`[${this.getProviderName()}] [TIMING] FAILED ${methodName} in ${methodDuration}ms | error: ${errorMsg}`);
       logCollector?.error(`Failed to match components: ${errorMsg}`);
       return {
         components: [],
@@ -6162,6 +6291,10 @@ ${executedToolsText}`);
    * Determines if question is for data analysis, requires external tools, or needs text response
    */
   async classifyQuestionCategory(userPrompt, apiKey, logCollector, conversationHistory, externalTools) {
+    const methodStartTime = Date.now();
+    const methodName = "classifyQuestionCategory";
+    const promptPreview = userPrompt.substring(0, 50) + (userPrompt.length > 50 ? "..." : "");
+    logger.info(`[${this.getProviderName()}] [TIMING] START ${methodName} | model: ${this.getModelForTask("simple")} | prompt: "${promptPreview}"`);
     try {
       const schemaDoc = schema.generateSchemaDocumentation();
       const availableToolsDoc = externalTools && externalTools.length > 0 ? externalTools.map((tool) => {
@@ -6205,6 +6338,8 @@ ${executedToolsText}`);
           confidence: result.confidence
         }
       );
+      const methodDuration = Date.now() - methodStartTime;
+      logger.info(`[${this.getProviderName()}] [TIMING] DONE ${methodName} in ${methodDuration}ms | category: ${result.category} | confidence: ${result.confidence}% | tools: ${(result.externalTools || []).length}`);
       return {
         category: result.category || "data_analysis",
         externalTools: result.externalTools || [],
@@ -6213,8 +6348,9 @@ ${executedToolsText}`);
         confidence: result.confidence || 0
       };
     } catch (error) {
+      const methodDuration = Date.now() - methodStartTime;
       const errorMsg = error instanceof Error ? error.message : String(error);
-      logger.error(`[${this.getProviderName()}] Error classifying question category: ${errorMsg}`);
+      logger.error(`[${this.getProviderName()}] [TIMING] FAILED ${methodName} in ${methodDuration}ms | error: ${errorMsg}`);
       logger.debug(`[${this.getProviderName()}] Category classification error details:`, error);
       throw error;
     }
@@ -6225,9 +6361,15 @@ ${executedToolsText}`);
    * Also adapts the cached text response to match the new question
    */
   async adaptUIBlockParameters(currentUserPrompt, originalUserPrompt, matchedUIBlock, apiKey, logCollector, cachedTextResponse) {
+    const methodStartTime = Date.now();
+    const methodName = "adaptUIBlockParameters";
+    const promptPreview = currentUserPrompt.substring(0, 50) + (currentUserPrompt.length > 50 ? "..." : "");
+    logger.info(`[${this.getProviderName()}] [TIMING] START ${methodName} | model: ${this.getModelForTask("complex")} | prompt: "${promptPreview}"`);
     try {
       const component = matchedUIBlock?.generatedComponentMetadata || matchedUIBlock?.component;
       if (!matchedUIBlock || !component) {
+        const methodDuration2 = Date.now() - methodStartTime;
+        logger.info(`[${this.getProviderName()}] [TIMING] DONE ${methodName} in ${methodDuration2}ms | result: no component found`);
         return {
           success: false,
           explanation: "No component found in matched UI block"
@@ -6260,9 +6402,8 @@ ${executedToolsText}`);
         // Parse as JSON
       );
       if (!result.success) {
-        logger.info(
-          `[${this.getProviderName()}] Could not adapt UI block: ${result.reason}`
-        );
+        const methodDuration2 = Date.now() - methodStartTime;
+        logger.info(`[${this.getProviderName()}] [TIMING] DONE ${methodName} in ${methodDuration2}ms | result: adaptation failed - ${result.reason}`);
         logCollector?.warn(
           "Could not adapt matched UI block",
           "explanation",
@@ -6287,6 +6428,8 @@ ${executedToolsText}`);
           componentType: result.adaptedComponent?.type
         }
       );
+      const methodDuration = Date.now() - methodStartTime;
+      logger.info(`[${this.getProviderName()}] [TIMING] DONE ${methodName} in ${methodDuration}ms | result: success | changes: ${(result.parametersChanged || []).length}`);
       return {
         success: true,
         adaptedComponent: result.adaptedComponent,
@@ -6295,8 +6438,9 @@ ${executedToolsText}`);
         explanation: result.explanation || "Parameters adapted successfully"
       };
     } catch (error) {
+      const methodDuration = Date.now() - methodStartTime;
       const errorMsg = error instanceof Error ? error.message : String(error);
-      logger.error(`[${this.getProviderName()}] Error adapting UI block parameters: ${errorMsg}`);
+      logger.error(`[${this.getProviderName()}] [TIMING] FAILED ${methodName} in ${methodDuration}ms | error: ${errorMsg}`);
       logger.debug(`[${this.getProviderName()}] Adaptation error details:`, error);
       return {
         success: false,
@@ -6314,8 +6458,13 @@ ${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 methodStartTime = Date.now();
+    const methodName = "generateTextResponse";
+    const promptPreview = userPrompt.substring(0, 50) + (userPrompt.length > 50 ? "..." : "");
+    logger.info(`[${this.getProviderName()}] [TIMING] START ${methodName} | model: ${this.getModelForTask("complex")} | category: ${category} | prompt: "${promptPreview}"`);
     const errors = [];
     logger.debug(`[${this.getProviderName()}] Starting text response generation`);
     logger.debug(`[${this.getProviderName()}] User prompt: "${userPrompt.substring(0, 50)}..."`);
@@ -6364,11 +6513,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",
@@ -6494,26 +6645,48 @@ ${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();
-        let dotCount = 0;
-        const maxDots = 3;
+        await streamDelay(30);
         wrappedStreamCallback(`\u23F3 ${progressMessage}`);
         const heartbeatInterval = setInterval(() => {
           const elapsedSeconds = Math.floor((Date.now() - startTime) / 1e3);
-          dotCount = (dotCount + 1) % (maxDots + 1);
-          const dots = ".".repeat(dotCount || 1);
-          if (elapsedSeconds >= 2) {
-            wrappedStreamCallback(`${dots} (${elapsedSeconds}s)`);
-          } else {
-            wrappedStreamCallback(dots);
+          if (elapsedSeconds >= 1) {
+            wrappedStreamCallback(` (${elapsedSeconds}s)`);
           }
         }, intervalMs);
         try {
@@ -6558,6 +6731,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)}` : "";
@@ -6567,10 +6741,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
@@ -6578,16 +6754,19 @@ ${sql}
 \`\`\`${paramsDisplay}
 
 `);
+                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
@@ -6595,6 +6774,7 @@ ${sql}
 \`\`\`${paramsDisplay}
 
 `);
+                await streamDelay(50);
               }
             }
             logCollector?.logQuery(
@@ -6621,6 +6801,7 @@ ${sql}
 \u2705 **Query executed successfully!**
 
 `);
+              await streamDelay(50);
               if (Array.isArray(data) && data.length > 0) {
                 const firstRow = data[0];
                 const columns = Object.keys(firstRow);
@@ -6629,18 +6810,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...**
 
@@ -6690,6 +6875,7 @@ Please try rephrasing your request or contact support.
               throw new Error(errorMsg);
             }
             try {
+              flushStream();
               if (wrappedStreamCallback) {
                 if (attempts === 1) {
                   wrappedStreamCallback(`
@@ -6704,6 +6890,7 @@ Please try rephrasing your request or contact support.
 
 `);
                 }
+                await streamDelay(50);
               }
               const result2 = await withProgressHeartbeat(
                 () => externalTool.fn(toolInput),
@@ -6743,6 +6930,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) {
@@ -6790,7 +6978,8 @@ ${errorMsg}
       logger.info(`[${this.getProviderName()}] Text response stream completed`);
       const textResponse = fullStreamedText || result || "I apologize, but I was unable to generate a response.";
       if (maxAttemptsReached) {
-        logger.warn(`[${this.getProviderName()}] Max query attempts reached, returning failure response`);
+        const methodDuration2 = Date.now() - methodStartTime;
+        logger.warn(`[${this.getProviderName()}] [TIMING] DONE ${methodName} in ${methodDuration2}ms | result: max attempts reached`);
         logCollector?.error("Failed to generate valid query after maximum attempts");
         return {
           success: false,
@@ -6811,6 +7000,7 @@ ${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__");
@@ -6892,6 +7082,8 @@ ${errorMsg}
           }
         };
       }
+      const methodDuration = Date.now() - methodStartTime;
+      logger.info(`[${this.getProviderName()}] [TIMING] DONE ${methodName} in ${methodDuration}ms | result: success | components: ${matchedComponents.length} | actions: ${actions.length}`);
       return {
         success: true,
         data: {
@@ -6903,8 +7095,9 @@ ${errorMsg}
         errors: []
       };
     } catch (error) {
+      const methodDuration = Date.now() - methodStartTime;
       const errorMsg = error instanceof Error ? error.message : String(error);
-      logger.error(`[${this.getProviderName()}] Error generating text response: ${errorMsg}`);
+      logger.error(`[${this.getProviderName()}] [TIMING] FAILED ${methodName} in ${methodDuration}ms | error: ${errorMsg}`);
       logCollector?.error(`Error generating text response: ${errorMsg}`);
       userPromptErrorLogger.logLlmError(
         this.getProviderName(),
@@ -7122,7 +7315,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)`);
@@ -7157,6 +7351,10 @@ ${errorMsg}
    * For general/conversational questions without components, pass textResponse instead
    */
   async generateNextQuestions(originalUserPrompt, component, componentData, apiKey, logCollector, conversationHistory, textResponse) {
+    const methodStartTime = Date.now();
+    const methodName = "generateNextQuestions";
+    const promptPreview = originalUserPrompt.substring(0, 50) + (originalUserPrompt.length > 50 ? "..." : "");
+    logger.info(`[${this.getProviderName()}] [TIMING] START ${methodName} | model: ${this.getModelForTask("simple")} | prompt: "${promptPreview}"`);
     try {
       let component_info;
       if (component) {
@@ -7205,10 +7403,13 @@ ${errorMsg}
           questions: nextQuestions
         }
       );
+      const methodDuration = Date.now() - methodStartTime;
+      logger.info(`[${this.getProviderName()}] [TIMING] DONE ${methodName} in ${methodDuration}ms | questions: ${nextQuestions.length}`);
       return nextQuestions;
     } catch (error) {
+      const methodDuration = Date.now() - methodStartTime;
       const errorMsg = error instanceof Error ? error.message : String(error);
-      logger.error(`[${this.getProviderName()}] Error generating next questions: ${errorMsg}`);
+      logger.error(`[${this.getProviderName()}] [TIMING] FAILED ${methodName} in ${methodDuration}ms | error: ${errorMsg}`);
       logger.debug(`[${this.getProviderName()}] Next questions generation error details:`, error);
       logCollector?.error(`Error generating next questions: ${errorMsg}`);
       return [];
@@ -10195,6 +10396,208 @@ 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;
+    const filters = requestData?.filters;
+    const sort = requestData?.sort;
+    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;
+      case "query":
+        await handleQuery6(id, { filters, limit, sort }, 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);
+  }
+}
+async function handleQuery6(id, queryParams, executeCollection, sendMessage, clientId) {
+  try {
+    const result = await executeCollection("artifacts", "query", {
+      filters: queryParams.filters,
+      limit: queryParams.limit || 50,
+      sort: queryParams.sort || "DESC"
+    });
+    sendResponse8(id, {
+      success: true,
+      data: result.data,
+      count: result.count,
+      message: `Query returned ${result.count} artifacts`
+    }, sendMessage, clientId);
+    logger.info(`Query artifacts (count: ${result.count})`);
+  } catch (error) {
+    sendResponse8(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to query artifacts"
+    }, 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) {
@@ -10214,6 +10617,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;
@@ -10223,22 +10627,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);
@@ -10253,37 +10657,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);
@@ -10295,11 +10699,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,
@@ -10308,29 +10713,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);
@@ -10343,11 +10748,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,
@@ -10356,21 +10762,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);
@@ -10380,7 +10786,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,
@@ -10390,19 +10796,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,
@@ -10410,7 +10816,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,
@@ -10420,21 +10826,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);
@@ -10444,7 +10850,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,
@@ -10453,32 +10859,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,
@@ -10488,13 +10895,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);
@@ -10502,7 +10909,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);
@@ -10516,7 +10923,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,
@@ -10527,13 +10934,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);
@@ -10541,7 +10948,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);
@@ -10555,7 +10962,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,
@@ -10566,13 +10973,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);
@@ -10583,7 +10990,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,
@@ -10593,13 +11000,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);
@@ -10610,7 +11017,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,
@@ -10620,19 +11027,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",
@@ -10677,19 +11084,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);
@@ -10701,35 +11108,35 @@ async function handleMenusRequest(data, collections, sendMessage) {
         await handleGetHierarchy(id, executeCollection, sendMessage, from.id);
         break;
       case "query":
-        await handleQuery6(id, filters, limit, sort, executeCollection, sendMessage, from.id);
+        await handleQuery7(id, filters, limit, sort, executeCollection, sendMessage, from.id);
         break;
       case "reorder":
         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);
@@ -10746,22 +11153,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);
@@ -10779,22 +11186,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);
@@ -10802,23 +11209,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,
@@ -10826,15 +11233,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);
@@ -10842,14 +11249,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);
@@ -10858,7 +11265,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,
@@ -10866,7 +11273,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);
@@ -10874,7 +11281,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);
@@ -10882,7 +11289,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,
@@ -10890,7 +11297,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);
@@ -10899,7 +11306,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,
@@ -10907,20 +11314,20 @@ 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);
   }
 }
-async function handleQuery6(id, filters, limit, sort, executeCollection, sendMessage, clientId) {
+async function handleQuery7(id, filters, limit, sort, executeCollection, sendMessage, clientId) {
   try {
     const result = await executeCollection("menus", "query", {
       filters: filters || {},
       limit,
       sort
     });
-    sendResponse9(id, {
+    sendResponse10(id, {
       success: true,
       data: result.data,
       count: result.count,
@@ -10928,7 +11335,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);
@@ -10936,7 +11343,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);
@@ -10944,20 +11351,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",
@@ -12489,6 +12896,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);