llama.cpp/common/inline-tools.h

#pragma once

#include <string>
#include <vector>
#include <functional>
#include <map>
#include <sstream>
#include <cmath>
#include <iostream>
#include <fstream>
#include <regex>
#include <chrono>
#include <ctime>
#include <iomanip>
#include <algorithm>
#include "base64.hpp"
#include <random>
#include <cctype>
#include <climits>

// Inline tool callback function type
// Args are passed as strings, return value is string
using InlineToolCallback = std::function<std::string(const std::vector<std::string>&)>;

struct InlineTool {
    std::string name;
    InlineToolCallback callback;
    int num_args;
};

class InlineToolManager {
private:
    std::map<std::string, InlineTool> tools;

public:
    InlineToolManager() {
        // Register default tools
        
        // Addition
        register_tool("add", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() < 2) {
                return "ERROR: add() requires at least 2 arguments, got " + std::to_string(args.size()) + ". Usage: [[add(5,10,15){==} → 30";
            }
            try {
                double sum = 0.0;
                for (size_t i = 0; i < args.size(); i++) {
                    try {
                        sum += std::stod(args[i]);
                    } catch (...) {
                        return "ERROR: add() argument " + std::to_string(i+1) + " is not a valid number: '" + args[i] + "'. Usage: [[add(5,10){==} → 15";
                    }
                }
                if (sum == std::floor(sum)) {
                    return std::to_string(static_cast<long long>(sum));
                }
                return std::to_string(sum);
            } catch (...) {
                return "ERROR: add() failed. Usage: [[add(5,10,15){==} → 30";
            }
        }, -1); // Variable number of args

        // Subtraction
        register_tool("sub", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 2) {
                return "ERROR: sub() requires exactly 2 arguments, got " + std::to_string(args.size()) + ". Usage: [[sub(10,3){==} → 7";
            }
            try {
                double a = std::stod(args[0]);
                double b = std::stod(args[1]);
                double result = a - b;
                if (result == std::floor(result)) {
                    return std::to_string(static_cast<long long>(result));
                }
                return std::to_string(result);
            } catch (...) {
                return "ERROR: sub() arguments must be numbers. Got: '" + args[0] + "', '" + args[1] + "'. Usage: [[sub(10,3){==} → 7";
            }
        }, 2);

        // Division
        register_tool("div", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 2) {
                return "ERROR: div() requires exactly 2 arguments, got " + std::to_string(args.size()) + ". Usage: [[div(10,2){==} → 5";
            }
            try {
                double a = std::stod(args[0]);
                double b = std::stod(args[1]);
                if (b == 0) {
                    return "ERROR: Division by zero (" + args[0] + "/0). Cannot divide by zero. Usage: [[div(10,2){==} → 5";
                }
                double result = a / b;
                if (result == std::floor(result)) {
                    return std::to_string(static_cast<long long>(result));
                }
                return std::to_string(result);
            } catch (...) {
                return "ERROR: div() arguments must be numbers. Got: '" + args[0] + "', '" + args[1] + "'. Usage: [[div(10,2){==} → 5";
            }
        }, 2);

        // Square Root
        register_tool("sqrt", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: sqrt() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[sqrt(25){==} → 5";
            }
            try {
                double a = std::stod(args[0]);
                if (a < 0) {
                    return "ERROR: sqrt() requires non-negative number, got " + args[0] + ". Cannot take square root of negative. Usage: [[sqrt(25){==} → 5";
                }
                double result = std::sqrt(a);
                if (result == std::floor(result)) {
                    return std::to_string(static_cast<long long>(result));
                }
                return std::to_string(result);
            } catch (...) {
                return "ERROR: sqrt() argument must be a number. Got: '" + args[0] + "'. Usage: [[sqrt(25){==} → 5";
            }
        }, 1);

        // Power
        register_tool("pow", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 2) {
                return "ERROR: pow() requires exactly 2 arguments (base, exponent), got " + std::to_string(args.size()) + ". Usage: [[pow(2,10){==} → 1024";
            }
            try {
                double base = std::stod(args[0]);
                double exp = std::stod(args[1]);
                double result = std::pow(base, exp);
                if (std::isnan(result) || std::isinf(result)) {
                    return "ERROR: pow(" + args[0] + "," + args[1] + ") resulted in invalid value. Usage: [[pow(2,10){==} → 1024";
                }
                if (result == std::floor(result)) {
                    return std::to_string(static_cast<long long>(result));
                }
                return std::to_string(result);
            } catch (...) {
                return "ERROR";
            }
        }, 2);

        // Linear equation solver: ax + b = c
        register_tool("solve_linear", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 3) return "ERROR";
            try {
                double a = std::stod(args[0]);
                double b = std::stod(args[1]);
                double c = std::stod(args[2]);
                if (a == 0) return "ERROR: Not a linear equation";
                double x = (c - b) / a;
                if (x == std::floor(x)) {
                    return std::to_string(static_cast<long long>(x));
                }
                return std::to_string(x);
            } catch (...) {
                return "ERROR";
            }
        }, 3);

        // Quadratic equation solver: ax² + bx + c = 0
        register_tool("solve_quadratic", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 3) return "ERROR";
            try {
                double a = std::stod(args[0]);
                double b = std::stod(args[1]);
                double c = std::stod(args[2]);
                if (a == 0) return "ERROR: Not a quadratic equation";
                double discriminant = b*b - 4*a*c;
                if (discriminant < 0) return "ERROR: No real solutions";
                double sqrt_disc = std::sqrt(discriminant);
                double x1 = (-b + sqrt_disc) / (2*a);
                double x2 = (-b - sqrt_disc) / (2*a);
                std::string result = std::to_string(x1) + ", " + std::to_string(x2);
                return result;
            } catch (...) {
                return "ERROR";
            }
        }, 3);

        // Multiplication (existing)
        register_tool("multiply", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 2) {
                return "ERROR: multiply() requires exactly 2 arguments, got " + std::to_string(args.size()) + ". Usage: [[multiply(7,8){==} → 56";
            }
            try {
                double a = std::stod(args[0]);
                double b = std::stod(args[1]);
                double result = a * b;
                if (std::isnan(result) || std::isinf(result)) {
                    return "ERROR: multiply(" + args[0] + "," + args[1] + ") resulted in invalid value. Usage: [[multiply(7,8){==} → 56";
                }
                if (result == std::floor(result)) {
                    return std::to_string(static_cast<long long>(result));
                }
                return std::to_string(result);
            } catch (...) {
                return "ERROR";
            }
        }, 2);

        // ===== INTEGER ARITHMETIC =====
        
        // Factorial
        register_tool("factorial", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: factorial() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[factorial(5){==} → 120";
            }
            try {
                long long n = std::stoll(args[0]);
                if (n < 0) {
                    return "ERROR: factorial() requires non-negative integer, got " + args[0] + ". Usage: [[factorial(5){==} → 120";
                }
                if (n > 20) {
                    return "ERROR: factorial() input too large (>20), got " + args[0] + ". Would cause overflow. Usage: [[factorial(5){==} → 120";
                }
                long long result = 1;
                for (int i = 2; i <= n; i++) result *= i;
                return std::to_string(result);
            } catch (...) {
                return "ERROR: factorial() argument must be an integer. Got: '" + args[0] + "'. Usage: [[factorial(5){==} → 120";
            }
        }, 1);

        // GCD (variable args)
        register_tool("gcd", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() < 2) {
                return "ERROR: gcd() requires at least 2 arguments, got " + std::to_string(args.size()) + ". Usage: [[gcd(48,18){==} → 6";
            }
            try {
                auto gcd_func = [](long long a, long long b) -> long long {
                    while (b) { long long t = b; b = a % b; a = t; }
                    return a;
                };
                long long result = std::stoll(args[0]);
                for (size_t i = 1; i < args.size(); i++) {
                    result = gcd_func(result, std::stoll(args[i]));
                }
                return std::to_string(result);
            } catch (...) {
                return "ERROR: gcd() arguments must be integers. Usage: [[gcd(48,18){==} → 6";
            }
        }, -1);

        // LCM (variable args)
        register_tool("lcm", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() < 2) {
                return "ERROR: lcm() requires at least 2 arguments, got " + std::to_string(args.size()) + ". Usage: [[lcm(12,15){==} → 60";
            }
            try {
                auto gcd_func = [](long long a, long long b) -> long long {
                    while (b) { long long t = b; b = a % b; a = t; }
                    return a;
                };
                auto lcm_func = [&](long long a, long long b) -> long long {
                    return (a / gcd_func(a, b)) * b;
                };
                long long result = std::stoll(args[0]);
                for (size_t i = 1; i < args.size(); i++) {
                    result = lcm_func(result, std::stoll(args[i]));
                }
                return std::to_string(result);
            } catch (...) {
                return "ERROR: lcm() arguments must be integers. Usage: [[lcm(12,15){==} → 60";
            }
        }, -1);

        // Integer square root
        register_tool("isqrt", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: isqrt() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[isqrt(25){==} → 5";
            }
            try {
                long long n = std::stoll(args[0]);
                if (n < 0) {
                    return "ERROR: isqrt() requires non-negative integer, got " + args[0] + ". Usage: [[isqrt(25){==} → 5";
                }
                long long result = static_cast<long long>(std::sqrt(n));
                return std::to_string(result);
            } catch (...) { return "ERROR"; }
        }, 1);

        // Combinations: C(n,k) = n! / (k! * (n-k)!)
        register_tool("comb", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 2) {
                return "ERROR: comb() requires exactly 2 arguments (n,k), got " + std::to_string(args.size()) + ". Usage: [[comb(5,2){==} → 10";
            }
            try {
                long long n = std::stoll(args[0]);
                long long k = std::stoll(args[1]);
                if (n < 0 || k < 0) {
                    return "ERROR: comb() requires non-negative integers. Got n=" + args[0] + ", k=" + args[1] + ". Usage: [[comb(5,2){==} → 10";
                }
                if (k > n) {
                    return "ERROR: comb() requires k ≤ n. Got n=" + args[0] + ", k=" + args[1] + ". Usage: [[comb(5,2){==} → 10";
                }
                if (n > 30) {
                    return "ERROR: comb() input too large (>30), got n=" + args[0] + ". Would cause overflow. Usage: [[comb(5,2){==} → 10";
                }
                if (k > n - k) k = n - k;
                long long result = 1;
                for (int i = 0; i < k; i++) {
                    result = result * (n - i) / (i + 1);
                }
                return std::to_string(result);
            } catch (...) { return "ERROR"; }
        }, 2);

        // Permutations: P(n,k) = n! / (n-k)!
        register_tool("perm", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 2) {
                return "ERROR: perm() requires exactly 2 arguments (n,k), got " + std::to_string(args.size()) + ". Usage: [[perm(5,2){==} → 20";
            }
            try {
                long long n = std::stoll(args[0]);
                long long k = std::stoll(args[1]);
                if (n < 0 || k < 0) {
                    return "ERROR: perm() requires non-negative integers. Got n=" + args[0] + ", k=" + args[1] + ". Usage: [[perm(5,2){==} → 20";
                }
                if (k > n) {
                    return "ERROR: perm() requires k ≤ n. Got n=" + args[0] + ", k=" + args[1] + ". Usage: [[perm(5,2){==} → 20";
                }
                if (n > 20) {
                    return "ERROR: perm() input too large (>20), got n=" + args[0] + ". Would cause overflow. Usage: [[perm(5,2){==} → 20";
                }
                long long result = 1;
                for (int i = 0; i < k; i++) {
                    result *= (n - i);
                }
                return std::to_string(result);
            } catch (...) { return "ERROR"; }
        }, 2);

        // ===== FLOATING POINT MANIPULATION =====
        
        // Ceiling
        register_tool("ceil", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: ceil() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[ceil(3.2){==} → 4";
            }
            try {
                double x = std::stod(args[0]);
                return std::to_string(std::ceil(x));
            } catch (...) {
                return "ERROR: ceil() argument must be a number. Got: '" + args[0] + "'. Usage: [[ceil(3.2){==} → 4";
            }
        }, 1);

        // Floor
        register_tool("floor", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: floor() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[floor(3.9){==} → 3";
            }
            try {
                double x = std::stod(args[0]);
                return std::to_string(std::floor(x));
            } catch (...) {
                return "ERROR: floor() argument must be a number. Got: '" + args[0] + "'. Usage: [[floor(3.9){==} → 3";
            }
        }, 1);

        // Absolute value
        register_tool("fabs", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: fabs() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[fabs(-5.3){==} → 5.3";
            }
            try {
                double x = std::stod(args[0]);
                return std::to_string(std::fabs(x));
            } catch (...) {
                return "ERROR: fabs() argument must be a number. Got: '" + args[0] + "'. Usage: [[fabs(-5.3){==} → 5.3";
            }
        }, 1);

        // Truncate
        register_tool("trunc", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: trunc() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[trunc(3.9){==} → 3";
            }
            try {
                double x = std::stod(args[0]);
                return std::to_string(std::trunc(x));
            } catch (...) {
                return "ERROR: trunc() argument must be a number. Got: '" + args[0] + "'. Usage: [[trunc(3.9){==} → 3";
            }
        }, 1);

        // Floating point modulo
        register_tool("fmod", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 2) {
                return "ERROR: fmod() requires exactly 2 arguments (x,y), got " + std::to_string(args.size()) + ". Usage: [[fmod(10,3){==} → 1";
            }
            try {
                double x = std::stod(args[0]);
                double y = std::stod(args[1]);
                if (y == 0) {
                    return "ERROR: fmod() division by zero (mod by 0). Usage: [[fmod(10,3){==} → 1";
                }
                return std::to_string(std::fmod(x, y));
            } catch (...) {
                return "ERROR: fmod() arguments must be numbers. Got: '" + args[0] + "', '" + args[1] + "'. Usage: [[fmod(10,3){==} → 1";
            }
        }, 2);

        // ===== EXPONENTIAL & LOGARITHMIC =====
        
        // Cube root
        register_tool("cbrt", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: cbrt() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[cbrt(27){==} → 3";
            }
            try {
                double x = std::stod(args[0]);
                return std::to_string(std::cbrt(x));
            } catch (...) {
                return "ERROR: cbrt() argument must be a number. Got: '" + args[0] + "'. Usage: [[cbrt(27){==} → 3";
            }
        }, 1);

        // e^x
        register_tool("exp", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: exp() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[exp(1){==} → 2.71828";
            }
            try {
                double x = std::stod(args[0]);
                double result = std::exp(x);
                if (std::isinf(result)) {
                    return "ERROR: exp() result too large (overflow). Input: '" + args[0] + "'. Usage: [[exp(1){==} → 2.71828";
                }
                return std::to_string(result);
            } catch (...) {
                return "ERROR: exp() argument must be a number. Got: '" + args[0] + "'. Usage: [[exp(1){==} → 2.71828";
            }
        }, 1);

        // 2^x
        register_tool("exp2", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: exp2() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[exp2(3){==} → 8";
            }
            try {
                double x = std::stod(args[0]);
                double result = std::exp2(x);
                if (std::isinf(result)) {
                    return "ERROR: exp2() result too large (overflow). Input: '" + args[0] + "'. Usage: [[exp2(3){==} → 8";
                }
                return std::to_string(result);
            } catch (...) {
                return "ERROR: exp2() argument must be a number. Got: '" + args[0] + "'. Usage: [[exp2(3){==} → 8";
            }
        }, 1);

        // e^x - 1
        register_tool("expm1", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: expm1() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[expm1(1){==} → 1.71828";
            }
            try {
                double x = std::stod(args[0]);
                double result = std::expm1(x);
                if (std::isinf(result)) {
                    return "ERROR: expm1() result too large (overflow). Input: '" + args[0] + "'. Usage: [[expm1(1){==} → 1.71828";
                }
                return std::to_string(result);
            } catch (...) {
                return "ERROR: expm1() argument must be a number. Got: '" + args[0] + "'. Usage: [[expm1(1){==} → 1.71828";
            }
        }, 1);

        // Natural logarithm (ln)
        register_tool("log", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: log() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[log(2.71828){==} → 1";
            }
            try {
                double x = std::stod(args[0]);
                if (x <= 0) {
                    return "ERROR: log() input must be positive (>0). Got: " + args[0] + ". Usage: [[log(2.71828){==} → 1";
                }
                return std::to_string(std::log(x));
            } catch (...) {
                return "ERROR: log() argument must be a number. Got: '" + args[0] + "'. Usage: [[log(2.71828){==} → 1";
            }
        }, 1);

        // Base-2 logarithm
        register_tool("log2", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: log2() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[log2(8){==} → 3";
            }
            try {
                double x = std::stod(args[0]);
                if (x <= 0) {
                    return "ERROR: log2() input must be positive (>0). Got: " + args[0] + ". Usage: [[log2(8){==} → 3";
                }
                return std::to_string(std::log2(x));
            } catch (...) {
                return "ERROR: log2() argument must be a number. Got: '" + args[0] + "'. Usage: [[log2(8){==} → 3";
            }
        }, 1);

        // Base-10 logarithm
        register_tool("log10", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: log10() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[log10(100){==} → 2";
            }
            try {
                double x = std::stod(args[0]);
                if (x <= 0) {
                    return "ERROR: log10() input must be positive (>0). Got: " + args[0] + ". Usage: [[log10(100){==} → 2";
                }
                return std::to_string(std::log10(x));
            } catch (...) {
                return "ERROR: log10() argument must be a number. Got: '" + args[0] + "'. Usage: [[log10(100){==} → 2";
            }
        }, 1);

        // ln(1+x)
        register_tool("log1p", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: log1p() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[log1p(1){==} → 0.693147";
            }
            try {
                double x = std::stod(args[0]);
                if (x <= -1) {
                    return "ERROR: log1p() input must be > -1. Got: " + args[0] + ". Usage: [[log1p(1){==} → 0.693147";
                }
                return std::to_string(std::log1p(x));
            } catch (...) {
                return "ERROR: log1p() argument must be a number. Got: '" + args[0] + "'. Usage: [[log1p(1){==} → 0.693147";
            }
        }, 1);

        // ===== TRIGONOMETRIC FUNCTIONS =====
        
        // Sine
        register_tool("sin", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: sin() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[sin(0){==} → 0";
            }
            try {
                double x = std::stod(args[0]);
                return std::to_string(std::sin(x));
            } catch (...) {
                return "ERROR: sin() argument must be a number (radians). Got: '" + args[0] + "'. Usage: [[sin(0){==} → 0";
            }
        }, 1);

        // Cosine
        register_tool("cos", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: cos() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[cos(0){==} → 1";
            }
            try {
                double x = std::stod(args[0]);
                return std::to_string(std::cos(x));
            } catch (...) {
                return "ERROR: cos() argument must be a number (radians). Got: '" + args[0] + "'. Usage: [[cos(0){==} → 1";
            }
        }, 1);

        // Tangent
        register_tool("tan", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: tan() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[tan(0){==} → 0";
            }
            try {
                double x = std::stod(args[0]);
                double result = std::tan(x);
                if (std::isinf(result)) {
                    return "ERROR: tan() undefined (asymptote). Input: '" + args[0] + "' (radians). Usage: [[tan(0){==} → 0";
                }
                return std::to_string(result);
            } catch (...) {
                return "ERROR: tan() argument must be a number (radians). Got: '" + args[0] + "'. Usage: [[tan(0){==} → 0";
            }
        }, 1);

        // Arcsine
        register_tool("asin", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: asin() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[asin(0){==} → 0";
            }
            try {
                double x = std::stod(args[0]);
                if (x < -1 || x > 1) {
                    return "ERROR: asin() input must be between -1 and 1. Got: " + args[0] + ". Usage: [[asin(0){==} → 0";
                }
                return std::to_string(std::asin(x));
            } catch (...) {
                return "ERROR: asin() argument must be a number. Got: '" + args[0] + "'. Usage: [[asin(0){==} → 0";
            }
        }, 1);

        // Arccosine
        register_tool("acos", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: acos() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[acos(1){==} → 0";
            }
            try {
                double x = std::stod(args[0]);
                if (x < -1 || x > 1) {
                    return "ERROR: acos() input must be between -1 and 1. Got: " + args[0] + ". Usage: [[acos(1){==} → 0";
                }
                return std::to_string(std::acos(x));
            } catch (...) {
                return "ERROR: acos() argument must be a number. Got: '" + args[0] + "'. Usage: [[acos(1){==} → 0";
            }
        }, 1);

        // Arctangent
        register_tool("atan", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: atan() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[atan(1){==} → 0.785398";
            }
            try {
                double x = std::stod(args[0]);
                return std::to_string(std::atan(x));
            } catch (...) {
                return "ERROR: atan() argument must be a number. Got: '" + args[0] + "'. Usage: [[atan(1){==} → 0.785398";
            }
        }, 1);

        // Arctangent2 (y, x)
        register_tool("atan2", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 2) {
                return "ERROR: atan2() requires exactly 2 arguments (y,x), got " + std::to_string(args.size()) + ". Usage: [[atan2(1,1){==} → 0.785398";
            }
            try {
                double y = std::stod(args[0]);
                double x = std::stod(args[1]);
                return std::to_string(std::atan2(y, x));
            } catch (...) {
                return "ERROR: atan2() arguments must be numbers. Got: '" + args[0] + "', '" + args[1] + "'. Usage: [[atan2(1,1){==} → 0.785398";
            }
        }, 2);

        // Degrees to radians
        register_tool("radians", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: radians() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[radians(180){==} → 3.14159";
            }
            try {
                double x = std::stod(args[0]);
                return std::to_string(x * M_PI / 180.0);
            } catch (...) {
                return "ERROR: radians() argument must be a number. Got: '" + args[0] + "'. Usage: [[radians(180){==} → 3.14159";
            }
        }, 1);

        // Radians to degrees
        register_tool("degrees", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: degrees() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[degrees(3.14159){==} → 180";
            }
            try {
                double x = std::stod(args[0]);
                return std::to_string(x * 180.0 / M_PI);
            } catch (...) {
                return "ERROR: degrees() argument must be a number. Got: '" + args[0] + "'. Usage: [[degrees(3.14159){==} → 180";
            }
        }, 1);

        // ===== HYPERBOLIC FUNCTIONS =====
        
        // Hyperbolic sine
        register_tool("sinh", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: sinh() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[sinh(0){==} → 0";
            }
            try {
                double x = std::stod(args[0]);
                double result = std::sinh(x);
                if (std::isinf(result)) {
                    return "ERROR: sinh() result too large (overflow). Input: '" + args[0] + "'. Usage: [[sinh(0){==} → 0";
                }
                return std::to_string(result);
            } catch (...) {
                return "ERROR: sinh() argument must be a number. Got: '" + args[0] + "'. Usage: [[sinh(0){==} → 0";
            }
        }, 1);

        // Hyperbolic cosine
        register_tool("cosh", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: cosh() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[cosh(0){==} → 1";
            }
            try {
                double x = std::stod(args[0]);
                double result = std::cosh(x);
                if (std::isinf(result)) {
                    return "ERROR: cosh() result too large (overflow). Input: '" + args[0] + "'. Usage: [[cosh(0){==} → 1";
                }
                return std::to_string(result);
            } catch (...) {
                return "ERROR: cosh() argument must be a number. Got: '" + args[0] + "'. Usage: [[cosh(0){==} → 1";
            }
        }, 1);

        // Hyperbolic tangent
        register_tool("tanh", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: tanh() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[tanh(0){==} → 0";
            }
            try {
                double x = std::stod(args[0]);
                return std::to_string(std::tanh(x));
            } catch (...) {
                return "ERROR: tanh() argument must be a number. Got: '" + args[0] + "'. Usage: [[tanh(0){==} → 0";
            }
        }, 1);

        // Inverse hyperbolic sine
        register_tool("asinh", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: asinh() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[asinh(0){==} → 0";
            }
            try {
                double x = std::stod(args[0]);
                return std::to_string(std::asinh(x));
            } catch (...) {
                return "ERROR: asinh() argument must be a number. Got: '" + args[0] + "'. Usage: [[asinh(0){==} → 0";
            }
        }, 1);

        // Inverse hyperbolic cosine
        register_tool("acosh", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: acosh() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[acosh(1){==} → 0";
            }
            try {
                double x = std::stod(args[0]);
                if (x < 1) {
                    return "ERROR: acosh() input must be >= 1. Got: " + args[0] + ". Usage: [[acosh(1){==} → 0";
                }
                return std::to_string(std::acosh(x));
            } catch (...) {
                return "ERROR: acosh() argument must be a number. Got: '" + args[0] + "'. Usage: [[acosh(1){==} → 0";
            }
        }, 1);

        // Inverse hyperbolic tangent
        register_tool("atanh", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: atanh() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[atanh(0){==} → 0";
            }
            try {
                double x = std::stod(args[0]);
                if (x <= -1 || x >= 1) {
                    return "ERROR: atanh() input must be between -1 and 1. Got: " + args[0] + ". Usage: [[atanh(0){==} → 0";
                }
                return std::to_string(std::atanh(x));
            } catch (...) {
                return "ERROR: atanh() argument must be a number. Got: '" + args[0] + "'. Usage: [[atanh(0){==} → 0";
            }
        }, 1);

        // ===== SPECIAL FUNCTIONS =====
        
        // Error function
        register_tool("erf", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: erf() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[erf(0){==} → 0";
            }
            try {
                double x = std::stod(args[0]);
                return std::to_string(std::erf(x));
            } catch (...) {
                return "ERROR: erf() argument must be a number. Got: '" + args[0] + "'. Usage: [[erf(0){==} → 0";
            }
        }, 1);

        // Complementary error function
        register_tool("erfc", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: erfc() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[erfc(0){==} → 1";
            }
            try {
                double x = std::stod(args[0]);
                return std::to_string(std::erfc(x));
            } catch (...) {
                return "ERROR: erfc() argument must be a number. Got: '" + args[0] + "'. Usage: [[erfc(0){==} → 1";
            }
        }, 1);

        // Gamma function
        register_tool("gamma", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: gamma() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[gamma(5){==} → 24";
            }
            try {
                double x = std::stod(args[0]);
                if (x <= 0 && std::floor(x) == x) {
                    return "ERROR: gamma() undefined for non-positive integers. Got: " + args[0] + ". Usage: [[gamma(5){==} → 24";
                }
                double result = std::tgamma(x);
                if (std::isinf(result)) {
                    return "ERROR: gamma() result too large (overflow). Input: '" + args[0] + "'. Usage: [[gamma(5){==} → 24";
                }
                return std::to_string(result);
            } catch (...) {
                return "ERROR: gamma() argument must be a number. Got: '" + args[0] + "'. Usage: [[gamma(5){==} → 24";
            }
        }, 1);

        // Log gamma function
        register_tool("lgamma", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: lgamma() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[lgamma(5){==} → 3.17805";
            }
            try {
                double x = std::stod(args[0]);
                if (x <= 0 && std::floor(x) == x) {
                    return "ERROR: lgamma() undefined for non-positive integers. Got: " + args[0] + ". Usage: [[lgamma(5){==} → 3.17805";
                }
                return std::to_string(std::lgamma(x));
            } catch (...) {
                return "ERROR: lgamma() argument must be a number. Got: '" + args[0] + "'. Usage: [[lgamma(5){==} → 3.17805";
            }
        }, 1);

        // ===== MATHEMATICAL CONSTANTS =====
        
        // Pi constant
        register_tool("pi", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 0) {
                return "ERROR: pi() takes no arguments, got " + std::to_string(args.size()) + ". Usage: [[pi(){==} → 3.14159";
            }
            return std::to_string(M_PI);
        }, 0);

        // Euler's number
        register_tool("e", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 0) {
                return "ERROR: e() takes no arguments, got " + std::to_string(args.size()) + ". Usage: [[e(){==} → 2.71828";
            }
            return std::to_string(M_E);
        }, 0);

        // Tau (2*pi)
        register_tool("tau", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 0) {
                return "ERROR: tau() takes no arguments, got " + std::to_string(args.size()) + ". Usage: [[tau(){==} → 6.28318";
            }
            return std::to_string(2.0 * M_PI);
        }, 0);

        // ===== DATE & TIME FUNCTIONS =====
        
        // Get current Unix timestamp (seconds since epoch)
        register_tool("now", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 0) {
                return "ERROR: now() takes no arguments, got " + std::to_string(args.size()) + ". Usage: [[now(){==} → 1640995200";
            }
            try {
                auto now = std::chrono::system_clock::now();
                auto epoch = now.time_since_epoch();
                auto seconds = std::chrono::duration_cast<std::chrono::seconds>(epoch).count();
                return std::to_string(seconds);
            } catch (...) {
                return "ERROR: now() failed to get current timestamp. Usage: [[now(){==} → 1640995200";
            }
        }, 0);

        // Get current date in YYYY-MM-DD format (UTC)
        register_tool("current_date", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 0) {
                return "ERROR: current_date() takes no arguments, got " + std::to_string(args.size()) + ". Usage: [[current_date(){==} → '2024-01-01'";
            }
            try {
                auto now = std::chrono::system_clock::now();
                std::time_t now_c = std::chrono::system_clock::to_time_t(now);
                std::tm* now_tm = std::gmtime(&now_c);
                std::ostringstream oss;
                oss << std::put_time(now_tm, "%Y-%m-%d");
                return oss.str();
            } catch (...) {
                return "ERROR: current_date() failed to get current date. Usage: [[current_date(){==} → '2024-01-01'";
            }
        }, 0);

        // Get current time in HH:MM:SS format (UTC)
        register_tool("current_time", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 0) {
                return "ERROR: current_time() takes no arguments, got " + std::to_string(args.size()) + ". Usage: [[current_time(){==} → '12:30:45'";
            }
            try {
                auto now = std::chrono::system_clock::now();
                std::time_t now_c = std::chrono::system_clock::to_time_t(now);
                std::tm* now_tm = std::gmtime(&now_c);
                std::ostringstream oss;
                oss << std::put_time(now_tm, "%H:%M:%S");
                return oss.str();
            } catch (...) {
                return "ERROR: current_time() failed to get current time. Usage: [[current_time(){==} → '12:30:45'";
            }
        }, 0);

        // Get current datetime in ISO 8601 format (UTC)
        register_tool("current_datetime", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 0) {
                return "ERROR: current_datetime() takes no arguments, got " + std::to_string(args.size()) + ". Usage: [[current_datetime(){==} → '2024-01-01 12:30:45 UTC'";
            }
            try {
                auto now = std::chrono::system_clock::now();
                std::time_t now_c = std::chrono::system_clock::to_time_t(now);
                std::tm* now_tm = std::gmtime(&now_c);
                std::ostringstream oss;
                oss << std::put_time(now_tm, "%Y-%m-%d %H:%M:%S UTC");
                return oss.str();
            } catch (...) {
                return "ERROR: current_datetime() failed to get current datetime. Usage: [[current_datetime(){==} → '2024-01-01 12:30:45 UTC'";
            }
        }, 0);

        // Get current datetime in local timezone
        register_tool("local_datetime", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 0) {
                return "ERROR: local_datetime() takes no arguments, got " + std::to_string(args.size()) + ". Usage: [[local_datetime(){==} → '2024-01-01 12:30:45 (UTC+0)'";
            }
            try {
                auto now = std::chrono::system_clock::now();
                std::time_t now_c = std::chrono::system_clock::to_time_t(now);
                std::tm* local_tm = std::localtime(&now_c);
                std::ostringstream oss;
                oss << std::put_time(local_tm, "%Y-%m-%d %H:%M:%S");
                
                // Get timezone offset
                std::tm* utc_tm = std::gmtime(&now_c);
                int offset_hours = local_tm->tm_hour - utc_tm->tm_hour;
                int offset_mins = local_tm->tm_min - utc_tm->tm_min;
                
                // Handle day boundary crossings
                if (local_tm->tm_mday != utc_tm->tm_mday) {
                    if (local_tm->tm_mday > utc_tm->tm_mday || 
                        (local_tm->tm_mday == 1 && utc_tm->tm_mday > 20)) {
                        offset_hours += 24;
                    } else {
                        offset_hours -= 24;
                    }
                }
                
                int total_offset = offset_hours;
                if (offset_mins != 0) {
                    total_offset = offset_hours >= 0 ? offset_hours : offset_hours;
                }
                
                oss << " (UTC";
                if (total_offset >= 0) oss << "+";
                oss << total_offset << ")";
                
                return oss.str();
            } catch (...) {
                return "ERROR: local_datetime() failed to get local datetime. Usage: [[local_datetime(){==} → '2024-01-01 12:30:45 (UTC+0)'";
            }
        }, 0);

        // Get system timezone offset (hours from UTC)
        register_tool("system_timezone_offset", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 0) {
                return "ERROR: system_timezone_offset() takes no arguments, got " + std::to_string(args.size()) + ". Usage: [[system_timezone_offset(){==} → '0'";
            }
            try {
                auto now = std::chrono::system_clock::now();
                std::time_t now_c = std::chrono::system_clock::to_time_t(now);
                std::tm* local_tm = std::localtime(&now_c);
                std::tm* utc_tm = std::gmtime(&now_c);
                
                int offset_hours = local_tm->tm_hour - utc_tm->tm_hour;
                
                // Handle day boundary crossings
                if (local_tm->tm_mday != utc_tm->tm_mday) {
                    if (local_tm->tm_mday > utc_tm->tm_mday || 
                        (local_tm->tm_mday == 1 && utc_tm->tm_mday > 20)) {
                        offset_hours += 24;
                    } else {
                        offset_hours -= 24;
                    }
                }
                
                return std::to_string(offset_hours);
            } catch (...) {
                return "ERROR: system_timezone_offset() failed to get timezone offset. Usage: [[system_timezone_offset(){==} → '0'";
            }
        }, 0);

        // Add days to a Unix timestamp
        register_tool("add_days", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 2) {
                return "ERROR: add_days() requires exactly 2 arguments (timestamp, days), got " + std::to_string(args.size()) + ". Usage: [[add_days(1640995200,7){==} → 1641600000";
            }
            try {
                long long timestamp = std::stoll(args[0]);
                long long days = std::stoll(args[1]);
                if (days < LLONG_MIN / 86400 || days > LLONG_MAX / 86400) {
                    return "ERROR: add_days() days value too large, got " + args[1] + ". Usage: [[add_days(1640995200,7){==} → 1641600000";
                }
                long long result = timestamp + (days * 86400LL); // 86400 seconds per day
                return std::to_string(result);
            } catch (const std::out_of_range&) {
                return "ERROR: add_days() arguments out of range. Got: '" + args[0] + "', '" + args[1] + "'. Usage: [[add_days(1640995200,7){==} → 1641600000";
            } catch (const std::invalid_argument&) {
                return "ERROR: add_days() arguments must be numbers (timestamp, days). Got: '" + args[0] + "', '" + args[1] + "'. Usage: [[add_days(1640995200,7){==} → 1641600000";
            }
        }, 2);

        // Add hours to a Unix timestamp
        register_tool("add_hours", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 2) {
                return "ERROR: add_hours() requires exactly 2 arguments (timestamp, hours), got " + std::to_string(args.size()) + ". Usage: [[add_hours(1640995200,24){==} → 1641081600";
            }
            try {
                long long timestamp = std::stoll(args[0]);
                long long hours = std::stoll(args[1]);
                if (hours < LLONG_MIN / 3600 || hours > LLONG_MAX / 3600) {
                    return "ERROR: add_hours() hours value too large, got " + args[1] + ". Usage: [[add_hours(1640995200,24){==} → 1641081600";
                }
                long long result = timestamp + (hours * 3600LL); // 3600 seconds per hour
                return std::to_string(result);
            } catch (const std::out_of_range&) {
                return "ERROR: add_hours() arguments out of range. Got: '" + args[0] + "', '" + args[1] + "'. Usage: [[add_hours(1640995200,24){==} → 1641081600";
            } catch (const std::invalid_argument&) {
                return "ERROR: add_hours() arguments must be numbers (timestamp, hours). Got: '" + args[0] + "', '" + args[1] + "'. Usage: [[add_hours(1640995200,24){==} → 1641081600";
            }
        }, 2);

        // Add minutes to a Unix timestamp
        register_tool("add_minutes", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 2) {
                return "ERROR: add_minutes() requires exactly 2 arguments (timestamp, minutes), got " + std::to_string(args.size()) + ". Usage: [[add_minutes(1640995200,60){==} → 1640995260";
            }
            try {
                long long timestamp = std::stoll(args[0]);
                long long minutes = std::stoll(args[1]);
                if (minutes < LLONG_MIN / 60 || minutes > LLONG_MAX / 60) {
                    return "ERROR: add_minutes() minutes value too large, got " + args[1] + ". Usage: [[add_minutes(1640995200,60){==} → 1640995260";
                }
                long long result = timestamp + (minutes * 60LL);
                return std::to_string(result);
            } catch (const std::out_of_range&) {
                return "ERROR: add_minutes() arguments out of range. Got: '" + args[0] + "', '" + args[1] + "'. Usage: [[add_minutes(1640995200,60){==} → 1640995260";
            } catch (const std::invalid_argument&) {
                return "ERROR: add_minutes() arguments must be numbers (timestamp, minutes). Got: '" + args[0] + "', '" + args[1] + "'. Usage: [[add_minutes(1640995200,60){==} → 1640995260";
            }
        }, 2);

        // Calculate difference in days between two timestamps
        register_tool("diff_days", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 2) {
                return "ERROR: diff_days() requires exactly 2 arguments (ts1, ts2), got " + std::to_string(args.size()) + ". Usage: [[diff_days(1640995200,1641600000){==} → 7";
            }
            try {
                long long ts1 = std::stoll(args[0]);
                long long ts2 = std::stoll(args[1]);
                long long diff = (ts2 - ts1) / 86400LL;
                return std::to_string(diff);
            } catch (...) {
                return "ERROR: diff_days() arguments must be timestamps. Got: '" + args[0] + "', '" + args[1] + "'. Usage: [[diff_days(1640995200,1641600000){==} → 7";
            }
        }, 2);

        // Calculate difference in hours between two timestamps
        register_tool("diff_hours", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 2) {
                return "ERROR: diff_hours() requires exactly 2 arguments (ts1, ts2), got " + std::to_string(args.size()) + ". Usage: [[diff_hours(1640995200,1641081600){==} → 24";
            }
            try {
                long long ts1 = std::stoll(args[0]);
                long long ts2 = std::stoll(args[1]);
                long long diff = (ts2 - ts1) / 3600LL;
                return std::to_string(diff);
            } catch (...) {
                return "ERROR: diff_hours() arguments must be timestamps. Got: '" + args[0] + "', '" + args[1] + "'. Usage: [[diff_hours(1640995200,1641081600){==} → 24";
            }
        }, 2);

        // Convert timestamp to readable date string
        register_tool("timestamp_to_date", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: timestamp_to_date() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[timestamp_to_date(1640995200){==} → '2022-01-01 00:00:00 UTC'";
            }
            try {
                long long timestamp = std::stoll(args[0]);
                std::time_t time = static_cast<std::time_t>(timestamp);
                std::tm* tm_utc = std::gmtime(&time);
                std::ostringstream oss;
                oss << std::put_time(tm_utc, "%Y-%m-%d %H:%M:%S UTC");
                return oss.str();
            } catch (...) {
                return "ERROR: timestamp_to_date() argument must be a timestamp. Got: '" + args[0] + "'. Usage: [[timestamp_to_date(1640995200){==} → '2022-01-01 00:00:00 UTC'";
            }
        }, 1);

        // Get day of week from timestamp (0=Sunday, 6=Saturday)
        register_tool("day_of_week", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: day_of_week() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[day_of_week(1640995200){==} → 'Saturday'";
            }
            try {
                long long timestamp = std::stoll(args[0]);
                std::time_t time = static_cast<std::time_t>(timestamp);
                std::tm* tm_utc = std::gmtime(&time);
                const char* days[] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
                return days[tm_utc->tm_wday];
            } catch (...) {
                return "ERROR: day_of_week() argument must be a timestamp. Got: '" + args[0] + "'. Usage: [[day_of_week(1640995200){==} → 'Saturday'";
            }
        }, 1);

        // Convert time between timezones (offset in hours from UTC)
        // Args: timestamp, from_offset, to_offset
        // Example: timezone_convert(now, 3, 0) converts from UTC+3 (Istanbul) to UTC (London winter)
        register_tool("timezone_convert", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 3) {
                return "ERROR: timezone_convert() requires exactly 3 arguments (timestamp, from_offset, to_offset), got " + std::to_string(args.size()) + ". Usage: [[timezone_convert(1640995200,3,0){==} → 1640988000";
            }
            try {
                long long timestamp = std::stoll(args[0]);
                long long from_offset = std::stoll(args[1]); // hours from UTC
                long long to_offset = std::stoll(args[2]);   // hours from UTC
                
                if (from_offset < LLONG_MIN / 3600 || from_offset > LLONG_MAX / 3600 ||
                    to_offset < LLONG_MIN / 3600 || to_offset > LLONG_MAX / 3600) {
                    return "ERROR: timezone_convert() offset values too large. Got: '" + args[1] + "', '" + args[2] + "'. Usage: [[timezone_convert(1640995200,3,0){==} → 1640988000";
                }
                
                // Adjust timestamp from source timezone to UTC, then to target timezone
                long long utc_timestamp = timestamp - (from_offset * 3600LL);
                long long result = utc_timestamp + (to_offset * 3600LL);
                
                return std::to_string(result);
            } catch (...) {
                return "ERROR: timezone_convert() arguments must be numbers (timestamp, from_offset, to_offset). Got: '" + args[0] + "', '" + args[1] + "', '" + args[2] + "'. Usage: [[timezone_convert(1640995200,3,0){==} → 1640988000";
            }
        }, 3);

        // Get hour from timestamp in a given timezone offset
        register_tool("get_hour_tz", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 2) {
                return "ERROR: get_hour_tz() requires exactly 2 arguments (timestamp, offset), got " + std::to_string(args.size()) + ". Usage: [[get_hour_tz(1640995200,3){==} → 3";
            }
            try {
                long long timestamp = std::stoll(args[0]);
                long long tz_offset = std::stoll(args[1]); // hours from UTC
                
                if (tz_offset < LLONG_MIN / 3600 || tz_offset > LLONG_MAX / 3600) {
                    return "ERROR: get_hour_tz() timezone offset too large, got " + args[1] + ". Usage: [[get_hour_tz(1640995200,3){==} → 3";
                }
                
                long long adjusted = timestamp + (tz_offset * 3600LL);
                std::time_t time = static_cast<std::time_t>(adjusted);
                std::tm* tm_utc = std::gmtime(&time);
                
                return std::to_string(tm_utc->tm_hour);
            } catch (const std::out_of_range&) {
                return "ERROR: get_hour_tz() arguments out of range. Got: '" + args[0] + "', '" + args[1] + "'. Usage: [[get_hour_tz(1640995200,3){==} → 3";
            } catch (const std::invalid_argument&) {
                return "ERROR: get_hour_tz() arguments must be numbers (timestamp, offset). Got: '" + args[0] + "', '" + args[1] + "'. Usage: [[get_hour_tz(1640995200,3){==} → 3";
            }
        }, 2);

        // Get formatted datetime in a specific timezone
        register_tool("datetime_in_tz", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 2) {
                return "ERROR: datetime_in_tz() requires exactly 2 arguments (timestamp, offset), got " + std::to_string(args.size()) + ". Usage: [[datetime_in_tz(1640995200,3){==} → '2022-01-01 03:00:00 (UTC+3)'";
            }
            try {
                long long timestamp = std::stoll(args[0]);
                long long tz_offset = std::stoll(args[1]); // hours from UTC
                
                if (tz_offset < LLONG_MIN / 3600 || tz_offset > LLONG_MAX / 3600) {
                    return "ERROR: datetime_in_tz() timezone offset too large, got " + args[1] + ". Usage: [[datetime_in_tz(1640995200,3){==} → '2022-01-01 03:00:00 (UTC+3)'";
                }
                
                long long adjusted = timestamp + (tz_offset * 3600LL);
                std::time_t time = static_cast<std::time_t>(adjusted);
                std::tm* tm_utc = std::gmtime(&time);
                
                std::ostringstream oss;
                oss << std::put_time(tm_utc, "%Y-%m-%d %H:%M:%S (UTC");
                if (tz_offset >= 0) oss << "+";
                oss << tz_offset << ")";
                return oss.str();
            } catch (const std::out_of_range&) {
                return "ERROR: datetime_in_tz() arguments out of range. Got: '" + args[0] + "', '" + args[1] + "'. Usage: [[datetime_in_tz(1640995200,3){==} → '2022-01-01 03:00:00 (UTC+3)'";
            } catch (const std::invalid_argument&) {
                return "ERROR: datetime_in_tz() arguments must be numbers (timestamp, offset). Got: '" + args[0] + "', '" + args[1] + "'. Usage: [[datetime_in_tz(1640995200,3){==} → '2022-01-01 03:00:00 (UTC+3)'";
            }
        }, 2);

        // Create timestamp from date components (year, month, day, hour, minute, second)
        register_tool("make_timestamp", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 6) {
                return "ERROR: make_timestamp() requires exactly 6 arguments (y,m,d,h,m,s), got " + std::to_string(args.size()) + ". Usage: [[make_timestamp(2022,1,1,0,0,0){==} → 1640995200";
            }
            try {
                std::tm time_info = {};
                long long year = std::stoll(args[0]);
                long long month = std::stoll(args[1]);
                long long day = std::stoll(args[2]);
                long long hour = std::stoll(args[3]);
                long long minute = std::stoll(args[4]);
                long long second = std::stoll(args[5]);
                
                // Validate ranges
                if (year < 1970 || year > 2038) {
                    return "ERROR: make_timestamp() year must be between 1970-2038, got " + args[0] + ". Usage: [[make_timestamp(2022,1,1,0,0,0){==} → 1640995200";
                }
                if (month < 1 || month > 12) {
                    return "ERROR: make_timestamp() month must be 1-12, got " + args[1] + ". Usage: [[make_timestamp(2022,1,1,0,0,0){==} → 1640995200";
                }
                if (day < 1 || day > 31) {
                    return "ERROR: make_timestamp() day must be 1-31, got " + args[2] + ". Usage: [[make_timestamp(2022,1,1,0,0,0){==} → 1640995200";
                }
                if (hour < 0 || hour > 23) {
                    return "ERROR: make_timestamp() hour must be 0-23, got " + args[3] + ". Usage: [[make_timestamp(2022,1,1,0,0,0){==} → 1640995200";
                }
                if (minute < 0 || minute > 59) {
                    return "ERROR: make_timestamp() minute must be 0-59, got " + args[4] + ". Usage: [[make_timestamp(2022,1,1,0,0,0){==} → 1640995200";
                }
                if (second < 0 || second > 59) {
                    return "ERROR: make_timestamp() second must be 0-59, got " + args[5] + ". Usage: [[make_timestamp(2022,1,1,0,0,0){==} → 1640995200";
                }
                
                time_info.tm_year = static_cast<int>(year) - 1900;
                time_info.tm_mon = static_cast<int>(month) - 1;
                time_info.tm_mday = static_cast<int>(day);
                time_info.tm_hour = static_cast<int>(hour);
                time_info.tm_min = static_cast<int>(minute);
                time_info.tm_sec = static_cast<int>(second);
                
                std::time_t timestamp = timegm(&time_info);
                return std::to_string(timestamp);
            } catch (...) {
                return "ERROR: make_timestamp() arguments must be numbers (y,m,d,h,m,s). Got: '" + args[0] + "', '" + args[1] + "', '" + args[2] + "', '" + args[3] + "', '" + args[4] + "', '" + args[5] + "'. Usage: [[make_timestamp(2022,1,1,0,0,0){==} → 1640995200";
            }
        }, 6);

        // ===== STRING & ENCODING UTILITIES =====
        
        // Base64 encode
        register_tool("base64_encode", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: base64_encode() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[base64_encode('Hello'){==} → 'SGVsbG8='";
            }
            try {
                return base64::encode(args[0]);
            } catch (const std::exception& e) {
                return "ERROR: base64_encode() failed: " + std::string(e.what()) + ". Usage: [[base64_encode('Hello'){==} → 'SGVsbG8='";
            }
        }, 1);

        // Base64 decode
        register_tool("base64_decode", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: base64_decode() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[base64_decode('SGVsbG8='){==} → 'Hello'";
            }
            try {
                return base64::decode(args[0]);
            } catch (const base64_error& e) {
                return "ERROR: base64_decode() invalid input: " + std::string(e.what()) + ". Input must be valid base64. Usage: [[base64_decode('SGVsbG8='){==} → 'Hello'";
            } catch (const std::exception& e) {
                return "ERROR: base64_decode() failed: " + std::string(e.what()) + ". Usage: [[base64_decode('SGVsbG8='){==} → 'Hello'";
            }
        }, 1);

        // String length
        register_tool("strlen", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: strlen() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[strlen('Hello'){==} → 5";
            }
            return std::to_string(args[0].length());
        }, 1);

        // Substring (string, start, length)
        register_tool("substring", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 3) {
                return "ERROR: substring() requires exactly 3 arguments (string, start, length), got " + std::to_string(args.size()) + ". Usage: [[substring('Hello',0,3){==} → 'Hel'";
            }
            try {
                const std::string& str = args[0];
                size_t start = std::stoul(args[1]);
                size_t length = std::stoul(args[2]);
                if (start >= str.length()) {
                    return "ERROR: substring() start position " + args[1] + " is beyond string length " + std::to_string(str.length()) + ". Usage: [[substring('Hello',0,3){==} → 'Hel'";
                }
                return str.substr(start, length);
            } catch (...) {
                return "ERROR: substring() start and length must be numbers. Usage: [[substring('Hello',0,3){==} → 'Hel'";
            }
        }, 3);

        // String replace (string, old, new)
        register_tool("str_replace", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 3) {
                return "ERROR: str_replace() requires exactly 3 arguments (string, old, new), got " + std::to_string(args.size()) + ". Usage: [[str_replace('Hello','l','L'){==} → 'HeLLo'";
            }
            try {
                std::string result = args[0];
                const std::string& old_str = args[1];
                const std::string& new_str = args[2];
                
                size_t pos = 0;
                while ((pos = result.find(old_str, pos)) != std::string::npos) {
                    result.replace(pos, old_str.length(), new_str);
                    pos += new_str.length();
                }
                return result;
            } catch (...) { return "ERROR"; }
        }, 3);

        // Uppercase
        register_tool("uppercase", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: uppercase() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[uppercase('hello'){==} → 'HELLO'. Tip: Use quotes for strings with spaces.";
            }
            std::string result = args[0];
            std::transform(result.begin(), result.end(), result.begin(), ::toupper);
            return result;
        }, 1);

        // Lowercase
        register_tool("lowercase", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) {
                return "ERROR: lowercase() requires exactly 1 argument, got " + std::to_string(args.size()) + ". Usage: [[lowercase('HELLO'){==} → 'hello'. Tip: Use quotes for strings with spaces.";
            }
            std::string result = args[0];
            std::transform(result.begin(), result.end(), result.begin(), ::tolower);
            return result;
        }, 1);

        // String contains (haystack, needle) - returns "true" or "false"
        register_tool("str_contains", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 2) {
                return "ERROR: str_contains() requires exactly 2 arguments (string, substring), got " + std::to_string(args.size()) + ". Usage: [[str_contains('Hello, World','World'){==} → 'true'. Tip: Use quotes if string has commas/spaces.";
            }
            return args[0].find(args[1]) != std::string::npos ? "true" : "false";
        }, 2);

        // String starts with
        register_tool("str_startswith", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 2) {
                return "ERROR: str_startswith() requires exactly 2 arguments (string, prefix), got " + std::to_string(args.size()) + ". Usage: [[str_startswith('Hello','Hel'){==} → 'true'. Tip: Use quotes for strings.";
            }
            const std::string& str = args[0];
            const std::string& prefix = args[1];
            return str.size() >= prefix.size() && 
                   str.compare(0, prefix.size(), prefix) == 0 ? "true" : "false";
        }, 2);

        // String ends with
        register_tool("str_endswith", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 2) {
                return "ERROR: str_endswith() requires exactly 2 arguments (string, suffix), got " + std::to_string(args.size()) + ". Usage: [[str_endswith('Hello','lo'){==} → 'true'. Tip: Use quotes for strings.";
            }
            const std::string& str = args[0];
            const std::string& suffix = args[1];
            return str.size() >= suffix.size() && 
                   str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0 ? "true" : "false";
        }, 2);

        // URL encode
        register_tool("url_encode", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) return "ERROR";
            try {
                std::string result;
                const std::string& input = args[0];
                
                for (unsigned char c : input) {
                    if (isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') {
                        result += c;
                    } else {
                        char hex[4];
                        snprintf(hex, sizeof(hex), "%%%02X", c);
                        result += hex;
                    }
                }
                return result;
            } catch (...) { return "ERROR"; }
        }, 1);

        // URL decode
        register_tool("url_decode", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) return "ERROR";
            try {
                std::string result;
                const std::string& input = args[0];
                
                for (size_t i = 0; i < input.length(); i++) {
                    if (input[i] == '%' && i + 2 < input.length()) {
                        unsigned int value;
                        sscanf(input.substr(i + 1, 2).c_str(), "%x", &value);
                        result += static_cast<char>(value);
                        i += 2;
                    } else if (input[i] == '+') {
                        result += ' ';
                    } else {
                        result += input[i];
                    }
                }
                return result;
            } catch (...) { return "ERROR"; }
        }, 1);

        // Simple hash (djb2 algorithm) - for basic string hashing
        register_tool("hash_string", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) return "ERROR";
            unsigned long hash = 5381;
            for (char c : args[0]) {
                hash = ((hash << 5) + hash) + static_cast<unsigned char>(c);
            }
            return std::to_string(hash);
        }, 1);

        // Random integer (min, max inclusive)
        register_tool("random_int", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 2) return "ERROR: random_int() requires exactly 2 arguments (min, max), got " + std::to_string(args.size()) + ". Usage: [[random_int(1,100){==} → 42";
            try {
                long long min = std::stoll(args[0]);
                long long max = std::stoll(args[1]);
                if (min > max) return "ERROR: random_int() min > max. Got min=" + args[0] + ", max=" + args[1] + ". Usage: [[random_int(1,100){==} → 42";
                
                static std::random_device rd;
                static std::mt19937_64 gen(rd());
                std::uniform_int_distribution<long long> dis(min, max);
                
                return std::to_string(dis(gen));
            } catch (const std::out_of_range&) {
                return "ERROR: random_int() arguments out of range. Values must be within 64-bit range. Got: '" + args[0] + "', '" + args[1] + "'. Usage: [[random_int(1,100){==} → 42";
            } catch (const std::invalid_argument&) {
                return "ERROR: random_int() arguments must be integers. Got: '" + args[0] + "', '" + args[1] + "'. Usage: [[random_int(1,100){==} → 42";
            } catch (...) {
                return "ERROR: random_int() failed with arguments: '" + args[0] + "', '" + args[1] + "'. Usage: [[random_int(1,100){==} → 42";
            }
        }, 2);

        // Generate UUID (simplified v4)
        register_tool("uuid", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 0) return "ERROR";
            try {
                static std::random_device rd;
                static std::mt19937 gen(rd());
                static std::uniform_int_distribution<> dis(0, 15);
                static std::uniform_int_distribution<> dis2(8, 11);
                
                std::stringstream ss;
                ss << std::hex;
                
                for (int i = 0; i < 8; i++) ss << dis(gen);
                ss << "-";
                for (int i = 0; i < 4; i++) ss << dis(gen);
                ss << "-4"; // version 4
                for (int i = 0; i < 3; i++) ss << dis(gen);
                ss << "-";
                ss << dis2(gen); // variant
                for (int i = 0; i < 3; i++) ss << dis(gen);
                ss << "-";
                for (int i = 0; i < 12; i++) ss << dis(gen);
                
                return ss.str();
            } catch (...) {
                return "ERROR: uuid() failed to generate unique ID. Usage: [[uuid(){==} → '123e4567-e89b-12d3-a456-426614174000'";
            }
        }, 0);

        // Regex match (returns "true" or "false")
        register_tool("regex_match", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 2) {
                return "ERROR: regex_match() requires exactly 2 arguments (string, pattern), got " + std::to_string(args.size()) + ". Usage: [[regex_match('hello','^h.*o$'){==} → 'true'";
            }
            try {
                std::regex pattern(args[1]);
                return std::regex_search(args[0], pattern) ? "true" : "false";
            } catch (const std::regex_error& e) {
                return "ERROR: regex_match() invalid pattern: '" + args[1] + "' - " + e.what() + ". Usage: [[regex_match('hello','^h.*o$'){==} → 'true'";
            } catch (...) {
                return "ERROR: regex_match() failed. Usage: [[regex_match('hello','^h.*o$'){==} → 'true'";
            }
        }, 2);

        // Split string by delimiter (returns count of parts)
        register_tool("str_split_count", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 2) {
                return "ERROR: str_split_count() requires exactly 2 arguments (string, delimiter), got " + std::to_string(args.size()) + ". Usage: [[str_split_count('a,b,c',','){==} → 3";
            }
            try {
                const std::string& str = args[0];
                const std::string& delim = args[1];
                
                if (str.empty()) return "0";
                if (delim.empty()) return "1";
                
                size_t count = 1;
                size_t pos = 0;
                while ((pos = str.find(delim, pos)) != std::string::npos) {
                    count++;
                    pos += delim.length();
                }
                return std::to_string(count);
            } catch (...) {
                return "ERROR: str_split_count() failed. Usage: [[str_split_count('a,b,c',','){==} → 3";
            }
        }, 2);

        // Count occurrences of a character/substring in a string
        register_tool("str_count_char", [](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 2) {
                return "ERROR: str_count_char() requires exactly 2 arguments (string, character), got " + std::to_string(args.size()) + ". Usage: [[str_count_char('Hello','l'){==} → 2. Tip: Use quotes for single chars like 'p'";
            }
            try {
                const std::string& str = args[0];
                const std::string& target = args[1];
                
                if (target.empty()) {
                    return "ERROR: str_count_char() target character cannot be empty. Usage: [[str_count_char('test','t'){==} → 2";
                }
                
                if (str.empty()) return "0";
                
                size_t count = 0;
                size_t pos = 0;
                while ((pos = str.find(target, pos)) != std::string::npos) {
                    count++;
                    pos += target.length();
                }
                return std::to_string(count);
            } catch (...) {
                return "ERROR: str_count_char() failed. Usage: [[str_count_char('Hello','l'){==} → 2. Remember: use quotes for single characters!";
            }
        }, 2);

        // MEMORY MANAGEMENT - Persistent user information storage
        // Memory file path (max 5KB)
        const std::string memory_file = "llama_memory.txt";
        const size_t MAX_MEMORY_SIZE = 5 * 1024; // 5KB

        // Read entire memory contents
        register_tool("memory_read", [memory_file](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 0) return "ERROR";
            try {
                std::ifstream file(memory_file);
                if (!file.is_open()) return "[Empty - No memory saved yet]";
                
                std::stringstream buffer;
                buffer << file.rdbuf();
                std::string content = buffer.str();
                
                if (content.empty()) return "[Empty - No memory saved yet]";
                return content;
            } catch (...) { return "ERROR"; }
        }, 0);

        // Save/overwrite entire memory (replaces all content)
        register_tool("memory_save", [memory_file, MAX_MEMORY_SIZE](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) return "ERROR";
            try {
                const std::string& content = args[0];
                
                // Check size limit
                if (content.size() > MAX_MEMORY_SIZE) {
                    return "ERROR: Memory size exceeds 5KB limit";
                }
                
                std::ofstream file(memory_file, std::ios::trunc);
                if (!file.is_open()) return "ERROR: Cannot write to memory file";
                
                file << content;
                file.close();
                return "Memory saved successfully";
            } catch (...) { return "ERROR"; }
        }, 1);

        // Append text to memory
        register_tool("memory_append", [memory_file, MAX_MEMORY_SIZE](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) return "ERROR";
            try {
                const std::string& new_content = args[0];
                
                // Read current content
                std::string current_content;
                std::ifstream infile(memory_file);
                if (infile.is_open()) {
                    std::stringstream buffer;
                    buffer << infile.rdbuf();
                    current_content = buffer.str();
                    infile.close();
                }
                
                // Add newline if current content doesn't end with one
                if (!current_content.empty() && current_content.back() != '\n') {
                    current_content += "\n";
                }
                
                current_content += new_content;
                
                // Check size limit
                if (current_content.size() > MAX_MEMORY_SIZE) {
                    return "ERROR: Memory would exceed 5KB limit";
                }
                
                // Write back
                std::ofstream outfile(memory_file, std::ios::trunc);
                if (!outfile.is_open()) return "ERROR: Cannot write to memory file";
                
                outfile << current_content;
                outfile.close();
                return "Content appended to memory";
            } catch (...) { return "ERROR"; }
        }, 1);

        // Clear all memory
        register_tool("memory_clear", [memory_file](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 0) return "ERROR";
            try {
                std::ofstream file(memory_file, std::ios::trunc);
                if (!file.is_open()) return "ERROR: Cannot write to memory file";
                file.close();
                return "Memory cleared successfully";
            } catch (...) { return "ERROR"; }
        }, 0);

        // Replace text in memory
        register_tool("memory_replace", [memory_file, MAX_MEMORY_SIZE](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 2) return "ERROR";
            try {
                const std::string& old_text = args[0];
                const std::string& new_text = args[1];
                
                // Read current content
                std::ifstream infile(memory_file);
                if (!infile.is_open()) return "ERROR: No memory file found";
                
                std::stringstream buffer;
                buffer << infile.rdbuf();
                std::string content = buffer.str();
                infile.close();
                
                // Find and replace
                size_t pos = content.find(old_text);
                if (pos == std::string::npos) {
                    return "ERROR: Text not found in memory";
                }
                
                content.replace(pos, old_text.length(), new_text);
                
                // Check size limit
                if (content.size() > MAX_MEMORY_SIZE) {
                    return "ERROR: Memory would exceed 5KB limit";
                }
                
                // Write back
                std::ofstream outfile(memory_file, std::ios::trunc);
                if (!outfile.is_open()) return "ERROR: Cannot write to memory file";
                
                outfile << content;
                outfile.close();
                return "Memory updated successfully";
            } catch (...) { return "ERROR"; }
        }, 2);

        // Remove specific line from memory (1-indexed)
        register_tool("memory_remove_line", [memory_file](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 1) return "ERROR";
            try {
                long long line_num = std::stoll(args[0]);
                if (line_num < 1) return "ERROR: Line number must be >= 1";
                if (line_num > INT_MAX) return "ERROR: Line number too large, got " + args[0];
                
                // Read all lines
                std::ifstream infile(memory_file);
                if (!infile.is_open()) return "ERROR: No memory file found";
                
                std::vector<std::string> lines;
                std::string line;
                while (std::getline(infile, line)) {
                    lines.push_back(line);
                }
                infile.close();
                
                // Check if line exists
                if (line_num > static_cast<int>(lines.size())) {
                    return "ERROR: Line number out of range";
                }
                
                // Remove line (convert from 1-indexed to 0-indexed)
                lines.erase(lines.begin() + (line_num - 1));
                
                // Write back
                std::ofstream outfile(memory_file, std::ios::trunc);
                if (!outfile.is_open()) return "ERROR: Cannot write to memory file";
                
                for (size_t i = 0; i < lines.size(); ++i) {
                    outfile << lines[i];
                    if (i < lines.size() - 1) outfile << "\n";
                }
                outfile.close();
                
                return "Line removed from memory";
            } catch (...) { return "ERROR"; }
        }, 1);

        // Get line count in memory
        register_tool("memory_line_count", [memory_file](const std::vector<std::string>& args) -> std::string {
            if (args.size() != 0) return "ERROR";
            try {
                std::ifstream file(memory_file);
                if (!file.is_open()) return "0";
                
                int count = 0;
                std::string line;
                while (std::getline(file, line)) {
                    count++;
                }
                file.close();
                
                return std::to_string(count);
            } catch (...) { return "ERROR"; }
        }, 0);
    }

    void register_tool(const std::string& name, InlineToolCallback callback, int num_args) {
        tools[name] = {name, callback, num_args};
    }

    // Returns empty string if no match or incomplete
    // Returns result string if matched and executed
    // Buffer should be the recent context ending with "{==}"
    // Format expected: [[tool_name(arg1, arg2){==}
    // Returns: [KERNEL_ANSWER: result]
    std::string check_and_execute(const std::string& buffer) {
        // Simple parser
        // Find the last "[["
        size_t open_pos = buffer.rfind("[[");
        if (open_pos == std::string::npos) return "";

        // Check if we have "{==}" at the end (or close to it, allowing for whitespace)
        size_t eq_pos = buffer.rfind("{==}");
        if (eq_pos == std::string::npos || eq_pos < open_pos) return "";

        // Extract the content between [[ and {==}
        std::string content = buffer.substr(open_pos + 2, eq_pos - (open_pos + 2));
        
        std::cerr << "[DEBUG] Tool content found: '" << content << "'" << std::endl;

        // Parse tool name and args
        // Content should be "name(arg1,arg2)"
        size_t paren_open = content.find("(");
        size_t paren_close = content.rfind(")");
        
        if (paren_open == std::string::npos || paren_close == std::string::npos || paren_close < paren_open) {
             std::cerr << "[DEBUG] Malformed tool call: Missing parentheses" << std::endl;
             return "";
        }

        std::string name = content.substr(0, paren_open);
        // trim name
        name.erase(0, name.find_first_not_of(" \t\n\r\f\v"));
        name.erase(name.find_last_not_of(" \t\n\r\f\v") + 1);

        std::cerr << "[DEBUG] Tool name: '" << name << "'" << std::endl;

        if (tools.find(name) == tools.end()) {
            std::cerr << "[DEBUG] Unknown tool: '" << name << "'" << std::endl;
            return "[KERNEL_ANSWER: ERROR - Unknown command '" + name + "'. Check available commands in system prompt.]";
        }

        std::string args_str = content.substr(paren_open + 1, paren_close - (paren_open + 1));
        std::vector<std::string> args;
        
        // Quote-aware argument parsing
        // Handles: strings with commas, quotes, multi-line, spaces
        std::string current_arg;
        char quote_char = 0; // 0 = not in quote, '\'' or '"' = in quote
        bool escaped = false;
        
        for (size_t i = 0; i < args_str.length(); i++) {
            char c = args_str[i];
            
            if (escaped) {
                current_arg += c;
                escaped = false;
                continue;
            }
            
            if (c == '\\') {
                escaped = true;
                continue;
            }
            
            // Handle quotes
            if (c == '\'' || c == '"') {
                if (quote_char == 0) {
                    // Start of quoted string - don't include the quote
                    quote_char = c;
                } else if (c == quote_char) {
                    // End of quoted string - don't include the quote
                    quote_char = 0;
                } else {
                    // Different quote inside quoted string
                    current_arg += c;
                }
                continue;
            }
            
            // Comma delimiter (only if not inside quotes)
            if (c == ',' && quote_char == 0) {
                // Trim and add argument
                size_t first = current_arg.find_first_not_of(" \t\n\r\f\v");
                if (first != std::string::npos) {
                    size_t last = current_arg.find_last_not_of(" \t\n\r\f\v");
                    args.push_back(current_arg.substr(first, (last - first + 1)));
                }
                current_arg.clear();
                continue;
            }
            
            // Regular character
            current_arg += c;
        }
        
        // Add last argument
        if (!current_arg.empty() || args_str.empty()) {
            size_t first = current_arg.find_first_not_of(" \t\n\r\f\v");
            if (first != std::string::npos) {
                size_t last = current_arg.find_last_not_of(" \t\n\r\f\v");
                args.push_back(current_arg.substr(first, (last - first + 1)));
            }
        }

        std::cerr << "[DEBUG] Args count: " << args.size() << std::endl;
        for(const auto& a : args) std::cerr << "[DEBUG] Arg: '" << a << "'" << std::endl;

        const auto& tool = tools[name];
        // For variable args (num_args = -1), check min 1 arg (or specific logic in callback)
        if (tool.num_args != -1 && args.size() != (size_t)tool.num_args) {
            std::cerr << "[DEBUG] Arg count mismatch. Expected " << tool.num_args << ", got " << args.size() << std::endl;
            return "[KERNEL_ANSWER: ERROR - Command '" + name + "' requires " + std::to_string(tool.num_args) + 
                   " arguments, but got " + std::to_string(args.size()) + ". Check command syntax.]";
        }

        // Execute
        std::string result = tool.callback(args);
        std::cerr << "[DEBUG] Tool result: " << result << std::endl;
        
        // Format: [KERNEL_ANSWER: result]
        // Inject a newline to clearly end the tool output line.
        return "[KERNEL_ANSWER: " + result + "]\n";
    }
};