@superatomai/sdk-node 0.0.22 → 0.0.24

package/dist/index.js

@@ -702,6 +702,36 @@ var BookmarksRequestMessageSchema = import_zod3.z.object({
   type: import_zod3.z.literal("BOOKMARKS"),
   payload: BookmarksRequestPayloadSchema
 });
+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(),
+  createdBy: import_zod3.z.number().optional()
+});
+var KbNodesRequestPayloadSchema = import_zod3.z.object({
+  operation: import_zod3.z.enum(["create", "update", "delete", "getAll", "getOne", "search", "getByCategory", "getByUser", "getCategories", "getTags"]),
+  data: import_zod3.z.object({
+    id: import_zod3.z.number().optional(),
+    title: import_zod3.z.string().optional(),
+    content: import_zod3.z.string().optional(),
+    category: import_zod3.z.string().optional(),
+    tags: import_zod3.z.array(import_zod3.z.string()).optional(),
+    createdBy: import_zod3.z.number().optional(),
+    updatedBy: import_zod3.z.number().optional(),
+    userId: import_zod3.z.number().optional(),
+    // Query/search operation fields
+    query: import_zod3.z.string().optional(),
+    filters: KbNodesQueryFiltersSchema.optional(),
+    limit: import_zod3.z.number().optional(),
+    offset: import_zod3.z.number().optional()
+  }).optional()
+});
+var KbNodesRequestMessageSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  from: MessageParticipantSchema,
+  type: import_zod3.z.literal("KB_NODES"),
+  payload: KbNodesRequestPayloadSchema
+});
 
 // src/utils/logger.ts
 var import_fs = __toESM(require("fs"));
@@ -5723,7 +5753,7 @@ async function handleUserPromptSuggestions(data, components, sendMessage, collec
   try {
     const request = UserPromptSuggestionsMessageSchema.parse(data);
     const { id, payload, from } = request;
-    const { prompt, limit = 5 } = payload;
+    const { prompt, limit = 10 } = payload;
     const wsId = from.id;
     logger.info(`[USER_PROMPT_SUGGESTIONS_REQ ${id}] Processing user prompt suggestions: ${prompt}`);
     if (!prompt || prompt.trim().length === 0) {
@@ -5733,48 +5763,37 @@ async function handleUserPromptSuggestions(data, components, sendMessage, collec
       }, sendMessage, wsId);
       return;
     }
-    const componentSearchHandler = collections?.["components"]?.["search"];
-    const bookmarkSearchHandler = collections?.["bookmarks"]?.["search"];
+    const displayComponents = components.filter((c) => c.isDisplayComp === true);
+    const bookmarkTextSearchHandler = collections?.["bookmarks"]?.["textSearch"];
+    logger.info(`[USER_PROMPT_SUGGESTIONS_REQ ${id}] Using token-based search for components (${displayComponents.length} display components) and PostgreSQL text search for bookmarks`);
+    const searchPromises = [];
     let componentSuggestions = [];
     let bookmarkSuggestions = [];
-    let useEmbeddingSearch = false;
-    const searchPromises = [];
-    if (componentSearchHandler) {
-      searchPromises.push(
-        (async () => {
-          try {
-            logger.info("Using embedding-based search for components");
-            const result = await componentSearchHandler({ prompt, limit });
-            if (result.success && result.suggestions) {
-              componentSuggestions = result.suggestions.map((s) => ({
-                ...s,
-                suggestionType: "component"
-              }));
-              useEmbeddingSearch = true;
-              logger.info(`[USER_PROMPT_SUGGESTIONS_REQ ${id}] Found ${componentSuggestions.length} component suggestions`);
-            }
-          } catch (embeddingError) {
-            logger.warn("Component embedding search failed:", embeddingError);
-          }
-        })()
-      );
+    if (displayComponents.length > 0) {
+      const componentResults = searchComponents(prompt, displayComponents, limit);
+      componentSuggestions = componentResults.map((c) => ({
+        ...c,
+        suggestionType: "component",
+        similarity: 1
+        // Token-based search doesn't have similarity scores
+      }));
+      logger.info(`[USER_PROMPT_SUGGESTIONS_REQ ${id}] Found ${componentSuggestions.length} component suggestions via token search`);
     }
-    if (bookmarkSearchHandler && userId && userId !== "anonymous") {
+    if (bookmarkTextSearchHandler && userId && userId !== "anonymous") {
       searchPromises.push(
         (async () => {
           try {
-            logger.info(`Using embedding-based search for bookmarks (user: ${userId})`);
-            const result = await bookmarkSearchHandler({ prompt, userId, limit });
+            logger.info(`Using PostgreSQL text search for bookmarks (user: ${userId})`);
+            const result = await bookmarkTextSearchHandler({ prompt, userId, limit });
             if (result.success && result.suggestions) {
               bookmarkSuggestions = result.suggestions.map((s) => ({
                 ...s,
                 suggestionType: "bookmark"
               }));
-              useEmbeddingSearch = true;
-              logger.info(`[USER_PROMPT_SUGGESTIONS_REQ ${id}] Found ${bookmarkSuggestions.length} bookmark suggestions`);
+              logger.info(`[USER_PROMPT_SUGGESTIONS_REQ ${id}] Found ${bookmarkSuggestions.length} bookmark suggestions via PostgreSQL text search`);
             }
-          } catch (embeddingError) {
-            logger.warn("Bookmark embedding search failed:", embeddingError);
+          } catch (searchError) {
+            logger.warn("Bookmark PostgreSQL text search failed:", searchError);
           }
         })()
       );
@@ -5782,44 +5801,33 @@ async function handleUserPromptSuggestions(data, components, sendMessage, collec
     if (searchPromises.length > 0) {
       await Promise.all(searchPromises);
     }
-    if (useEmbeddingSearch && (componentSuggestions.length > 0 || bookmarkSuggestions.length > 0)) {
-      const allSuggestions = [...componentSuggestions, ...bookmarkSuggestions].sort((a, b) => (b.similarity || 0) - (a.similarity || 0)).slice(0, limit);
-      logger.info(`[USER_PROMPT_SUGGESTIONS_REQ ${id}] Returning all suggestions: ${componentSuggestions.length} components, ${bookmarkSuggestions.length} bookmarks`);
-      sendResponse(id, {
-        success: true,
-        data: {
-          prompt,
-          suggestions: allSuggestions,
-          count: allSuggestions.length,
-          componentCount: componentSuggestions.length,
-          bookmarkCount: bookmarkSuggestions.length,
-          message: `Found ${allSuggestions.length} suggestions (${componentSuggestions.length} components, ${bookmarkSuggestions.length} bookmarks)`
-        }
-      }, sendMessage, wsId);
-      return;
-    }
-    const displayComponents = components.filter((c) => c.isDisplayComp === true);
-    logger.info(`[USER_PROMPT_SUGGESTIONS_REQ ${id}] Using token-based approach. Display components: ${displayComponents.length}`);
-    if (!displayComponents || displayComponents.length === 0) {
+    const allSuggestions = [...componentSuggestions, ...bookmarkSuggestions].slice(0, limit);
+    const finalComponentCount = allSuggestions.filter((s) => s.suggestionType === "component").length;
+    const finalBookmarkCount = allSuggestions.filter((s) => s.suggestionType === "bookmark").length;
+    if (allSuggestions.length === 0) {
       sendResponse(id, {
         success: true,
         data: {
           prompt,
           suggestions: [],
           count: 0,
-          message: "No display components available"
+          componentCount: 0,
+          bookmarkCount: 0,
+          message: "No matching suggestions found"
         }
       }, sendMessage, wsId);
       return;
     }
-    const suggestions = searchComponents(prompt, displayComponents, limit);
+    logger.info(`[USER_PROMPT_SUGGESTIONS_REQ ${id}] Returning ${allSuggestions.length} suggestions: ${finalComponentCount} components, ${finalBookmarkCount} bookmarks`);
     sendResponse(id, {
       success: true,
       data: {
         prompt,
-        suggestions,
-        count: suggestions.length,
-        message: `Found ${suggestions.length} matching components`
+        suggestions: allSuggestions,
+        count: allSuggestions.length,
+        componentCount: finalComponentCount,
+        bookmarkCount: finalBookmarkCount,
+        message: `Found ${allSuggestions.length} suggestions (${finalComponentCount} components, ${finalBookmarkCount} bookmarks)`
       }
     }, sendMessage, wsId);
   } catch (error) {
@@ -7907,6 +7915,458 @@ function sendResponse7(id, res, sendMessage, clientId) {
   sendMessage(response);
 }
 
+// src/handlers/kb-nodes.ts
+async function handleKbNodesRequest(data, collections, sendMessage) {
+  const executeCollection = async (collection, op, params) => {
+    const handler = collections[collection]?.[op];
+    if (!handler) {
+      throw new Error(`Collection '${collection}' or operation '${op}' not found`);
+    }
+    return await handler(params);
+  };
+  try {
+    const request = KbNodesRequestMessageSchema.parse(data);
+    const { id, payload, from } = request;
+    const { operation, data: requestData } = payload;
+    const nodeId = requestData?.id;
+    const title = requestData?.title;
+    const content = requestData?.content;
+    const category = requestData?.category;
+    const tags = requestData?.tags;
+    const createdBy = requestData?.createdBy;
+    const updatedBy = requestData?.updatedBy;
+    const userId = requestData?.userId;
+    const query = requestData?.query;
+    const filters = requestData?.filters;
+    const limit = requestData?.limit;
+    const offset = requestData?.offset;
+    switch (operation) {
+      case "create":
+        await handleCreate6(id, { title, content, category, tags, createdBy }, executeCollection, sendMessage, from.id);
+        break;
+      case "update":
+        await handleUpdate6(id, nodeId, { title, content, category, tags, updatedBy }, executeCollection, sendMessage, from.id);
+        break;
+      case "delete":
+        await handleDelete6(id, nodeId, executeCollection, sendMessage, from.id);
+        break;
+      case "getAll":
+        await handleGetAll6(id, limit, offset, executeCollection, sendMessage, from.id);
+        break;
+      case "getOne":
+        await handleGetOne6(id, nodeId, executeCollection, sendMessage, from.id);
+        break;
+      case "search":
+        await handleSearch(id, { query, category, tags, createdBy, limit, offset }, executeCollection, sendMessage, from.id);
+        break;
+      case "getByCategory":
+        await handleGetByCategory(id, category, limit, offset, executeCollection, sendMessage, from.id);
+        break;
+      case "getByUser":
+        await handleGetByUser(id, userId, limit, offset, executeCollection, sendMessage, from.id);
+        break;
+      case "getCategories":
+        await handleGetCategories(id, executeCollection, sendMessage, from.id);
+        break;
+      case "getTags":
+        await handleGetTags(id, executeCollection, sendMessage, from.id);
+        break;
+      default:
+        sendResponse8(id, {
+          success: false,
+          error: `Unknown operation: ${operation}`
+        }, sendMessage, from.id);
+    }
+  } catch (error) {
+    logger.error("Failed to handle KB nodes request:", error);
+    sendResponse8(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;
+  if (!title || title.trim().length === 0) {
+    sendResponse8(id, {
+      success: false,
+      error: "Title is required and cannot be empty"
+    }, sendMessage, clientId);
+    return;
+  }
+  if (!content || content.trim().length === 0) {
+    sendResponse8(id, {
+      success: false,
+      error: "Content is required and cannot be empty"
+    }, sendMessage, clientId);
+    return;
+  }
+  if (!createdBy) {
+    sendResponse8(id, {
+      success: false,
+      error: "createdBy (user ID) is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("kbNodes", "create", {
+      title,
+      content,
+      category: category || void 0,
+      tags: tags || void 0,
+      createdBy
+    });
+    if (result && result.success) {
+      logger.info(`[DB] KB node created successfully: ${title}`);
+      sendResponse8(id, {
+        success: true,
+        data: {
+          ...result.data,
+          message: `Knowledge node '${title}' created successfully`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+    sendResponse8(id, {
+      success: false,
+      error: "Failed to create knowledge node"
+    }, sendMessage, clientId);
+  } catch (error) {
+    logger.error("[DB] Failed to create KB node:", error);
+    sendResponse8(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;
+  if (!nodeId) {
+    sendResponse8(id, {
+      success: false,
+      error: "Knowledge node ID is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  if (!updatedBy) {
+    sendResponse8(id, {
+      success: false,
+      error: "updatedBy (user ID) is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("kbNodes", "update", {
+      id: nodeId,
+      title,
+      content,
+      category,
+      tags,
+      updatedBy
+    });
+    if (result && result.success) {
+      logger.info(`[DB] KB node updated successfully, ID: ${nodeId}`);
+      sendResponse8(id, {
+        success: true,
+        data: {
+          ...result.data,
+          message: `Knowledge node updated successfully`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+    sendResponse8(id, {
+      success: false,
+      error: "Failed to update knowledge node"
+    }, sendMessage, clientId);
+  } catch (error) {
+    logger.error("[DB] Failed to update KB node:", error);
+    sendResponse8(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to update knowledge node"
+    }, sendMessage, clientId);
+  }
+}
+async function handleDelete6(id, nodeId, executeCollection, sendMessage, clientId) {
+  if (!nodeId) {
+    sendResponse8(id, {
+      success: false,
+      error: "Knowledge node ID is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("kbNodes", "delete", { id: nodeId });
+    if (result && result.success) {
+      logger.info(`[DB] KB node deleted successfully, ID: ${nodeId}`);
+      sendResponse8(id, {
+        success: true,
+        data: {
+          id: nodeId,
+          ...result.data,
+          message: `Knowledge node deleted successfully`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+    sendResponse8(id, {
+      success: false,
+      error: "Failed to delete knowledge node"
+    }, sendMessage, clientId);
+  } catch (error) {
+    logger.error("[DB] Failed to delete KB node:", error);
+    sendResponse8(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) {
+  try {
+    const result = await executeCollection("kbNodes", "getAll", {
+      limit: limit || 100,
+      offset: offset || 0
+    });
+    if (result && result.success) {
+      logger.info(`[DB] Retrieved ${result.count} KB nodes`);
+      sendResponse8(id, {
+        success: true,
+        data: {
+          nodes: result.data,
+          count: result.count,
+          message: `Retrieved ${result.count} knowledge nodes`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+    sendResponse8(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, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to retrieve knowledge nodes"
+    }, sendMessage, clientId);
+  }
+}
+async function handleGetOne6(id, nodeId, executeCollection, sendMessage, clientId) {
+  if (!nodeId) {
+    sendResponse8(id, {
+      success: false,
+      error: "Knowledge node ID is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("kbNodes", "getOne", { id: nodeId });
+    if (result && result.success) {
+      logger.info(`[DB] Retrieved KB node ID: ${nodeId}`);
+      sendResponse8(id, {
+        success: true,
+        data: {
+          node: result.data,
+          message: `Retrieved knowledge node`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+    sendResponse8(id, {
+      success: false,
+      error: "Failed to retrieve knowledge node"
+    }, sendMessage, clientId);
+  } catch (error) {
+    logger.error("[DB] Failed to get KB node:", error);
+    sendResponse8(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;
+  try {
+    const result = await executeCollection("kbNodes", "search", {
+      query,
+      category,
+      tags,
+      createdBy,
+      limit: limit || 50,
+      offset: offset || 0
+    });
+    if (result && result.success) {
+      logger.info(`[DB] Search returned ${result.count} KB nodes`);
+      sendResponse8(id, {
+        success: true,
+        data: {
+          nodes: result.data,
+          count: result.count,
+          message: `Search returned ${result.count} knowledge nodes`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+    sendResponse8(id, {
+      success: false,
+      error: "Failed to search knowledge nodes"
+    }, sendMessage, clientId);
+  } catch (error) {
+    logger.error("[DB] Failed to search KB nodes:", error);
+    sendResponse8(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to search knowledge nodes"
+    }, sendMessage, clientId);
+  }
+}
+async function handleGetByCategory(id, category, limit, offset, executeCollection, sendMessage, clientId) {
+  if (!category) {
+    sendResponse8(id, {
+      success: false,
+      error: "Category is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("kbNodes", "getByCategory", {
+      category,
+      limit: limit || 50,
+      offset: offset || 0
+    });
+    if (result && result.success) {
+      logger.info(`[DB] Retrieved ${result.count} KB nodes for category: ${category}`);
+      sendResponse8(id, {
+        success: true,
+        data: {
+          nodes: result.data,
+          count: result.count,
+          category,
+          message: `Retrieved ${result.count} knowledge nodes for category '${category}'`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+    sendResponse8(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, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to retrieve knowledge nodes by category"
+    }, sendMessage, clientId);
+  }
+}
+async function handleGetByUser(id, userId, limit, offset, executeCollection, sendMessage, clientId) {
+  if (!userId) {
+    sendResponse8(id, {
+      success: false,
+      error: "User ID is required"
+    }, sendMessage, clientId);
+    return;
+  }
+  try {
+    const result = await executeCollection("kbNodes", "getByUser", {
+      userId,
+      limit: limit || 50,
+      offset: offset || 0
+    });
+    if (result && result.success) {
+      logger.info(`[DB] Retrieved ${result.count} KB nodes for user: ${userId}`);
+      sendResponse8(id, {
+        success: true,
+        data: {
+          nodes: result.data,
+          count: result.count,
+          userId,
+          message: `Retrieved ${result.count} knowledge nodes for user ${userId}`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+    sendResponse8(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, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to retrieve knowledge nodes by user"
+    }, sendMessage, clientId);
+  }
+}
+async function handleGetCategories(id, executeCollection, sendMessage, clientId) {
+  try {
+    const result = await executeCollection("kbNodes", "getCategories", {});
+    if (result && result.success) {
+      logger.info(`[DB] Retrieved ${result.count} categories`);
+      sendResponse8(id, {
+        success: true,
+        data: {
+          categories: result.data,
+          count: result.count,
+          message: `Retrieved ${result.count} categories`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+    sendResponse8(id, {
+      success: false,
+      error: "Failed to retrieve categories"
+    }, sendMessage, clientId);
+  } catch (error) {
+    logger.error("[DB] Failed to get categories:", error);
+    sendResponse8(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to retrieve categories"
+    }, sendMessage, clientId);
+  }
+}
+async function handleGetTags(id, executeCollection, sendMessage, clientId) {
+  try {
+    const result = await executeCollection("kbNodes", "getTags", {});
+    if (result && result.success) {
+      logger.info(`[DB] Retrieved ${result.count} tags`);
+      sendResponse8(id, {
+        success: true,
+        data: {
+          tags: result.data,
+          count: result.count,
+          message: `Retrieved ${result.count} tags`
+        }
+      }, sendMessage, clientId);
+      return;
+    }
+    sendResponse8(id, {
+      success: false,
+      error: "Failed to retrieve tags"
+    }, sendMessage, clientId);
+  } catch (error) {
+    logger.error("[DB] Failed to get tags:", error);
+    sendResponse8(id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to retrieve tags"
+    }, sendMessage, clientId);
+  }
+}
+function sendResponse8(id, res, sendMessage, clientId) {
+  const response = {
+    id: id || "unknown",
+    type: "KB_NODES_RES",
+    from: { type: "data-agent" },
+    to: {
+      type: "admin",
+      id: clientId
+    },
+    payload: {
+      ...res
+    }
+  };
+  sendMessage(response);
+}
+
 // src/auth/user-manager.ts
 var import_fs4 = __toESM(require("fs"));
 var import_path3 = __toESM(require("path"));
@@ -8936,6 +9396,11 @@ var SuperatomSDK = class {
             logger.error("Failed to handle bookmarks 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);
+          });
+          break;
         default:
           const handler = this.messageTypeHandlers.get(message.type);
           if (handler) {