@fugood/llama.node 0.3.10 → 0.3.11

package/lib/binding.ts

@@ -150,6 +150,7 @@ export interface LlamaContext {
   getLoadedLoraAdapters(): { path: string; scaled: number }[]
   // static
   loadModelInfo(path: string, skip: string[]): Promise<Object>
+  toggleNativeLog(enable: boolean, callback: (level: string, text: string) => void): void
 }
 
 export interface Module {

package/lib/index.js

@@ -23,7 +23,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadLlamaModelInfo = exports.initLlama = exports.loadModel = void 0;
+exports.toggleNativeLog = exports.loadLlamaModelInfo = exports.initLlama = exports.loadModel = void 0;
+exports.addNativeLogListener = addNativeLogListener;
 const binding_1 = require("./binding");
 __exportStar(require("./binding"), exports);
 const mods = {};
@@ -49,3 +50,22 @@ const loadLlamaModelInfo = (path) => __awaiter(void 0, void 0, void 0, function*
     return mods[variant].LlamaContext.loadModelInfo(path, modelInfoSkip);
 });
 exports.loadLlamaModelInfo = loadLlamaModelInfo;
+const logListeners = [];
+const logCallback = (level, text) => {
+    logListeners.forEach((listener) => listener(level, text));
+};
+const toggleNativeLog = (enable, options) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const v = (_a = options === null || options === void 0 ? void 0 : options.variant) !== null && _a !== void 0 ? _a : 'default';
+    (_b = mods[v]) !== null && _b !== void 0 ? _b : (mods[v] = yield (0, binding_1.loadModule)(v));
+    return mods[v].LlamaContext.toggleNativeLog(enable, logCallback);
+});
+exports.toggleNativeLog = toggleNativeLog;
+function addNativeLogListener(listener) {
+    logListeners.push(listener);
+    return {
+        remove: () => {
+            logListeners.splice(logListeners.indexOf(listener), 1);
+        },
+    };
+}

package/lib/index.ts

@@ -32,3 +32,31 @@ export const loadLlamaModelInfo = async (path: string): Promise<Object> => {
   mods[variant] ??= await loadModule(variant)
   return mods[variant].LlamaContext.loadModelInfo(path, modelInfoSkip)
 }
+
+const logListeners: Array<(level: string, text: string) => void> = []
+
+const logCallback = (level: string, text: string) => {
+  logListeners.forEach((listener) => listener(level, text))
+}
+
+export const toggleNativeLog = async (
+  enable: boolean,
+  options?: {
+    variant?: LibVariant
+  },
+) => {
+  const v = options?.variant ?? 'default'
+  mods[v] ??= await loadModule(v)
+  return mods[v].LlamaContext.toggleNativeLog(enable, logCallback)
+}
+
+export function addNativeLogListener(
+  listener: (level: string, text: string) => void,
+): { remove: () => void } {
+  logListeners.push(listener)
+  return {
+    remove: () => {
+      logListeners.splice(logListeners.indexOf(listener), 1)
+    },
+  }
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@fugood/llama.node",
   "access": "public",
-  "version": "0.3.10",
-  "description": "Llama.cpp for Node.js",
+  "version": "0.3.11",
+  "description": "An another Node binding of llama.cpp",
   "main": "lib/index.js",
   "scripts": {
     "test": "jest",
@@ -22,7 +22,9 @@
     "llama",
     "llm",
     "ai",
-    "genai"
+    "genai",
+    "Local LLM",
+    "llama.cpp"
   ],
   "author": "Hans <hans.chen@bricks.tools>",
   "license": "MIT",

package/src/LlamaContext.cpp

@@ -120,6 +120,9 @@ void LlamaContext::Init(Napi::Env env, Napi::Object &exports) {
            "release", static_cast<napi_property_attributes>(napi_enumerable)),
        StaticMethod<&LlamaContext::ModelInfo>(
            "loadModelInfo",
+           static_cast<napi_property_attributes>(napi_enumerable)),
+       StaticMethod<&LlamaContext::ToggleNativeLog>(
+           "toggleNativeLog",
            static_cast<napi_property_attributes>(napi_enumerable))});
   Napi::FunctionReference *constructor = new Napi::FunctionReference();
   *constructor = Napi::Persistent(func);
@@ -278,6 +281,46 @@ bool validateModelChatTemplate(const struct llama_model * model, const bool use_
   return common_chat_verify_template(tmpl, use_jinja);
 }
 
+static Napi::FunctionReference _log_callback;
+
+// toggleNativeLog(enable: boolean, callback: (log: string) => void): void
+void LlamaContext::ToggleNativeLog(const Napi::CallbackInfo &info) {
+  bool enable = info[0].ToBoolean().Value();
+  if (enable) {
+    _log_callback.Reset(info[1].As<Napi::Function>());
+    
+    llama_log_set([](ggml_log_level level, const char * text, void * user_data) {
+      llama_log_callback_default(level, text, user_data);
+
+      std::string level_str = "";
+      if (level == GGML_LOG_LEVEL_ERROR) {
+        level_str = "error";
+      } else if (level == GGML_LOG_LEVEL_INFO) {
+        level_str = "info";
+      } else if (level == GGML_LOG_LEVEL_WARN) {
+        level_str = "warn";
+      }
+
+      if (_log_callback.IsEmpty()) {
+        return;
+      }
+      try {
+        Napi::Env env = _log_callback.Env();
+        Napi::HandleScope scope(env);
+        _log_callback.Call({
+          Napi::String::New(env, level_str),
+          Napi::String::New(env, text)
+        });
+      } catch (const std::exception &e) {
+        // printf("Error calling log callback: %s\n", e.what());
+      }
+    }, nullptr);
+  } else {
+    _log_callback.Reset();
+    llama_log_set(llama_log_callback_default, nullptr);
+  }
+}
+
 // getModelInfo(): object
 Napi::Value LlamaContext::GetModelInfo(const Napi::CallbackInfo &info) {
   char desc[1024];
@@ -312,8 +355,7 @@ Napi::Value LlamaContext::GetModelInfo(const Napi::CallbackInfo &info) {
   defaultCaps.Set("parallelToolCalls", _templates.template_default->original_caps().supports_parallel_tool_calls);
   defaultCaps.Set("toolCallId", _templates.template_default->original_caps().supports_tool_call_id);
   minja.Set("defaultCaps", defaultCaps);
-  Napi::Object toolUse = Napi::Object::New(info.Env());
-  toolUse.Set("toolUse", validateModelChatTemplate(model, true, "tool_use"));
+  minja.Set("toolUse", validateModelChatTemplate(model, true, "tool_use"));
   if (_templates.template_tool_use) {
     Napi::Object toolUseCaps = Napi::Object::New(info.Env());
     toolUseCaps.Set("tools", _templates.template_tool_use->original_caps().supports_tools);
@@ -322,13 +364,15 @@ Napi::Value LlamaContext::GetModelInfo(const Napi::CallbackInfo &info) {
     toolUseCaps.Set("systemRole", _templates.template_tool_use->original_caps().supports_system_role);
     toolUseCaps.Set("parallelToolCalls", _templates.template_tool_use->original_caps().supports_parallel_tool_calls);
     toolUseCaps.Set("toolCallId", _templates.template_tool_use->original_caps().supports_tool_call_id);
-    toolUse.Set("toolUseCaps", toolUseCaps);
+    minja.Set("toolUseCaps", toolUseCaps);
   }
-  minja.Set("toolUse", toolUse);
   chatTemplates.Set("minja", minja);
   details.Set("chatTemplates", chatTemplates);
 
   details.Set("metadata", metadata);
+
+  // Deprecated: use chatTemplates.llamaChat instead
+  details.Set("isChatTemplateSupported", validateModelChatTemplate(_sess->model(), false, ""));
   return details;
 }
 

package/src/LlamaContext.h

@@ -5,6 +5,7 @@ class LlamaCompletionWorker;
 class LlamaContext : public Napi::ObjectWrap<LlamaContext> {
 public:
   LlamaContext(const Napi::CallbackInfo &info);
+  static void ToggleNativeLog(const Napi::CallbackInfo &info);
   static Napi::Value ModelInfo(const Napi::CallbackInfo& info);
   static void Init(Napi::Env env, Napi::Object &exports);