@fugood/llama.node 0.4.6 → 0.5.0

package/src/LlamaCompletionWorker.cpp

@@ -1,367 +1,6 @@
 #include "LlamaCompletionWorker.h"
 #include "LlamaContext.h"
 
-// Computes FNV-1a hash of the data
-static std::string fnv_hash(const uint8_t * data, size_t len) {
-  const uint64_t fnv_prime = 0x100000001b3ULL;
-  uint64_t hash = 0xcbf29ce484222325ULL;
-
-  for (size_t i = 0; i < len; ++i) {
-    hash ^= data[i];
-    hash *= fnv_prime;
-  }
-  return std::to_string(hash);
-}
-
-static const std::string base64_chars =
-  "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-  "abcdefghijklmnopqrstuvwxyz"
-  "0123456789+/";
-
-// Base64 decoding function
-static std::vector<uint8_t> base64_decode(const std::string &encoded_string) {
-  std::vector<uint8_t> decoded;
-  int in_len = encoded_string.size();
-  int i = 0;
-  int j = 0;
-  int in_ = 0;
-  unsigned char char_array_4[4], char_array_3[3];
-
-  while (in_len-- && (encoded_string[in_] != '=')) {
-    if (isspace(encoded_string[in_])) {
-      in_++;
-      continue;
-    }
-
-    if (encoded_string[in_] == '=' || base64_chars.find(encoded_string[in_]) == std::string::npos) {
-      break;
-    }
-
-    char_array_4[i++] = encoded_string[in_]; in_++;
-    if (i == 4) {
-      for (i = 0; i < 4; i++) {
-        char_array_4[i] = base64_chars.find(char_array_4[i]);
-      }
-
-      char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
-      char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
-      char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
-
-      for (i = 0; i < 3; i++) {
-        decoded.push_back(char_array_3[i]);
-      }
-      i = 0;
-    }
-  }
-
-  if (i) {
-    for (j = i; j < 4; j++) {
-      char_array_4[j] = 0;
-    }
-
-    for (j = 0; j < 4; j++) {
-      char_array_4[j] = base64_chars.find(char_array_4[j]);
-    }
-
-    char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
-    char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
-    char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
-
-    for (j = 0; j < i - 1; j++) {
-      decoded.push_back(char_array_3[j]);
-    }
-  }
-
-  return decoded;
-}
-
-size_t common_part(const std::vector<llama_token> &a,
-                   const std::vector<llama_token> &b) {
-  size_t i = 0;
-  while (i < a.size() && i < b.size() && a[i] == b[i]) {
-    i++;
-  }
-  return i;
-}
-
-// Process images and add them to the tokenized input
-llama_pos processImage(
-  const mtmd_context* mtmd_ctx,
-  llama_context* ctx,
-  LlamaSessionPtr sess,
-  const std::vector<std::string>& image_paths,
-  const common_params& params,
-  std::vector<llama_token>& text_tokens
-) {
-  if (mtmd_ctx == nullptr) {
-    return false;
-  }
-
-  // Multimodal path
-  std::string full_prompt = params.prompt;
-  // Add image marker if it doesn't already exist
-  if (full_prompt.find("<__image__>") == std::string::npos) {
-    full_prompt += " <__image__>";
-  }
-
-  // Prepare bitmaps array for all images
-  mtmd::bitmaps bitmaps;
-
-  std::vector<std::string> bitmap_hashes;
-
-  // Load all images
-  for (const auto& image_path : image_paths) {
-    fprintf(stdout, "[DEBUG] Loading image: %s\n",
-             image_path.substr(0, 50).c_str()); // Only log part of path for base64
-
-    // Check if it's a base64 image
-    if (image_path.compare(0, 11, "data:image/") == 0) {
-
-      // Parse base64 data
-      std::vector<std::string> parts;
-      size_t comma_pos = image_path.find(',');
-      if (comma_pos == std::string::npos) {
-        bitmaps.entries.clear();
-        return false;
-      }
-
-      std::string header = image_path.substr(0, comma_pos);
-      std::string base64_data = image_path.substr(comma_pos + 1);
-
-      if (header.find("base64") == std::string::npos) {
-        bitmaps.entries.clear();
-        return false;
-      }
-
-      // Decode base64
-      try {
-        // Decode base64 to binary
-        std::vector<uint8_t> image_data = base64_decode(base64_data);
-
-        // Load bitmap from memory buffer using direct initialization
-        mtmd::bitmap bmp(mtmd_helper_bitmap_init_from_buf(image_data.data(), image_data.size()));
-        if (!bmp.ptr) {
-          bitmaps.entries.clear();
-          return false;
-        }
-
-        // Calculate bitmap hash (for KV caching)
-        std::string hash = fnv_hash(bmp.data(), bmp.nx()*bmp.ny()*3);
-        bmp.set_id(hash.c_str());
-        bitmaps.entries.push_back(std::move(bmp));
-        bitmap_hashes.push_back(hash.c_str());
-      } catch (const std::exception& e) {
-        bitmaps.entries.clear();
-        return false;
-      }
-    } else if (image_path.compare(0, 7, "http://") == 0 || image_path.compare(0, 8, "https://") == 0) {
-      // HTTP URLs are not supported yet
-      bitmaps.entries.clear();
-      return false;
-    } else {
-      // Check if file exists
-      FILE* file = fopen(image_path.c_str(), "rb");
-      if (file == nullptr) {
-        bitmaps.entries.clear();
-        return false;
-      }
-
-      // Get file size
-      fseek(file, 0, SEEK_END);
-      long file_size = ftell(file);
-      fseek(file, 0, SEEK_SET);
-      fclose(file);
-
-      // Create bitmap directly
-      mtmd::bitmap bmp(mtmd_helper_bitmap_init_from_file(image_path.c_str()));
-      if (!bmp.ptr) {
-        bitmaps.entries.clear();
-        return false;
-      }
-
-      // Calculate bitmap hash (for KV caching)
-      std::string hash = fnv_hash(bmp.data(), bmp.nx()*bmp.ny()*3);
-      bmp.set_id(hash.c_str());
-      bitmaps.entries.push_back(std::move(bmp));
-      bitmap_hashes.push_back(hash.c_str());
-    }
-  }
-
-  mtmd_input_chunks* chunks = mtmd_input_chunks_init();
-  if (chunks == nullptr) {
-    bitmaps.entries.clear();
-    return false;
-  }
-
-  // Create input text
-  mtmd_input_text input_text;
-  input_text.text = full_prompt.c_str(); // Use the full prompt with image marker
-  input_text.add_special = true;  // Add BOS token if this is the first message
-  input_text.parse_special = true;       // Parse special tokens like <__image__>
-
-  // Tokenize the text and images
-  fprintf(stdout, "[DEBUG] Tokenizing text and %zu images\n", bitmaps.entries.size());
-  auto bitmaps_c_ptr = bitmaps.c_ptr();
-  
-  // Cast away const for mtmd_tokenize
-  int32_t res = mtmd_tokenize(
-    const_cast<mtmd_context*>(mtmd_ctx), 
-    chunks, 
-    &input_text, 
-    bitmaps_c_ptr.data(), 
-    bitmaps_c_ptr.size()
-  );
-  
-  if (res != 0) {
-    mtmd_input_chunks_free(chunks);
-    bitmaps.entries.clear();
-    return false;
-  }
-
-  // Log chunk information
-  size_t num_chunks = mtmd_input_chunks_size(chunks);
-  fprintf(stdout, "[DEBUG] Tokenization successful: num_chunks=%zu\n", num_chunks);
-
-  // Clear text_tokens before adding new tokens
-  text_tokens.clear();
-
-  // Create a vector to store all tokens (both text and image)
-  std::vector<llama_token> all_tokens;
-
-  // Track the total number of tokens (both text and image)
-  size_t total_token_count = 0;
-
-  // chunk pos
-  std::vector<size_t> chunk_pos;
-  std::vector<size_t> chunk_pos_images;
-  for (size_t i = 0; i < num_chunks; i++) {
-    chunk_pos.push_back(total_token_count);
-
-    const mtmd_input_chunk* chunk = mtmd_input_chunks_get(chunks, i);
-    mtmd_input_chunk_type chunk_type = mtmd_input_chunk_get_type(chunk);
-
-    if (chunk_type == MTMD_INPUT_CHUNK_TYPE_TEXT) {
-      size_t n_tokens;
-      const llama_token* tokens = mtmd_input_chunk_get_tokens_text(chunk, &n_tokens);
-
-      // Add text tokens
-      text_tokens.insert(text_tokens.end(), tokens, tokens + n_tokens);
-      all_tokens.insert(all_tokens.end(), tokens, tokens + n_tokens);
-      total_token_count += n_tokens;
-    } else if (chunk_type == MTMD_INPUT_CHUNK_TYPE_IMAGE) {
-      chunk_pos_images.push_back(total_token_count);
-
-      const mtmd_image_tokens* img_tokens = mtmd_input_chunk_get_tokens_image(chunk);
-      size_t n_tokens = mtmd_image_tokens_get_n_tokens(img_tokens);
-      size_t n_pos = mtmd_image_tokens_get_n_pos(img_tokens);
-
-      for (size_t j = 0; j < n_pos; j++) {
-        all_tokens.push_back(LLAMA_TOKEN_NULL);
-      }
-      total_token_count += n_pos;
-    }
-  }
-
-  llama_pos n_past = common_part(*sess->tokens_ptr(), all_tokens);
-
-  llama_pos new_n_past = n_past;
-
-  // Adjust n_past to position of the text chunk
-  // TODO: Edit the text chunk to remove the tokens before n_past to speed up
-  // need to update the mtmd api
-  auto adjusted_n_past = -1;
-  for (size_t i = 0; i < chunk_pos.size(); i++) {
-    if (n_past < chunk_pos[i]) {
-      break;
-    }
-    bool is_end = i + 1 == chunk_pos.size();
-    if (
-      chunk_pos[i] < n_past &&
-      (!is_end && chunk_pos[i + 1] > n_past)
-      // is_end & n_past < total_token_count:
-      // don't need to adjust and it will skip eval_chunk_single, let nextToken() to finish the job
-    ) {
-      adjusted_n_past = chunk_pos[i];
-    }
-  }
-  if (adjusted_n_past != -1) {
-    n_past = adjusted_n_past;
-    new_n_past = n_past;
-    fprintf(stdout, "[DEBUG] Adjusted n_past to %d\n", n_past);
-  }
-
-  // Compare bitmap hashes, if they are not the same, backtrack n_past to the position of the first mismatch
-  auto mtmd_bitmap_past_hashes = sess->mtmd_bitmap_past_hashes_ptr();
-  if (mtmd_bitmap_past_hashes->size() > 0) {
-    for (size_t i = 0; i < bitmap_hashes.size(); i++) {
-      auto pos = chunk_pos_images[i];
-      if (n_past < pos) {
-        break;
-      }
-      if (i >= mtmd_bitmap_past_hashes->size()) {
-        break;
-      }
-      if (bitmap_hashes[i] != (*mtmd_bitmap_past_hashes)[i]) {
-        n_past = chunk_pos_images[i];
-        new_n_past = n_past;
-        break;
-      }
-    }
-  }
-
-  // Clear all KV cache entries after position n_past
-  llama_kv_self_seq_rm(ctx, 0, n_past, -1);
-
-  for (size_t i = 0; i < chunk_pos.size(); i++) {
-    fprintf(stdout, "[DEBUG] Evaluating chunk %zu: n_past=%d, chunk_pos=%zu\n", i, n_past, chunk_pos[i]);
-
-    // Process chunk only if it's after the current n_past
-    if (chunk_pos[i] >= new_n_past) {
-      bool chunk_logits_last = (i == num_chunks - 1);
-      auto chunk = mtmd_input_chunks_get(chunks, i);
-
-      // Cast away const for mtmd_helper_eval_chunk_single
-      int32_t res = mtmd_helper_eval_chunk_single(
-        const_cast<mtmd_context*>(mtmd_ctx),
-        ctx,
-        chunk,
-        n_past,
-        0,
-        params.n_batch, // batch size
-        chunk_logits_last,
-        &new_n_past
-      );
-      
-      if (res != 0) {
-        mtmd_input_chunks_free(chunks);
-        bitmaps.entries.clear();
-        return false;
-      }
-      n_past = new_n_past;
-    }
-  }
-
-  if (n_past == total_token_count && n_past > 0 && all_tokens[n_past - 1] != LLAMA_TOKEN_NULL) {
-    // we have to evaluate at least 1 token to generate logits.
-    n_past--;
-  }
-
-  // Update sampling context to process token sequences
-  for (auto & token : all_tokens) {
-    if (token == LLAMA_TOKEN_NULL) {
-      continue;
-    }
-  }
-  // Set the tokens
-  sess->set_tokens(std::move(all_tokens));
-
-  sess->set_mtmd_bitmap_past_hashes(bitmap_hashes);
-
-  // Clean up image resources
-  mtmd_input_chunks_free(chunks);
-  bitmaps.entries.clear();
-  return n_past;
-}
 
 size_t findStoppingStrings(const std::string &text,
                            const size_t last_token_size,
@@ -390,10 +29,10 @@ LlamaCompletionWorker::LlamaCompletionWorker(
     Napi::Function callback, common_params params,
     std::vector<std::string> stop_words,
     int32_t chat_format,
-    std::vector<std::string> image_paths)
+    std::vector<std::string> media_paths)
     : AsyncWorker(info.Env()), Deferred(info.Env()), _sess(sess),
       _params(params), _stop_words(stop_words), _chat_format(chat_format),
-      _image_paths(image_paths) {
+      _media_paths(media_paths) {
   if (!callback.IsEmpty()) {
     _tsfn = Napi::ThreadSafeFunction::New(info.Env(), callback,
                                           "LlamaCompletionCallback", 0, 1);
@@ -425,30 +64,33 @@ void LlamaCompletionWorker::Execute() {
   LlamaCppSampling sampling{common_sampler_init(model, _params.sampling),
                             common_sampler_free};
 
-  std::vector<llama_token> prompt_tokens;
-
-  // Process images if any are provided
-  if (!_image_paths.empty()) {
+  // Process media if any are provided
+  if (!_media_paths.empty()) {
     const auto* mtmd_ctx = _sess->get_mtmd_ctx();
     
     if (mtmd_ctx != nullptr) {
-      // Process the images and get the tokens
-      n_cur = processImage(
-        mtmd_ctx,
-        ctx,
-        _sess,
-        _image_paths,
-        _params,
-        prompt_tokens
-      );
+      // Process the media and get the tokens
+      try {
+        n_cur = processMediaPrompt(
+          ctx,
+          mtmd_ctx,
+          _sess,
+          _params,
+          _media_paths
+        );
+      } catch (const std::exception& e) {
+        SetError(e.what());
+        _sess->get_mutex().unlock();
+        return;
+      }
       
       if (n_cur <= 0) {
-        SetError("Failed to process images");
+        SetError("Failed to process media");
         _sess->get_mutex().unlock();
         return;
       }
 
-      fprintf(stdout, "[DEBUG] Image processing successful, n_cur=%zu, tokens=%zu\n", 
+      fprintf(stdout, "[DEBUG] Media processing successful, n_cur=%zu, tokens=%zu\n", 
                        n_cur, _sess->tokens_ptr()->size());
 
       n_input = _sess->tokens_ptr()->size();
@@ -456,7 +98,6 @@ void LlamaCompletionWorker::Execute() {
         --n_cur;
       }
       n_input -= n_cur;
-      llama_kv_self_seq_rm(ctx, 0, n_cur, -1);
     } else {
       SetError("Multimodal context not initialized");
       _sess->get_mutex().unlock();
@@ -464,11 +105,11 @@ void LlamaCompletionWorker::Execute() {
     }
   } else {
     // Text-only path
-    prompt_tokens = ::common_tokenize(ctx, _params.prompt, add_bos);
+    std::vector<llama_token> prompt_tokens = ::common_tokenize(ctx, _params.prompt, add_bos);
     n_input = prompt_tokens.size();
     
     if (_sess->tokens_ptr()->size() > 0) {
-      n_cur = common_part(*(_sess->tokens_ptr()), prompt_tokens);
+      n_cur = common_tokens_part(*(_sess->tokens_ptr()), prompt_tokens);
       if (n_cur == n_input) {
         --n_cur;
       }

package/src/LlamaCompletionWorker.h

@@ -4,8 +4,6 @@
 #include <atomic>
 #include <functional>
 #include <napi.h>
-#include "tools/mtmd/mtmd.h"
-#include "tools/mtmd/clip.h"
 
 struct CompletionResult {
   std::string text = "";
@@ -22,7 +20,7 @@ public:
                         Napi::Function callback, common_params params,
                         std::vector<std::string> stop_words,
                         int32_t chat_format,
-                        std::vector<std::string> image_paths = {});
+                        std::vector<std::string> media_paths = {});
 
   ~LlamaCompletionWorker();
 
@@ -46,7 +44,7 @@ private:
   common_params _params;
   std::vector<std::string> _stop_words;
   int32_t _chat_format;
-  std::vector<std::string> _image_paths;
+  std::vector<std::string> _media_paths;
   std::function<void()> _onComplete;
   bool _has_callback = false;
   bool _stop = false;

package/src/LlamaContext.cpp

@@ -27,80 +27,6 @@ static std::string format_string(const std::string& format, Args ... args) {
     return std::string(buf.get(), buf.get() + size - 1); // -1 to exclude null terminator
 }
 
-// Computes FNV-1a hash of the data
-static std::string fnv_hash(const uint8_t* data, size_t len) {
-  const uint64_t fnv_prime = 0x100000001b3ULL;
-  uint64_t hash = 0xcbf29ce484222325ULL;
-
-  for (size_t i = 0; i < len; ++i) {
-    hash ^= data[i];
-    hash *= fnv_prime;
-  }
-  return std::to_string(hash);
-}
-
-static const std::string base64_chars =
-  "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-  "abcdefghijklmnopqrstuvwxyz"
-  "0123456789+/";
-
-// Base64 decoding function
-static std::vector<uint8_t> base64_decode(const std::string &encoded_string) {
-  std::vector<uint8_t> decoded;
-  int in_len = encoded_string.size();
-  int i = 0;
-  int j = 0;
-  int in_ = 0;
-  unsigned char char_array_4[4], char_array_3[3];
-
-  while (in_len-- && (encoded_string[in_] != '=')) {
-    if (isspace(encoded_string[in_])) {
-      in_++;
-      continue;
-    }
-
-    if (encoded_string[in_] == '=' || base64_chars.find(encoded_string[in_]) == std::string::npos) {
-      break;
-    }
-
-    char_array_4[i++] = encoded_string[in_]; in_++;
-    if (i == 4) {
-      for (i = 0; i < 4; i++) {
-        char_array_4[i] = base64_chars.find(char_array_4[i]);
-      }
-
-      char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
-      char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
-      char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
-
-      for (i = 0; i < 3; i++) {
-        decoded.push_back(char_array_3[i]);
-      }
-      i = 0;
-    }
-  }
-
-  if (i) {
-    for (j = i; j < 4; j++) {
-      char_array_4[j] = 0;
-    }
-
-    for (j = 0; j < 4; j++) {
-      char_array_4[j] = base64_chars.find(char_array_4[j]);
-    }
-
-    char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
-    char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
-    char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
-
-    for (j = 0; j < i - 1; j++) {
-      decoded.push_back(char_array_3[j]);
-    }
-  }
-
-  return decoded;
-}
-
 using json = nlohmann::ordered_json;
 
 // loadModelInfo(path: string): object
@@ -153,18 +79,6 @@ Napi::Value LlamaContext::ModelInfo(const Napi::CallbackInfo& info) {
   return metadata;
 }
 
-std::vector<common_chat_msg> get_messages(Napi::Array messages) {
-  std::vector<common_chat_msg> chat;
-  for (size_t i = 0; i < messages.Length(); i++) {
-    auto message = messages.Get(i).As<Napi::Object>();
-    chat.push_back({
-      get_option<std::string>(message, "role", ""),
-      get_option<std::string>(message, "content", ""),
-    });
-  }
-  return std::move(chat);
-}
-
 void LlamaContext::Init(Napi::Env env, Napi::Object &exports) {
   Napi::Function func = DefineClass(
       env, "LlamaContext",
@@ -221,6 +135,9 @@ void LlamaContext::Init(Napi::Env env, Napi::Object &exports) {
            static_cast<napi_property_attributes>(napi_enumerable)),
        StaticMethod<&LlamaContext::ToggleNativeLog>(
            "toggleNativeLog",
+           static_cast<napi_property_attributes>(napi_enumerable)),
+       InstanceMethod<&LlamaContext::GetMultimodalSupport>(
+           "getMultimodalSupport",
            static_cast<napi_property_attributes>(napi_enumerable))});
   Napi::FunctionReference *constructor = new Napi::FunctionReference();
   *constructor = Napi::Persistent(func);
@@ -693,22 +610,22 @@ Napi::Value LlamaContext::Completion(const Napi::CallbackInfo &info) {
     }
   }
 
-  // Process image_paths parameter
-  std::vector<std::string> image_paths;
-  if (options.Has("image_paths")) {
-    if (options.Get("image_paths").IsArray()) {
-      auto image_paths_array = options.Get("image_paths").As<Napi::Array>();
-      for (size_t i = 0; i < image_paths_array.Length(); i++) {
-        image_paths.push_back(image_paths_array.Get(i).ToString().Utf8Value());
+  // Process media_paths parameter
+  std::vector<std::string> media_paths;
+  if (options.Has("media_paths")) {
+    if (options.Get("media_paths").IsArray()) {
+      auto media_paths_array = options.Get("media_paths").As<Napi::Array>();
+      for (size_t i = 0; i < media_paths_array.Length(); i++) {
+        media_paths.push_back(media_paths_array.Get(i).ToString().Utf8Value());
       }
-    } else if (options.Get("image_paths").IsString()) {
-      image_paths.push_back(options.Get("image_paths").ToString().Utf8Value());
+    } else if (options.Get("media_paths").IsString()) {
+      media_paths.push_back(options.Get("media_paths").ToString().Utf8Value());
     }
   }
 
-  // Check if multimodal is enabled when image_paths are provided
-  if (!image_paths.empty() && !(_has_multimodal && _mtmd_ctx != nullptr)) {
-    Napi::Error::New(env, "Multimodal support must be enabled via initMultimodal to use image_paths").ThrowAsJavaScriptException();
+  // Check if multimodal is enabled when media_paths are provided
+  if (!media_paths.empty() && !(_has_multimodal && _mtmd_ctx != nullptr)) {
+    Napi::Error::New(env, "Multimodal support must be enabled via initMultimodal to use media_paths").ThrowAsJavaScriptException();
     return env.Undefined();
   }
 
@@ -894,7 +811,7 @@ Napi::Value LlamaContext::Completion(const Napi::CallbackInfo &info) {
   }
 
   auto *worker =
-      new LlamaCompletionWorker(info, _sess, callback, params, stop_words, chat_format, image_paths);
+      new LlamaCompletionWorker(info, _sess, callback, params, stop_words, chat_format, media_paths);
   worker->Queue();
   _wip = worker;
   worker->OnComplete([this]() { _wip = nullptr; });
@@ -919,7 +836,14 @@ Napi::Value LlamaContext::Tokenize(const Napi::CallbackInfo &info) {
         .ThrowAsJavaScriptException();
   }
   auto text = info[0].ToString().Utf8Value();
-  auto *worker = new TokenizeWorker(info, _sess, text);
+  std::vector<std::string> media_paths;
+  if (info.Length() >= 2 && info[1].IsArray()) {
+    auto media_paths_array = info[1].As<Napi::Array>();
+    for (size_t i = 0; i < media_paths_array.Length(); i++) {
+      media_paths.push_back(media_paths_array.Get(i).ToString().Utf8Value());
+    }
+  }
+  auto *worker = new TokenizeWorker(info, _sess, text, media_paths);
   worker->Queue();
   return worker->Promise();
 }
@@ -1160,6 +1084,22 @@ Napi::Value LlamaContext::IsMultimodalEnabled(const Napi::CallbackInfo &info) {
   return Napi::Boolean::New(info.Env(), _has_multimodal && _mtmd_ctx != nullptr);
 }
 
+// getMultimodalSupport(): Promise<{ vision: boolean, audio: boolean }>
+Napi::Value LlamaContext::GetMultimodalSupport(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  auto result = Napi::Object::New(env);
+  
+  if (_has_multimodal && _mtmd_ctx != nullptr) {
+    result.Set("vision", Napi::Boolean::New(env, mtmd_support_vision(_mtmd_ctx)));
+    result.Set("audio", Napi::Boolean::New(env, mtmd_support_audio(_mtmd_ctx)));
+  } else {
+    result.Set("vision", Napi::Boolean::New(env, false));
+    result.Set("audio", Napi::Boolean::New(env, false));
+  }
+  
+  return result;
+}
+
 // releaseMultimodal(): void
 void LlamaContext::ReleaseMultimodal(const Napi::CallbackInfo &info) {
   if (_mtmd_ctx != nullptr) {

package/src/LlamaContext.h

@@ -31,6 +31,7 @@ private:
   // Multimodal methods
   Napi::Value InitMultimodal(const Napi::CallbackInfo &info);
   Napi::Value IsMultimodalEnabled(const Napi::CallbackInfo &info);
+  Napi::Value GetMultimodalSupport(const Napi::CallbackInfo &info);
   void ReleaseMultimodal(const Napi::CallbackInfo &info);
 
   std::string _info;