@nebula-ai/sdk 0.0.31 → 0.0.34

package/dist/index.mjs

@@ -104,23 +104,18 @@ var NebulaClient = class {
   async _makeRequest(method, endpoint, jsonData, params) {
     const url = new URL(endpoint, this.baseUrl);
     if (params) {
-      console.log("SDK: _makeRequest params before processing:", params);
       Object.entries(params).forEach(([key, value]) => {
         if (value !== void 0 && value !== null) {
           if (Array.isArray(value)) {
-            console.log(`SDK: Adding array param ${key}:`, value);
             value.forEach((item) => {
               url.searchParams.append(key, String(item));
-              console.log(`SDK: Appended ${key}=${item} to URL`);
             });
           } else {
-            console.log(`SDK: Adding single param ${key}:`, value);
             url.searchParams.append(key, String(value));
           }
         }
       });
     }
-    console.log("SDK: Final URL being requested:", url.toString());
     const headers = this._buildAuthHeaders(true);
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), this.timeout);
@@ -132,7 +127,7 @@ var NebulaClient = class {
         signal: controller.signal
       });
       clearTimeout(timeoutId);
-      if (response.status === 200) {
+      if (response.status === 200 || response.status === 202) {
         return await response.json();
       } else if (response.status === 401) {
         throw new NebulaAuthenticationException("Invalid API key");
@@ -250,7 +245,7 @@ var NebulaClient = class {
     if (options?.metadata_filters) {
       params.metadata_filters = JSON.stringify(options.metadata_filters);
     }
-    const response = await this._makeRequest("GET", "/v1/conversations", void 0, params);
+    const response = await this._makeRequest("GET", "/v1/memories", void 0, params);
     let conversations;
     if (response && response.results) {
       conversations = response.results;
@@ -263,36 +258,46 @@ var NebulaClient = class {
   }
   async getConversationMessages(conversationIdOrIds) {
     if (typeof conversationIdOrIds === "string") {
-      const response2 = await this._makeRequest("GET", `/v1/conversations/${conversationIdOrIds}`);
-      if (!response2 || !response2.results) {
-        return [];
-      }
-      return this._transformConversationMessages(response2.results);
+      const batchResults = await this.getConversationMessages([conversationIdOrIds]);
+      return batchResults[conversationIdOrIds] || [];
     }
     if (!Array.isArray(conversationIdOrIds) || conversationIdOrIds.length === 0) {
       return {};
     }
-    const response = await this._makeRequest("POST", "/v1/conversations/batch", {
-      conversation_ids: conversationIdOrIds
-    });
-    console.log("\u{1F50D} SDK: Raw batch response:", response);
-    console.log("\u{1F50D} SDK: Response has results?", !!response?.results);
-    if (response?.results) {
-      console.log("\u{1F50D} SDK: Results keys:", Object.keys(response.results));
-      console.log("\u{1F50D} SDK: Sample result:", Object.keys(response.results)[0], ":", response.results[Object.keys(response.results)[0]]);
-    }
+    const params = { ids: conversationIdOrIds };
+    const response = await this._makeRequest("GET", "/v1/memories", void 0, params);
     const results = {};
-    if (response && response.results) {
-      const batchResults = response.results.results || response.results;
-      console.log("\u{1F50D} SDK: Processing", Object.keys(batchResults).length, "conversations");
-      for (const [conversationId, messages] of Object.entries(batchResults)) {
-        if (Array.isArray(messages)) {
-          const transformed = this._transformConversationMessages(messages);
-          results[conversationId] = transformed;
-          console.log(`\u{1F50D} SDK: Conversation ${conversationId.slice(-8)}: ${messages.length} raw -> ${transformed.length} transformed`);
+    if (response && response.results && Array.isArray(response.results)) {
+      for (const doc of response.results) {
+        const conversationId = doc.id;
+        if (!conversationId) {
+          continue;
+        }
+        if (Array.isArray(doc.chunks) && doc.chunks.length > 0) {
+          const messages = [];
+          for (let i = 0; i < doc.chunks.length; i++) {
+            const structuredChunk = doc.chunks[i];
+            if (!structuredChunk || typeof structuredChunk.text !== "string" || structuredChunk.text.length === 0) {
+              continue;
+            }
+            const text = structuredChunk.text;
+            const role = structuredChunk.role ?? "user";
+            messages.push({
+              id: `${doc.id}-${i}`,
+              content: text,
+              metadata: {
+                ...doc.metadata,
+                // Copy engram metadata (playground, session_id, etc.)
+                role
+                // Add/override role for this specific message
+              },
+              created_at: doc.created_at,
+              collection_ids: doc.collection_ids || []
+            });
+          }
+          results[conversationId] = messages;
         } else {
           results[conversationId] = [];
-          console.log(`\u{1F50D} SDK: Conversation ${conversationId.slice(-8)}: not array, setting empty`);
         }
       }
     }
@@ -303,36 +308,6 @@ var NebulaClient = class {
     }
     return results;
   }
-  /** Helper method to transform conversation messages to MemoryResponse format */
-  _transformConversationMessages(messageResponses) {
-    return messageResponses.map((msgResp) => {
-      const msgId = String(msgResp.id || "");
-      const msg = msgResp.message || {};
-      const metadata = msgResp.metadata || {};
-      let text = "";
-      const rawContent = msg.content;
-      if (typeof rawContent === "string") {
-        text = rawContent;
-      } else if (rawContent && typeof rawContent === "object") {
-        text = String(rawContent.content || rawContent.text || JSON.stringify(rawContent));
-      } else if (rawContent != null) {
-        text = String(rawContent);
-      }
-      const role = msg.role || metadata.role || "user";
-      const combinedMetadata = {
-        ...metadata,
-        role
-        // Ensure role is in metadata for UI compatibility
-      };
-      return {
-        id: msgId,
-        content: text,
-        metadata: combinedMetadata,
-        created_at: msgResp.created_at,
-        collection_ids: msgResp.collection_ids || []
-      };
-    });
-  }
   /** Update a collection */
   async updateCollection(options) {
     const data = {};
@@ -416,50 +391,31 @@ var NebulaClient = class {
     }
     const memoryType = mem.role ? "conversation" : "document";
     if (memoryType === "conversation") {
-      const docMetadata2 = { ...mem.metadata };
+      const messages = [];
+      if (mem.content && mem.role) {
+        messages.push({
+          content: String(mem.content),
+          role: mem.role,
+          metadata: mem.metadata || {},
+          ...typeof mem.authority === "number" ? { authority: Number(mem.authority) } : {}
+        });
+      }
+      if (messages.length === 0) {
+        throw new NebulaClientException("Cannot create conversation without messages. Provide content and role.");
+      }
       const data2 = {
         engram_type: "conversation",
+        collection_ref: mem.collection_id,
         name: name || "Conversation",
-        metadata: JSON.stringify(docMetadata2),
-        collection_ids: JSON.stringify([mem.collection_id])
+        messages,
+        metadata: mem.metadata || {}
       };
-      const url2 = `${this.baseUrl}/v1/memories`;
-      const headers2 = this._buildAuthHeaders(false);
-      const response2 = await fetch(url2, {
-        method: "POST",
-        headers: headers2,
-        body: this._formDataFromObject(data2)
-      });
-      if (!response2.ok) {
-        const errorData = await response2.json().catch(() => ({}));
-        throw new NebulaException(
-          errorData.message || `Failed to create conversation: ${response2.status}`,
-          response2.status,
-          errorData
-        );
-      }
-      const respData2 = await response2.json();
-      if (respData2.results) {
-        const convId = respData2.results.engram_id || respData2.results.id;
+      const response2 = await this._makeRequest("POST", "/v1/memories", data2);
+      if (response2.results) {
+        const convId = response2.results.memory_id || response2.results.id;
         if (!convId) {
           throw new NebulaClientException("Failed to create conversation: no id returned");
         }
-        if (mem.content && mem.role) {
-          const appendMem = {
-            collection_id: mem.collection_id,
-            content: [
-              {
-                content: String(mem.content),
-                role: mem.role,
-                metadata: mem.metadata,
-                ...typeof mem.authority === "number" ? { authority: Number(mem.authority) } : {}
-              }
-            ],
-            memory_id: convId,
-            metadata: {}
-          };
-          await this._appendToMemory(convId, appendMem);
-        }
         return String(convId);
       }
       throw new NebulaClientException("Failed to create conversation: invalid response format");
@@ -564,32 +520,39 @@ var NebulaClient = class {
     for (const [key, group] of Object.entries(convGroups)) {
       const collectionId = group[0].collection_id;
       let convId;
-      if (key.startsWith("__new__::")) {
-        convId = await this.storeMemory(
-          {
-            collection_id: collectionId,
-            content: "",
-            role: "assistant",
-            // Placeholder role to infer conversation type
-            metadata: {}
-          },
-          "Conversation"
-        );
-      } else {
-        convId = key;
-      }
       const messages = group.map((m) => ({
         content: String(m.content || ""),
         role: m.role,
-        metadata: m.metadata || {}
+        metadata: m.metadata || {},
+        ...typeof m.authority === "number" ? { authority: Number(m.authority) } : {}
       }));
-      const appendMem = {
-        collection_id: collectionId,
-        content: messages,
-        memory_id: convId,
-        metadata: {}
-      };
-      await this._appendToMemory(convId, appendMem);
+      if (key.startsWith("__new__::")) {
+        const data = {
+          engram_type: "conversation",
+          collection_ref: collectionId,
+          name: "Conversation",
+          messages,
+          metadata: {}
+        };
+        const response = await this._makeRequest("POST", "/v1/memories", data);
+        if (response.results) {
+          convId = response.results.memory_id || response.results.id;
+          if (!convId) {
+            throw new NebulaClientException("Failed to create conversation: no id returned");
+          }
+        } else {
+          throw new NebulaClientException("Failed to create conversation: invalid response format");
+        }
+      } else {
+        convId = key;
+        const appendMem = {
+          collection_id: collectionId,
+          content: messages,
+          memory_id: convId,
+          metadata: {}
+        };
+        await this._appendToMemory(convId, appendMem);
+      }
       results.push(...Array(group.length).fill(String(convId)));
     }
     for (const m of others) {
@@ -710,7 +673,7 @@ var NebulaClient = class {
   /** Delete a conversation and all its messages */
   async deleteConversation(conversationId) {
     try {
-      await this._makeRequest("DELETE", `/v1/conversations/${conversationId}`);
+      await this._makeRequest("DELETE", `/v1/memories/${conversationId}`);
       return true;
     } catch (error) {
       if (error instanceof Error) {