cactus-react-native 1.0.1 → 1.0.2

package/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/graph.h

@@ -28,8 +28,9 @@ enum class OpType {
     INPUT, PRECISION_CAST,
     ADD, ADD_CLIPPED, SUBTRACT, MULTIPLY, DIVIDE,
     MATMUL, TRANSPOSE, RESHAPE, SLICE, GATHER, EMBEDDING,
+    BILINEAR_INTERPOLATION,
     SUM, MEAN, VARIANCE, MIN, MAX,
-    RMS_NORM, ROPE, SOFTMAX, ATTENTION, CONV1D_CAUSAL,
+    RMS_NORM, ROPE, SOFTMAX, ATTENTION, CONV1D_CAUSAL, CONV1D_K3,
     SCALAR_ADD, SCALAR_SUBTRACT, SCALAR_MULTIPLY, SCALAR_DIVIDE, SCALAR_EXP, SCALAR_SQRT, SCALAR_COS, SCALAR_SIN,
     SILU, GELU,
     SAMPLE, CONCAT,
@@ -139,6 +140,7 @@ struct OpParams {
     ComputeBackend backend = ComputeBackend::CPU;
 
     size_t dilation = 1;
+    size_t stride = 1;
     float temperature = 1.0f;
     float top_p = 1.0f;
     size_t top_k = 0;
@@ -146,6 +148,8 @@ struct OpParams {
     
     size_t index_value = 0;  // For INDEX operation
     size_t num_classes = 0;  // For scatter operations
+    size_t dst_height = 0;
+    size_t dst_width = 0;   
 };
 
 struct GraphNode {
@@ -187,6 +191,12 @@ namespace ValidationUtils {
 class CactusGraph {
 public:
     CactusGraph();
+
+    struct DebugNodeEntry {
+        uint32_t layer_idx;
+        std::string name;
+        size_t node_id;
+    };
     
     size_t input(const std::vector<size_t>& shape, Precision precision = Precision::INT8);
     size_t precision_cast(size_t input, Precision target_precision);
@@ -212,6 +222,7 @@ public:
     
     size_t matmul(size_t input1, size_t input2, bool pretransposed_rhs = false, ComputeBackend backend = ComputeBackend::CPU);
     size_t transpose(size_t input, ComputeBackend backend = ComputeBackend::CPU);
+    size_t transposeN(size_t input, const std::vector<size_t>& permutation, ComputeBackend backend = ComputeBackend::CPU);
     size_t reshape(size_t input, const std::vector<size_t>& new_shape);
     size_t slice(size_t input, int axis, size_t start, size_t length);
     size_t index(size_t input, size_t index_value, int dim);
@@ -228,6 +239,7 @@ public:
     void set_quantization_scale(size_t node_id, float scale);
     size_t embedding(const std::string& filename, size_t indices);
     size_t embedding(size_t embedding_tensor, size_t indices);
+    size_t bilinear_interpolation(size_t pos_embeds, size_t dst_height, size_t dst_width);
 
     size_t layernorm(size_t input, size_t weight, size_t bias, float epsilon = 1e-5f);
     size_t topk(size_t input, size_t k);
@@ -239,6 +251,7 @@ public:
     size_t attention(size_t query, size_t key, size_t value, float scale, size_t position_offset, size_t window_size, ComputeBackend backend = ComputeBackend::CPU);
 
     size_t conv1d_causal(size_t input, size_t weight, size_t kernel_size, size_t dilation = 1);
+    size_t conv1d_k3(size_t input, size_t weight, size_t stride);
     
     size_t sample(size_t logits, float temperature = 0.6f, float top_p = 0.95f, size_t top_k = 20);
     
@@ -252,6 +265,11 @@ public:
     void execute(const std::string& profile_file = "");
     void hard_reset();
     void soft_reset();
+
+    void register_debug_node(uint32_t layer_idx, const std::string& name, size_t node_id);
+    void capture_debug_node(uint32_t layer_idx, const std::string& name, size_t node_id);
+    const std::vector<DebugNodeEntry>& get_debug_nodes() const;
+    void clear_debug_nodes();
     
     size_t add_node(OpType op_type, const std::vector<size_t>& inputs, const std::vector<size_t>& output_shape, const OpParams& params = {});
     const BufferDesc& get_output_buffer(size_t node_id) const;
@@ -265,6 +283,7 @@ private:
     size_t next_node_id_;
     std::vector<std::unique_ptr<GraphFile::MappedFile>> mapped_files_;
     std::unordered_map<std::string, size_t> weight_cache_;
+    std::vector<DebugNodeEntry> debug_nodes_;
 };
 
 

package/ios/cactus.xcframework/ios-arm64/cactus.framework/Headers/kernel.h

@@ -225,6 +225,27 @@ void cactus_conv1d_causal_depthwise_int8(
     float weight_scale,
     float output_scale);
 
+void cactus_conv1d_f32_k3(
+    const float* input,
+    const float* weight,
+    float* output,
+    size_t N, size_t L,
+    size_t C_in, size_t C_out,
+    size_t stride
+);
+
+void cactus_conv1d_f16_k3(
+    const __fp16* input,
+    const __fp16* weight,
+    __fp16* output,
+    size_t N, size_t L,
+    size_t C_in, size_t C_out,
+    size_t stride
+);
+
+void cactus_bilinear_interpolation_fp32(const float* input, float* output, size_t src_height, size_t src_width, size_t embed_dim,
+                                        size_t dst_height, size_t dst_width);
+
 void cactus_sample_f32(const float* logits, uint32_t* output, size_t vocab_size,
                        float temperature, float top_p, size_t top_k, size_t random_seed);
 void cactus_sample_f16(const __fp16* logits, uint32_t* output, size_t vocab_size,

package/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/cactus_ffi.h

@@ -20,7 +20,7 @@ typedef void* cactus_model_t;
 
 typedef void (*cactus_token_callback)(const char* token, uint32_t token_id, void* user_data);
 
-CACTUS_FFI_EXPORT cactus_model_t cactus_init(const char* model_path, size_t context_size);
+CACTUS_FFI_EXPORT cactus_model_t cactus_init(const char* model_path, size_t context_size, const char* corpus_dir);
 
 CACTUS_FFI_EXPORT int cactus_complete(
     cactus_model_t model,

package/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/engine.h

@@ -7,12 +7,18 @@
 #include <cstdint>
 
 #include "../graph/graph.h"
+extern "C" {
+    #include "../../libs/stb/stb_image.h"
+    #include "../../libs/stb/stb_image_resize2.h"
+}
 
 class CactusGraph;
 
 namespace cactus {
 namespace engine {
 
+class Siglip2Preprocessor;
+
 struct Config {
     uint32_t vocab_size = 151936;
     uint32_t bos_token_id = 151643;
@@ -31,9 +37,43 @@ struct Config {
     uint32_t moe_every_n_layers = 0;
     bool tie_word_embeddings = true;
 
-    enum class ModelType {QWEN = 0, GEMMA = 1, SMOL = 2, NOMIC = 3, LFM2 = 4};
+    uint32_t vision_hidden_dim = 0;
+    uint32_t vision_num_layers = 0;
+    uint32_t vision_attention_heads = 0;
+    uint32_t vision_image_size = 0;
+    uint32_t vision_patch_size = 0;
+    uint32_t vision_num_channels = 3;
+    uint32_t vision_embed_dim = 0;
+    uint32_t visual_tokens_per_img = 0;
+    bool use_pixel_shuffle = false;
+    uint32_t pixel_shuffle_factor = 1;
+    bool use_image_tokens = false;
+    bool use_layout_tags = false;
+    uint32_t image_seq_len = 64;
+
+    uint32_t global_image_size = 2048;
+    uint32_t max_tile_size = 512;
+    float rescale_factor = 0.00392156862745098f;
+    float image_mean = 0.5f;
+    float image_std = 0.5f;
+    
+    uint32_t downsample_factor = 2;
+    uint32_t min_tiles = 2;
+    uint32_t max_tiles = 10;
+    bool use_thumbnail = true;
+    uint32_t min_image_tokens = 64;
+    uint32_t max_image_tokens = 256;
+        uint32_t max_num_patches = 1024;
+    uint32_t tile_size = 512;
+    float max_pixels_tolerance = 2.0f;
+    bool do_image_splitting = true;
+
+    enum class ModelType {QWEN = 0, GEMMA = 1, SMOL = 2, NOMIC = 3, LFM2 = 5, SIGLIP2 = 6};
     ModelType model_type = ModelType::QWEN;
 
+    enum class ModelVariant {DEFAULT = 0, VLM = 1, EXTRACT = 2, RAG = 3};
+    ModelVariant model_variant = ModelVariant::DEFAULT;
+
     enum class Activation {GELU = 0, SILU = 1};
     Activation activation = Activation::SILU;
 
@@ -70,6 +110,7 @@ struct MergeRule {
 struct ChatMessage {
     std::string role;
     std::string content;
+    std::vector<std::string> images;
 };
 
 class Tokenizer {
@@ -89,18 +130,32 @@ public:
     virtual bool has_chat_template() const { return has_chat_template_; }
 
     virtual bool load_vocabulary_with_config(const std::string& vocab_file, const std::string& merges_file, const std::string& config_file) = 0;
+    
+    uint32_t get_image_token_id() const { return image_token_id_; }
+    uint32_t get_fake_token_id() const { return fake_token_id_; }
+    uint32_t get_global_img_token_id() const { return global_img_token_id_; }
 
-protected:
 
-    enum class ModelType { UNKNOWN, QWEN, GEMMA, LFM2 , SMOL, BERT };
+    void set_corpus_dir(const std::string& dir) { corpus_dir_ = dir; }
+
+protected:
+    enum class ModelType { UNKNOWN, QWEN, GEMMA, LFM2, SMOL, BERT };
     ModelType model_type_ = ModelType::UNKNOWN;
+    enum class ModelVariant { DEFAULT, VLM, EXTRACT, RAG};
+    ModelVariant model_variant_ = ModelVariant::DEFAULT;
     bool has_chat_template_ = false;
     std::string chat_template_;
+    
+    uint32_t image_token_id_ = 396;
+    uint32_t fake_token_id_ = 49189;
+    uint32_t global_img_token_id_ = 49152;
+    std::string corpus_dir_;
 
     void detect_model_type(const std::string& config_path);
     std::string format_qwen_style(const std::vector<ChatMessage>& messages, bool add_generation_prompt, const std::string& tools_json) const;
     std::string format_gemma_style(const std::vector<ChatMessage>& messages, bool add_generation_prompt, const std::string& tools_json) const;
     std::string format_lfm2_style(const std::vector<ChatMessage>& messages, bool add_generation_prompt, const std::string& tools_json) const;
+    std::string format_lfm2_vl_style(const std::vector<ChatMessage>& messages, bool add_generation_prompt, const std::string& tools_json) const;
     std::string format_smol_style(const std::vector<ChatMessage>& messages, bool add_generation_prompt, const std::string& tools_json) const;
 };
 
@@ -295,22 +350,37 @@ struct KVCache {
 
 class Model {
 public:
+    struct DebugNode {
+        uint32_t layer_idx;
+        std::string name;
+        size_t node_id;
+    };
+
     Model();
     explicit Model(const Config& config);
     virtual ~Model();
 
     const Config& get_config() const { return config_; }
     Tokenizer* get_tokenizer() const { return tokenizer_.get(); }
+    const std::vector<DebugNode>& get_debug_nodes() const;
 
-    bool init(const std::string& model_folder, size_t context_size, const std::string& system_prompt = "");
-    uint32_t generate(const std::vector<uint32_t>& tokens, float temperature = -1.0f, float top_p = -1.0f,
+    virtual bool init(const std::string& model_folder, size_t context_size, const std::string& system_prompt = "", bool do_warmup = true);
+    virtual bool init(CactusGraph* external_graph, const std::string& model_folder, size_t context_size,
+              const std::string& system_prompt = "", bool do_warmup = true);
+    virtual uint32_t generate(const std::vector<uint32_t>& tokens, float temperature = -1.0f, float top_p = -1.0f,
                       size_t top_k = 0, const std::string& profile_file = "");
 
+    virtual uint32_t generate_with_images(const std::vector<uint32_t>& tokens, const std::vector<std::string>& image_paths,
+                                          float temperature = -1.0f, float top_p = -1.0f,
+                                          size_t top_k = 0, const std::string& profile_file = "");
+
     std::vector<float> get_embeddings(const std::vector<uint32_t>& tokens, bool pooled = true, const std::string& profile_file = "");
 
     virtual void reset_cache() { kv_cache_.reset(); }
     void set_cache_window(size_t window_size, size_t sink_size = 4) { kv_cache_.set_window_size(window_size, sink_size); }
 
+    void* graph_handle_;
+
 protected:
     virtual size_t forward(const std::vector<uint32_t>& tokens, bool use_cache = false) = 0;
     virtual void load_weights_to_graph(CactusGraph* gb) = 0;
@@ -326,7 +396,6 @@ protected:
     Config config_;
     std::unique_ptr<Tokenizer> tokenizer_;
 
-    void* graph_handle_;
     bool initialized_;
     float attention_scale_;
 
@@ -339,9 +408,138 @@ protected:
     size_t embedding_node_id_;
     std::string model_folder_path_;
     size_t output_weight_node_id_;
+
+    mutable std::vector<DebugNode> debug_nodes_;
+
+    void capture_debug_node(uint32_t layer_idx, const std::string& name, size_t node_id) const;
+    void clear_debug_nodes();
+
+    bool init_internal(CactusGraph* gb, const std::string& model_folder, size_t context_size,
+                       const std::string& system_prompt, bool do_warmup);
+    bool owns_graph_;
 };
 
 std::unique_ptr<Model> create_model(const std::string& model_folder);
 
+class Siglip2Preprocessor {
+public:
+    struct Config {
+        int patch_size = 16;
+        int downsample_factor = 2;
+        int min_tiles = 2;
+        int max_tiles = 10;
+    bool use_thumbnail = true;
+        int min_image_tokens = 64;
+        int max_image_tokens = 256;
+        int max_num_patches = 1024;
+        int tile_size = 512;
+        float max_pixels_tolerance = 2.0f;
+        bool do_resize = true;
+        bool do_rescale = true;
+        bool do_normalize = true;
+        bool do_convert_rgb = true;
+        bool do_image_splitting = true;
+        float rescale_factor = 1.0f / 255.0f;
+        float image_mean[3] = {0.5f, 0.5f, 0.5f};
+        float image_std[3] = {0.5f, 0.5f, 0.5f};
+    };
+
+    struct PreprocessedImage {
+        std::vector<float> pixel_values;       
+        std::vector<int> pixel_attention_mask; 
+        std::vector<std::pair<int,int>> spatial_shapes;  
+        std::vector<size_t> pixel_values_shape;           
+        std::vector<size_t> pixel_attention_mask_shape;   
+        std::vector<size_t> spatial_shapes_shape;         
+        int num_patches_height;                 
+        int num_patches_width;                  
+        int actual_num_patches;                 
+        int num_tiles;                          
+        int patch_dim;                          
+        int max_patches_per_tile;               
+          
+        int image_rows;                         
+        int image_cols;                         
+        int image_height;                       
+        int image_width;                        
+        int tokens_per_tile;                    
+        int thumbnail_tokens;                   
+        
+        ~PreprocessedImage();
+    };
+
+    struct SpatialShapeResult {
+        std::vector<std::pair<int, int>> shapes;  
+        int grid_rows;                             
+        int grid_cols;                             
+    };
+
+    explicit Siglip2Preprocessor(const Config& config);
+    Siglip2Preprocessor();
+    ~Siglip2Preprocessor();
+
+    PreprocessedImage preprocess_from_file(const std::string& image_path);
+    PreprocessedImage preprocess_from_memory(const unsigned char* img_data, int width, int height, int channels);
+    SpatialShapeResult compute_spatial_shapes(int height, int width);
+
+private:
+    Config config_;
+
+    std::vector<unsigned char> convert_to_rgb(const unsigned char* img_data, int width, int height, int channels);
+    std::pair<int, int> smart_resize(int height, int width);
+    bool is_image_too_large(int height, int width);
+    std::pair<int, int> get_grid_layout(int height, int width);
+    std::pair<int, int> find_closest_aspect_ratio(float aspect_ratio, int width, int height);
+    std::vector<float> resize_image(const unsigned char* img_data, int src_width, int src_height,
+                                    int dst_width, int dst_height, int channels);
+    std::vector<float> normalize_image(const float* img_data, int width, int height, int channels);
+    std::vector<std::vector<float>> convert_image_to_patches(
+        const std::vector<float>& image, int width, int height, int channels, int patch_size);
+    PreprocessedImage pad_patches(const std::vector<std::vector<float>>& tile_patches,
+                                  const std::vector<std::pair<int,int>>& spatial_shapes,
+                                  int patch_dim,
+                                  int max_patches_per_tile);
+    int round_by_factor(int number, int factor);
+};
+
+class AudioProcessor {
+public:
+    struct SpectrogramConfig {
+        size_t n_fft = 400;
+        size_t hop_length = 160;
+        size_t frame_length = 400;
+        float power = 2.0f;
+        bool center = true;
+        const char* pad_mode = "reflect";
+        bool onesided = true;
+        float dither = 0.0f;
+        float mel_floor = 1e-10f;
+        const char* log_mel = nullptr;
+        float reference = 1.0f;
+        float min_value = 1e-10f;
+        bool remove_dc_offset = false;
+    };
+
+    AudioProcessor();
+    ~AudioProcessor();
+
+    void init_mel_filters(size_t num_frequency_bins, size_t num_mel_filters,
+                          float min_freq, float max_freq, size_t sampling_rate);
+
+    std::vector<float> compute_spectrogram(
+        const std::vector<float>& waveform,
+        const SpectrogramConfig& config);
+
+    const std::vector<float>& get_mel_filters() const { return mel_filters_; }
+
+    size_t get_num_mel_filters() const { return num_mel_filters_; }
+    size_t get_num_frequency_bins() const { return num_frequency_bins_; }
+
+private:
+    std::vector<float> mel_filters_;
+    size_t num_frequency_bins_;
+    size_t num_mel_filters_;
+};
+
 }
 }

package/ios/cactus.xcframework/ios-arm64-simulator/cactus.framework/Headers/ffi_utils.h

@@ -8,6 +8,8 @@
 #include <stdexcept>
 #include <sstream>
 #include <iomanip>
+#include <filesystem>
+#include <cctype>
 
 namespace cactus {
 namespace ffi {
@@ -30,8 +32,10 @@ inline void handle_error_response(const std::string& error_message, char* respon
     }
 }
 
-inline std::vector<cactus::engine::ChatMessage> parse_messages_json(const std::string& json) {
+inline std::vector<cactus::engine::ChatMessage> parse_messages_json(const std::string& json, 
+                                                                   std::vector<std::string>& out_image_paths) {
     std::vector<cactus::engine::ChatMessage> messages;
+    out_image_paths.clear();
     
     size_t pos = json.find('[');
     if (pos == std::string::npos) {
@@ -42,42 +46,79 @@ inline std::vector<cactus::engine::ChatMessage> parse_messages_json(const std::s
     while (pos != std::string::npos) {
         cactus::engine::ChatMessage msg;
         
+        size_t obj_start = pos;
+        int brace_count = 1;
+        size_t obj_end = obj_start + 1;
+        while (obj_end < json.length() && brace_count > 0) {
+            if (json[obj_end] == '{') brace_count++;
+            else if (json[obj_end] == '}') brace_count--;
+            obj_end++;
+        }
+
         size_t role_pos = json.find("\"role\"", pos);
-        if (role_pos == std::string::npos) break;
+        if (role_pos == std::string::npos || role_pos >= obj_end) break;
         
         size_t role_start = json.find('"', role_pos + 6) + 1;
         size_t role_end = json.find('"', role_start);
         msg.role = json.substr(role_start, role_end - role_start);
         
         size_t content_pos = json.find("\"content\"", role_end);
-        if (content_pos == std::string::npos) break;
-        
-        size_t content_start = json.find('"', content_pos + 9) + 1;
-        size_t content_end = content_start;
-        
-        while (content_end < json.length()) {
-            content_end = json.find('"', content_end);
-            if (content_end == std::string::npos) break;
-            if (json[content_end - 1] != '\\') break;
-            content_end++;
+        if (content_pos != std::string::npos && content_pos < obj_end) {
+            size_t content_start = json.find('"', content_pos + 9) + 1;
+            size_t content_end = content_start;
+            
+            while (content_end < json.length()) {
+                content_end = json.find('"', content_end);
+                if (content_end == std::string::npos) break;
+                if (json[content_end - 1] != '\\') break;
+                content_end++;
+            }
+            
+            msg.content = json.substr(content_start, content_end - content_start);
+            
+            size_t escape_pos = 0;
+            while ((escape_pos = msg.content.find("\\n", escape_pos)) != std::string::npos) {
+                msg.content.replace(escape_pos, 2, "\n");
+                escape_pos += 1;
+            }
+            escape_pos = 0;
+            while ((escape_pos = msg.content.find("\\\"", escape_pos)) != std::string::npos) {
+                msg.content.replace(escape_pos, 2, "\"");
+                escape_pos += 1;
+            }
         }
         
-        msg.content = json.substr(content_start, content_end - content_start);
-        
-        size_t escape_pos = 0;
-        while ((escape_pos = msg.content.find("\\n", escape_pos)) != std::string::npos) {
-            msg.content.replace(escape_pos, 2, "\n");
-            escape_pos += 1;
-        }
-        escape_pos = 0;
-        while ((escape_pos = msg.content.find("\\\"", escape_pos)) != std::string::npos) {
-            msg.content.replace(escape_pos, 2, "\"");
-            escape_pos += 1;
+        size_t images_pos = json.find("\"images\"", pos);
+        if (images_pos != std::string::npos && images_pos < obj_end) {
+            size_t array_start = json.find('[', images_pos);
+            if (array_start != std::string::npos && array_start < obj_end) {
+                size_t array_end = json.find(']', array_start);
+                if (array_end != std::string::npos && array_end < obj_end) {
+                    size_t img_pos = array_start;
+                    while (true) {
+                        img_pos = json.find('"', img_pos + 1);
+                        if (img_pos == std::string::npos || img_pos >= array_end) break;
+                        
+                        size_t img_start = img_pos + 1;
+                        size_t img_end = json.find('"', img_start);
+                        if (img_end == std::string::npos || img_end > array_end) break;
+                        
+                        std::string img_path = json.substr(img_start, img_end - img_start);
+                        
+                        std::filesystem::path p(img_path);
+                        img_path = std::filesystem::absolute(p).string();
+                        
+                        msg.images.push_back(img_path);
+                        out_image_paths.push_back(img_path);
+                        img_pos = img_end;
+                    }
+                }
+            }
         }
         
         messages.push_back(msg);
         
-        pos = json.find('{', content_end);
+        pos = json.find('{', obj_end);
     }
     
     return messages;
@@ -136,10 +177,10 @@ inline void parse_options_json(const std::string& json,
                                float& temperature, float& top_p, 
                                size_t& top_k, size_t& max_tokens,
                                std::vector<std::string>& stop_sequences) {
-    temperature = -1.0f; // Use model default
-    top_p = -1.0f;       // Use model default
-    top_k = 0;           // Use model default
-    max_tokens = 100;    // FFI-level default
+    temperature = -1.0f; 
+    top_p = -1.0f;       
+    top_k = 0;           
+    max_tokens = 100;    
     stop_sequences.clear();
     
     if (json.empty()) return;
@@ -205,34 +246,107 @@ inline std::string format_tools_for_prompt(const std::vector<ToolFunction>& tool
     return formatted_tools_json;
 }
 
-inline void parse_function_calls_from_response(const std::string& response_text, 
-                                               std::string& regular_response, 
+inline void parse_function_calls_from_response(const std::string& response_text,
+                                               std::string& regular_response,
                                                std::vector<std::string>& function_calls) {
     regular_response = response_text;
     function_calls.clear();
 
+    const std::string TOOL_CALL_START = "<|tool_call_start|>";
+    const std::string TOOL_CALL_END = "<|tool_call_end|>";
+    size_t tool_start_pos = 0;
+
+    while ((tool_start_pos = response_text.find(TOOL_CALL_START, tool_start_pos)) != std::string::npos) {
+        size_t content_start = tool_start_pos + TOOL_CALL_START.length();
+        size_t tool_end_pos = response_text.find(TOOL_CALL_END, content_start);
+
+        if (tool_end_pos != std::string::npos) {
+            std::string tool_content = response_text.substr(content_start, tool_end_pos - content_start);
+
+            if (tool_content.size() > 2 && tool_content[0] == '[' && tool_content[tool_content.size()-1] == ']') {
+                tool_content = tool_content.substr(1, tool_content.size() - 2); 
+
+                size_t paren_pos = tool_content.find('(');
+                if (paren_pos != std::string::npos) {
+                    std::string func_name = tool_content.substr(0, paren_pos);
+                    std::string args_str = tool_content.substr(paren_pos + 1);
+
+                    if (!args_str.empty() && args_str.back() == ')') {
+                        args_str.pop_back();
+                    }
+
+                    std::string json_call = "{\"name\":\"" + func_name + "\",\"arguments\":{";
+
+                    size_t arg_pos = 0;
+                    bool first_arg = true;
+                    while (arg_pos < args_str.length()) {
+                        while (arg_pos < args_str.length() && std::isspace(args_str[arg_pos])) arg_pos++;
+
+                        size_t eq_pos = args_str.find('=', arg_pos);
+                        if (eq_pos == std::string::npos) break;
+
+                        std::string arg_name = args_str.substr(arg_pos, eq_pos - arg_pos);
+
+                        size_t val_start = eq_pos + 1;
+                        size_t val_end = val_start;
+
+                        if (val_start < args_str.length() && args_str[val_start] == '"') {
+                            val_start++;
+                            val_end = args_str.find('"', val_start);
+                            if (val_end == std::string::npos) break;
+                        } else {
+                            val_end = args_str.find(',', val_start);
+                            if (val_end == std::string::npos) val_end = args_str.length();
+                        }
+
+                        std::string arg_value = args_str.substr(val_start, val_end - val_start);
+
+                        if (!first_arg) json_call += ",";
+                        json_call += "\"" + arg_name + "\":\"" + arg_value + "\"";
+                        first_arg = false;
+
+                        arg_pos = args_str.find(',', val_end);
+                        if (arg_pos != std::string::npos) {
+                            arg_pos++;
+                        } else {
+                            break;
+                        }
+                    }
+
+                    json_call += "}}";
+                    function_calls.push_back(json_call);
+                }
+            }
+
+            regular_response.erase(tool_start_pos, tool_end_pos + TOOL_CALL_END.length() - tool_start_pos);
+            tool_start_pos = tool_end_pos + TOOL_CALL_END.length();
+        } else {
+            break;
+        }
+    }
+
     const char* FUNCTION_CALL_MARKER = "\"function_call\"";
     size_t search_pos = 0;
-    const size_t text_len = response_text.length();
+    const size_t text_len = regular_response.length();
 
     while (search_pos < text_len) {
-        size_t marker_pos = response_text.find(FUNCTION_CALL_MARKER, search_pos);
+        size_t marker_pos = regular_response.find(FUNCTION_CALL_MARKER, search_pos);
         if (marker_pos == std::string::npos) break;
 
-        size_t json_start = response_text.find('{', marker_pos);
+        size_t json_start = regular_response.find('{', marker_pos);
         if (json_start == std::string::npos) break;
 
         int brace_count = 1;
         size_t json_end = json_start + 1;
         while (json_end < text_len && brace_count > 0) {
-            char c = response_text[json_end];
+            char c = regular_response[json_end];
             brace_count += (c == '{') - (c == '}');
             json_end++;
         }
 
         if (brace_count == 0) {
-            function_calls.push_back(response_text.substr(json_start, json_end - json_start));
-            regular_response = response_text.substr(0, marker_pos); 
+            function_calls.push_back(regular_response.substr(json_start, json_end - json_start));
+            regular_response = regular_response.substr(0, marker_pos);
             size_t last_bracket = regular_response.rfind('{');
             if(last_bracket != std::string::npos) {
                 regular_response = regular_response.substr(0, last_bracket);