@realtimex/node-llama-cpp 0.1.0

package/llama/addon/AddonModel.h

@@ -0,0 +1,64 @@
+#pragma once
+#include "llama.h"
+#include "napi.h"
+#include "addonGlobals.h"
+#include "globals/addonProgress.h"
+
+class AddonModel : public Napi::ObjectWrap<AddonModel> {
+    public:
+        llama_model_params model_params;
+        std::vector<llama_model_kv_override> kv_overrides;
+        llama_model* model;
+        const llama_vocab* vocab;
+        uint64_t loadedModelSize = 0;
+        Napi::Reference<Napi::Object> addonExportsRef;
+        bool hasAddonExportsRef = false;
+        AddonModelData* data;
+
+        std::string modelPath;
+        bool modelLoaded = false;
+        bool abortModelLoad = false;
+        bool model_load_stopped = false;
+        float rawModelLoadPercentage = 0;
+        unsigned modelLoadPercentage = 0;
+        AddonThreadSafeProgressEventCallbackFunction addonThreadSafeOnLoadProgressEventCallback;
+        bool onLoadProgressEventCallbackSet = false;
+        bool hasLoadAbortSignal = false;
+
+        bool disposed = false;
+
+        AddonModel(const Napi::CallbackInfo& info);
+        ~AddonModel();
+        void dispose();
+
+        Napi::Value Init(const Napi::CallbackInfo& info);
+        Napi::Value LoadLora(const Napi::CallbackInfo& info);
+        Napi::Value AbortActiveModelLoad(const Napi::CallbackInfo& info);
+        Napi::Value Dispose(const Napi::CallbackInfo& info);
+        Napi::Value Tokenize(const Napi::CallbackInfo& info);
+        Napi::Value Detokenize(const Napi::CallbackInfo& info);
+        Napi::Value GetTrainContextSize(const Napi::CallbackInfo& info);
+        Napi::Value GetEmbeddingVectorSize(const Napi::CallbackInfo& info);
+        Napi::Value GetTotalSize(const Napi::CallbackInfo& info);
+        Napi::Value GetTotalParameters(const Napi::CallbackInfo& info);
+        Napi::Value GetModelDescription(const Napi::CallbackInfo& info);
+
+        Napi::Value TokenBos(const Napi::CallbackInfo& info);
+        Napi::Value TokenEos(const Napi::CallbackInfo& info);
+        Napi::Value TokenNl(const Napi::CallbackInfo& info);
+        Napi::Value PrefixToken(const Napi::CallbackInfo& info);
+        Napi::Value MiddleToken(const Napi::CallbackInfo& info);
+        Napi::Value SuffixToken(const Napi::CallbackInfo& info);
+        Napi::Value EotToken(const Napi::CallbackInfo& info);
+        Napi::Value SepToken(const Napi::CallbackInfo& info);
+        Napi::Value GetTokenString(const Napi::CallbackInfo& info);
+
+        Napi::Value GetTokenAttributes(const Napi::CallbackInfo& info);
+        Napi::Value IsEogToken(const Napi::CallbackInfo& info);
+        Napi::Value GetVocabularyType(const Napi::CallbackInfo& info);
+        Napi::Value ShouldPrependBosToken(const Napi::CallbackInfo& info);
+        Napi::Value ShouldAppendEosToken(const Napi::CallbackInfo& info);
+        Napi::Value GetModelSize(const Napi::CallbackInfo& info);
+
+        static void init(Napi::Object exports);
+};

package/llama/addon/AddonModelData.cpp

@@ -0,0 +1,25 @@
+#include <iostream>
+
+#include "addonGlobals.h"
+#include "AddonModelData.h"
+#include "AddonModelLora.h"
+
+AddonModelData::AddonModelData() {
+
+}
+AddonModelData::~AddonModelData() {
+    std::set<AddonModelLora *> currentLoraAdapters;
+    currentLoraAdapters.swap(loraAdapters);
+
+    for (auto lora : currentLoraAdapters) {
+        lora->dispose(true);
+    }
+    currentLoraAdapters.clear();
+}
+
+void AddonModelData::removeLora(AddonModelLora* lora) {
+    auto pos = loraAdapters.find(lora);
+    if (pos != loraAdapters.end()) {
+        loraAdapters.erase(pos);
+    }
+}

package/llama/addon/AddonModelData.h

@@ -0,0 +1,15 @@
+#pragma once
+#include <set>
+#include "llama.h"
+#include "napi.h"
+#include "addonGlobals.h"
+
+class AddonModelData {
+    public:
+        std::set<AddonModelLora *> loraAdapters;
+
+        AddonModelData();
+        ~AddonModelData();
+
+        void removeLora(AddonModelLora* lora);
+};

package/llama/addon/AddonModelLora.cpp

@@ -0,0 +1,103 @@
+#include "addonGlobals.h"
+#include "AddonModel.h"
+#include "AddonModelData.h"
+#include "AddonModelLora.h"
+
+class AddonModelLoraUnloadLoraWorker : public Napi::AsyncWorker {
+    public:
+        AddonModelLora* addonLora;
+
+        AddonModelLoraUnloadLoraWorker(const Napi::Env& env, AddonModelLora* addonLora)
+            : Napi::AsyncWorker(env, "AddonModelLoraUnloadLoraWorker"),
+              addonLora(addonLora),
+              deferred(Napi::Promise::Deferred::New(env)) {
+            addonLora->Ref();
+        }
+        ~AddonModelLoraUnloadLoraWorker() {
+            addonLora->Unref();
+        }
+
+        Napi::Promise GetPromise() {
+            return deferred.Promise();
+        }
+
+    protected:
+        Napi::Promise::Deferred deferred;
+
+        void Execute() {
+            try {
+                addonLora->dispose();
+            } catch (const std::exception& e) {
+                SetError(e.what());
+            } catch(...) {
+                SetError("Unknown error when calling \"llama_adapter_lora_free\"");
+            }
+        }
+        void OnOK() {
+            deferred.Resolve(Env().Undefined());
+        }
+        void OnError(const Napi::Error& err) {
+            deferred.Reject(err.Value());
+        }
+};
+
+AddonModelLora::AddonModelLora(const Napi::CallbackInfo& info) : Napi::ObjectWrap<AddonModelLora>(info) {
+    model = Napi::ObjectWrap<AddonModel>::Unwrap(info[0].As<Napi::Object>());
+    loraFilePath = info[1].As<Napi::String>().Utf8Value();
+    lora_adapter = nullptr;
+}
+
+AddonModelLora::~AddonModelLora() {
+    dispose();
+}
+
+void AddonModelLora::dispose(bool skipErase) {
+    if (lora_adapter != nullptr) {
+        lora_adapter = nullptr;
+
+        if (!skipErase && model->data != nullptr) {
+            model->data->removeLora(this);
+        }
+
+        model->Unref();
+    }
+}
+
+Napi::Value AddonModelLora::GetFilePath(const Napi::CallbackInfo& info) {
+    return Napi::String::New(info.Env(), loraFilePath);
+}
+
+
+Napi::Value AddonModelLora::GetUsages(const Napi::CallbackInfo& info) {
+    return Napi::Number::From(info.Env(), usages);
+}
+
+void AddonModelLora::SetUsages(const Napi::CallbackInfo& info, const Napi::Value &value) {
+    usages = value.As<Napi::Number>().Uint32Value();
+}
+
+Napi::Value AddonModelLora::Dispose(const Napi::CallbackInfo& info) {
+    AddonModelLoraUnloadLoraWorker* worker = new AddonModelLoraUnloadLoraWorker(this->Env(), this);
+    worker->Queue();
+    return worker->GetPromise();
+}
+
+Napi::Value AddonModelLora::GetDisposed(const Napi::CallbackInfo& info) {
+    return Napi::Boolean::New(info.Env(), lora_adapter == nullptr);
+}
+
+void AddonModelLora::init(Napi::Object exports) {
+    exports.Set(
+        "AddonModelLora",
+        DefineClass(
+            exports.Env(),
+            "AddonModelLora",
+            {
+                InstanceAccessor("usages", &AddonModelLora::GetUsages, &AddonModelLora::SetUsages),
+                InstanceAccessor("filePath", &AddonModelLora::GetFilePath, nullptr),
+                InstanceAccessor("disposed", &AddonModelLora::GetDisposed, nullptr),
+                InstanceMethod("dispose", &AddonModelLora::Dispose),
+            }
+        )
+    );
+}

package/llama/addon/AddonModelLora.h

@@ -0,0 +1,28 @@
+#pragma once
+#include "llama.h"
+#include "napi.h"
+#include "addonGlobals.h"
+
+class AddonModelLora : public Napi::ObjectWrap<AddonModelLora> {
+    public:
+        AddonModel* model;
+        llama_adapter_lora * lora_adapter;
+        std::string loraFilePath;
+        uint32_t usages = 0;
+
+        AddonModelLora(const Napi::CallbackInfo& info);
+        ~AddonModelLora();
+
+        void dispose(bool skipErase = false);
+
+        Napi::Value GetFilePath(const Napi::CallbackInfo& info);
+
+        Napi::Value GetUsages(const Napi::CallbackInfo& info);
+        void SetUsages(const Napi::CallbackInfo& info, const Napi::Value &value);
+
+        Napi::Value GetDisposed(const Napi::CallbackInfo& info);
+
+        Napi::Value Dispose(const Napi::CallbackInfo& info);
+
+        static void init(Napi::Object exports);
+};