feat: add support for Model and Engine service

Author: namchuai

engine/commands/engine_install_cmd.cc

@@ -1,18 +1,16 @@
 #include "engine_install_cmd.h"
-// clang-format off
-#include "utils/cortexso_parser.h" 
-#include "utils/archive_utils.h"
-// clang-format on
-#include "utils/cuda_toolkit_utils.h"
-#include "utils/engine_matcher_utils.h"
 #include "utils/logging_utils.h"
 
 namespace commands {
 
 void EngineInstallCmd::Exec(const std::string& engine,
                             const std::string& version,
                             const std::string& src) {
-  engine_service_.InstallEngine(engine, version, src);
-  CLI_LOG("Engine " << engine << " installed successfully!");
+  auto result = engine_service_.InstallEngine(engine, version, src);
+  if (result.has_error()) {
+    CLI_LOG(result.error());
+  } else {
+    CLI_LOG("Engine " << engine << " installed successfully!");
+  }
 }
 };  // namespace commands

engine/commands/engine_uninstall_cmd.cc

@@ -5,7 +5,12 @@
 namespace commands {
 
 void EngineUninstallCmd::Exec(const std::string& engine) {
-  engine_service_.UninstallEngine(engine);
-  CLI_LOG("Engine " << engine << " uninstalled successfully!");
+  auto result = engine_service_.UninstallEngine(engine);
+
+  if (result.has_error()) {
+    CLI_LOG(result.error());
+  } else {
+    CLI_LOG("Engine uninstalled successfully");
+  }
 }
 };  // namespace commands

engine/commands/run_cmd.cc

@@ -1,13 +1,12 @@
 #include "run_cmd.h"
 #include "chat_cmd.h"
-#include "cmd_info.h"
 #include "config/yaml_config.h"
 #include "model_start_cmd.h"
 #include "model_status_cmd.h"
 #include "server_start_cmd.h"
-#include "utils/cortex_utils.h"
-#include "utils/file_manager_utils.h"
+#include "utils/logging_utils.h"
 #include "utils/modellist_utils.h"
+
 namespace commands {
 
 void RunCmd::Exec() {
@@ -45,7 +44,10 @@ void RunCmd::Exec() {
         throw std::runtime_error("Engine " + mc.engine + " is incompatible");
       }
       if (required_engine.value().status == EngineService::kNotInstalled) {
-        engine_service_.InstallEngine(mc.engine);
+        auto install_engine_result = engine_service_.InstallEngine(mc.engine);
+        if (install_engine_result.has_error()) {
+          throw std::runtime_error(install_engine_result.error());
+        }
       }
     }
 

engine/services/download_service.cc

@@ -10,6 +10,7 @@
 #include "download_service.h"
 #include "utils/format_utils.h"
 #include "utils/logging_utils.h"
+#include "utils/result.hpp"
 
 #ifdef _WIN32
 #define ftell64(f) _ftelli64(f)
@@ -26,7 +27,7 @@ size_t WriteCallback(void* ptr, size_t size, size_t nmemb, FILE* stream) {
 }
 }  // namespace
 
-void DownloadService::AddDownloadTask(
+cpp::result<void, std::string> DownloadService::AddDownloadTask(
     DownloadTask& task, std::optional<OnDownloadTaskSuccessfully> callback) {
   CLI_LOG("Validating download items, please wait..");
   // preprocess to check if all the item are valid
@@ -45,7 +46,7 @@ void DownloadService::AddDownloadTask(
 
   if (err_msg.has_value()) {
     CTL_ERR(err_msg.value());
-    return;
+    return cpp::fail(err_msg.value());
   }
 
   // all items are valid, start downloading
@@ -62,12 +63,13 @@ void DownloadService::AddDownloadTask(
   }
   if (dl_err_msg.has_value()) {
     CTL_ERR(dl_err_msg.value());
-    return;
+    return cpp::fail(dl_err_msg.value());
   }
 
   if (callback.has_value()) {
     callback.value()(task);
   }
+  return {};
 }
 
 cpp::result<uint64_t, std::string> DownloadService::GetFileSize(

engine/services/download_service.h

@@ -57,7 +57,7 @@ class DownloadService {
   using OnDownloadTaskSuccessfully =
       std::function<void(const DownloadTask& task)>;
 
-  void AddDownloadTask(
+  cpp::result<void, std::string> AddDownloadTask(
       DownloadTask& task,
       std::optional<OnDownloadTaskSuccessfully> callback = std::nullopt);
 

engine/services/engine_service.cc

@@ -1,11 +1,11 @@
 #include "engine_service.h"
 #include <httplib.h>
-#include <stdexcept>
 #include "algorithm"
 #include "utils/archive_utils.h"
 #include "utils/engine_matcher_utils.h"
 #include "utils/file_manager_utils.h"
 #include "utils/json.hpp"
+#include "utils/result.hpp"
 #include "utils/semantic_version_utils.h"
 #include "utils/system_info_utils.h"
 #include "utils/url_parser.h"
@@ -40,7 +40,6 @@ EngineService::~EngineService() {}
 
 std::optional<EngineInfo> EngineService::GetEngineInfo(
     const std::string& engine) const {
-  // if engine is not found in kSupportEngine, throw runtime error
   if (std::find(kSupportEngines.begin(), kSupportEngines.end(), engine) ==
       kSupportEngines.end()) {
     return std::nullopt;
@@ -99,21 +98,24 @@ std::vector<EngineInfo> EngineService::GetEngineInfoList() const {
   return engines;
 }
 
-void EngineService::InstallEngine(const std::string& engine,
-                                  const std::string& version,
-                                  const std::string& src) {
+cpp::result<void, std::string> EngineService::InstallEngine(
+    const std::string& engine, const std::string& version,
+    const std::string& src) {
 
   if (!src.empty()) {
-    UnzipEngine(engine, version, src);
+    return UnzipEngine(engine, version, src);
   } else {
-    DownloadEngine(engine, version);
-    DownloadCuda(engine);
+    auto result = DownloadEngine(engine, version);
+    if (result.has_error()) {
+      return result;
+    }
+    return DownloadCuda(engine);
   }
 }
 
-void EngineService::UnzipEngine(const std::string& engine,
-                                const std::string& version,
-                                const std::string& path) {
+cpp::result<void, std::string> EngineService::UnzipEngine(
+    const std::string& engine, const std::string& version,
+    const std::string& path) {
   bool found_cuda = false;
 
   CTL_INF("engine: " << engine);
@@ -150,9 +152,8 @@ void EngineService::UnzipEngine(const std::string& engine,
       }
     }
   } else {
-    // Folder does not exist, throw exception
-    CTL_ERR("Folder does not exist: " << path);
-    return;
+    // Folder does not exist
+    return cpp::fail("Folder does not exist: " + path);
   }
 
   auto matched_variant = GetMatchedVariant(engine, variants);
@@ -162,7 +163,7 @@ void EngineService::UnzipEngine(const std::string& engine,
                                     << hw_inf_.sys_inf->arch
                                     << ", will get engine from remote");
     // Go with the remote flow
-    DownloadEngine(engine, version);
+    return DownloadEngine(engine, version);
   } else {
     auto engine_path = file_manager_utils::GetEnginesContainerPath();
     archive_utils::ExtractArchive(path + "/" + matched_variant,
@@ -171,33 +172,33 @@ void EngineService::UnzipEngine(const std::string& engine,
 
   // Not match any cuda binary, download from remote
   if (!found_cuda) {
-    DownloadCuda(engine);
+    return DownloadCuda(engine);
   }
-}
-
-void EngineService::UninstallEngine(const std::string& engine) {
-  // TODO: Unload the model which is currently running on engine_
 
-  // TODO: Unload engine if is loaded
+  return {};
+}
 
+cpp::result<void, std::string> EngineService::UninstallEngine(
+    const std::string& engine) {
   auto ecp = file_manager_utils::GetEnginesContainerPath();
   auto engine_path = ecp / engine;
 
   if (!std::filesystem::exists(engine_path)) {
-    throw std::runtime_error("Engine " + engine + " is not installed!");
+    return cpp::fail("Engine " + engine + " is not installed!");
   }
 
   try {
     std::filesystem::remove_all(engine_path);
     CTL_INF("Engine " << engine << " uninstalled successfully!");
+    return {};
   } catch (const std::exception& e) {
     CTL_ERR("Failed to uninstall engine " << engine << ": " << e.what());
-    throw;
+    return cpp::fail("Failed to uninstall engine " + engine + ": " + e.what());
   }
 }
 
-void EngineService::DownloadEngine(const std::string& engine,
-                                   const std::string& version) {
+cpp::result<void, std::string> EngineService::DownloadEngine(
+    const std::string& engine, const std::string& version) {
   auto get_params = [&engine, &version]() -> std::vector<std::string> {
     if (version == "latest") {
       return {"repos", "janhq", engine, "releases", version};
@@ -231,7 +232,7 @@ void EngineService::DownloadEngine(const std::string& engine,
       body = get_data(body);
     }
     if (body.empty()) {
-      throw std::runtime_error("No release found for " + version);
+      return cpp::fail("No release found for " + version);
     }
 
     auto assets = body["assets"];
@@ -249,7 +250,7 @@ void EngineService::DownloadEngine(const std::string& engine,
     CTL_INF("Matched variant: " << matched_variant);
     if (matched_variant.empty()) {
       CTL_ERR("No variant found for " << os_arch);
-      throw std::runtime_error("No variant found for " + os_arch);
+      return cpp::fail("No variant found for " + os_arch);
     }
 
     for (auto& asset : assets) {
@@ -280,8 +281,7 @@ void EngineService::DownloadEngine(const std::string& engine,
                                            .localPath = local_path,
                                        }}}};
 
-        DownloadService download_service;
-        download_service.AddDownloadTask(
+        return DownloadService().AddDownloadTask(
             downloadTask, [](const DownloadTask& finishedTask) {
               // try to unzip the downloaded file
               CTL_INF("Engine zip path: "
@@ -302,23 +302,24 @@ void EngineService::DownloadEngine(const std::string& engine,
               }
               CTL_INF("Finished!");
             });
-        return;
       }
     }
+    return {};
   } else {
-    throw std::runtime_error("Failed to fetch engine release: " + engine);
+    return cpp::fail("Failed to fetch engine release: " + engine);
   }
 }
 
-void EngineService::DownloadCuda(const std::string& engine) {
+cpp::result<void, std::string> EngineService::DownloadCuda(
+    const std::string& engine) {
   if (hw_inf_.sys_inf->os == "mac" || engine == "cortex.onnx") {
     // mac and onnx engine does not require cuda toolkit
-    return;
+    return {};
   }
 
   if (hw_inf_.cuda_driver_version.empty()) {
     CTL_WRN("No cuda driver, continue with CPU");
-    return;
+    return {};
   }
   // download cuda toolkit
   const std::string jan_host = "catalog.jan.ai";
@@ -336,7 +337,7 @@ void EngineService::DownloadCuda(const std::string& engine) {
             << hw_inf_.cuda_driver_version
             << " is not compatible with cuda toolkit version "
             << suitable_toolkit_version);
-    throw std::runtime_error("Cuda driver is not compatible with cuda toolkit");
+    return cpp::fail("Cuda driver is not compatible with cuda toolkit");
   }
 
   auto url_obj = url_parser::Url{
@@ -362,8 +363,7 @@ void EngineService::DownloadCuda(const std::string& engine) {
                              .localPath = cuda_toolkit_local_path}},
   }};
 
-  DownloadService download_service;
-  download_service.AddDownloadTask(
+  return DownloadService().AddDownloadTask(
       downloadCudaToolkitTask, [&](const DownloadTask& finishedTask) {
         auto engine_path =
             file_manager_utils::GetEnginesContainerPath() / engine;
@@ -395,4 +395,4 @@ std::string EngineService::GetMatchedVariant(
         hw_inf_.cuda_driver_version);
   }
   return matched_variant;
-}
+}

engine/services/engine_service.h

@@ -6,6 +6,7 @@
 #include <string_view>
 #include <vector>
 #include "utils/cpuid/cpu_info.h"
+#include "utils/result.hpp"
 
 struct EngineInfo {
   std::string name;
@@ -35,19 +36,21 @@ class EngineService {
 
   std::vector<EngineInfo> GetEngineInfoList() const;
 
-  void InstallEngine(const std::string& engine,
-                     const std::string& version = "latest",
-                     const std::string& src = "");
+  cpp::result<void, std::string> InstallEngine(
+      const std::string& engine, const std::string& version = "latest",
+      const std::string& src = "");
 
-  void UnzipEngine(const std::string& engine, const std::string& version,
-                   const std::string& path);
-
-  void UninstallEngine(const std::string& engine);
+  cpp::result<void, std::string> UninstallEngine(const std::string& engine);
 
  private:
-  void DownloadEngine(const std::string& engine,
-                      const std::string& version = "latest");
-  void DownloadCuda(const std::string& engine);
+  cpp::result<void, std::string> UnzipEngine(const std::string& engine,
+                                             const std::string& version,
+                                             const std::string& path);
+
+  cpp::result<void, std::string> DownloadEngine(
+      const std::string& engine, const std::string& version = "latest");
+
+  cpp::result<void, std::string> DownloadCuda(const std::string& engine);
 
   std::string GetMatchedVariant(const std::string& engine,
                                 const std::vector<std::string>& variants);

engine/services/model_service.cc

@@ -138,7 +138,11 @@ std::optional<std::string> ModelService::DownloadModelByDirectUrl(
     ParseGguf(gguf_download_item, author);
   };
 
-  download_service_.AddDownloadTask(downloadTask, on_finished);
+  auto result = download_service_.AddDownloadTask(downloadTask, on_finished);
+  if (result.has_error()) {
+    CTL_ERR(result.error());
+    return std::nullopt;
+  }
   return unique_model_id;
 }
 
@@ -148,7 +152,7 @@ std::optional<std::string> ModelService::DownloadModelFromCortexso(
   auto downloadTask = cortexso_parser::getDownloadTask(name, branch);
   if (downloadTask.has_value()) {
     std::string model_id{name + ":" + branch};
-    DownloadService().AddDownloadTask(
+    auto result = DownloadService().AddDownloadTask(
         downloadTask.value(), [&](const DownloadTask& finishedTask) {
           const DownloadItem* model_yml_item = nullptr;
           auto need_parse_gguf = true;
@@ -179,6 +183,10 @@ std::optional<std::string> ModelService::DownloadModelFromCortexso(
             modellist_utils_obj.AddModelEntry(model_entry);
           }
         });
+    if (result.has_error()) {
+      CTL_ERR(result.error());
+      return std::nullopt;
+    }
 
     CLI_LOG("Model " << model_id << " downloaded successfully!")
     return model_id;