@pairsystems/goodmem-client 1.0.0-dev.cb052d6 → 1.0.0

package/dist/streaming.js

@@ -113,6 +113,26 @@ var StreamingClient = exports.StreamingClient = /*#__PURE__*/function () {
               if (request.generateAbstract !== undefined) {
                 params.append('generateAbstract', request.generateAbstract.toString());
               }
+
+              // Add ChatPostProcessor parameters
+              if (request.ppLlmId) {
+                params.append('ppLlmId', request.ppLlmId);
+              }
+              if (request.ppRerankerId) {
+                params.append('ppRerankerId', request.ppRerankerId);
+              }
+              if (request.ppRelevanceThreshold !== undefined) {
+                params.append('ppRelevanceThreshold', request.ppRelevanceThreshold.toString());
+              }
+              if (request.ppLlmTemp !== undefined) {
+                params.append('ppLlmTemp', request.ppLlmTemp.toString());
+              }
+              if (request.ppMaxResults !== undefined) {
+                params.append('ppMaxResults', request.ppMaxResults.toString());
+              }
+              if (request.ppChronologicalResort !== undefined) {
+                params.append('ppChronologicalResort', request.ppChronologicalResort.toString());
+              }
               fullURL = "".concat(endpoint, "?").concat(params.toString()); // Set appropriate headers
               headers = {
                 'Accept': request.format === StreamingClient.StreamingFormat.SSE ? 'text/event-stream' : 'application/x-ndjson'
@@ -442,6 +462,171 @@ var StreamingClient = exports.StreamingClient = /*#__PURE__*/function () {
       }
       return retrieveMemoryStreamSimple;
     }()
+    /**
+     * Stream semantic memory retrieval results using ChatPostProcessor
+     *
+     * @param {AbortSignal} signal - Abort signal for cancellation
+     * @param {string} message - Primary query/message for semantic search
+     * @param {string[]} spaceIds - Array of space UUIDs to search within
+     * @param {number} [requestedSize] - Maximum number of memories to retrieve
+     * @param {boolean} [fetchMemory] - Whether to fetch memory definitions
+     * @param {boolean} [fetchMemoryContent] - Whether to fetch original content
+     * @param {string} [format] - Streaming format ('ndjson' or 'sse', defaults to 'ndjson')
+     * @param {string} [ppLlmId] - UUID of LLM for abstract generation
+     * @param {string} [ppRerankerId] - UUID of reranker for result reranking
+     * @param {number} [ppRelevanceThreshold] - Minimum relevance score
+     * @param {number} [ppLlmTemp] - LLM temperature for generation
+     * @param {number} [ppMaxResults] - Maximum results to return
+     * @param {boolean} [ppChronologicalResort] - Whether to resort by creation time
+     * @returns {Promise<AsyncIterableIterator<MemoryStreamResponse>>} Async iterator of streaming events
+     */
+    )
+  }, {
+    key: "retrieveMemoryStreamChat",
+    value: (function () {
+      var _retrieveMemoryStreamChat = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(signal, message, spaceIds, requestedSize, fetchMemory, fetchMemoryContent, format, ppLlmId, ppRerankerId, ppRelevanceThreshold, ppLlmTemp, ppMaxResults, ppChronologicalResort) {
+        var request;
+        return _regenerator().w(function (_context5) {
+          while (1) switch (_context5.n) {
+            case 0:
+              request = {
+                message: message,
+                spaceIds: spaceIds,
+                requestedSize: requestedSize,
+                fetchMemory: fetchMemory,
+                fetchMemoryContent: fetchMemoryContent,
+                format: format || StreamingClient.StreamingFormat.NDJSON,
+                ppLlmId: ppLlmId,
+                ppRerankerId: ppRerankerId,
+                ppRelevanceThreshold: ppRelevanceThreshold,
+                ppLlmTemp: ppLlmTemp,
+                ppMaxResults: ppMaxResults,
+                ppChronologicalResort: ppChronologicalResort
+              };
+              return _context5.a(2, this.retrieveMemoryStream(signal, request));
+          }
+        }, _callee5, this);
+      }));
+      function retrieveMemoryStreamChat(_x6, _x7, _x8, _x9, _x0, _x1, _x10, _x11, _x12, _x13, _x14, _x15, _x16) {
+        return _retrieveMemoryStreamChat.apply(this, arguments);
+      }
+      return retrieveMemoryStreamChat;
+    }()
+    /**
+     * Stream semantic memory retrieval using advanced POST endpoint with custom post-processor
+     *
+     * @param {AbortSignal} signal - Abort signal for cancellation
+     * @param {AdvancedMemoryStreamRequest} request - Advanced request with post-processor config
+     * @returns {Promise<AsyncIterableIterator<MemoryStreamResponse>>} Async iterator of streaming events
+     */
+    )
+  }, {
+    key: "retrieveMemoryStreamAdvanced",
+    value: (function () {
+      var _retrieveMemoryStreamAdvanced = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6(signal, request) {
+        var requestBody, postProcessor, baseURL, endpoint, headers, response, errorText;
+        return _regenerator().w(function (_context6) {
+          while (1) switch (_context6.n) {
+            case 0:
+              if (request) {
+                _context6.n = 1;
+                break;
+              }
+              throw new Error('Request cannot be null');
+            case 1:
+              if (request.message) {
+                _context6.n = 2;
+                break;
+              }
+              throw new Error('Message is required');
+            case 2:
+              if (!request.format) {
+                request.format = StreamingClient.StreamingFormat.NDJSON;
+              }
+
+              // Build request body
+              requestBody = {
+                message: request.message,
+                spaceKeys: []
+              }; // Convert spaceIds to spaceKeys array
+              if (request.spaceIds && request.spaceIds.length > 0) {
+                request.spaceIds.forEach(function (spaceId) {
+                  requestBody.spaceKeys.push({
+                    spaceId: spaceId
+                  });
+                });
+              }
+
+              // Add optional parameters
+              if (request.requestedSize !== undefined) {
+                requestBody.requestedSize = request.requestedSize;
+              }
+              if (request.fetchMemory !== undefined) {
+                requestBody.fetchMemory = request.fetchMemory;
+              }
+              if (request.fetchMemoryContent !== undefined) {
+                requestBody.fetchMemoryContent = request.fetchMemoryContent;
+              }
+
+              // Add post-processor configuration
+              if (request.postProcessorName) {
+                postProcessor = {
+                  name: request.postProcessorName
+                };
+                if (request.postProcessorConfig) {
+                  postProcessor.config = request.postProcessorConfig;
+                }
+                requestBody.postProcessor = postProcessor;
+              }
+
+              // Build URL for POST endpoint
+              baseURL = this.client.basePath || 'http://localhost:8080';
+              endpoint = "".concat(baseURL, "/v1/memories:retrieve"); // Set appropriate headers
+              headers = {
+                'Accept': request.format === StreamingClient.StreamingFormat.SSE ? 'text/event-stream' : 'application/x-ndjson',
+                'Content-Type': 'application/json'
+              }; // Add authentication headers
+              if (this.client.defaultHeaders) {
+                Object.assign(headers, this.client.defaultHeaders);
+              }
+
+              // Make the POST request
+              _context6.n = 3;
+              return fetch(endpoint, {
+                method: 'POST',
+                headers: headers,
+                body: JSON.stringify(requestBody),
+                signal: signal
+              });
+            case 3:
+              response = _context6.v;
+              if (response.ok) {
+                _context6.n = 5;
+                break;
+              }
+              _context6.n = 4;
+              return response.text();
+            case 4:
+              errorText = _context6.v;
+              throw new StreamError(errorText, response.status);
+            case 5:
+              if (!(request.format === StreamingClient.StreamingFormat.SSE)) {
+                _context6.n = 6;
+                break;
+              }
+              return _context6.a(2, this._processSSEStream(response));
+            case 6:
+              return _context6.a(2, this._processNDJSONStream(response));
+            case 7:
+              return _context6.a(2);
+          }
+        }, _callee6, this);
+      }));
+      function retrieveMemoryStreamAdvanced(_x17, _x18) {
+        return _retrieveMemoryStreamAdvanced.apply(this, arguments);
+      }
+      return retrieveMemoryStreamAdvanced;
+    }()
     /**
      * Collects all streaming results into an array
      * @param {AbortSignal} signal - Abort signal for cancellation
@@ -460,43 +645,43 @@ var StreamingClient = exports.StreamingClient = /*#__PURE__*/function () {
      * @returns {Promise<MemoryStreamResponse[]>} Array of streaming events
      */
     function () {
-      var _streamWithTimeout = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(message, spaceIds, timeoutMs) {
+      var _streamWithTimeout = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7(message, spaceIds, timeoutMs) {
         var controller, timeoutId, stream, results, _t5;
-        return _regenerator().w(function (_context5) {
-          while (1) switch (_context5.p = _context5.n) {
+        return _regenerator().w(function (_context7) {
+          while (1) switch (_context7.p = _context7.n) {
             case 0:
               controller = new AbortController();
               timeoutId = setTimeout(function () {
                 return controller.abort();
               }, timeoutMs);
-              _context5.p = 1;
-              _context5.n = 2;
+              _context7.p = 1;
+              _context7.n = 2;
               return this.retrieveMemoryStreamSimple(controller.signal, message, spaceIds);
             case 2:
-              stream = _context5.v;
-              _context5.n = 3;
+              stream = _context7.v;
+              _context7.n = 3;
               return StreamingClient.collectStreamResults(controller.signal, stream);
             case 3:
-              results = _context5.v;
+              results = _context7.v;
               clearTimeout(timeoutId);
-              return _context5.a(2, results);
+              return _context7.a(2, results);
             case 4:
-              _context5.p = 4;
-              _t5 = _context5.v;
+              _context7.p = 4;
+              _t5 = _context7.v;
               clearTimeout(timeoutId);
               if (!(_t5.name === 'AbortError' || _t5.message === 'Operation was aborted')) {
-                _context5.n = 5;
+                _context7.n = 5;
                 break;
               }
               throw new Error('Streaming operation timed out');
             case 5:
               throw _t5;
             case 6:
-              return _context5.a(2);
+              return _context7.a(2);
           }
-        }, _callee5, this, [[1, 4]]);
+        }, _callee7, this, [[1, 4]]);
       }));
-      function streamWithTimeout(_x6, _x7, _x8) {
+      function streamWithTimeout(_x19, _x20, _x21) {
         return _streamWithTimeout.apply(this, arguments);
       }
       return streamWithTimeout;
@@ -504,28 +689,28 @@ var StreamingClient = exports.StreamingClient = /*#__PURE__*/function () {
   }], [{
     key: "collectStreamResults",
     value: (function () {
-      var _collectStreamResults = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6(signal, stream) {
+      var _collectStreamResults = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee8(signal, stream) {
         var results, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, event, _t6, _t7;
-        return _regenerator().w(function (_context6) {
-          while (1) switch (_context6.p = _context6.n) {
+        return _regenerator().w(function (_context8) {
+          while (1) switch (_context8.p = _context8.n) {
             case 0:
               results = [];
-              _context6.p = 1;
+              _context8.p = 1;
               _iteratorAbruptCompletion = false;
               _didIteratorError = false;
-              _context6.p = 2;
+              _context8.p = 2;
               _iterator = _asyncIterator(stream);
             case 3:
-              _context6.n = 4;
+              _context8.n = 4;
               return _iterator.next();
             case 4:
-              if (!(_iteratorAbruptCompletion = !(_step = _context6.v).done)) {
-                _context6.n = 7;
+              if (!(_iteratorAbruptCompletion = !(_step = _context8.v).done)) {
+                _context8.n = 7;
                 break;
               }
               event = _step.value;
               if (!(signal && signal.aborted)) {
-                _context6.n = 5;
+                _context8.n = 5;
                 break;
               }
               throw new Error('Operation was aborted');
@@ -533,55 +718,55 @@ var StreamingClient = exports.StreamingClient = /*#__PURE__*/function () {
               results.push(event);
             case 6:
               _iteratorAbruptCompletion = false;
-              _context6.n = 3;
+              _context8.n = 3;
               break;
             case 7:
-              _context6.n = 9;
+              _context8.n = 9;
               break;
             case 8:
-              _context6.p = 8;
-              _t6 = _context6.v;
+              _context8.p = 8;
+              _t6 = _context8.v;
               _didIteratorError = true;
               _iteratorError = _t6;
             case 9:
-              _context6.p = 9;
-              _context6.p = 10;
+              _context8.p = 9;
+              _context8.p = 10;
               if (!(_iteratorAbruptCompletion && _iterator["return"] != null)) {
-                _context6.n = 11;
+                _context8.n = 11;
                 break;
               }
-              _context6.n = 11;
+              _context8.n = 11;
               return _iterator["return"]();
             case 11:
-              _context6.p = 11;
+              _context8.p = 11;
               if (!_didIteratorError) {
-                _context6.n = 12;
+                _context8.n = 12;
                 break;
               }
               throw _iteratorError;
             case 12:
-              return _context6.f(11);
+              return _context8.f(11);
             case 13:
-              return _context6.f(9);
+              return _context8.f(9);
             case 14:
-              _context6.n = 17;
+              _context8.n = 17;
               break;
             case 15:
-              _context6.p = 15;
-              _t7 = _context6.v;
+              _context8.p = 15;
+              _t7 = _context8.v;
               if (!(_t7.name === 'AbortError' || _t7.message === 'Operation was aborted')) {
-                _context6.n = 16;
+                _context8.n = 16;
                 break;
               }
               throw _t7;
             case 16:
               throw _t7;
             case 17:
-              return _context6.a(2, results);
+              return _context8.a(2, results);
           }
-        }, _callee6, null, [[10,, 11, 13], [2, 8, 9, 14], [1, 15]]);
+        }, _callee8, null, [[10,, 11, 13], [2, 8, 9, 14], [1, 15]]);
       }));
-      function collectStreamResults(_x9, _x0) {
+      function collectStreamResults(_x22, _x23) {
         return _collectStreamResults.apply(this, arguments);
       }
       return collectStreamResults;
@@ -598,6 +783,24 @@ var StreamingClient = exports.StreamingClient = /*#__PURE__*/function () {
  * @property {boolean} [fetchMemoryContent] - Whether to fetch memory content details
  * @property {boolean} [generateAbstract] - Whether to generate abstract
  * @property {string} [format] - Streaming format (ndjson or sse)
+ * @property {string} [ppLlmId] - UUID of LLM for ChatPostProcessor
+ * @property {string} [ppRerankerId] - UUID of reranker for ChatPostProcessor
+ * @property {number} [ppRelevanceThreshold] - Minimum relevance score
+ * @property {number} [ppLlmTemp] - LLM temperature for generation
+ * @property {number} [ppMaxResults] - Maximum results to return
+ * @property {boolean} [ppChronologicalResort] - Whether to resort by creation time
+ */
+/**
+ * Advanced request parameters for streaming with custom post-processor
+ * @typedef {Object} AdvancedMemoryStreamRequest
+ * @property {string} message - The search message
+ * @property {string[]} [spaceIds] - Array of space IDs to search
+ * @property {number} [requestedSize] - Maximum number of results to return
+ * @property {boolean} [fetchMemory] - Whether to fetch memory content
+ * @property {boolean} [fetchMemoryContent] - Whether to fetch memory content details
+ * @property {string} [format] - Streaming format (ndjson or sse)
+ * @property {string} [postProcessorName] - Name of custom post-processor
+ * @property {Object} [postProcessorConfig] - Configuration for post-processor
  */
 /**
  * Streaming response event

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pairsystems/goodmem-client",
-  "version": "1.0.0-dev.cb052d6",
+  "version": "1.0.0",
   "description": "JavaScript client for GoodMem API",
   "license": "Unlicense",
   "main": "dist/index.js",