@superatomai/sdk-node 0.0.21 → 0.0.23

package/dist/index.js

@@ -682,7 +682,7 @@ var BookmarkQueryFiltersSchema = import_zod3.z.object({
   name: import_zod3.z.string().optional()
 });
 var BookmarksRequestPayloadSchema = import_zod3.z.object({
-  operation: import_zod3.z.enum(["create", "update", "delete", "getAll", "getOne", "getByUser", "getByThread", "query"]),
+  operation: import_zod3.z.enum(["create", "update", "delete", "getAll", "getOne", "query"]),
   data: import_zod3.z.object({
     id: import_zod3.z.number().optional(),
     userId: import_zod3.z.number().optional(),
@@ -5723,7 +5723,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 +5733,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 +5771,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) {
@@ -7737,12 +7715,6 @@ async function handleBookmarksRequest(data, collections, sendMessage) {
       case "getOne":
         await handleGetOne5(id, bookmarkId, executeCollection, sendMessage, from.id);
         break;
-      case "getByUser":
-        await handleGetByUser(id, userId, threadId, executeCollection, sendMessage, from.id);
-        break;
-      case "getByThread":
-        await handleGetByThread(id, threadId, executeCollection, sendMessage, from.id);
-        break;
       case "query":
         await handleQuery5(id, filters, limit, sort, executeCollection, sendMessage, from.id);
         break;
@@ -7876,54 +7848,6 @@ async function handleGetOne5(id, bookmarkId, executeCollection, sendMessage, cli
     }, sendMessage, clientId);
   }
 }
-async function handleGetByUser(id, userId, threadId, executeCollection, sendMessage, clientId) {
-  if (!userId) {
-    sendResponse7(id, {
-      success: false,
-      error: "userId is required"
-    }, sendMessage, clientId);
-    return;
-  }
-  try {
-    const result = await executeCollection("bookmarks", "getByUser", { userId, threadId });
-    sendResponse7(id, {
-      success: true,
-      data: result.data,
-      count: result.count,
-      message: `Retrieved ${result.count} bookmarks for user ${userId}`
-    }, sendMessage, clientId);
-    logger.info(`Retrieved bookmarks for user ${userId} (count: ${result.count})`);
-  } catch (error) {
-    sendResponse7(id, {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to get bookmarks by user"
-    }, sendMessage, clientId);
-  }
-}
-async function handleGetByThread(id, threadId, executeCollection, sendMessage, clientId) {
-  if (!threadId) {
-    sendResponse7(id, {
-      success: false,
-      error: "threadId is required"
-    }, sendMessage, clientId);
-    return;
-  }
-  try {
-    const result = await executeCollection("bookmarks", "getByThread", { threadId });
-    sendResponse7(id, {
-      success: true,
-      data: result.data,
-      count: result.count,
-      message: `Retrieved ${result.count} bookmarks for thread ${threadId}`
-    }, sendMessage, clientId);
-    logger.info(`Retrieved bookmarks for thread ${threadId} (count: ${result.count})`);
-  } catch (error) {
-    sendResponse7(id, {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to get bookmarks by thread"
-    }, sendMessage, clientId);
-  }
-}
 async function handleQuery5(id, filters, limit, sort, executeCollection, sendMessage, clientId) {
   try {
     const result = await executeCollection("bookmarks", "query", {