feat: add thread

Author: namchuai

…i-dto/messages/delete_message_response.h …common/api-dto/delete_success_response.hengine/common/api-dto/messages/delete_message_response.h renamed to engine/common/api-dto/delete_success_response.h engine/common/api-dto/messages/delete_message_response.h renamed to engine/common/api-dto/delete_success_response.h

@@ -3,7 +3,7 @@
 #include "common/json_serializable.h"
 
 namespace api_response {
-struct DeleteMessageResponse : JsonSerializable {
+struct DeleteSuccessResponse : JsonSerializable {
   std::string id;
   std::string object;
   bool deleted;

engine/common/message.h

@@ -17,20 +17,11 @@
 #include "utils/logging_utils.h"
 #include "utils/result.hpp"
 
+// TODO: change name to OpenAi
 namespace ThreadMessage {
 
 // Represents a message within a thread.
 struct Message : JsonSerializable {
-  Message() = default;
-
-  Message(Message&&) = default;
-
-  Message& operator=(Message&&) = default;
-
-  Message(const Message&) = delete;
-
-  Message& operator=(const Message&) = delete;
-
   // The identifier, which can be referenced in API endpoints.
   std::string id;
 

engine/common/message_attachment_factory.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include <optional>
 #include "common/message_attachment.h"
 #include "utils/result.hpp"

engine/common/repository/thread_repository.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "common/message.h"
+#include "common/thread.h"
+#include "utils/result.hpp"
+
+class ThreadRepository {
+ public:
+  virtual cpp::result<void, std::string> CreateThread(
+      OpenAi::Thread& thread,
+      std::optional<std::vector<ThreadMessage::Message>> messages) = 0;
+
+  virtual cpp::result<std::vector<OpenAi::Thread>, std::string> ListThreads(
+      uint8_t limit, const std::string& order, const std::string&,
+      const std::string& before) const = 0;
+
+  virtual cpp::result<OpenAi::Thread, std::string> RetrieveThread(
+      const std::string& thread_id) const = 0;
+
+  virtual cpp::result<void, std::string> ModifyThread(
+      OpenAi::Thread& thread) = 0;
+
+  virtual cpp::result<void, std::string> DeleteThread(
+      const std::string& thread_id) = 0;
+
+  virtual ~ThreadRepository() = default;
+};

engine/common/thread.h

@@ -0,0 +1,102 @@
+#pragma once
+
+#include <json/reader.h>
+#include <json/value.h>
+#include <json/writer.h>
+#include "common/thread_tool_resources.h"
+#include "common/variant_map.h"
+#include "json_serializable.h"
+#include "utils/logging_utils.h"
+
+namespace OpenAi {
+
+/**
+ * Represents a thread that contains messages.
+ */
+struct Thread : JsonSerializable {
+  /**
+   * The identifier, which can be referenced in API endpoints.
+   */
+  std::string id;
+
+  /**
+   * The object type, which is always thread.
+   */
+  std::string object = "thread";
+
+  /**
+   * The Unix timestamp (in seconds) for when the thread was created.
+   */
+  uint64_t created_at;
+
+  /**
+   * A set of resources that are made available to the assistant's
+   * tools in this thread. The resources are specific to the type
+   * of tool. For example, the code_interpreter tool requires a list of
+   * file IDs, while the file_search tool requires a list of vector store IDs.
+   */
+  std::optional<std::unique_ptr<ToolResources>> tool_resources;
+
+  /**
+   * Set of 16 key-value pairs that can be attached to an object.
+   * This can be useful for storing additional information about the object 
+   * in a structured format. 
+   * 
+   * Keys can be a maximum of 64 characters long and values can be a maximum
+   * of 512 characters long.
+   */
+  Cortex::VariantMap metadata;
+
+  static cpp::result<Thread, std::string> FromJson(const Json::Value& json) {
+    Thread thread;
+
+    thread.id = json["id"].asString();
+    thread.object = "thread";
+    thread.created_at = json["created_at"].asUInt();
+    if (thread.created_at == 0 && json["created"].asUInt64() != 0) {
+      thread.created_at = json["created"].asUInt64() / 1000;
+    }
+    // TODO: namh parse tool_resources
+
+    if (json["metadata"].isObject() && !json["metadata"].empty()) {
+      auto res = Cortex::ConvertJsonValueToMap(json["metadata"]);
+      if (res.has_error()) {
+        CTL_WRN("Failed to convert metadata to map: " + res.error());
+      } else {
+        thread.metadata = res.value();
+      }
+    }
+
+    return thread;
+  }
+
+  cpp::result<Json::Value, std::string> ToJson() override {
+    try {
+      Json::Value json;
+
+      json["id"] = id;
+      json["object"] = object;
+      json["created_at"] = created_at;
+      // TODO: namh handle tool_resources
+
+      Json::Value metadata_json{Json::objectValue};
+      for (const auto& [key, value] : metadata) {
+        if (std::holds_alternative<bool>(value)) {
+          metadata_json[key] = std::get<bool>(value);
+        } else if (std::holds_alternative<uint64_t>(value)) {
+          metadata_json[key] = std::get<uint64_t>(value);
+        } else if (std::holds_alternative<double>(value)) {
+          metadata_json[key] = std::get<double>(value);
+        } else {
+          metadata_json[key] = std::get<std::string>(value);
+        }
+      }
+      json["metadata"] = metadata_json;
+
+      return json;
+    } catch (const std::exception& e) {
+      return cpp::fail(std::string("ToJson failed: ") + e.what());
+    }
+  }
+};
+}  // namespace OpenAi

engine/common/thread_tool_resources.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include "common/json_serializable.h"
+
+namespace OpenAi {
+
+struct ToolResources : JsonSerializable {
+  ~ToolResources() = default;
+
+  virtual cpp::result<Json::Value, std::string> ToJson() override = 0;
+};
+
+struct CodeInterpreter : ToolResources {
+  std::vector<std::string> file_ids;
+
+  cpp::result<Json::Value, std::string> ToJson() override {
+    try {
+      Json::Value json;
+      Json::Value file_ids_json{Json::arrayValue};
+      for (auto& file_id : file_ids) {
+        file_ids_json.append(file_id);
+      }
+      json["file_ids"] = file_ids_json;
+      return json;
+    } catch (const std::exception& e) {
+      return cpp::fail(std::string("ToJson failed: ") + e.what());
+    }
+  }
+};
+
+struct FileSearch : ToolResources {
+  std::vector<std::string> vector_store_ids;
+
+  cpp::result<Json::Value, std::string> ToJson() override {
+    try {
+      Json::Value json;
+      Json::Value vector_store_ids_json{Json::arrayValue};
+      for (auto& vector_store_id : vector_store_ids) {
+        vector_store_ids_json.append(vector_store_id);
+      }
+      json["vector_store_ids"] = vector_store_ids_json;
+      return json;
+    } catch (const std::exception& e) {
+      return cpp::fail(std::string("ToJson failed: ") + e.what());
+    }
+  }
+};
+}  // namespace OpenAi

engine/controllers/messages.cc

@@ -1,5 +1,5 @@
 #include "messages.h"
-#include "common/api-dto/messages/delete_message_response.h"
+#include "common/api-dto/delete_success_response.h"
 #include "common/message_content.h"
 #include "common/message_role.h"
 #include "common/variant_map.h"
@@ -287,7 +287,7 @@ void Messages::DeleteMessage(
     return;
   }
 
-  api_response::DeleteMessageResponse response;
+  api_response::DeleteSuccessResponse response;
   response.id = message_id;
   response.object = "thread.message.deleted";
   response.deleted = true;