Merge branch 'dev' into chore/models-api

Author: vansangpfiev

docs/docs/installation/mac.mdx

@@ -22,7 +22,7 @@ Before installation, make sure that you have met the required [dependencies](#de
     - Stable: https://github.com/janhq/cortex.cpp/releases
     - Beta: https://github.com/janhq/cortex.cpp/releases
     - Nightly: https://github.com/janhq/cortex.cpp/releases
-2. Ensure that Cortex.cpp is sucessfulyy installed:
+2. Ensure that Cortex.cpp is sucessfully installed:
 ```bash
 # Stable
 cortex

docs/docs/overview.mdx

@@ -51,7 +51,7 @@ Cortex.cpp allows users to pull models from multiple Model Hubs, offering flexib
 | Model /Engine  | llama.cpp             | Command                       |
 | -------------- | --------------------- | ----------------------------- |
 | phi-3.5        | ✅                    | cortex run phi3.5             |
-| llama3.2       | ✅                    | cortex run llama3.1           |
+| llama3.2       | ✅                    | cortex run llama3.2           |
 | llama3.1       | ✅                    | cortex run llama3.1           |
 | codestral      | ✅                    | cortex run codestral          |
 | gemma2         | ✅                    | cortex run gemma2             |

docs/static/openapi/cortex.json

@@ -644,7 +644,8 @@
               "example": {
                 "model": "model-id",
                 "modelPath": "/path/to/gguf",
-                "name": "model display name"
+                "name": "model display name",
+                "option": "symlink"
               }
             }
           }
@@ -3248,6 +3249,11 @@
           "name": {
             "type": "string",
             "description": "The display name of the model."
+          },
+          "option": {
+            "type": "string",
+            "description": "Import options such as symlink or copy.",
+            "enum": ["symlink", "copy"]
           }
         },
         "required": [

engine/config/gguf_parser.cc

@@ -9,6 +9,7 @@
 #include <stdexcept>
 #include <string>
 #include <vector>
+#include <filesystem>
 
 #ifdef _WIN32
 #include <io.h>
@@ -71,24 +72,9 @@ void GGUFHandler::OpenFile(const std::string& file_path) {
   CloseHandle(file_handle_);
 
 #else
-  FILE* fd = fopen(file_path.c_str(), "rb");
-  if (!fd) {
-    perror("Error opening file");
-    throw std::runtime_error("Failed to open file");
-  }
-
-  // Get file size
-  // file_size_ = lseek(fd, 0, SEEK_END);
-  fseek(fd, 0, SEEK_END);  // move file pointer to end of file
-  file_size_ = ftell(fd);  // get the file size, in bytes
-  fclose(fd);
-  if (file_size_ == -1) {
-    perror("Error getting file size");
-    // close(fd);
-    throw std::runtime_error("Failed to get file size");
-  }
+  file_size_ = std::filesystem::file_size(file_path);
+ 
   int file_descriptor = open(file_path.c_str(), O_RDONLY);
-  ;
   // Memory-map the file
   data_ = static_cast<uint8_t*>(
       mmap(nullptr, file_size_, PROT_READ, MAP_PRIVATE, file_descriptor, 0));

engine/controllers/models.cc

@@ -1,5 +1,6 @@
 #include "database/models.h"
 #include <drogon/HttpTypes.h>
+#include <filesystem>
 #include <optional>
 #include "config/gguf_parser.h"
 #include "config/yaml_config.h"
@@ -320,6 +321,7 @@ void Models::ImportModel(
   auto modelHandle = (*(req->getJsonObject())).get("model", "").asString();
   auto modelPath = (*(req->getJsonObject())).get("modelPath", "").asString();
   auto modelName = (*(req->getJsonObject())).get("name", "").asString();
+  auto option = (*(req->getJsonObject())).get("option", "symlink").asString();
   config::GGUFHandler gguf_handler;
   config::YamlHandler yaml_handler;
   cortex::db::Models modellist_utils_obj;
@@ -339,7 +341,23 @@ void Models::ImportModel(
         std::filesystem::path(model_yaml_path).parent_path());
     gguf_handler.Parse(modelPath);
     config::ModelConfig model_config = gguf_handler.GetModelConfig();
-    model_config.files.push_back(modelPath);
+    // There are 2 options: symlink and copy
+    if (option == "copy") {
+      // Copy GGUF file to the destination path
+      std::filesystem::path file_path =
+          std::filesystem::path(model_yaml_path).parent_path() /
+          std::filesystem::path(modelPath).filename();
+      std::filesystem::copy_file(
+          modelPath, file_path,
+          std::filesystem::copy_options::update_existing);
+      model_config.files.push_back(file_path.string());
+      auto size = std::filesystem::file_size(file_path);
+      model_config.size = size;
+    } else {
+      model_config.files.push_back(modelPath);
+      auto size = std::filesystem::file_size(modelPath);
+      model_config.size = size;
+    }
     model_config.model = modelHandle;
     model_config.name = modelName.empty() ? model_config.name : modelName;
     yaml_handler.UpdateModelConfig(model_config);

engine/e2e-test/test_api_model_import.py

@@ -29,6 +29,21 @@ def test_model_import_with_name_should_be_success(self):
         response = requests.post("http://localhost:3928/models/import", json=body_json)
         assert response.status_code == 200
 
+    @pytest.mark.skipif(True, reason="Expensive test. Only test when you have local gguf file.")
+    def test_model_import_with_name_should_be_success(self):
+        body_json = {'model': 'testing-model',
+                     'modelPath': '/path/to/local/gguf',
+                     'name': 'test_model',
+                     'option': 'copy'}
+        response = requests.post("http://localhost:3928/models/import", json=body_json)
+        assert response.status_code == 200
+        # Test imported path
+        response = requests.get("http://localhost:3928/models/testing-model")
+        assert response.status_code == 200
+        # Since this is a dynamic test - require actual file path
+        # it's not safe to assert with the gguf file name
+        assert response.json()['files'][0] != '/path/to/local/gguf'
+
     def test_model_import_with_invalid_path_should_fail(self):
         body_json = {'model': 'tinyllama:gguf',
                      'modelPath': '/invalid/path/to/gguf'}

engine/services/download_service.cc

@@ -7,7 +7,6 @@
 #include <optional>
 #include <ostream>
 #include <utility>
-#include "download_service.h"
 #include "utils/format_utils.h"
 #include "utils/huggingface_utils.h"
 #include "utils/logging_utils.h"
@@ -148,11 +147,10 @@ cpp::result<bool, std::string> DownloadService::Download(
   std::string mode = "wb";
   if (std::filesystem::exists(download_item.localPath) &&
       download_item.bytes.has_value()) {
-    curl_off_t existing_file_size = GetLocalFileSize(download_item.localPath);
-    if (existing_file_size == -1) {
-      CLI_LOG("Cannot get file size: " << download_item.localPath.string()
-                                       << " . Start download over!");
-    } else {
+    try {
+      curl_off_t existing_file_size =
+          std::filesystem::file_size(download_item.localPath);
+
       CTL_INF("Existing file size: " << download_item.downloadUrl << " - "
                                      << download_item.localPath.string()
                                      << " - " << existing_file_size);
@@ -186,6 +184,9 @@ cpp::result<bool, std::string> DownloadService::Download(
           return false;
         }
       }
+    } catch (const std::filesystem::filesystem_error& e) {
+      CLI_LOG("Cannot get file size: "
+              << e.what() << download_item.localPath.string() << "\n");
     }
   }
 
@@ -205,12 +206,12 @@ cpp::result<bool, std::string> DownloadService::Download(
   curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
 
   if (mode == "ab") {
-    auto local_file_size = GetLocalFileSize(download_item.localPath);
-    if (local_file_size != -1) {
-      curl_easy_setopt(curl, CURLOPT_RESUME_FROM_LARGE,
-                       GetLocalFileSize(download_item.localPath));
-    } else {
-      CTL_ERR("Cannot get file size: " << download_item.localPath.string());
+    try {
+      curl_off_t local_file_size =
+          std::filesystem::file_size(download_item.localPath);
+      curl_easy_setopt(curl, CURLOPT_RESUME_FROM_LARGE, local_file_size);
+    } catch (const std::filesystem::filesystem_error& e) {
+      CTL_ERR("Cannot get file size: " << e.what() << '\n');
     }
   }
 
@@ -225,23 +226,6 @@ cpp::result<bool, std::string> DownloadService::Download(
   curl_easy_cleanup(curl);
   return true;
 }
-
-curl_off_t DownloadService::GetLocalFileSize(
-    const std::filesystem::path& path) const {
-  auto file = fopen(path.string().c_str(), "r");
-  if (!file) {
-    return -1;
-  }
-
-  if (fseek64(file, 0, SEEK_END) != 0) {
-    return -1;
-  }
-
-  auto file_size = ftell64(file);
-  fclose(file);
-  return file_size;
-}
-
 void DownloadService::WorkerThread() {
   while (!stop_flag_) {
     DownloadTask task;

engine/services/download_service.h

@@ -90,8 +90,6 @@ class DownloadService {
       const std::string& download_id,
       const DownloadItem& download_item) noexcept;
 
-  curl_off_t GetLocalFileSize(const std::filesystem::path& path) const;
-
   std::shared_ptr<EventQueue> event_queue_;
 
   CURLM* multi_handle_;