@eko-ai/eko 1.2.0 → 1.2.2

package/dist/index.cjs.js

@@ -2,6 +2,11 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var os = require('os');
+var path = require('path');
+var util = require('util');
+var uuid = require('uuid');
+
 const VERSION$1 = '0.33.1'; // x-release-please-version
 
 let auto$1 = false;
@@ -2714,7 +2719,7 @@ class ClaudeProvider {
         if (typeof window !== 'undefined' &&
             typeof document !== 'undefined' &&
             (typeof param == 'string' || param.apiKey)) {
-            console.warn(`
+            logger.warn(`
         ⚠️ Security Warning:
         DO NOT use API Keys in browser/frontend code!
         This will expose your credentials and may lead to unauthorized usage.
@@ -8782,6 +8787,630 @@ OpenAI.BatchesPage = BatchesPage;
 OpenAI.Uploads = Uploads;
 OpenAI.Responses = Responses;
 
+const prettyLogStyles = {
+    reset: [0, 0],
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29],
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    blackBright: [90, 39],
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39],
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    bgBlackBright: [100, 49],
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49],
+};
+
+function formatTemplate(settings, template, values, hideUnsetPlaceholder = false) {
+    const templateString = String(template);
+    const ansiColorWrap = (placeholderValue, code) => `\u001b[${code[0]}m${placeholderValue}\u001b[${code[1]}m`;
+    const styleWrap = (value, style) => {
+        if (style != null && typeof style === "string") {
+            return ansiColorWrap(value, prettyLogStyles[style]);
+        }
+        else if (style != null && Array.isArray(style)) {
+            return style.reduce((prevValue, thisStyle) => styleWrap(prevValue, thisStyle), value);
+        }
+        else {
+            if (style != null && style[value.trim()] != null) {
+                return styleWrap(value, style[value.trim()]);
+            }
+            else if (style != null && style["*"] != null) {
+                return styleWrap(value, style["*"]);
+            }
+            else {
+                return value;
+            }
+        }
+    };
+    const defaultStyle = null;
+    return templateString.replace(/{{(.+?)}}/g, (_, placeholder) => {
+        const value = values[placeholder] != null ? String(values[placeholder]) : hideUnsetPlaceholder ? "" : _;
+        return settings.stylePrettyLogs
+            ? styleWrap(value, settings?.prettyLogStyles?.[placeholder] ?? defaultStyle) + ansiColorWrap("", prettyLogStyles.reset)
+            : value;
+    });
+}
+
+function formatNumberAddZeros(value, digits = 2, addNumber = 0) {
+    if (value != null && isNaN(value)) {
+        return "";
+    }
+    value = value != null ? value + addNumber : value;
+    return digits === 2
+        ? value == null
+            ? "--"
+            : value < 10
+                ? "0" + value
+                : value.toString()
+        : value == null
+            ? "---"
+            : value < 10
+                ? "00" + value
+                : value < 100
+                    ? "0" + value
+                    : value.toString();
+}
+
+function urlToObject(url) {
+    return {
+        href: url.href,
+        protocol: url.protocol,
+        username: url.username,
+        password: url.password,
+        host: url.host,
+        hostname: url.hostname,
+        port: url.port,
+        pathname: url.pathname,
+        search: url.search,
+        searchParams: [...url.searchParams].map(([key, value]) => ({ key, value })),
+        hash: url.hash,
+        origin: url.origin,
+    };
+}
+
+var Runtime = {
+    getCallerStackFrame,
+    getErrorTrace,
+    getMeta,
+    transportJSON,
+    transportFormatted: transportFormatted$1,
+    isBuffer,
+    isError,
+    prettyFormatLogObj,
+    prettyFormatErrorObj,
+};
+const meta = {
+    runtime: "Nodejs",
+    runtimeVersion: process?.version,
+    hostname: os.hostname ? os.hostname() : undefined,
+};
+function getMeta(logLevelId, logLevelName, stackDepthLevel, hideLogPositionForPerformance, name, parentNames) {
+    return Object.assign({}, meta, {
+        name,
+        parentNames,
+        date: new Date(),
+        logLevelId,
+        logLevelName,
+        path: !hideLogPositionForPerformance ? getCallerStackFrame(stackDepthLevel) : undefined,
+    });
+}
+function getCallerStackFrame(stackDepthLevel, error = Error()) {
+    return stackLineToStackFrame(error?.stack?.split("\n")?.filter((thisLine) => thisLine.includes("    at "))?.[stackDepthLevel]);
+}
+function getErrorTrace(error) {
+    return error?.stack?.split("\n")?.reduce((result, line) => {
+        if (line.includes("    at ")) {
+            result.push(stackLineToStackFrame(line));
+        }
+        return result;
+    }, []);
+}
+function stackLineToStackFrame(line) {
+    const pathResult = {
+        fullFilePath: undefined,
+        fileName: undefined,
+        fileNameWithLine: undefined,
+        fileColumn: undefined,
+        fileLine: undefined,
+        filePath: undefined,
+        filePathWithLine: undefined,
+        method: undefined,
+    };
+    if (line != null && line.includes("    at ")) {
+        line = line.replace(/^\s+at\s+/gm, "");
+        const errorStackLine = line.split(" (");
+        const fullFilePath = line?.slice(-1) === ")" ? line?.match(/\(([^)]+)\)/)?.[1] : line;
+        const pathArray = fullFilePath?.includes(":") ? fullFilePath?.replace("file://", "")?.replace(process.cwd(), "")?.split(":") : undefined;
+        const fileColumn = pathArray?.pop();
+        const fileLine = pathArray?.pop();
+        const filePath = pathArray?.pop();
+        const filePathWithLine = path.normalize(`${filePath}:${fileLine}`);
+        const fileName = filePath?.split("/")?.pop();
+        const fileNameWithLine = `${fileName}:${fileLine}`;
+        if (filePath != null && filePath.length > 0) {
+            pathResult.fullFilePath = fullFilePath;
+            pathResult.fileName = fileName;
+            pathResult.fileNameWithLine = fileNameWithLine;
+            pathResult.fileColumn = fileColumn;
+            pathResult.fileLine = fileLine;
+            pathResult.filePath = filePath;
+            pathResult.filePathWithLine = filePathWithLine;
+            pathResult.method = errorStackLine?.[1] != null ? errorStackLine?.[0] : undefined;
+        }
+    }
+    return pathResult;
+}
+function isError(e) {
+    return util.types?.isNativeError != null ? util.types.isNativeError(e) : e instanceof Error;
+}
+function prettyFormatLogObj(maskedArgs, settings) {
+    return maskedArgs.reduce((result, arg) => {
+        isError(arg) ? result.errors.push(prettyFormatErrorObj(arg, settings)) : result.args.push(arg);
+        return result;
+    }, { args: [], errors: [] });
+}
+function prettyFormatErrorObj(error, settings) {
+    const errorStackStr = getErrorTrace(error).map((stackFrame) => {
+        return formatTemplate(settings, settings.prettyErrorStackTemplate, { ...stackFrame }, true);
+    });
+    const placeholderValuesError = {
+        errorName: ` ${error.name} `,
+        errorMessage: Object.getOwnPropertyNames(error)
+            .reduce((result, key) => {
+            if (key !== "stack") {
+                result.push(error[key]);
+            }
+            return result;
+        }, [])
+            .join(", "),
+        errorStack: errorStackStr.join("\n"),
+    };
+    return formatTemplate(settings, settings.prettyErrorTemplate, placeholderValuesError);
+}
+function transportFormatted$1(logMetaMarkup, logArgs, logErrors, settings) {
+    const logErrorsStr = (logErrors.length > 0 && logArgs.length > 0 ? "\n" : "") + logErrors.join("\n");
+    settings.prettyInspectOptions.colors = settings.stylePrettyLogs;
+    console.log(logMetaMarkup + util.formatWithOptions(settings.prettyInspectOptions, ...logArgs) + logErrorsStr);
+}
+function transportJSON(json) {
+    console.log(jsonStringifyRecursive(json));
+    function jsonStringifyRecursive(obj) {
+        const cache = new Set();
+        return JSON.stringify(obj, (key, value) => {
+            if (typeof value === "object" && value !== null) {
+                if (cache.has(value)) {
+                    return "[Circular]";
+                }
+                cache.add(value);
+            }
+            if (typeof value === "bigint") {
+                return `${value}`;
+            }
+            if (typeof value === "undefined") {
+                return "[undefined]";
+            }
+            return value;
+        });
+    }
+}
+function isBuffer(arg) {
+    return Buffer.isBuffer(arg);
+}
+
+class BaseLogger {
+    constructor(settings, logObj, stackDepthLevel = 4) {
+        this.logObj = logObj;
+        this.stackDepthLevel = stackDepthLevel;
+        this.runtime = Runtime;
+        this.settings = {
+            type: settings?.type ?? "pretty",
+            name: settings?.name,
+            parentNames: settings?.parentNames,
+            minLevel: settings?.minLevel ?? 0,
+            argumentsArrayName: settings?.argumentsArrayName,
+            hideLogPositionForProduction: settings?.hideLogPositionForProduction ?? false,
+            prettyLogTemplate: settings?.prettyLogTemplate ??
+                "{{yyyy}}.{{mm}}.{{dd}} {{hh}}:{{MM}}:{{ss}}:{{ms}}\t{{logLevelName}}\t{{filePathWithLine}}{{nameWithDelimiterPrefix}}\t",
+            prettyErrorTemplate: settings?.prettyErrorTemplate ?? "\n{{errorName}} {{errorMessage}}\nerror stack:\n{{errorStack}}",
+            prettyErrorStackTemplate: settings?.prettyErrorStackTemplate ?? "  • {{fileName}}\t{{method}}\n\t{{filePathWithLine}}",
+            prettyErrorParentNamesSeparator: settings?.prettyErrorParentNamesSeparator ?? ":",
+            prettyErrorLoggerNameDelimiter: settings?.prettyErrorLoggerNameDelimiter ?? "\t",
+            stylePrettyLogs: settings?.stylePrettyLogs ?? true,
+            prettyLogTimeZone: settings?.prettyLogTimeZone ?? "UTC",
+            prettyLogStyles: settings?.prettyLogStyles ?? {
+                logLevelName: {
+                    "*": ["bold", "black", "bgWhiteBright", "dim"],
+                    SILLY: ["bold", "white"],
+                    TRACE: ["bold", "whiteBright"],
+                    DEBUG: ["bold", "green"],
+                    INFO: ["bold", "blue"],
+                    WARN: ["bold", "yellow"],
+                    ERROR: ["bold", "red"],
+                    FATAL: ["bold", "redBright"],
+                },
+                dateIsoStr: "white",
+                filePathWithLine: "white",
+                name: ["white", "bold"],
+                nameWithDelimiterPrefix: ["white", "bold"],
+                nameWithDelimiterSuffix: ["white", "bold"],
+                errorName: ["bold", "bgRedBright", "whiteBright"],
+                fileName: ["yellow"],
+                fileNameWithLine: "white",
+            },
+            prettyInspectOptions: settings?.prettyInspectOptions ?? {
+                colors: true,
+                compact: false,
+                depth: Infinity,
+            },
+            metaProperty: settings?.metaProperty ?? "_meta",
+            maskPlaceholder: settings?.maskPlaceholder ?? "[***]",
+            maskValuesOfKeys: settings?.maskValuesOfKeys ?? ["password"],
+            maskValuesOfKeysCaseInsensitive: settings?.maskValuesOfKeysCaseInsensitive ?? false,
+            maskValuesRegEx: settings?.maskValuesRegEx,
+            prefix: [...(settings?.prefix ?? [])],
+            attachedTransports: [...(settings?.attachedTransports ?? [])],
+            overwrite: {
+                mask: settings?.overwrite?.mask,
+                toLogObj: settings?.overwrite?.toLogObj,
+                addMeta: settings?.overwrite?.addMeta,
+                addPlaceholders: settings?.overwrite?.addPlaceholders,
+                formatMeta: settings?.overwrite?.formatMeta,
+                formatLogObj: settings?.overwrite?.formatLogObj,
+                transportFormatted: settings?.overwrite?.transportFormatted,
+                transportJSON: settings?.overwrite?.transportJSON,
+            },
+        };
+    }
+    log(logLevelId, logLevelName, ...args) {
+        if (logLevelId < this.settings.minLevel) {
+            return;
+        }
+        const logArgs = [...this.settings.prefix, ...args];
+        const maskedArgs = this.settings.overwrite?.mask != null
+            ? this.settings.overwrite?.mask(logArgs)
+            : this.settings.maskValuesOfKeys != null && this.settings.maskValuesOfKeys.length > 0
+                ? this._mask(logArgs)
+                : logArgs;
+        const thisLogObj = this.logObj != null ? this._recursiveCloneAndExecuteFunctions(this.logObj) : undefined;
+        const logObj = this.settings.overwrite?.toLogObj != null ? this.settings.overwrite?.toLogObj(maskedArgs, thisLogObj) : this._toLogObj(maskedArgs, thisLogObj);
+        const logObjWithMeta = this.settings.overwrite?.addMeta != null
+            ? this.settings.overwrite?.addMeta(logObj, logLevelId, logLevelName)
+            : this._addMetaToLogObj(logObj, logLevelId, logLevelName);
+        let logMetaMarkup;
+        let logArgsAndErrorsMarkup = undefined;
+        if (this.settings.overwrite?.formatMeta != null) {
+            logMetaMarkup = this.settings.overwrite?.formatMeta(logObjWithMeta?.[this.settings.metaProperty]);
+        }
+        if (this.settings.overwrite?.formatLogObj != null) {
+            logArgsAndErrorsMarkup = this.settings.overwrite?.formatLogObj(maskedArgs, this.settings);
+        }
+        if (this.settings.type === "pretty") {
+            logMetaMarkup = logMetaMarkup ?? this._prettyFormatLogObjMeta(logObjWithMeta?.[this.settings.metaProperty]);
+            logArgsAndErrorsMarkup = logArgsAndErrorsMarkup ?? this.runtime.prettyFormatLogObj(maskedArgs, this.settings);
+        }
+        if (logMetaMarkup != null && logArgsAndErrorsMarkup != null) {
+            this.settings.overwrite?.transportFormatted != null
+                ? this.settings.overwrite?.transportFormatted(logMetaMarkup, logArgsAndErrorsMarkup.args, logArgsAndErrorsMarkup.errors, this.settings)
+                : this.runtime.transportFormatted(logMetaMarkup, logArgsAndErrorsMarkup.args, logArgsAndErrorsMarkup.errors, this.settings);
+        }
+        else {
+            this.settings.overwrite?.transportJSON != null
+                ? this.settings.overwrite?.transportJSON(logObjWithMeta)
+                : this.settings.type !== "hidden"
+                    ? this.runtime.transportJSON(logObjWithMeta)
+                    : undefined;
+        }
+        if (this.settings.attachedTransports != null && this.settings.attachedTransports.length > 0) {
+            this.settings.attachedTransports.forEach((transportLogger) => {
+                transportLogger(logObjWithMeta);
+            });
+        }
+        return logObjWithMeta;
+    }
+    attachTransport(transportLogger) {
+        this.settings.attachedTransports.push(transportLogger);
+    }
+    getSubLogger(settings, logObj) {
+        const subLoggerSettings = {
+            ...this.settings,
+            ...settings,
+            parentNames: this.settings?.parentNames != null && this.settings?.name != null
+                ? [...this.settings.parentNames, this.settings.name]
+                : this.settings?.name != null
+                    ? [this.settings.name]
+                    : undefined,
+            prefix: [...this.settings.prefix, ...(settings?.prefix ?? [])],
+        };
+        const subLogger = new this.constructor(subLoggerSettings, logObj ?? this.logObj, this.stackDepthLevel);
+        return subLogger;
+    }
+    _mask(args) {
+        const maskValuesOfKeys = this.settings.maskValuesOfKeysCaseInsensitive !== true ? this.settings.maskValuesOfKeys : this.settings.maskValuesOfKeys.map((key) => key.toLowerCase());
+        return args?.map((arg) => {
+            return this._recursiveCloneAndMaskValuesOfKeys(arg, maskValuesOfKeys);
+        });
+    }
+    _recursiveCloneAndMaskValuesOfKeys(source, keys, seen = []) {
+        if (seen.includes(source)) {
+            return { ...source };
+        }
+        if (typeof source === "object" && source !== null) {
+            seen.push(source);
+        }
+        if (this.runtime.isError(source) || this.runtime.isBuffer(source)) {
+            return source;
+        }
+        else if (source instanceof Map) {
+            return new Map(source);
+        }
+        else if (source instanceof Set) {
+            return new Set(source);
+        }
+        else if (Array.isArray(source)) {
+            return source.map((item) => this._recursiveCloneAndMaskValuesOfKeys(item, keys, seen));
+        }
+        else if (source instanceof Date) {
+            return new Date(source.getTime());
+        }
+        else if (source instanceof URL) {
+            return urlToObject(source);
+        }
+        else if (source !== null && typeof source === "object") {
+            const baseObject = this.runtime.isError(source) ? this._cloneError(source) : Object.create(Object.getPrototypeOf(source));
+            return Object.getOwnPropertyNames(source).reduce((o, prop) => {
+                o[prop] = keys.includes(this.settings?.maskValuesOfKeysCaseInsensitive !== true ? prop : prop.toLowerCase())
+                    ? this.settings.maskPlaceholder
+                    : (() => {
+                        try {
+                            return this._recursiveCloneAndMaskValuesOfKeys(source[prop], keys, seen);
+                        }
+                        catch (e) {
+                            return null;
+                        }
+                    })();
+                return o;
+            }, baseObject);
+        }
+        else {
+            if (typeof source === "string") {
+                let modifiedSource = source;
+                for (const regEx of this.settings?.maskValuesRegEx || []) {
+                    modifiedSource = modifiedSource.replace(regEx, this.settings?.maskPlaceholder || "");
+                }
+                return modifiedSource;
+            }
+            return source;
+        }
+    }
+    _recursiveCloneAndExecuteFunctions(source, seen = []) {
+        if (this.isObjectOrArray(source) && seen.includes(source)) {
+            return this.shallowCopy(source);
+        }
+        if (this.isObjectOrArray(source)) {
+            seen.push(source);
+        }
+        if (Array.isArray(source)) {
+            return source.map((item) => this._recursiveCloneAndExecuteFunctions(item, seen));
+        }
+        else if (source instanceof Date) {
+            return new Date(source.getTime());
+        }
+        else if (this.isObject(source)) {
+            return Object.getOwnPropertyNames(source).reduce((o, prop) => {
+                const descriptor = Object.getOwnPropertyDescriptor(source, prop);
+                if (descriptor) {
+                    Object.defineProperty(o, prop, descriptor);
+                    const value = source[prop];
+                    o[prop] = typeof value === "function" ? value() : this._recursiveCloneAndExecuteFunctions(value, seen);
+                }
+                return o;
+            }, Object.create(Object.getPrototypeOf(source)));
+        }
+        else {
+            return source;
+        }
+    }
+    isObjectOrArray(value) {
+        return typeof value === "object" && value !== null;
+    }
+    isObject(value) {
+        return typeof value === "object" && !Array.isArray(value) && value !== null;
+    }
+    shallowCopy(source) {
+        if (Array.isArray(source)) {
+            return [...source];
+        }
+        else {
+            return { ...source };
+        }
+    }
+    _toLogObj(args, clonedLogObj = {}) {
+        args = args?.map((arg) => (this.runtime.isError(arg) ? this._toErrorObject(arg) : arg));
+        if (this.settings.argumentsArrayName == null) {
+            if (args.length === 1 && !Array.isArray(args[0]) && this.runtime.isBuffer(args[0]) !== true && !(args[0] instanceof Date)) {
+                clonedLogObj = typeof args[0] === "object" && args[0] != null ? { ...args[0], ...clonedLogObj } : { 0: args[0], ...clonedLogObj };
+            }
+            else {
+                clonedLogObj = { ...clonedLogObj, ...args };
+            }
+        }
+        else {
+            clonedLogObj = {
+                ...clonedLogObj,
+                [this.settings.argumentsArrayName]: args,
+            };
+        }
+        return clonedLogObj;
+    }
+    _cloneError(error) {
+        const cloned = new error.constructor();
+        Object.getOwnPropertyNames(error).forEach((key) => {
+            cloned[key] = error[key];
+        });
+        return cloned;
+    }
+    _toErrorObject(error) {
+        return {
+            nativeError: error,
+            name: error.name ?? "Error",
+            message: error.message,
+            stack: this.runtime.getErrorTrace(error),
+        };
+    }
+    _addMetaToLogObj(logObj, logLevelId, logLevelName) {
+        return {
+            ...logObj,
+            [this.settings.metaProperty]: this.runtime.getMeta(logLevelId, logLevelName, this.stackDepthLevel, this.settings.hideLogPositionForProduction, this.settings.name, this.settings.parentNames),
+        };
+    }
+    _prettyFormatLogObjMeta(logObjMeta) {
+        if (logObjMeta == null) {
+            return "";
+        }
+        let template = this.settings.prettyLogTemplate;
+        const placeholderValues = {};
+        if (template.includes("{{yyyy}}.{{mm}}.{{dd}} {{hh}}:{{MM}}:{{ss}}:{{ms}}")) {
+            template = template.replace("{{yyyy}}.{{mm}}.{{dd}} {{hh}}:{{MM}}:{{ss}}:{{ms}}", "{{dateIsoStr}}");
+        }
+        else {
+            if (this.settings.prettyLogTimeZone === "UTC") {
+                placeholderValues["yyyy"] = logObjMeta?.date?.getUTCFullYear() ?? "----";
+                placeholderValues["mm"] = formatNumberAddZeros(logObjMeta?.date?.getUTCMonth(), 2, 1);
+                placeholderValues["dd"] = formatNumberAddZeros(logObjMeta?.date?.getUTCDate(), 2);
+                placeholderValues["hh"] = formatNumberAddZeros(logObjMeta?.date?.getUTCHours(), 2);
+                placeholderValues["MM"] = formatNumberAddZeros(logObjMeta?.date?.getUTCMinutes(), 2);
+                placeholderValues["ss"] = formatNumberAddZeros(logObjMeta?.date?.getUTCSeconds(), 2);
+                placeholderValues["ms"] = formatNumberAddZeros(logObjMeta?.date?.getUTCMilliseconds(), 3);
+            }
+            else {
+                placeholderValues["yyyy"] = logObjMeta?.date?.getFullYear() ?? "----";
+                placeholderValues["mm"] = formatNumberAddZeros(logObjMeta?.date?.getMonth(), 2, 1);
+                placeholderValues["dd"] = formatNumberAddZeros(logObjMeta?.date?.getDate(), 2);
+                placeholderValues["hh"] = formatNumberAddZeros(logObjMeta?.date?.getHours(), 2);
+                placeholderValues["MM"] = formatNumberAddZeros(logObjMeta?.date?.getMinutes(), 2);
+                placeholderValues["ss"] = formatNumberAddZeros(logObjMeta?.date?.getSeconds(), 2);
+                placeholderValues["ms"] = formatNumberAddZeros(logObjMeta?.date?.getMilliseconds(), 3);
+            }
+        }
+        const dateInSettingsTimeZone = this.settings.prettyLogTimeZone === "UTC" ? logObjMeta?.date : new Date(logObjMeta?.date?.getTime() - logObjMeta?.date?.getTimezoneOffset() * 60000);
+        placeholderValues["rawIsoStr"] = dateInSettingsTimeZone?.toISOString();
+        placeholderValues["dateIsoStr"] = dateInSettingsTimeZone?.toISOString().replace("T", " ").replace("Z", "");
+        placeholderValues["logLevelName"] = logObjMeta?.logLevelName;
+        placeholderValues["fileNameWithLine"] = logObjMeta?.path?.fileNameWithLine ?? "";
+        placeholderValues["filePathWithLine"] = logObjMeta?.path?.filePathWithLine ?? "";
+        placeholderValues["fullFilePath"] = logObjMeta?.path?.fullFilePath ?? "";
+        let parentNamesString = this.settings.parentNames?.join(this.settings.prettyErrorParentNamesSeparator);
+        parentNamesString = parentNamesString != null && logObjMeta?.name != null ? parentNamesString + this.settings.prettyErrorParentNamesSeparator : undefined;
+        placeholderValues["name"] = logObjMeta?.name != null || parentNamesString != null ? (parentNamesString ?? "") + logObjMeta?.name ?? "" : "";
+        placeholderValues["nameWithDelimiterPrefix"] =
+            placeholderValues["name"].length > 0 ? this.settings.prettyErrorLoggerNameDelimiter + placeholderValues["name"] : "";
+        placeholderValues["nameWithDelimiterSuffix"] =
+            placeholderValues["name"].length > 0 ? placeholderValues["name"] + this.settings.prettyErrorLoggerNameDelimiter : "";
+        if (this.settings.overwrite?.addPlaceholders != null) {
+            this.settings.overwrite?.addPlaceholders(logObjMeta, placeholderValues);
+        }
+        return formatTemplate(this.settings, template, placeholderValues);
+    }
+}
+
+class Logger extends BaseLogger {
+    constructor(settings, logObj) {
+        const isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+        const isBrowserBlinkEngine = isBrowser ? window.chrome !== undefined && window.CSS !== undefined && window.CSS.supports("color", "green") : false;
+        const isSafari = isBrowser ? /^((?!chrome|android).)*safari/i.test(navigator.userAgent) : false;
+        settings = settings || {};
+        settings.stylePrettyLogs = settings.stylePrettyLogs && isBrowser && !isBrowserBlinkEngine ? false : settings.stylePrettyLogs;
+        super(settings, logObj, isSafari ? 4 : 5);
+    }
+    log(logLevelId, logLevelName, ...args) {
+        return super.log(logLevelId, logLevelName, ...args);
+    }
+    silly(...args) {
+        return super.log(0, "SILLY", ...args);
+    }
+    trace(...args) {
+        return super.log(1, "TRACE", ...args);
+    }
+    debug(...args) {
+        return super.log(2, "DEBUG", ...args);
+    }
+    info(...args) {
+        return super.log(3, "INFO", ...args);
+    }
+    warn(...args) {
+        return super.log(4, "WARN", ...args);
+    }
+    error(...args) {
+        return super.log(5, "ERROR", ...args);
+    }
+    fatal(...args) {
+        return super.log(6, "FATAL", ...args);
+    }
+    getSubLogger(settings, logObj) {
+        return super.getSubLogger(settings, logObj);
+    }
+}
+
+function transportFormatted(logMetaMarkup, logArgs, logErrors, settings) {
+    const logErrorsStr = (logErrors.length > 0 && logArgs.length > 0 ? "\n" : "") + logErrors.join("\n");
+    settings.prettyInspectOptions.colors = settings.stylePrettyLogs;
+    console.log(logMetaMarkup, ...logArgs, logErrorsStr);
+}
+function formatMeta(logObjMeta) {
+    if (!logObjMeta) {
+        return '';
+    }
+    const { date, logLevelName } = logObjMeta;
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    const hours = String(date.getHours()).padStart(2, '0');
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    const seconds = String(date.getSeconds()).padStart(2, '0');
+    const milliseconds = String(date.getMilliseconds()).padStart(3, '0');
+    const formattedDate = `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${milliseconds}`;
+    const loggerName = logObjMeta.name;
+    return `${formattedDate} ${logLevelName} ${loggerName}`;
+}
+const logger$1 = new Logger({
+    name: "ekoLogger",
+    overwrite: {
+        transportFormatted,
+        formatMeta,
+    }
+});
+
 class OpenaiProvider {
     constructor(param, defaultModel, options) {
         this.defaultModel = 'gpt-4o';
@@ -8791,7 +9420,7 @@ class OpenaiProvider {
         if (typeof window !== 'undefined' &&
             typeof document !== 'undefined' &&
             (typeof param == 'string' || param.apiKey)) {
-            console.warn(`
+            logger$1.warn(`
         ⚠️ Security Warning:
         DO NOT use API Keys in browser/frontend code!
         This will expose your credentials and may lead to unauthorized usage.
@@ -9065,7 +9694,7 @@ class OpenaiProvider {
                     if (choice.finish_reason) {
                         stop_reason = choice.finish_reason;
                         if (currentToolUse) {
-                            console.log("currentToolUse.accumulatedJson=", currentToolUse.accumulatedJson);
+                            logger$1.debug("currentToolUse.accumulatedJson=", currentToolUse.accumulatedJson);
                             const toolCall = {
                                 id: currentToolUse.id,
                                 name: currentToolUse.name,
@@ -9159,7 +9788,7 @@ class ExecutionLogger {
         if (this.shouldLog(level)) {
             const timestamp = this.includeTimestamp ? new Date().toISOString() : '';
             const contextSummary = this.summarizeContext(context);
-            console.log(`${timestamp} [${level.toUpperCase()}] ${message}${contextSummary}`);
+            logger$1.debug(`${timestamp} [${level.toUpperCase()}] ${message}${contextSummary}`);
         }
     }
     /**
@@ -9227,7 +9856,7 @@ class ExecutionLogger {
      * Logs an error that occurred during execution
      */
     logError(error, context) {
-        console.error(error);
+        logger$1.error(error);
         try {
             this.log('error', `Error occurred: ${error.message}`, context);
             if (error.stack) {
@@ -9235,8 +9864,8 @@ class ExecutionLogger {
             }
         }
         catch (error) {
-            console.error("An error occurs when trying to log another error:");
-            console.error(error);
+            logger$1.error("An error occurs when trying to log another error:");
+            logger$1.error(error);
         }
     }
     extractFromDataUrl(dataUrl) {
@@ -9289,7 +9918,7 @@ class ExecutionLogger {
             return '[image]';
         }
         catch (error) {
-            console.warn('Failed to save debug image:', error);
+            logger$1.warn('Failed to save debug image:', error);
             return '[image]';
         }
     }
@@ -9328,7 +9957,7 @@ class ExecutionLogger {
             const timestamp = this.includeTimestamp ? new Date().toISOString() : '';
             const contextSummary = this.summarizeContext(context);
             const formattedResult = await this.formatToolResult(result);
-            console.log(`${timestamp} [INFO] Tool executed: ${toolName}\n` +
+            logger$1.debug(`${timestamp} [INFO] Tool executed: ${toolName}\n` +
                 `${timestamp} [INFO] Tool result: ${formattedResult}${contextSummary}`);
         }
     }
@@ -9361,7 +9990,7 @@ ${JSON.stringify(nodeOutputs)}
       `,
         },
     ];
-    console.log(messages);
+    logger$1.debug(messages);
     const params = {
         temperature: 0.7,
         maxTokens: 8192,
@@ -9392,9 +10021,9 @@ ${JSON.stringify(nodeOutputs)}
             }],
         toolChoice: { type: 'tool', name: 'summarize_workflow' },
     };
-    console.log(params);
+    logger$1.debug(params);
     const response = await llmProvider.generateText(messages, params);
-    console.log(response);
+    logger$1.debug(response);
     return {
         isSuccessful: contextVariables.get("__isSuccessful__"),
         summary: response.toolCalls[0].input.summary,
@@ -9493,9 +10122,7 @@ class WorkflowImpl {
             const action_executing_result = await node.action.execute(node.input, node.output, context);
             node.output.value = action_executing_result.nodeOutput;
             const action_reacts = action_executing_result.reacts;
-            console.log("debug `action_reacts`...");
-            console.log(action_reacts);
-            console.log("debug `action_reacts`...done");
+            logger$1.debug("debug `action_reacts`...", action_reacts);
             executing.delete(nodeId);
             executed.add(nodeId);
             callback && await ((_d = (_c = callback.hooks).afterSubtask) === null || _d === void 0 ? void 0 : _d.call(_c, node, context, (_e = node.output) === null || _e === void 0 ? void 0 : _e.value));
@@ -9511,12 +10138,10 @@ class WorkflowImpl {
             workflowSummary = await summarizeWorkflow(this.llmProvider, this, this.variables, node_outputs);
         }
         else {
-            console.warn("WorkflowImpl.llmProvider is undefined, cannot generate workflow summary");
+            logger$1.warn("WorkflowImpl.llmProvider is undefined, cannot generate workflow summary");
         }
-        // Special context variables
-        console.log("debug special context variables...");
         let workflowPayload = this.variables.get("workflow_transcript");
-        console.log(workflowPayload);
+        logger$1.debug("workflowPayload", workflowPayload);
         if (!workflowPayload) {
             workflowPayload = workflowSummary === null || workflowSummary === void 0 ? void 0 : workflowSummary.payload;
         }
@@ -9639,13 +10264,11 @@ function createReturnTool(actionName, outputDescription, outputSchema) {
                     description: 'The output value. Only provide a value if the previous tool result is not suitable for the output description. Otherwise, leave this as null.',
                 },
             },
-            required: ['use_tool_result', 'value'],
+            required: ['isSuccessful', 'use_tool_result', 'value'],
         },
         async execute(context, params) {
             context.variables.set(`__action_${actionName}_output`, params);
-            console.info('debug the output...');
-            console.log(params);
-            console.info('debug the output...done');
+            console.debug('debug the output...', params);
             context.variables.set("__isSuccessful__", params.isSuccessful);
             return { success: true };
         },
@@ -9678,7 +10301,6 @@ class ActionImpl {
         let params_copy = JSON.parse(JSON.stringify(params));
         params_copy.tools = (_a = params_copy.tools) === null || _a === void 0 ? void 0 : _a.map(this.wrapToolInputSchema);
         while (!((_b = context.signal) === null || _b === void 0 ? void 0 : _b.aborted)) {
-            this.logger = context.logger;
             roundMessages = [];
             hasToolUse = false;
             response = null;
@@ -9701,8 +10323,13 @@ class ActionImpl {
                     }
                 },
                 onToolUse: async (toolCall) => {
-                    this.logger.log('info', `Assistant: ${assistantTextMessage}`);
-                    this.logger.logToolExecution(toolCall.name, toolCall.input, context);
+                    logger$1.info("toolCall start", {
+                        assistant: assistantTextMessage,
+                        toolCall: {
+                            name: toolCall.name,
+                            input: toolCall.input,
+                        },
+                    });
                     hasToolUse = true;
                     const tool = toolMap.get(toolCall.name);
                     if (!tool) {
@@ -9742,7 +10369,7 @@ class ActionImpl {
                     };
                     // Store the promise of tool execution
                     toolExecutionPromise = (async () => {
-                        var _a, _b, _c, _d;
+                        var _a, _b, _c, _d, _e, _f, _g;
                         try {
                             // beforeToolUse
                             context.__skip = false;
@@ -9768,12 +10395,18 @@ class ActionImpl {
                             // unwrap the toolCall
                             let unwrapped = this.unwrapToolCall(toolCall);
                             let input = unwrapped.toolCall.input;
-                            console.log("unwrapped", unwrapped);
+                            logger$1.debug("unwrapped", unwrapped);
+                            if (unwrapped.thinking) {
+                                (_d = (_b = context.callback) === null || _b === void 0 ? void 0 : (_c = _b.hooks).onLlmMessage) === null || _d === void 0 ? void 0 : _d.call(_c, unwrapped.thinking);
+                            }
+                            else {
+                                logger$1.warn("LLM returns without `userSidePrompt`");
+                            }
                             if (unwrapped.userSidePrompt) {
-                                (_d = (_b = context.callback) === null || _b === void 0 ? void 0 : (_c = _b.hooks).onLlmMessageUserSidePrompt) === null || _d === void 0 ? void 0 : _d.call(_c, unwrapped.userSidePrompt, toolCall.name);
+                                (_g = (_e = context.callback) === null || _e === void 0 ? void 0 : (_f = _e.hooks).onLlmMessageUserSidePrompt) === null || _g === void 0 ? void 0 : _g.call(_f, unwrapped.userSidePrompt, toolCall.name);
                             }
                             else {
-                                console.warn("LLM returns without `userSidePrompt`");
+                                logger$1.warn("LLM returns without `userSidePrompt`");
                             }
                             // Execute the tool
                             let result = await tool.execute(context, input);
@@ -9811,15 +10444,30 @@ class ActionImpl {
                                 content: [resultContent],
                             };
                             toolResultMessage = resultMessage;
-                            this.logger.logToolResult(tool.name, result, context);
+                            const truncate = (x) => {
+                                const s = JSON.stringify(x);
+                                const maxLength = 1000;
+                                if (s.length < maxLength) {
+                                    return x;
+                                }
+                                else {
+                                    return s.slice(0, maxLength) + "...(truncated)";
+                                }
+                            };
+                            logger$1.info("toolCall done", {
+                                toolCall: {
+                                    name: tool.name,
+                                    result: truncate(result),
+                                },
+                            });
                             // Store tool results except for the return_output tool
                             if (tool.name !== 'return_output') {
                                 this.toolResults.set(toolCall.id, resultContentText);
                             }
                         }
                         catch (err) {
-                            console.log('An error occurred when calling tool:');
-                            console.log(err);
+                            logger$1.error('An error occurred when calling tool:');
+                            logger$1.error(err);
                             const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
                             const errorResult = {
                                 role: 'user',
@@ -9833,7 +10481,6 @@ class ActionImpl {
                                 ],
                             };
                             toolResultMessage = errorResult;
-                            this.logger.logError(err, context);
                         }
                     })();
                 },
@@ -9841,8 +10488,8 @@ class ActionImpl {
                     response = llmResponse;
                 },
                 onError: (error) => {
-                    // console.error('Stream Error:', error);
-                    // console.log('Last message array sent to LLM:', JSON.stringify(messages, null, 2));
+                    logger$1.error('Stream Error:', error);
+                    logger$1.debug('Last message array sent to LLM:', JSON.stringify(messages, null, 2));
                     throw error;
                 },
             };
@@ -9855,8 +10502,7 @@ class ActionImpl {
                 await this.llmProvider.generateStream(messages, params_copy, handler);
             }
             catch (e) {
-                console.warn("an error occurs when LLM generate response");
-                console.warn(e);
+                logger$1.warn("an error occurs when LLM generate response, retry...", e);
                 continue;
             }
             // Wait for tool execution to complete if it was started
@@ -9911,7 +10557,7 @@ class ActionImpl {
         }
         const finalImageCount = this.countImages(messages);
         if (initialImageCount !== finalImageCount) {
-            this.logger.log('info', `Removed ${initialImageCount - finalImageCount} images from history`);
+            logger$1.debug(`Removed ${initialImageCount - finalImageCount} images from history`);
         }
     }
     countImages(messages) {
@@ -9928,9 +10574,8 @@ class ActionImpl {
         return count;
     }
     async execute(input, output, context, outputSchema) {
-        var _a, _b, _c, _d, _e;
-        this.logger = context.logger;
-        console.log(`Executing action started: ${this.name}`);
+        var _a, _b;
+        logger$1.debug(`Executing action started: ${this.name}`);
         // Create return tool with output schema
         const returnTool = createReturnTool(this.name, output.description, outputSchema);
         // Create tool map combining context tools, action tools, and return tool
@@ -9956,7 +10601,12 @@ class ActionImpl {
                 content: this.formatUserPrompt(this.name, this.description, this.tabs, existingTabs, patchs),
             },
         ];
-        this.logger.logActionStart(this.name, input, context);
+        logger$1.info("action start", {
+            action: {
+                name: this.name,
+                input,
+            },
+        });
         // Configure tool parameters
         const params = {
             ...this.llmConfig,
@@ -9973,19 +10623,15 @@ class ActionImpl {
                 throw new Error('Workflow cancelled');
             }
             roundCount++;
-            this.logger.log('info', `Starting round ${roundCount} of ${this.maxRounds}`, context);
+            logger$1.info(`Starting round ${roundCount} of ${this.maxRounds}`);
             const { response, hasToolUse, roundMessages } = await this.executeSingleRound(messages, params, toolMap, context);
-            if (response === null || response === void 0 ? void 0 : response.textContent) {
-                (_e = (_d = (_c = context.callback) === null || _c === void 0 ? void 0 : _c.hooks) === null || _d === void 0 ? void 0 : _d.onLlmMessage) === null || _e === void 0 ? void 0 : _e.call(_d, response.textContent);
-            }
             // Add round messages to conversation history
             messages.push(...roundMessages);
-            this.logger.log('debug', `Round ${roundCount} messages: ${JSON.stringify(roundMessages)}`, context);
             // Check termination conditions
             if (!hasToolUse && response) {
                 // LLM sent a message without using tools - request explicit return
-                this.logger.log('info', `Assistant: ${response.textContent}`);
-                this.logger.log('warn', 'LLM sent a message without using tools; requesting explicit return');
+                logger$1.info(`Assistant: ${response.textContent}`);
+                logger$1.warn('LLM sent a message without using tools; requesting explicit return');
                 const returnOnlyParams = {
                     ...params,
                     tools: [
@@ -10009,7 +10655,7 @@ class ActionImpl {
             }
             // If this is the last round, force an explicit return
             if (roundCount === this.maxRounds) {
-                this.logger.log('warn', 'Max rounds reached, requesting explicit return');
+                logger$1.warn('Max rounds reached, requesting explicit return');
                 const returnOnlyParams = {
                     ...params,
                     tools: [
@@ -10032,7 +10678,7 @@ class ActionImpl {
         const outputKey = `__action_${this.name}_output`;
         const outputParams = context.variables.get(outputKey);
         if (!outputParams) {
-            console.warn('outputParams is `undefined`, action return `{}`');
+            logger$1.warn('outputParams is `undefined`, action return `{}`');
             return { nodeOutput: {}, reacts: messages };
         }
         context.variables.delete(outputKey);
@@ -10041,7 +10687,7 @@ class ActionImpl {
             ? Array.from(this.toolResults.values()).pop()
             : outputParams === null || outputParams === void 0 ? void 0 : outputParams.value;
         if (outputValue === undefined) {
-            console.warn('Action completed without returning a value');
+            logger$1.warn('Action completed without returning a value');
             return { nodeOutput: {}, reacts: messages };
         }
         return { nodeOutput: outputValue, reacts: messages };
@@ -10049,7 +10695,7 @@ class ActionImpl {
     formatSystemPrompt() {
         const now = new Date();
         const formattedTime = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')} ${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}:${String(now.getSeconds()).padStart(2, '0')}`;
-        console.log('Now is ' + formattedTime);
+        logger$1.debug('Now is ' + formattedTime);
         return `You are an AI agent designed to automate browser tasks. Your goal is to accomplish the ultimate task following the rules. Now is ${formattedTime}.
 
 ## GENERIC:
@@ -10166,7 +10812,7 @@ Navigation Bar or Menu Changes: After logging in, the navigation bar will includ
             return data.map((entryWithScore) => entryWithScore.entry);
         }
         catch (error) {
-            console.error('Failed to fetch patches:', error);
+            logger$1.error('Failed to fetch patches:', error);
             return [];
         }
     }
@@ -10183,10 +10829,10 @@ Navigation Bar or Menu Changes: After logging in, the navigation bar will includ
                 //   "type": "string",
                 //   "description": 'Your observation of the previous steps. Should start with "In the previous step, I\'ve ...".',
                 // },
-                // thinking: {
-                //   "type": "string",
-                //   "description": 'Your thinking draft. Should start with "As observation before, now I should ...".',
-                // },
+                thinking: {
+                    "type": "string",
+                    "description": 'Your thinking draft.',
+                },
                 userSidePrompt: {
                     "type": "string",
                     "description": 'The user-side prompt, showing why calling this tool. Should start with "I\'m calling the ...(tool) to ...(target)". Rememeber to keep the same language of the ultimate task.',
@@ -10196,7 +10842,7 @@ Navigation Bar or Menu Changes: After logging in, the navigation bar will includ
             required: [
                 // comment for backup
                 // "observation",
-                // "thinking",
+                "thinking",
                 "userSidePrompt",
                 "toolCall",
             ],
@@ -10251,62 +10897,6 @@ The workflow must  ensure proper dependencies between nodes.`,
     };
 }
 
-const byteToHex = [];
-for (let i = 0; i < 256; ++i) {
-    byteToHex.push((i + 0x100).toString(16).slice(1));
-}
-function unsafeStringify(arr, offset = 0) {
-    return (byteToHex[arr[offset + 0]] +
-        byteToHex[arr[offset + 1]] +
-        byteToHex[arr[offset + 2]] +
-        byteToHex[arr[offset + 3]] +
-        '-' +
-        byteToHex[arr[offset + 4]] +
-        byteToHex[arr[offset + 5]] +
-        '-' +
-        byteToHex[arr[offset + 6]] +
-        byteToHex[arr[offset + 7]] +
-        '-' +
-        byteToHex[arr[offset + 8]] +
-        byteToHex[arr[offset + 9]] +
-        '-' +
-        byteToHex[arr[offset + 10]] +
-        byteToHex[arr[offset + 11]] +
-        byteToHex[arr[offset + 12]] +
-        byteToHex[arr[offset + 13]] +
-        byteToHex[arr[offset + 14]] +
-        byteToHex[arr[offset + 15]]).toLowerCase();
-}
-
-let getRandomValues;
-const rnds8 = new Uint8Array(16);
-function rng() {
-    if (!getRandomValues) {
-        if (typeof crypto === 'undefined' || !crypto.getRandomValues) {
-            throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
-        }
-        getRandomValues = crypto.getRandomValues.bind(crypto);
-    }
-    return getRandomValues(rnds8);
-}
-
-const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
-var native = { randomUUID };
-
-function v4(options, buf, offset) {
-    if (native.randomUUID && true && !options) {
-        return native.randomUUID();
-    }
-    options = options || {};
-    const rnds = options.random ?? options.rng?.() ?? rng();
-    if (rnds.length < 16) {
-        throw new Error('Random bytes length must be >= 16');
-    }
-    rnds[6] = (rnds[6] & 0x0f) | 0x40;
-    rnds[8] = (rnds[8] & 0x3f) | 0x80;
-    return unsafeStringify(rnds);
-}
-
 class WorkflowGenerator {
     constructor(llmProvider, toolRegistry) {
         this.llmProvider = llmProvider;
@@ -10380,12 +10970,10 @@ class WorkflowGenerator {
         });
         const workflowData = response.toolCalls[0].input.workflow;
         // debug
-        console.log("Debug the workflow...");
-        console.log({ ...workflowData });
-        console.log("Debug the workflow...Done");
+        logger$1.debug("Debug the workflow...", { ...workflowData });
         // Generate a new UUID if not provided
         if (!workflowData.id) {
-            workflowData.id = v4();
+            workflowData.id = uuid.v4();
         }
         return this.createFastWorkflowFromData(workflowData, ekoConfig);
     }
@@ -10400,7 +10988,7 @@ class WorkflowGenerator {
                 const tools = nodeData.action.tools.filter((toolName) => {
                     let hasTool = this.toolRegistry.hasTools([toolName]);
                     if (!hasTool) {
-                        console.warn(`The [${toolName}] tool does not exist.`);
+                        logger$1.warn(`The [${toolName}] tool does not exist.`);
                     }
                     return hasTool;
                 }).map((toolName) => this.toolRegistry.getTool(toolName));
@@ -10554,15 +11142,17 @@ class Eko {
         this.prompt = "";
         this.tabs = [];
         this.workflow = undefined;
-        console.info("using Eko@" + "ffed3dcfde4a8b89072e1c33ad98532f7522fe47");
-        console.warn("this version is POC, should not used for production");
         this.llmProvider = LLMProviderFactory.buildLLMProvider(llmConfig);
         this.ekoConfig = this.buildEkoConfig(ekoConfig);
         this.registerTools();
+        logger$1.info("using Eko@" + "eccb3dbbb41a09c67cd27351fbe1dd7491793d2b");
+    }
+    static getLogger() {
+        return logger$1;
     }
     buildEkoConfig(ekoConfig) {
         if (!ekoConfig) {
-            console.warn("`ekoConfig` is missing when construct `Eko` instance");
+            logger$1.warn("`ekoConfig` is missing when construct `Eko` instance");
         }
         const defaultEkoConfig = {
             workingWindowId: undefined,
@@ -10599,11 +11189,12 @@ class Eko {
             });
         }
         else {
-            console.warn("`ekoConfig.callback` is missing when construct `Eko` instance.");
+            logger$1.warn("`ekoConfig.callback` is missing when construct `Eko` instance.");
         }
         tools.forEach(tool => this.toolRegistry.registerTool(tool));
     }
     async generate(prompt, tabs = [], param) {
+        logger$1.info("workflow generating...");
         this.prompt = prompt;
         this.tabs = tabs;
         let toolRegistry = this.toolRegistry;
@@ -10622,12 +11213,12 @@ class Eko {
         const generator = new WorkflowGenerator(this.llmProvider, toolRegistry);
         const workflow = await generator.generateWorkflow(prompt, this.ekoConfig);
         this.workflowGeneratorMap.set(workflow, generator);
-        console.log("the workflow returned by generate");
-        console.log(workflow);
         this.workflow = workflow;
+        logger$1.info("workflow generating...done");
         return workflow;
     }
     async execute(workflow) {
+        logger$1.info("workflow executing...");
         let prompt = this.prompt;
         let description = "";
         workflow.nodes.forEach(node => {
@@ -10663,12 +11254,11 @@ class Eko {
                 },
             ],
         };
-        console.log("debug the workflow...");
-        console.log(json);
-        console.log("debug the workflow...done");
-        console.log("debug the LLMProvider...");
-        console.log(this.llmProvider);
-        console.log("debug the LLMProvider...done");
+        logger$1.debug("workflow", json);
+        logger$1.debug("LLMProvider", {
+            client: (typeof this.llmProvider.client),
+            defaultModel: this.llmProvider.defaultModel,
+        });
         const generator = new WorkflowGenerator(this.llmProvider, this.toolRegistry);
         workflow = await generator.generateWorkflowFromJson(json, this.ekoConfig);
         this.workflow = workflow;
@@ -10689,7 +11279,8 @@ class Eko {
             }
         }
         const result = await workflow.execute(this.ekoConfig.callback);
-        console.log(result);
+        logger$1.debug(result);
+        logger$1.info("workflow executing...done");
         return result;
     }
     async cancel() {
@@ -10966,8 +11557,6 @@ class WorkflowParser {
  * In this example, `tabs_get` is a mock implementation that logs the `tabId` before calling the original `chrome.tabs.get` method, and the same as `chrome.windows.create` method.
  */
 function createChromeApiProxy(mockClass) {
-    console.log("debug mockClass:");
-    console.log(mockClass);
     // Helper function to recursively create nested proxies
     function createNestedProxy(target, path) {
         return new Proxy(target, {