add pagination messages

Author: namchuai

engine/controllers/messages.cc

@@ -10,13 +10,13 @@
 void Messages::ListMessages(
     const HttpRequestPtr& req,
     std::function<void(const HttpResponsePtr&)>&& callback,
-    const std::string& thread_id, std::optional<uint8_t> limit,
+    const std::string& thread_id, std::optional<std::string> limit,
     std::optional<std::string> order, std::optional<std::string> after,
     std::optional<std::string> before,
     std::optional<std::string> run_id) const {
   auto res = message_service_->ListMessages(
-      thread_id, limit.value_or(20), order.value_or("desc"), after.value_or(""),
-      before.value_or(""), run_id.value_or(""));
+      thread_id, std::stoi(limit.value_or("20")), order.value_or("desc"),
+      after.value_or(""), before.value_or(""), run_id.value_or(""));
 
   Json::Value root;
   if (res.has_error()) {

engine/controllers/messages.h

@@ -34,7 +34,8 @@ class Messages : public drogon::HttpController<Messages, false> {
 
   void ListMessages(const HttpRequestPtr& req,
                     std::function<void(const HttpResponsePtr&)>&& callback,
-                    const std::string& thread_id, std::optional<uint8_t> limit,
+                    const std::string& thread_id,
+                    std::optional<std::string> limit,
                     std::optional<std::string> order,
                     std::optional<std::string> after,
                     std::optional<std::string> before,

engine/repositories/message_fs_repository.cc

@@ -1,4 +1,5 @@
 #include "message_fs_repository.h"
+#include <algorithm>
 #include <fstream>
 #include <mutex>
 #include "utils/result.hpp"
@@ -52,7 +53,61 @@ MessageFsRepository::ListMessages(const std::string& thread_id, uint8_t limit,
   auto mutex = GrabMutex(thread_id);
   std::shared_lock<std::shared_mutex> lock(*mutex);
 
-  return ReadMessageFromFile(thread_id);
+  auto read_result = ReadMessageFromFile(thread_id);
+  if (read_result.has_error()) {
+    return cpp::fail(read_result.error());
+  }
+
+  std::vector<OpenAi::Message> messages = std::move(read_result.value());
+
+  if (!run_id.empty()) {
+    messages.erase(std::remove_if(messages.begin(), messages.end(),
+                                  [&run_id](const OpenAi::Message& msg) {
+                                    return msg.run_id != run_id;
+                                  }),
+                   messages.end());
+  }
+
+  std::sort(messages.begin(), messages.end(),
+            [&order](const OpenAi::Message& a, const OpenAi::Message& b) {
+              if (order == "desc") {
+                return a.created_at > b.created_at;
+              }
+              return a.created_at < b.created_at;
+            });
+
+  auto start_it = messages.begin();
+  auto end_it = messages.end();
+
+  if (!after.empty()) {
+    start_it = std::find_if(
+        messages.begin(), messages.end(),
+        [&after](const OpenAi::Message& msg) { return msg.id == after; });
+    if (start_it != messages.end()) {
+      ++start_it;  // Start from the message after the 'after' message
+    } else {
+      start_it = messages.begin();
+    }
+  }
+
+  if (!before.empty()) {
+    end_it = std::find_if(
+        messages.begin(), messages.end(),
+        [&before](const OpenAi::Message& msg) { return msg.id == before; });
+  }
+
+  std::vector<OpenAi::Message> result;
+  size_t distance = std::distance(start_it, end_it);
+  size_t limit_size = static_cast<size_t>(limit);
+  CTL_INF("Distance: " + std::to_string(distance) +
+          ", limit_size: " + std::to_string(limit_size));
+  result.reserve(distance < limit_size ? distance : limit_size);
+
+  for (auto it = start_it; it != end_it && result.size() < limit_size; ++it) {
+    result.push_back(std::move(*it));
+  }
+
+  return result;
 }
 
 cpp::result<OpenAi::Message, std::string> MessageFsRepository::RetrieveMessage(

engine/services/message_service.h

@@ -21,9 +21,9 @@ class MessageService {
       std::optional<std::vector<OpenAi::Message>> messages);
 
   cpp::result<std::vector<OpenAi::Message>, std::string> ListMessages(
-      const std::string& thread_id, uint8_t limit = 20,
-      const std::string& order = "desc", const std::string& after = "",
-      const std::string& before = "", const std::string& run_id = "") const;
+      const std::string& thread_id, uint8_t limit, const std::string& order,
+      const std::string& after, const std::string& before,
+      const std::string& run_id) const;
 
   cpp::result<OpenAi::Message, std::string> RetrieveMessage(
       const std::string& thread_id, const std::string& message_id) const;