@nebula-ai/sdk 0.0.33 → 0.0.35

package/dist/index.d.ts

@@ -9,6 +9,14 @@ interface Chunk {
     metadata: Record<string, any>;
     role?: string;
 }
+/**
+ * Structured chunk format returned by backend for conversation messages.
+ * Contains message text and role metadata inline.
+ */
+interface StructuredChunk {
+    text: string;
+    role: 'user' | 'assistant' | 'system';
+}
 interface MemoryResponse {
     id: string;
     content?: string;
@@ -193,11 +201,20 @@ declare class NebulaClient {
         collection_ids?: string[];
         metadata_filters?: Record<string, any>;
     }): Promise<any[]>;
-    /** Get conversation messages directly from the conversations API */
+    /**
+     * Get conversation messages from the engrams API.
+     *
+     * This method retrieves conversation engrams and parses their chunks into structured messages.
+     * Expects conversation engrams to contain structured chunks with role metadata:
+     * `{text: string, role: 'user'|'assistant'|'system'}`.
+     * Converts chunks to `MemoryResponse` objects with proper role metadata.
+     *
+     * @param conversationId - Single conversation ID (returns array of messages)
+     * @param conversationIds - Multiple conversation IDs (returns map of conversation_id -> messages)
+     * @returns Messages for the requested conversation(s)
+     */
     getConversationMessages(conversationId: string): Promise<MemoryResponse[]>;
     getConversationMessages(conversationIds: string[]): Promise<Record<string, MemoryResponse[]>>;
-    /** Helper method to transform conversation messages to MemoryResponse format */
-    private _transformConversationMessages;
     /** Update a collection */
     updateCollection(options: {
         collectionId: string;
@@ -440,4 +457,4 @@ declare class NebulaClient {
     private _formDataFromObject;
 }
 
-export { type AgentResponse, type Chunk, type Collection, type GraphCommunityResult, type GraphEntityResult, type GraphRelationshipResult, GraphSearchResultType, type Memory, type MemoryResponse, NebulaAuthenticationException, NebulaClient, type NebulaClientConfig, NebulaClientException, NebulaCollectionNotFoundException, NebulaException, NebulaNotFoundException, NebulaRateLimitException, NebulaValidationException, type SearchOptions, type SearchResult };
+export { type AgentResponse, type Chunk, type Collection, type GraphCommunityResult, type GraphEntityResult, type GraphRelationshipResult, GraphSearchResultType, type Memory, type MemoryResponse, NebulaAuthenticationException, NebulaClient, type NebulaClientConfig, NebulaClientException, NebulaCollectionNotFoundException, NebulaException, NebulaNotFoundException, NebulaRateLimitException, NebulaValidationException, type SearchOptions, type SearchResult, type StructuredChunk };

package/dist/index.js

@@ -106,23 +106,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);
@@ -265,35 +260,46 @@ var NebulaClient = class {
   }
   async getConversationMessages(conversationIdOrIds) {
     if (typeof conversationIdOrIds === "string") {
-      const response2 = await this._makeRequest("GET", `/v1/memories/${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 params = { ids: conversationIdOrIds };
     const response = await this._makeRequest("GET", "/v1/memories", void 0, params);
-    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 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`);
         }
       }
     }
@@ -304,36 +310,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 = {};
@@ -417,50 +393,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");
@@ -565,32 +522,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) {