fix ci

Author: namchuai

engine/common/thread.h

@@ -3,7 +3,6 @@
 #include <json/reader.h>
 #include <json/value.h>
 #include <json/writer.h>
-#include <optional>
 #include "common/thread_tool_resources.h"
 #include "common/variant_map.h"
 #include "json_serializable.h"
@@ -36,7 +35,7 @@ struct Thread : JsonSerializable {
    * 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<ThreadToolResources>> tool_resources;
+  std::unique_ptr<ThreadToolResources> tool_resources;
 
   /**
    * Set of 16 key-value pairs that can be attached to an object.
@@ -57,7 +56,30 @@ struct Thread : JsonSerializable {
     if (thread.created_at == 0 && json["created"].asUInt64() != 0) {
       thread.created_at = json["created"].asUInt64() / 1000;
     }
-    // TODO: namh parse tool_resources
+
+    if (json.isMember("tool_resources") && !json["tool_resources"].isNull()) {
+      const auto& tool_json = json["tool_resources"];
+
+      if (tool_json.isMember("code_interpreter")) {
+        auto code_interpreter = std::make_unique<ThreadCodeInterpreter>();
+        const auto& file_ids = tool_json["code_interpreter"]["file_ids"];
+        if (file_ids.isArray()) {
+          for (const auto& file_id : file_ids) {
+            code_interpreter->file_ids.push_back(file_id.asString());
+          }
+        }
+        thread.tool_resources = std::move(code_interpreter);
+      } else if (tool_json.isMember("file_search")) {
+        auto file_search = std::make_unique<ThreadFileSearch>();
+        const auto& store_ids = tool_json["file_search"]["vector_store_ids"];
+        if (store_ids.isArray()) {
+          for (const auto& store_id : store_ids) {
+            file_search->vector_store_ids.push_back(store_id.asString());
+          }
+        }
+        thread.tool_resources = std::move(file_search);
+      }
+    }
 
     if (json["metadata"].isObject() && !json["metadata"].empty()) {
       auto res = Cortex::ConvertJsonValueToMap(json["metadata"]);
@@ -78,7 +100,24 @@ struct Thread : JsonSerializable {
       json["id"] = id;
       json["object"] = object;
       json["created_at"] = created_at;
-      // TODO: namh handle tool_resources
+
+      if (tool_resources) {
+        auto tool_result = tool_resources->ToJson();
+        if (tool_result.has_error()) {
+          return cpp::fail("Failed to serialize tool_resources: " +
+                           tool_result.error());
+        }
+
+        Json::Value tool_json;
+        if (auto code_interpreter =
+                dynamic_cast<ThreadCodeInterpreter*>(tool_resources.get())) {
+          tool_json["code_interpreter"] = tool_result.value();
+        } else if (auto file_search =
+                       dynamic_cast<ThreadFileSearch*>(tool_resources.get())) {
+          tool_json["file_search"] = tool_result.value();
+        }
+        json["tool_resources"] = tool_json;
+      }
 
       Json::Value metadata_json{Json::objectValue};
       for (const auto& [key, value] : metadata) {

engine/controllers/threads.cc

@@ -65,7 +65,7 @@ void Threads::CreateThread(
     }
   }
 
-  auto res = thread_service_->CreateThread(std::nullopt, metadata);
+  auto res = thread_service_->CreateThread(nullptr, metadata);
 
   if (res.has_error()) {
     Json::Value ret;
@@ -170,7 +170,7 @@ void Threads::ModifyThread(
 
   // TODO: namh handle tools
   auto res =
-      thread_service_->ModifyThread(thread_id, std::nullopt, metadata.value());
+      thread_service_->ModifyThread(thread_id, nullptr, metadata.value());
   if (res.has_error()) {
     Json::Value ret;
     ret["message"] = res.error();

engine/repositories/message_fs_repository.cc

@@ -1,5 +1,6 @@
 #include "message_fs_repository.h"
 #include <fstream>
+#include <mutex>
 #include "utils/result.hpp"
 
 std::filesystem::path MessageFsRepository::GetMessagePath(

engine/repositories/thread_fs_repository.cc

@@ -1,5 +1,6 @@
 #include "thread_fs_repository.h"
 #include <fstream>
+#include <mutex>
 
 cpp::result<std::vector<OpenAi::Thread>, std::string>
 ThreadFsRepository::ListThreads(uint8_t limit, const std::string& order,

engine/repositories/thread_fs_repository.h

@@ -34,7 +34,7 @@ class ThreadFsRepository : public ThreadRepository {
   cpp::result<void, std::string> SaveThread(OpenAi::Thread& thread);
 
  public:
-  explicit ThreadFsRepository(std::filesystem::path data_folder_path)
+  explicit ThreadFsRepository(const std::filesystem::path& data_folder_path)
       : data_folder_path_{data_folder_path} {
     CTL_INF("Constructing ThreadFsRepository..");
     auto thread_container_path = data_folder_path_ / kThreadContainerFolderName;

engine/services/thread_service.cc

@@ -3,7 +3,7 @@
 #include "utils/ulid/ulid.hh"
 
 cpp::result<OpenAi::Thread, std::string> ThreadService::CreateThread(
-    std::optional<std::unique_ptr<OpenAi::ThreadToolResources>> tool_resources,
+    std::unique_ptr<OpenAi::ThreadToolResources> tool_resources,
     std::optional<Cortex::VariantMap> metadata) {
   LOG_TRACE << "CreateThread";
 
@@ -20,8 +20,8 @@ cpp::result<OpenAi::Thread, std::string> ThreadService::CreateThread(
   thread.object = "thread";
   thread.created_at = seconds_since_epoch;
 
-  if (tool_resources.has_value()) {
-    thread.tool_resources = std::move(tool_resources.value());
+  if (tool_resources) {
+    thread.tool_resources = std::move(tool_resources);
   }
   thread.metadata = metadata.value_or(Cortex::VariantMap{});
 
@@ -42,21 +42,23 @@ ThreadService::ListThreads(uint8_t limit, const std::string& order,
 
 cpp::result<OpenAi::Thread, std::string> ThreadService::RetrieveThread(
     const std::string& thread_id) const {
-  LOG_TRACE << "RetriveThread: " << thread_id;
+  CTL_INF("RetrieveThread: " + thread_id);
   return thread_repository_->RetrieveThread(thread_id);
 }
 
 cpp::result<OpenAi::Thread, std::string> ThreadService::ModifyThread(
     const std::string& thread_id,
-    std::optional<std::unique_ptr<OpenAi::ThreadToolResources>> tool_resources,
+    std::unique_ptr<OpenAi::ThreadToolResources> tool_resources,
     std::optional<Cortex::VariantMap> metadata) {
   LOG_TRACE << "ModifyThread " << thread_id;
   auto retrieve_res = RetrieveThread(thread_id);
   if (retrieve_res.has_error()) {
     return cpp::fail("Failed to retrieve thread: " + retrieve_res.error());
   }
 
-  retrieve_res->tool_resources = std::move(tool_resources.value());
+  if (tool_resources) {
+    retrieve_res->tool_resources = std::move(tool_resources);
+  }
   retrieve_res->metadata = std::move(metadata.value());
 
   auto res = thread_repository_->ModifyThread(retrieve_res.value());

engine/services/thread_service.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <optional>
 #include "common/repository/thread_repository.h"
 #include "common/thread_tool_resources.h"
 #include "common/variant_map.h"
@@ -11,8 +12,7 @@ class ThreadService {
       : thread_repository_{thread_repository} {}
 
   cpp::result<OpenAi::Thread, std::string> CreateThread(
-      std::optional<std::unique_ptr<OpenAi::ThreadToolResources>>
-          tool_resources,
+      std::unique_ptr<OpenAi::ThreadToolResources> tool_resources,
       std::optional<Cortex::VariantMap> metadata);
 
   cpp::result<std::vector<OpenAi::Thread>, std::string> ListThreads(
@@ -24,8 +24,7 @@ class ThreadService {
 
   cpp::result<OpenAi::Thread, std::string> ModifyThread(
       const std::string& thread_id,
-      std::optional<std::unique_ptr<OpenAi::ThreadToolResources>>
-          tool_resources,
+      std::unique_ptr<OpenAi::ThreadToolResources> tool_resources,
       std::optional<Cortex::VariantMap> metadata);
 
   cpp::result<std::string, std::string> DeleteThread(