node-llama-cpp 3.0.0-beta.37 → 3.0.0-beta.39

package/llama/addon/AddonContext.h

@@ -0,0 +1,53 @@
+#pragma once
+#include "llama.h"
+#include "napi.h"
+#include "addonGlobals.h"
+
+class AddonContext : public Napi::ObjectWrap<AddonContext> {
+    public:
+        AddonModel* model;
+        llama_context_params context_params;
+        llama_context* ctx;
+        llama_batch batch;
+        uint64_t batchMemorySize;
+        bool has_batch;
+        int32_t batch_n_tokens;
+        int n_cur;
+
+        uint64_t loadedContextMemorySize;
+        bool contextLoaded;
+
+        bool disposed;
+
+        AddonContext(const Napi::CallbackInfo& info);
+        ~AddonContext();
+
+        void dispose();
+        void disposeBatch();
+
+        Napi::Value Init(const Napi::CallbackInfo& info);
+        Napi::Value Dispose(const Napi::CallbackInfo& info);
+
+        Napi::Value GetContextSize(const Napi::CallbackInfo& info);
+        Napi::Value InitBatch(const Napi::CallbackInfo& info);
+        Napi::Value DisposeBatch(const Napi::CallbackInfo& info);
+        Napi::Value AddToBatch(const Napi::CallbackInfo& info);
+        Napi::Value DisposeSequence(const Napi::CallbackInfo& info);
+        Napi::Value RemoveTokenCellsFromSequence(const Napi::CallbackInfo& info);
+        Napi::Value ShiftSequenceTokenCells(const Napi::CallbackInfo& info);
+        Napi::Value DecodeBatch(const Napi::CallbackInfo& info);
+        Napi::Value SampleToken(const Napi::CallbackInfo& info);
+
+        Napi::Value AcceptGrammarEvaluationStateToken(const Napi::CallbackInfo& info);
+
+        Napi::Value CanBeNextTokenForGrammarEvaluationState(const Napi::CallbackInfo& info);
+
+        Napi::Value GetEmbedding(const Napi::CallbackInfo& info);
+        Napi::Value GetStateSize(const Napi::CallbackInfo& info);
+
+        Napi::Value PrintTimings(const Napi::CallbackInfo& info);
+
+        Napi::Value SetLora(const Napi::CallbackInfo& info);
+
+        static void init(Napi::Object exports);
+};

package/llama/addon/AddonGrammar.cpp

@@ -0,0 +1,44 @@
+#include "addonGlobals.h"
+#include "AddonGrammar.h"
+
+AddonGrammar::AddonGrammar(const Napi::CallbackInfo& info) : Napi::ObjectWrap<AddonGrammar>(info) {
+    hasAddonExportsRef = false;
+    
+    // Get the model path
+    std::string grammarCode = info[0].As<Napi::String>().Utf8Value();
+    bool should_print_grammar = false;
+
+    if (info.Length() > 1 && info[1].IsObject()) {
+        Napi::Object options = info[1].As<Napi::Object>();
+
+        if (options.Has("addonExports")) {
+            addonExportsRef = Napi::Persistent(options.Get("addonExports").As<Napi::Object>());
+            hasAddonExportsRef = true;
+        }
+
+        if (options.Has("debugPrintGrammar")) {
+            should_print_grammar = options.Get("debugPrintGrammar").As<Napi::Boolean>().Value();
+        }
+    }
+
+    parsed_grammar = grammar_parser::parse(grammarCode.c_str());
+    // will be empty (default) if there are parse errors
+    if (parsed_grammar.rules.empty()) {
+        Napi::Error::New(info.Env(), "Failed to parse grammar").ThrowAsJavaScriptException();
+        return;
+    }
+
+    if (should_print_grammar) {
+        grammar_parser::print_grammar(stderr, parsed_grammar);
+    }
+}
+AddonGrammar::~AddonGrammar() {
+    if (hasAddonExportsRef) {
+        addonExportsRef.Unref();
+        hasAddonExportsRef = false;
+    }
+}
+
+void AddonGrammar::init(Napi::Object exports) {
+    exports.Set("AddonGrammar", DefineClass(exports.Env(), "AddonGrammar", {}));
+}

package/llama/addon/AddonGrammar.h

@@ -0,0 +1,18 @@
+#pragma once
+#include "llama.h"
+#include "common.h"
+#include "common/grammar-parser.h"
+#include "napi.h"
+#include "addonGlobals.h"
+
+class AddonGrammar : public Napi::ObjectWrap<AddonGrammar> {
+    public:
+        grammar_parser::parse_state parsed_grammar;
+        Napi::Reference<Napi::Object> addonExportsRef;
+        bool hasAddonExportsRef;
+
+        AddonGrammar(const Napi::CallbackInfo& info);
+        ~AddonGrammar();
+
+        static void init(Napi::Object exports);
+};

package/llama/addon/AddonGrammarEvaluationState.cpp

@@ -0,0 +1,28 @@
+#include <sstream>
+#include "addonGlobals.h"
+#include "common.h"
+#include "llama.h"
+#include "AddonGrammarEvaluationState.h"
+#include "AddonGrammar.h"
+
+AddonGrammarEvaluationState::AddonGrammarEvaluationState(const Napi::CallbackInfo& info) : Napi::ObjectWrap<AddonGrammarEvaluationState>(info) {
+    grammar = nullptr;
+
+    grammarDef = Napi::ObjectWrap<AddonGrammar>::Unwrap(info[0].As<Napi::Object>());
+    grammarDef->Ref();
+
+    std::vector<const llama_grammar_element*> grammar_rules(grammarDef->parsed_grammar.c_rules());
+    grammar = llama_grammar_init(grammar_rules.data(), grammar_rules.size(), grammarDef->parsed_grammar.symbol_ids.at("root"));
+}
+AddonGrammarEvaluationState::~AddonGrammarEvaluationState() {
+    grammarDef->Unref();
+
+    if (grammar != nullptr) {
+        llama_grammar_free(grammar);
+        grammar = nullptr;
+    }
+}
+
+void AddonGrammarEvaluationState::init(Napi::Object exports) {
+    exports.Set("AddonGrammarEvaluationState", DefineClass(exports.Env(), "AddonGrammarEvaluationState", {}));
+}

package/llama/addon/AddonGrammarEvaluationState.h

@@ -0,0 +1,15 @@
+#pragma once
+#include "llama.h"
+#include "napi.h"
+#include "addonGlobals.h"
+
+class AddonGrammarEvaluationState : public Napi::ObjectWrap<AddonGrammarEvaluationState> {
+    public:
+        AddonGrammar* grammarDef;
+        llama_grammar* grammar;
+
+        AddonGrammarEvaluationState(const Napi::CallbackInfo& info);
+        ~AddonGrammarEvaluationState();
+
+        static void init(Napi::Object exports);
+};