fix: Remove support for remote URL

Author: hiro-v

controllers/llamaCPP.cc

@@ -240,38 +240,32 @@ void llamaCPP::chatCompletion(
             role = user_prompt;
 
             json content_piece_image_data;
+            content_piece_image_data["data"] = "";
 
             auto content_piece_type = content_piece["type"].asString();
             if (content_piece_type == "text") {
               auto text = content_piece["text"].asString();
               formatted_output += text;
             } else if (content_piece_type == "image_url") {
               auto image_url = content_piece["image_url"]["url"].asString();
-              std::string
-                  base64_image_data; // Declare the variable 'base64_image_data'
+              std::string base64_image_data;
               if (image_url.find("http") != std::string::npos) {
-                // If image url is a remote link, extract and use convert to
-                // base64
-                nitro_utils::processRemoteImage(
-                    image_url, [](const std::string &base64Image) {
-                      auto base64_image_data = base64Image;
-                      LOG_INFO << base64_image_data;
-                    });
+                LOG_INFO << "Remote image detected but not supported yet";
               } else if (image_url.find("data:image") != std::string::npos) {
-                // If image url is already in base64, use it directly
-                auto base64_image_data = nitro_utils::extractBase64(image_url);
+                LOG_INFO << "Base64 image detected";
+                base64_image_data = nitro_utils::extractBase64(image_url);
                 LOG_INFO << base64_image_data;
               } else {
-                // If image url is a local file, convert to base64
+                LOG_INFO << "Local image detected";
                 nitro_utils::processLocalImage(
-                    image_url, [](const std::string &base64Image) {
-                      auto base64_image_data = base64Image;
-                      LOG_INFO << base64_image_data;
+                    image_url, [&](const std::string &base64Image) {
+                      base64_image_data = base64Image;
                     });
+                LOG_INFO << base64_image_data;
               }
+              content_piece_image_data["data"] = base64_image_data;
 
               formatted_output += "[img-" + std::to_string(no_images) + "]";
-              content_piece_image_data["data"] = base64_image_data;
               content_piece_image_data["id"] = no_images;
               data["image_data"].push_back(content_piece_image_data);
               no_images++;

llama.cpp

@@ -108,51 +108,6 @@ inline std::string generateUniqueFilename(const std::string &prefix,
   return ss.str();
 }
 
-// Function to download an image
-inline void downloadImage(const std::string &url, const std::string &savePath,
-                          std::function<void(bool)> callback) {
-  auto client = drogon::HttpClient::newHttpClient(url);
-  client->sendRequest(
-      drogon::HttpRequest::newHttpRequest(),
-      [savePath, callback](drogon::ReqResult result,
-                           const drogon::HttpResponsePtr &response) {
-        if (result == drogon::ReqResult::Ok) {
-          // Save the image to the specified path
-          std::ofstream outFile(savePath, std::ios::binary);
-          outFile.write(response->body().data(), response->body().size());
-          outFile.close();
-
-          // Invoke the callback with true to indicate success
-          callback(true);
-        } else {
-          std::cerr << "Failed to download the image: " << result << std::endl;
-          // Invoke the callback with false to indicate failure
-          callback(false);
-        }
-      });
-}
-
-inline void
-processRemoteImage(const std::string &url,
-                   std::function<void(const std::string &)> callback) {
-  std::string localPath =
-      generateUniqueFilename("temp_", ".jpg"); // Generate a unique filename
-
-  downloadImage(url, localPath, [localPath, callback](bool success) {
-    if (success) {
-      try {
-        std::string base64Image = imageToBase64(localPath);
-        std::remove(localPath.c_str()); // Delete the local file
-        callback(base64Image); // Invoke the callback with the Base64 string
-      } catch (const std::exception &e) {
-        std::cerr << "Error during processing: " << e.what() << std::endl;
-      }
-    } else {
-      std::cerr << "Failed to download the image." << std::endl;
-    }
-  });
-}
-
 inline void
 processLocalImage(const std::string &localPath,
                   std::function<void(const std::string &)> callback) {