@kjerneverk/agentic 1.0.5-dev.0

package/dist/index.js

@@ -0,0 +1,1822 @@
+import { z, ZodError } from "zod";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var LogFormat_exports = {};
+__export(LogFormat_exports, {
+  LogFormats: () => LogFormats,
+  STRUCTURED: () => STRUCTURED,
+  TEXT: () => TEXT,
+  getConfig: () => getConfig
+});
+var TEXT = {
+  name: "TEXT",
+  description: "Text format"
+};
+var STRUCTURED = {
+  name: "STRUCTURED",
+  description: "Structured format"
+};
+var LogFormats = [
+  TEXT,
+  STRUCTURED
+];
+var getConfig = (name) => {
+  const config = LogFormats.find((config2) => config2.name === name);
+  if (!config) {
+    throw new Error(`Invalid Log Format Supplied to Logging Configuration '${name}'`);
+  }
+  return config;
+};
+var LogLevel_exports = {};
+__export(LogLevel_exports, {
+  ALERT: () => ALERT,
+  CRITICAL: () => CRITICAL,
+  DEBUG: () => DEBUG,
+  DEFAULT: () => DEFAULT,
+  EMERGENCY: () => EMERGENCY,
+  ERROR: () => ERROR,
+  INFO: () => INFO,
+  LogLevels: () => LogLevels,
+  NOTICE: () => NOTICE,
+  TRACE: () => TRACE,
+  WARNING: () => WARNING,
+  getConfig: () => getConfig2
+});
+var EMERGENCY = {
+  name: "EMERGENCY",
+  value: 0
+};
+var ALERT = {
+  name: "ALERT",
+  value: 1
+};
+var CRITICAL = {
+  name: "CRITICAL",
+  value: 2
+};
+var ERROR = {
+  name: "ERROR",
+  value: 3
+};
+var WARNING = {
+  name: "WARNING",
+  value: 4
+};
+var NOTICE = {
+  name: "NOTICE",
+  value: 5
+};
+var INFO = {
+  name: "INFO",
+  value: 6
+};
+var DEBUG = {
+  name: "DEBUG",
+  value: 7
+};
+var TRACE = {
+  name: "TRACE",
+  value: 8
+};
+var DEFAULT = {
+  name: "DEFAULT",
+  value: 9
+};
+var LogLevels = [
+  EMERGENCY,
+  ALERT,
+  CRITICAL,
+  ERROR,
+  WARNING,
+  NOTICE,
+  INFO,
+  DEBUG,
+  TRACE,
+  DEFAULT
+];
+var getConfig2 = (name) => {
+  const config = LogLevels.find((config2) => config2.name === name);
+  if (!config) {
+    throw new Error(`Invalid Log Level Supplied to Logging Configuration '${name}'`);
+  }
+  return config;
+};
+var defaultMaskingConfig = {
+  enabled: false,
+  maskEmails: true,
+  maskSSNs: true,
+  maskPrivateKeys: true,
+  maskBase64Blobs: true,
+  maskJWTs: true,
+  maxDepth: 8,
+  // New security-focused defaults (all true when masking is enabled)
+  maskApiKeys: true,
+  maskBearerTokens: true,
+  maskPasswords: true,
+  maskGenericSecrets: true
+};
+var defaultLogLevel = INFO;
+var defaultLogFormat = TEXT;
+var defaultLoggingConfig = {
+  logLevel: defaultLogLevel,
+  logFormat: defaultLogFormat,
+  overrides: {},
+  floodControl: {
+    enabled: false,
+    threshold: 10,
+    timeframe: 1e3
+    // 1 second
+  },
+  masking: defaultMaskingConfig
+};
+var convertComponentOverride = (override) => {
+  const result = {
+    logLevel: override.logLevel ? getConfig2(override.logLevel) : defaultLogLevel
+  };
+  if (override.components && typeof override.components === "object") {
+    result.components = {};
+    Object.entries(override.components).forEach(([componentName, componentOverride]) => {
+      result.components[componentName] = convertComponentOverride(componentOverride);
+    });
+  }
+  return result;
+};
+var convertOverrides = (overrides) => {
+  const convertedOverrides = {};
+  if (overrides) {
+    Object.entries(overrides).forEach(([key, value]) => {
+      convertedOverrides[key] = convertComponentOverride(value);
+    });
+  }
+  return convertedOverrides;
+};
+var convertConfig = (config) => {
+  return {
+    logLevel: config.logLevel ? getConfig2(config.logLevel) : defaultLogLevel,
+    logFormat: config.logFormat ? getConfig(config.logFormat) : defaultLogFormat,
+    overrides: convertOverrides(config.overrides),
+    floodControl: {
+      ...defaultLoggingConfig.floodControl,
+      ...config.floodControl || {}
+    },
+    masking: {
+      ...defaultLoggingConfig.masking,
+      ...config.masking || {}
+    }
+  };
+};
+var resolveLogLevel = (config, category, components) => {
+  let logLevel = config.logLevel;
+  const overrides = config.overrides;
+  if (!overrides || !overrides[category]) {
+    return logLevel;
+  }
+  let currentOverride = overrides[category];
+  logLevel = currentOverride.logLevel;
+  for (const component of components) {
+    if (!currentOverride.components || !currentOverride.components[component]) {
+      break;
+    }
+    currentOverride = currentOverride.components[component];
+    logLevel = currentOverride.logLevel;
+  }
+  return logLevel;
+};
+var configureLogging = () => {
+  let config = {};
+  const loggingConfigEnv = process.env.LOGGING_CONFIG;
+  const expoLoggingConfigEnv = process.env.EXPO_PUBLIC_LOGGING_CONFIG;
+  const nextLoggingConfigEnv = process.env.NEXT_PUBLIC_LOGGING_CONFIG;
+  let logLevelEnv = process.env.LOG_LEVEL;
+  let logFormatEnv = process.env.LOG_FORMAT;
+  if (loggingConfigEnv) {
+    try {
+      config = JSON.parse(loggingConfigEnv);
+    } catch (error) {
+      console.error("Invalid JSON in LOGGING_CONFIG environment variable:", error);
+      config = {};
+    }
+  } else if (expoLoggingConfigEnv) {
+    try {
+      config = JSON.parse(expoLoggingConfigEnv);
+    } catch (error) {
+      console.error("Invalid JSON in EXPO_PUBLIC_LOGGING_CONFIG environment variable:", error);
+      config = {};
+    }
+  } else if (nextLoggingConfigEnv) {
+    try {
+      config = JSON.parse(nextLoggingConfigEnv);
+    } catch (error) {
+      console.error("Invalid JSON in NEXT_PUBLIC_LOGGING_CONFIG environment variable:", error);
+      config = {};
+    }
+  }
+  const convertedConfig = convertConfig(config);
+  if (logLevelEnv) {
+    logLevelEnv = logLevelEnv?.toUpperCase();
+    const logLevelConfig = getConfig2(logLevelEnv);
+    convertedConfig.logLevel = logLevelConfig;
+  }
+  if (logFormatEnv) {
+    logFormatEnv = logFormatEnv.toUpperCase();
+    const logFormatConfig = getConfig(logFormatEnv);
+    convertedConfig.logFormat = logFormatConfig;
+  }
+  const finalConfig = { ...defaultLoggingConfig, ...convertedConfig };
+  return finalConfig;
+};
+var createWriter = (formatter, logMethod, options = {}) => {
+  const {
+    respectInjectedMethod = false,
+    errorMethod = console.error,
+    warningMethod = console.warn,
+    infoMethod = console.log
+  } = options;
+  return {
+    write: (level, coordinates, payload) => {
+      let finalLogMethod = logMethod;
+      if (!respectInjectedMethod) {
+        if (level.name === ERROR.name || level.name === CRITICAL.name || level.name === ALERT.name || level.name === EMERGENCY.name) {
+          finalLogMethod = errorMethod;
+        } else if (level.name === WARNING.name) {
+          finalLogMethod = warningMethod;
+        } else {
+          finalLogMethod = infoMethod;
+        }
+      }
+      finalLogMethod(formatter.formatLog(level, coordinates, payload));
+    }
+  };
+};
+var stringifyJSON = function(obj, visited = /* @__PURE__ */ new Set()) {
+  try {
+    return stringifyJSONCustom(obj, visited);
+  } catch (error) {
+    console.error("[Fjell Logging] Critical error in stringifyJSON, using ultimate fallback:", error);
+    try {
+      return `"[Object: ${typeof obj}]"`;
+    } catch {
+      return '"[Object: unknown]"';
+    }
+  }
+};
+var STRINGIFY_CONFIG = {
+  MAX_ARRAY_ELEMENTS: 100,
+  MAX_OBJECT_PROPERTIES: 100,
+  TRUNCATION_MESSAGE: "...[truncated]"
+};
+var stringifyJSONCustom = function(obj, visited = /* @__PURE__ */ new Set()) {
+  try {
+    const arrOfKeyVals = [];
+    const arrVals = [];
+    let objKeys = [];
+    if (typeof obj === "number" || typeof obj === "boolean" || obj === null)
+      return "" + obj;
+    else if (typeof obj === "string")
+      return '"' + obj + '"';
+    else if (typeof obj === "symbol")
+      return "";
+    else if (typeof obj === "function")
+      return "";
+    else if (obj instanceof Date)
+      return "{}";
+    else if (obj instanceof RegExp)
+      return "{}";
+    else if (obj instanceof Error)
+      return "{}";
+    else if (typeof obj === "object" && obj.constructor && obj.constructor.name === "Buffer") {
+      const result = {};
+      for (let i = 0; i < obj.length; i++) {
+        result[i] = obj[i];
+      }
+      return stringifyJSONCustom(result, visited);
+    }
+    if (obj instanceof Object && visited.has(obj)) {
+      return '"(circular)"';
+    } else if (Array.isArray(obj)) {
+      if (obj.length === 0)
+        return "[]";
+      else {
+        visited.add(obj);
+        try {
+          const maxElements = STRINGIFY_CONFIG.MAX_ARRAY_ELEMENTS;
+          const shouldTruncate = obj.length > maxElements;
+          const elementsToProcess = shouldTruncate ? maxElements : obj.length;
+          for (let i = 0; i < elementsToProcess; i++) {
+            try {
+              arrVals.push(stringifyJSONCustom(obj[i], visited));
+            } catch {
+              arrVals.push('"[Error serializing array element]"');
+            }
+          }
+          if (shouldTruncate) {
+            arrVals.push(`"${STRINGIFY_CONFIG.TRUNCATION_MESSAGE} (${obj.length - maxElements} more items)"`);
+          }
+        } finally {
+          visited.delete(obj);
+        }
+        try {
+          return "[" + arrVals.join(",") + "]";
+        } catch {
+          console.warn("[Fjell Logging] Array too large to serialize completely, using truncated representation");
+          return `[${arrVals.slice(0, 10).join(",")},${STRINGIFY_CONFIG.TRUNCATION_MESSAGE}]`;
+        }
+      }
+    } else if (obj instanceof Object) {
+      visited.add(obj);
+      try {
+        objKeys = Object.keys(obj);
+        const maxProperties = STRINGIFY_CONFIG.MAX_OBJECT_PROPERTIES;
+        const shouldTruncate = objKeys.length > maxProperties;
+        const propertiesToProcess = shouldTruncate ? maxProperties : objKeys.length;
+        for (let i = 0; i < propertiesToProcess; i++) {
+          const key = objKeys[i];
+          try {
+            const keyOut = '"' + key + '":';
+            const keyValOut = obj[key];
+            if (keyValOut instanceof Function || typeof keyValOut === "undefined")
+              continue;
+            else if (typeof keyValOut === "string")
+              arrOfKeyVals.push(keyOut + '"' + keyValOut + '"');
+            else if (typeof keyValOut === "boolean" || typeof keyValOut === "number" || keyValOut === null)
+              arrOfKeyVals.push(keyOut + keyValOut);
+            else if (keyValOut instanceof Object) {
+              arrOfKeyVals.push(keyOut + stringifyJSONCustom(keyValOut, visited));
+            }
+          } catch {
+            arrOfKeyVals.push('"' + key + '":"[Error serializing property]"');
+          }
+        }
+        if (shouldTruncate) {
+          arrOfKeyVals.push(`"${STRINGIFY_CONFIG.TRUNCATION_MESSAGE}":"(${objKeys.length - maxProperties} more properties)"`);
+        }
+      } finally {
+        visited.delete(obj);
+      }
+      try {
+        return "{" + arrOfKeyVals.join(",") + "}";
+      } catch {
+        console.warn("[Fjell Logging] Object too large to serialize completely, using truncated representation");
+        return `{${arrOfKeyVals.slice(0, 10).join(",")},${STRINGIFY_CONFIG.TRUNCATION_MESSAGE}}`;
+      }
+    }
+    return "";
+  } catch (error) {
+    console.error("[Fjell Logging] Error in stringifyJSONCustom, using fallback:", error);
+    return "[Object: serialization failed]";
+  }
+};
+var safeFormat = (message, ...args) => {
+  let result = message;
+  let argIndex = 0;
+  result = result.replace(/%([sdjifoO%])/g, (match, specifier) => {
+    if (specifier === "%") {
+      return "%";
+    }
+    if (argIndex >= args.length) {
+      return match;
+    }
+    const arg = args[argIndex++];
+    switch (specifier) {
+      case "s":
+        return String(arg);
+      case "d":
+        return String(parseInt(arg, 10));
+      case "i":
+        return String(parseInt(arg, 10));
+      case "f":
+        return String(parseFloat(arg));
+      case "j":
+        try {
+          return stringifyJSON(arg);
+        } catch {
+          return String(arg);
+        }
+      case "o":
+        return stringifyJSON(arg);
+      case "O":
+        return stringifyJSON(arg);
+      default:
+        return String(arg);
+    }
+  });
+  return result;
+};
+var safeInspect = (obj) => {
+  try {
+    if (obj && typeof obj === "object" && obj.problematic && typeof obj.problematic === "object") {
+      return "[Object: object]";
+    }
+    return stringifyJSON(obj);
+  } catch {
+    return `[Object: ${typeof obj}]`;
+  }
+};
+var safeJSONStringify = (obj) => {
+  try {
+    const seen = /* @__PURE__ */ new WeakSet();
+    return JSON.stringify(obj, (key, value) => {
+      try {
+        if (typeof value === "symbol") {
+          return String(value);
+        }
+        if (typeof value === "function") {
+          return "[Function]";
+        }
+        if (typeof value === "object" && value !== null) {
+          if (seen.has(value)) {
+            return "[Circular Reference]";
+          }
+          seen.add(value);
+        }
+        if (value instanceof Error) {
+          return {
+            name: value.name,
+            message: value.message,
+            stack: value.stack
+          };
+        }
+        if (value instanceof RegExp) {
+          return value.toString();
+        }
+        if (value instanceof Date) {
+          return value.toISOString();
+        }
+        return value;
+      } catch (error) {
+        console.error("[Fjell Logging] Error processing value in replacer:", error);
+        return "[Error: unable to serialize value]";
+      }
+    });
+  } catch (error) {
+    console.error("[Fjell Logging] CRITICAL: safeJSONStringify failed, returning fallback:", error);
+    try {
+      const message = obj?.message || obj?.severity || "Unknown";
+      return JSON.stringify({
+        severity: "ERROR",
+        message: "[Fjell Logging] Failed to serialize log entry",
+        originalMessage: String(message),
+        error: "Circular reference or non-serializable object detected"
+      });
+    } catch {
+      return '{"severity":"ERROR","message":"[Fjell Logging] Critical serialization failure"}';
+    }
+  }
+};
+var createFormatter = (logFormat) => {
+  if (logFormat.name === "TEXT") {
+    return getTextFormatter();
+  } else if (logFormat.name === "STRUCTURED") {
+    return getStructuredFormatter();
+  }
+  throw new Error(`Unknown log format: ${logFormat.name}`);
+};
+var getTextFormatter = () => {
+  const formatLog = (level, coordinates, payload) => {
+    const hasSpecifiers = /%[sdjifoO%]/.test(payload.message);
+    let logMessage;
+    if (payload.data.length === 0) {
+      logMessage = payload.message;
+    } else if (hasSpecifiers) {
+      logMessage = safeFormat(payload.message, ...payload.data);
+    } else {
+      logMessage = `${payload.message} ${safeInspect(payload.data)}`;
+    }
+    return `(${(/* @__PURE__ */ new Date()).valueOf()}) [${level.name}] - [${coordinates.category}] ${coordinates.components.map((c) => `[${c}]`)} ${logMessage}`;
+  };
+  const timerMessage = (level, coordinates, payload) => {
+    const randomInt = Math.floor(Math.random() * 1e6);
+    const timerMessage2 = `(${(/* @__PURE__ */ new Date()).valueOf()}) [${level.name}] - [${coordinates.category}] ${coordinates.components.map((c) => `[${c}]`)} ${safeFormat(payload.message, ...payload.data)} ${safeInspect(payload.data)} ${randomInt}`;
+    return timerMessage2;
+  };
+  return { formatLog, timerMessage, getLogFormat: () => TEXT };
+};
+var getStructuredFormatter = () => {
+  const formatLog = (level, coordinates, payload) => {
+    const severity = level.name;
+    const hasSpecifiers = /%[sdjifoO%]/.test(payload.message);
+    return safeJSONStringify({
+      severity,
+      message: hasSpecifiers ? safeFormat(payload.message, ...payload.data) : payload.message,
+      "logging.googleapis.com/labels": {
+        category: coordinates.category,
+        components: `${coordinates.components.map((c) => `[${c}]`)}`
+      },
+      ...!hasSpecifiers && payload.data.length > 0 && { data: safeInspect(payload.data) }
+    });
+  };
+  const timerMessage = (level, coordinates, payload) => {
+    const severity = level.name;
+    const randomInt = Math.floor(Math.random() * 1e6);
+    return safeJSONStringify({
+      severity,
+      message: safeFormat(payload.message, ...payload.data),
+      "logging.googleapis.com/labels": {
+        category: coordinates.category,
+        components: `${coordinates.components.map((c) => `[${c}]`)}`
+      },
+      data: safeInspect(payload.data),
+      "logging.googleapis.com/spanId": String(randomInt)
+    });
+  };
+  return { formatLog, timerMessage, getLogFormat: () => STRUCTURED };
+};
+var hash = (message, data) => {
+  const dataString = data.map((item) => {
+    try {
+      return JSON.stringify(item);
+    } catch {
+      return stringifyJSON(item);
+    }
+  }).join("");
+  return `${message}${dataString}`;
+};
+var FloodControl = class {
+  config;
+  history = /* @__PURE__ */ new Map();
+  suppressed = /* @__PURE__ */ new Map();
+  cleanupTimer = null;
+  constructor(config) {
+    this.config = config;
+    if (this.config.enabled) {
+      this.cleanupTimer = setInterval(() => this.cleanup(), this.config.timeframe * 2);
+    }
+  }
+  destroy() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [hash2, timestamps] of this.history.entries()) {
+      const recentTimestamps = timestamps.filter(
+        (timestamp) => now - timestamp < this.config.timeframe
+      );
+      if (recentTimestamps.length > 0) {
+        this.history.set(hash2, recentTimestamps);
+      } else {
+        this.history.delete(hash2);
+        this.suppressed.delete(hash2);
+      }
+    }
+  }
+  check(message, data) {
+    if (!this.config.enabled) {
+      return "log";
+    }
+    const messageHash = hash(message, data);
+    const now = Date.now();
+    const timestamps = (this.history.get(messageHash) || []).filter(
+      (timestamp) => now - timestamp < this.config.timeframe
+    );
+    timestamps.push(now);
+    this.history.set(messageHash, timestamps);
+    if (timestamps.length > this.config.threshold) {
+      const suppressedInfo = this.suppressed.get(messageHash);
+      if (suppressedInfo) {
+        suppressedInfo.count++;
+        return "suppress";
+      } else {
+        this.suppressed.set(messageHash, { count: 1, firstTimestamp: timestamps[0], summaryLogged: false });
+        return "suppress";
+      }
+    } else {
+      if (this.suppressed.has(messageHash)) {
+        this.suppressed.delete(messageHash);
+        return "resume";
+      }
+    }
+    return "log";
+  }
+  getSuppressedCount(message, data) {
+    const messageHash = hash(message, data);
+    return this.suppressed.get(messageHash)?.count || 0;
+  }
+};
+var createLogger = (logFormat, logLevel, coordinates, floodControlConfig, loggingConfig, writerOptions, options) => {
+  const formatter = createFormatter(logFormat);
+  const floodControl = floodControlConfig.enabled ? new FloodControl(floodControlConfig) : null;
+  const logFunction = console.log;
+  const writer = createWriter(formatter, logFunction, writerOptions);
+  const asyncLogging = options?.asyncLogging !== false;
+  const enableDebugBuffering = asyncLogging;
+  const debugBuffer = [];
+  const DEBUG_BUFFER_SIZE = 100;
+  const DEBUG_FLUSH_INTERVAL = 100;
+  let debugFlushTimer = null;
+  const flushDebugBuffer = () => {
+    if (debugBuffer.length === 0) return;
+    try {
+      const messagesToFlush = [...debugBuffer];
+      debugBuffer.length = 0;
+      messagesToFlush.forEach(({ level, coordinates: coordinates2, payload }) => {
+        try {
+          writer.write(level, coordinates2, payload);
+        } catch (error) {
+          console.error("[Fjell Logging] Error writing buffered log message:", error);
+        }
+      });
+    } catch (error) {
+      console.error("[Fjell Logging] Error flushing debug buffer:", error);
+    } finally {
+      if (debugFlushTimer) {
+        clearTimeout(debugFlushTimer);
+        debugFlushTimer = null;
+      }
+    }
+  };
+  const scheduleDebugFlush = () => {
+    if (debugFlushTimer) return;
+    try {
+      debugFlushTimer = setTimeout(() => {
+        try {
+          flushDebugBuffer();
+        } catch (error) {
+          console.error("[Fjell Logging] Error in scheduled debug flush:", error);
+        }
+      }, DEBUG_FLUSH_INTERVAL);
+    } catch (error) {
+      console.error("[Fjell Logging] Error scheduling debug flush:", error);
+    }
+  };
+  const writeImmediate = (level, coordinates2, payload) => {
+    try {
+      writer.write(level, coordinates2, payload);
+    } catch (error) {
+      console.error("[Fjell Logging] Error writing log message:", error);
+    }
+  };
+  const handleDebugBuffering = (level, coordinates2, payload) => {
+    try {
+      debugBuffer.push({ level, coordinates: coordinates2, payload });
+      if (debugBuffer.length >= DEBUG_BUFFER_SIZE) {
+        flushDebugBuffer();
+      } else {
+        scheduleDebugFlush();
+      }
+    } catch (error) {
+      console.error("[Fjell Logging] Error buffering debug message, falling back to immediate write:", error);
+      writeImmediate(level, coordinates2, payload);
+    }
+  };
+  const write = (level, message, data) => {
+    if (logLevel.value < level.value) {
+      return;
+    }
+    const check = floodControl ? floodControl.check(message, data) : "log";
+    const payload = { message, data };
+    const asyncWrite = () => {
+      try {
+        switch (check) {
+          case "log":
+            if (enableDebugBuffering && (level.name === "TRACE" || level.name === "DEFAULT" || level.name === "DEBUG")) {
+              handleDebugBuffering(level, coordinates, payload);
+            } else {
+              writeImmediate(level, coordinates, payload);
+            }
+            break;
+          case "suppress":
+            if (floodControl && floodControl.getSuppressedCount(message, data) === 1) {
+              try {
+                const originalLevel = level;
+                const newPayload = { message: `Started suppressing repeated log message`, data: [] };
+                writer.write(originalLevel, coordinates, newPayload);
+              } catch (error) {
+                console.error("[Fjell Logging] Error writing suppress message:", error);
+              }
+            }
+            break;
+          case "resume": {
+            try {
+              const count = floodControl ? floodControl.getSuppressedCount(message, data) : 0;
+              const resumePayload = {
+                message: `Stopped suppressing repeated log message. Suppressed ${count} times.`,
+                data: []
+              };
+              writer.write(level, coordinates, resumePayload);
+              writer.write(level, coordinates, payload);
+            } catch (error) {
+              console.error("[Fjell Logging] Error writing resume messages:", error);
+            }
+            break;
+          }
+        }
+      } catch (error) {
+        console.error("[Fjell Logging] Error in async write operation:", error);
+      }
+    };
+    if (asyncLogging) {
+      try {
+        if (typeof setImmediate !== "undefined") {
+          setImmediate(asyncWrite);
+        } else {
+          setTimeout(asyncWrite, 0);
+        }
+      } catch (error) {
+        console.error("[Fjell Logging] Error scheduling async write, falling back to sync:", error);
+        try {
+          asyncWrite();
+        } catch (syncError) {
+          console.error("[Fjell Logging] Error in synchronous fallback write:", syncError);
+        }
+      }
+    } else {
+      asyncWrite();
+    }
+  };
+  const startTimeLogger = (logLevel2, coordinates2, payload) => {
+    const timerMessage = formatter.timerMessage(logLevel2, coordinates2, payload);
+    logLevel2.value >= DEBUG.value && console.time(timerMessage);
+    return {
+      end: () => {
+        logLevel2.value >= DEBUG.value && console.timeEnd(timerMessage);
+      },
+      log: (...data) => {
+        logLevel2.value >= DEBUG.value && console.timeLog(timerMessage, ...data);
+      }
+    };
+  };
+  return {
+    emergency: (message, ...data) => {
+      write(EMERGENCY, message, data);
+    },
+    alert: (message, ...data) => {
+      write(ALERT, message, data);
+    },
+    critical: (message, ...data) => {
+      write(CRITICAL, message, data);
+    },
+    error: (message, ...data) => {
+      write(ERROR, message, data);
+    },
+    warning: (message, ...data) => {
+      write(WARNING, message, data);
+    },
+    notice: (message, ...data) => {
+      write(NOTICE, message, data);
+    },
+    info: (message, ...data) => {
+      write(INFO, message, data);
+    },
+    debug: (message, ...data) => {
+      write(DEBUG, message, data);
+    },
+    trace: (message, ...data) => {
+      write(TRACE, message, data);
+    },
+    default: (message, ...data) => {
+      write(DEFAULT, message, data);
+    },
+    time: (message, ...data) => {
+      const payload = { message, data };
+      return startTimeLogger(logLevel, coordinates, payload);
+    },
+    get: (...additionalComponents) => {
+      const newComponents = [...coordinates.components, ...additionalComponents];
+      let childLogLevel = logLevel;
+      if (loggingConfig) {
+        childLogLevel = resolveLogLevel(loggingConfig, coordinates.category, newComponents);
+      }
+      return createLogger(logFormat, childLogLevel, {
+        category: coordinates.category,
+        components: newComponents
+      }, floodControlConfig, loggingConfig, writerOptions, options);
+    },
+    destroy: () => {
+      try {
+        flushDebugBuffer();
+      } catch (error) {
+        console.error("[Fjell Logging] Error flushing debug buffer during destroy:", error);
+      }
+      try {
+        if (debugFlushTimer) {
+          clearTimeout(debugFlushTimer);
+          debugFlushTimer = null;
+        }
+      } catch (error) {
+        console.error("[Fjell Logging] Error clearing debug flush timer during destroy:", error);
+      }
+      try {
+        if (floodControl) {
+          floodControl.destroy();
+        }
+      } catch (error) {
+        console.error("[Fjell Logging] Error destroying flood control during destroy:", error);
+      }
+    }
+  };
+};
+var getLogger = (name) => {
+  const config = configureLogging();
+  const logger = createBaseLogger(name, config);
+  return logger;
+};
+var createBaseLogger = (name, config) => {
+  const { logFormat, floodControl } = config;
+  const coordinates = { category: name, components: [] };
+  const logLevel = resolveLogLevel(config, name, []);
+  return createLogger(logFormat, logLevel, coordinates, floodControl, config, void 0, {
+    asyncLogging: false
+  });
+};
+var index_default = { getLogger };
+const LIBRARY_NAME = "agentic";
+const LibLogger = index_default.getLogger("@riotprompt/agentic");
+function createSilentLogger(name) {
+  return {
+    name,
+    debug: () => {
+    },
+    info: () => {
+    },
+    warn: () => {
+    },
+    error: () => {
+    },
+    verbose: () => {
+    },
+    silly: () => {
+    },
+    get: (...components) => createSilentLogger(`${name}:${components.join(":")}`)
+  };
+}
+const SILENT_LOGGER = createSilentLogger("silent");
+const isLoggingEnabled = () => {
+  return process.env.AGENTIC_LOGGING === "true" || process.env.DEBUG?.includes("agentic") || process.env.NODE_ENV === "development";
+};
+function createLoggerFromFjell(fjellLogger, name) {
+  return {
+    name,
+    debug: (message, ...args) => fjellLogger.debug(message, ...args),
+    info: (message, ...args) => fjellLogger.info(message, ...args),
+    warn: (message, ...args) => fjellLogger.warning(message, ...args),
+    error: (message, ...args) => fjellLogger.error(message, ...args),
+    verbose: (message, ...args) => fjellLogger.debug(message, ...args),
+    silly: (message, ...args) => fjellLogger.debug(message, ...args),
+    get: (...components) => {
+      const childLogger = fjellLogger.get(...components);
+      return createLoggerFromFjell(childLogger, `${name}:${components.join(":")}`);
+    }
+  };
+}
+const FJELL_LOGGER = {
+  name: "fjell",
+  debug: (message, ...args) => LibLogger.debug(message, ...args),
+  info: (message, ...args) => LibLogger.info(message, ...args),
+  warn: (message, ...args) => LibLogger.warning(message, ...args),
+  error: (message, ...args) => LibLogger.error(message, ...args),
+  verbose: (message, ...args) => LibLogger.debug(message, ...args),
+  silly: (message, ...args) => LibLogger.debug(message, ...args),
+  get: (...components) => {
+    const childLogger = LibLogger.get(...components);
+    return createLoggerFromFjell(childLogger, components.join(":"));
+  }
+};
+const DEFAULT_LOGGER = isLoggingEnabled() ? FJELL_LOGGER : SILENT_LOGGER;
+function wrapLogger(toWrap, name) {
+  const requiredMethods = [
+    "debug",
+    "info",
+    "warn",
+    "error",
+    "verbose",
+    "silly"
+  ];
+  const missingMethods = requiredMethods.filter(
+    (method) => typeof toWrap[method] !== "function"
+  );
+  if (missingMethods.length > 0) {
+    throw new Error(
+      `Logger is missing required methods: ${missingMethods.join(", ")}`
+    );
+  }
+  const log = (level, message, ...args) => {
+    message = `[${LIBRARY_NAME}] ${name ? `[${name}]` : ""}: ${message}`;
+    if (level === "debug") toWrap.debug(message, ...args);
+    else if (level === "info") toWrap.info(message, ...args);
+    else if (level === "warn") toWrap.warn(message, ...args);
+    else if (level === "error") toWrap.error(message, ...args);
+    else if (level === "verbose") toWrap.verbose(message, ...args);
+    else if (level === "silly") toWrap.silly(message, ...args);
+  };
+  return {
+    name: name || "wrapped",
+    debug: (message, ...args) => log("debug", message, ...args),
+    info: (message, ...args) => log("info", message, ...args),
+    warn: (message, ...args) => log("warn", message, ...args),
+    error: (message, ...args) => log("error", message, ...args),
+    verbose: (message, ...args) => log("verbose", message, ...args),
+    silly: (message, ...args) => log("silly", message, ...args),
+    get: (...components) => wrapLogger(toWrap, name ? `${name}:${components.join(":")}` : components.join(":"))
+  };
+}
+const ToolSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().min(1),
+  parameters: z.object({
+    type: z.literal("object"),
+    properties: z.record(z.string(), z.any()).default({}),
+    required: z.array(z.string()).optional()
+  }).passthrough(),
+  execute: z.custom(
+    (val) => typeof val === "function",
+    { message: "execute must be a function" }
+  ),
+  category: z.string().optional(),
+  cost: z.enum(["cheap", "moderate", "expensive"]).optional(),
+  examples: z.array(
+    z.object({
+      scenario: z.string(),
+      params: z.any(),
+      expectedResult: z.string()
+    })
+  ).optional()
+}).passthrough();
+class ToolRegistry {
+  tools;
+  context;
+  logger;
+  usageStats;
+  toolGuard;
+  toolSandbox;
+  constructor(context = {}, logger) {
+    this.tools = /* @__PURE__ */ new Map();
+    this.context = context;
+    this.logger = wrapLogger(logger || DEFAULT_LOGGER, "ToolRegistry");
+    this.usageStats = /* @__PURE__ */ new Map();
+    this.logger.debug("Created ToolRegistry");
+  }
+  /**
+   * Create a new ToolRegistry instance
+   */
+  static create(context, logger) {
+    return new ToolRegistry(context, logger);
+  }
+  /**
+   * Configure security guard for tool execution
+   */
+  withSecurity(guard) {
+    this.toolGuard = guard;
+    this.logger.debug("Security guard configured");
+    return this;
+  }
+  /**
+   * Get the configured security guard
+   */
+  getSecurityGuard() {
+    return this.toolGuard;
+  }
+  /**
+   * Configure sandbox for tool execution
+   */
+  withSandbox(sandbox) {
+    this.toolSandbox = sandbox;
+    this.logger.debug("Sandbox configured");
+    return this;
+  }
+  /**
+   * Get the configured sandbox
+   */
+  getSandbox() {
+    return this.toolSandbox;
+  }
+  /**
+   * Register a single tool
+   */
+  register(tool) {
+    try {
+      ToolSchema.parse(tool);
+    } catch (error) {
+      throw new Error(`Invalid tool definition for "${tool.name}": ${error}`);
+    }
+    if (this.tools.has(tool.name)) {
+      this.logger.warn(`Tool "${tool.name}" already registered, overwriting`);
+    }
+    this.tools.set(tool.name, tool);
+    this.usageStats.set(tool.name, { calls: 0, failures: 0, totalDuration: 0 });
+    this.logger.debug("Registered tool", {
+      name: tool.name,
+      category: tool.category
+    });
+  }
+  /**
+   * Register multiple tools at once
+   */
+  registerAll(tools) {
+    this.logger.debug("Registering multiple tools", { count: tools.length });
+    tools.forEach((tool) => this.register(tool));
+  }
+  /**
+   * Get a tool by name
+   */
+  get(name) {
+    return this.tools.get(name);
+  }
+  /**
+   * Get all registered tools
+   */
+  getAll() {
+    return Array.from(this.tools.values());
+  }
+  /**
+   * Get tools by category
+   */
+  getByCategory(category) {
+    return this.getAll().filter((tool) => tool.category === category);
+  }
+  /**
+   * Check if a tool is registered
+   */
+  has(name) {
+    return this.tools.has(name);
+  }
+  /**
+   * Get number of registered tools
+   */
+  count() {
+    return this.tools.size;
+  }
+  /**
+   * Execute a tool by name
+   */
+  async execute(name, params) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      throw new Error(`Tool "${name}" not found`);
+    }
+    if (this.toolGuard && !this.toolGuard.isToolAllowed(name)) {
+      throw new Error(`Tool "${name}" is not allowed`);
+    }
+    if (this.toolGuard && tool.schema) {
+      const validation = this.toolGuard.validateParams(
+        name,
+        params,
+        tool.schema
+      );
+      if (!validation.success) {
+        throw new Error(`Tool "${name}": ${validation.error}`);
+      }
+      params = validation.data;
+    }
+    this.logger.debug("Executing tool", { name, params });
+    const startTime = Date.now();
+    const stats = this.usageStats.get(name);
+    stats.calls++;
+    try {
+      let result;
+      if (this.toolSandbox) {
+        result = await this.toolSandbox.execute(
+          tool,
+          params,
+          this.context
+        );
+      } else {
+        result = await tool.execute(params, this.context);
+      }
+      const duration = Date.now() - startTime;
+      stats.totalDuration += duration;
+      this.logger.debug("Tool execution succeeded", { name, duration });
+      return result;
+    } catch (error) {
+      stats.failures++;
+      this.logger.error("Tool execution failed", { name, error });
+      throw error;
+    }
+  }
+  /**
+   * Safely parse and execute a tool from JSON arguments
+   */
+  async executeFromJSON(name, jsonArgs) {
+    if (this.toolGuard) {
+      const parseResult = this.toolGuard.parseToolArguments(name, jsonArgs);
+      if (!parseResult.success) {
+        throw new Error(`Tool "${name}": ${parseResult.error}`);
+      }
+      return this.execute(name, parseResult.data);
+    }
+    const params = JSON.parse(jsonArgs);
+    return this.execute(name, params);
+  }
+  /**
+   * Execute multiple tools in sequence
+   */
+  async executeBatch(calls) {
+    this.logger.debug("Executing batch", { count: calls.length });
+    const results = [];
+    for (const call of calls) {
+      try {
+        const result = await this.execute(call.name, call.params);
+        results.push(result);
+      } catch (error) {
+        results.push({ error: String(error) });
+      }
+    }
+    return results;
+  }
+  /**
+   * Export tools in OpenAI format
+   */
+  toOpenAIFormat() {
+    return this.getAll().map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: {
+          type: "object",
+          properties: tool.parameters.properties,
+          required: tool.parameters.required
+        }
+      }
+    }));
+  }
+  /**
+   * Export tools in Anthropic format
+   */
+  toAnthropicFormat() {
+    return this.getAll().map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      input_schema: {
+        type: "object",
+        properties: tool.parameters.properties,
+        required: tool.parameters.required
+      }
+    }));
+  }
+  /**
+   * Get tool definitions (without execute function)
+   */
+  getDefinitions() {
+    return this.getAll().map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters,
+      category: tool.category,
+      cost: tool.cost,
+      examples: tool.examples,
+      schema: tool.schema
+    }));
+  }
+  /**
+   * Get usage statistics for all tools
+   */
+  getUsageStats() {
+    const stats = /* @__PURE__ */ new Map();
+    this.usageStats.forEach((rawStats, name) => {
+      stats.set(name, {
+        calls: rawStats.calls,
+        failures: rawStats.failures,
+        successRate: rawStats.calls > 0 ? (rawStats.calls - rawStats.failures) / rawStats.calls : 0,
+        averageDuration: rawStats.calls > 0 ? rawStats.totalDuration / rawStats.calls : void 0
+      });
+    });
+    return stats;
+  }
+  /**
+   * Get most frequently used tools
+   */
+  getMostUsed(limit = 5) {
+    const sorted = Array.from(this.usageStats.entries()).sort((a, b) => b[1].calls - a[1].calls).slice(0, limit).map(([name]) => this.tools.get(name)).filter((tool) => tool !== void 0);
+    return sorted;
+  }
+  /**
+   * Get list of all categories
+   */
+  getCategories() {
+    const categories = /* @__PURE__ */ new Set();
+    this.getAll().forEach((tool) => {
+      if (tool.category) {
+        categories.add(tool.category);
+      }
+    });
+    return Array.from(categories).sort();
+  }
+  /**
+   * Update execution context
+   */
+  updateContext(context) {
+    this.context = { ...this.context, ...context };
+    this.logger.debug("Updated context", { keys: Object.keys(context) });
+  }
+  /**
+   * Get current context
+   */
+  getContext() {
+    return { ...this.context };
+  }
+  /**
+   * Clear all tools
+   */
+  clear() {
+    this.logger.debug("Clearing all tools");
+    this.tools.clear();
+    this.usageStats.clear();
+  }
+  /**
+   * Unregister a specific tool
+   */
+  unregister(name) {
+    if (this.tools.has(name)) {
+      this.tools.delete(name);
+      this.usageStats.delete(name);
+      this.logger.debug("Unregistered tool", { name });
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Reset usage statistics
+   */
+  resetStats() {
+    this.logger.debug("Resetting usage statistics");
+    this.usageStats.forEach((stats) => {
+      stats.calls = 0;
+      stats.failures = 0;
+      stats.totalDuration = 0;
+    });
+  }
+}
+const DEFAULT_CONFIG = {
+  enabled: true,
+  validateParams: true,
+  sandboxExecution: false,
+  maxExecutionTime: 3e4,
+  maxConcurrentCalls: 10,
+  deniedTools: []
+};
+class ToolGuard {
+  config;
+  logger;
+  events;
+  constructor(config = {}, logger, events = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.logger = wrapLogger(logger || DEFAULT_LOGGER, "ToolGuard");
+    this.events = events;
+  }
+  /**
+   * Validate tool parameters against a Zod schema
+   */
+  validateParams(toolName, params, schema) {
+    if (!this.config.enabled || !this.config.validateParams) {
+      return { success: true, data: params };
+    }
+    try {
+      const data = schema.parse(params);
+      return { success: true, data };
+    } catch (error) {
+      if (error instanceof ZodError) {
+        const issues = error.issues || [];
+        const violations = issues.map(
+          (e) => `${e.path.join(".")}: ${e.message}`
+        );
+        const message = `Schema validation failed: ${violations.join("; ")}`;
+        this.logger.warn(`Tool validation failed for "${toolName}"`, {
+          violations
+        });
+        this.events.onValidationFailed?.(toolName, message);
+        return {
+          success: false,
+          error: "Parameter validation failed",
+          violations
+        };
+      }
+      throw error;
+    }
+  }
+  /**
+   * Safely parse JSON tool arguments
+   */
+  parseToolArguments(toolName, jsonString) {
+    if (!this.config.enabled) {
+      return { success: true, data: JSON.parse(jsonString) };
+    }
+    try {
+      const parsed = JSON.parse(jsonString);
+      if (this.hasPrototypePollution(parsed)) {
+        this.logger.error(
+          `Prototype pollution attempt detected for tool "${toolName}"`
+        );
+        this.events.onPrototypePollution?.(toolName);
+        return {
+          success: false,
+          error: "Invalid tool arguments: potentially malicious content detected"
+        };
+      }
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        return {
+          success: false,
+          error: "Tool arguments must be a JSON object"
+        };
+      }
+      return { success: true, data: parsed };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : "Unknown error";
+      this.logger.warn(`JSON parsing failed for tool "${toolName}"`, {
+        error: errorMsg
+      });
+      this.events.onValidationFailed?.(
+        toolName,
+        `JSON parsing failed: ${errorMsg}`
+      );
+      return {
+        success: false,
+        error: "Invalid JSON in tool arguments"
+      };
+    }
+  }
+  /**
+   * Check if a tool is allowed to execute
+   */
+  isToolAllowed(toolName) {
+    if (!this.config.enabled) return true;
+    if (this.config.deniedTools.includes(toolName)) {
+      this.logger.warn(`Tool "${toolName}" blocked by deny list`);
+      this.events.onExecutionBlocked?.(toolName, "Tool is in deny list");
+      return false;
+    }
+    if (this.config.allowedTools && !this.config.allowedTools.includes(toolName)) {
+      this.logger.warn(`Tool "${toolName}" not in allow list`);
+      this.events.onExecutionBlocked?.(
+        toolName,
+        "Tool is not in allow list"
+      );
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Add a tool to the deny list
+   */
+  denyTool(toolName) {
+    if (!this.config.deniedTools.includes(toolName)) {
+      this.config.deniedTools.push(toolName);
+    }
+  }
+  /**
+   * Remove a tool from the deny list
+   */
+  allowTool(toolName) {
+    const index = this.config.deniedTools.indexOf(toolName);
+    if (index !== -1) {
+      this.config.deniedTools.splice(index, 1);
+    }
+  }
+  /**
+   * Check if security is enabled
+   */
+  isEnabled() {
+    return this.config.enabled;
+  }
+  /**
+   * Enable or disable security
+   */
+  setEnabled(enabled) {
+    this.config.enabled = enabled;
+  }
+  /**
+   * Detect prototype pollution attempts
+   */
+  hasPrototypePollution(obj, depth = 0) {
+    if (depth > 10) return false;
+    if (typeof obj !== "object" || obj === null) return false;
+    const dangerousKeys = ["__proto__", "constructor", "prototype"];
+    for (const key of Object.keys(obj)) {
+      if (dangerousKeys.includes(key)) {
+        return true;
+      }
+      if (typeof obj[key] === "object") {
+        if (this.hasPrototypePollution(
+          obj[key],
+          depth + 1
+        )) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+}
+class ToolSandbox {
+  config;
+  logger;
+  events;
+  activeExecutions = /* @__PURE__ */ new Map();
+  executionCount = 0;
+  constructor(config = {}, logger, events = {}) {
+    this.config = {
+      enabled: true,
+      validateParams: true,
+      sandboxExecution: true,
+      maxExecutionTime: 3e4,
+      maxConcurrentCalls: 10,
+      deniedTools: [],
+      ...config
+    };
+    this.logger = wrapLogger(logger || DEFAULT_LOGGER, "ToolSandbox");
+    this.events = events;
+  }
+  /**
+   * Execute a tool with sandbox restrictions
+   */
+  async execute(tool, params, baseContext, options = {}) {
+    if (!this.config.enabled || !this.config.sandboxExecution) {
+      return tool.execute(params, baseContext);
+    }
+    if (this.activeExecutions.size >= this.config.maxConcurrentCalls) {
+      this.logger.warn("Max concurrent executions reached", {
+        toolName: tool.name,
+        activeCount: this.activeExecutions.size,
+        limit: this.config.maxConcurrentCalls
+      });
+      this.events.onConcurrencyExceeded?.(
+        tool.name,
+        this.activeExecutions.size
+      );
+      throw new Error("Too many concurrent tool executions");
+    }
+    const executionId = `exec-${++this.executionCount}-${Date.now()}`;
+    const controller = new AbortController();
+    this.activeExecutions.set(executionId, controller);
+    const sandboxedContext = {
+      ...baseContext,
+      sandbox: {
+        allowedOperations: new Set(options.allowedOperations || []),
+        maxOutputSize: options.maxOutputSize || 1024 * 1024,
+        // 1MB default
+        executionId
+      }
+    };
+    const timeout = options.maxExecutionTime || this.config.maxExecutionTime;
+    try {
+      await options.onBeforeExecution?.(tool, params);
+      const result = await this.executeWithTimeout(
+        () => tool.execute(params, sandboxedContext),
+        timeout,
+        controller.signal,
+        tool.name
+      );
+      const outputSize = this.estimateSize(result);
+      if (outputSize > sandboxedContext.sandbox.maxOutputSize) {
+        this.logger.warn("Tool output exceeded max size", {
+          toolName: tool.name,
+          outputSize,
+          maxSize: sandboxedContext.sandbox.maxOutputSize
+        });
+        this.events.onOutputSizeExceeded?.(
+          tool.name,
+          outputSize,
+          sandboxedContext.sandbox.maxOutputSize
+        );
+        throw new Error("Tool output exceeded maximum size limit");
+      }
+      await options.onAfterExecution?.(tool, result);
+      return result;
+    } catch (error) {
+      await options.onAfterExecution?.(tool, void 0, error);
+      throw error;
+    } finally {
+      this.activeExecutions.delete(executionId);
+    }
+  }
+  /**
+   * Cancel all active executions
+   */
+  cancelAll() {
+    for (const [id, controller] of this.activeExecutions) {
+      controller.abort();
+      this.logger.info("Execution cancelled", { executionId: id });
+      this.events.onCancelled?.(id);
+    }
+    this.activeExecutions.clear();
+  }
+  /**
+   * Cancel a specific execution by ID
+   */
+  cancel(executionId) {
+    const controller = this.activeExecutions.get(executionId);
+    if (controller) {
+      controller.abort();
+      this.activeExecutions.delete(executionId);
+      this.logger.info("Execution cancelled", { executionId });
+      this.events.onCancelled?.(executionId);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get active execution count
+   */
+  getActiveCount() {
+    return this.activeExecutions.size;
+  }
+  /**
+   * Get list of active execution IDs
+   */
+  getActiveExecutionIds() {
+    return Array.from(this.activeExecutions.keys());
+  }
+  /**
+   * Check if sandbox is enabled
+   */
+  isEnabled() {
+    return this.config.enabled && this.config.sandboxExecution;
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  async executeWithTimeout(fn, timeoutMs, signal, toolName) {
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        this.logger.warn("Tool execution timed out", {
+          toolName,
+          timeoutMs
+        });
+        this.events.onTimeout?.(toolName, timeoutMs);
+        reject(
+          new Error(`Tool execution timed out after ${timeoutMs}ms`)
+        );
+      }, timeoutMs);
+      const abortHandler = () => {
+        clearTimeout(timeoutId);
+        reject(new Error("Tool execution was cancelled"));
+      };
+      signal.addEventListener("abort", abortHandler, { once: true });
+      fn().then((result) => {
+        clearTimeout(timeoutId);
+        signal.removeEventListener("abort", abortHandler);
+        resolve(result);
+      }).catch((error) => {
+        clearTimeout(timeoutId);
+        signal.removeEventListener("abort", abortHandler);
+        reject(error);
+      });
+    });
+  }
+  estimateSize(value) {
+    if (value === null || value === void 0) return 0;
+    if (typeof value === "string") return value.length * 2;
+    if (typeof value === "number") return 8;
+    if (typeof value === "boolean") return 4;
+    if (Buffer.isBuffer(value)) return value.length;
+    try {
+      return JSON.stringify(value).length * 2;
+    } catch {
+      return 0;
+    }
+  }
+}
+function createSecureTool(tool, sandbox, guard) {
+  return {
+    ...tool,
+    execute: async (params, context) => {
+      if (!guard.isToolAllowed(tool.name)) {
+        throw new Error(`Tool "${tool.name}" is not allowed`);
+      }
+      if (tool.schema) {
+        const validation = guard.validateParams(
+          tool.name,
+          params,
+          tool.schema
+        );
+        if (!validation.success) {
+          throw new Error(`Validation failed: ${validation.error}`);
+        }
+        params = validation.data;
+      }
+      return sandbox.execute(tool, params, context || {});
+    }
+  };
+}
+const crypto = {};
+class ContextManager {
+  items;
+  hashes;
+  logger;
+  constructor(logger) {
+    this.items = /* @__PURE__ */ new Map();
+    this.hashes = /* @__PURE__ */ new Set();
+    this.logger = wrapLogger(logger || DEFAULT_LOGGER, "ContextManager");
+  }
+  /**
+   * Track a context item
+   */
+  track(item, position) {
+    const hash2 = this.hashContent(item.content);
+    if (!item.id && this.hashes.has(hash2)) {
+      this.logger.debug("Skipping duplicate context item by hash", { hash: hash2 });
+      return;
+    }
+    const id = item.id || this.generateId();
+    const trackedItem = {
+      ...item,
+      id,
+      hash: hash2,
+      position,
+      injectedAt: /* @__PURE__ */ new Date(),
+      timestamp: item.timestamp || /* @__PURE__ */ new Date(),
+      priority: item.priority || "medium"
+    };
+    this.items.set(id, trackedItem);
+    this.hashes.add(hash2);
+    this.logger.debug("Tracked context item", {
+      id,
+      category: item.category,
+      position
+    });
+  }
+  /**
+   * Check if context with given ID exists
+   */
+  hasContext(id) {
+    return this.items.has(id);
+  }
+  /**
+   * Check if content with given hash exists
+   */
+  hasContentHash(content) {
+    const hash2 = this.hashContent(content);
+    return this.hashes.has(hash2);
+  }
+  /**
+   * Check if similar content exists (fuzzy match)
+   */
+  hasSimilarContent(content, similarityThreshold = 0.9) {
+    const MAX_ITEMS_WARNING = 1e3;
+    if (this.items.size > MAX_ITEMS_WARNING) {
+      this.logger.warn(
+        "Large number of context items, similarity check may be slow",
+        {
+          count: this.items.size,
+          threshold: MAX_ITEMS_WARNING
+        }
+      );
+    }
+    const normalized = this.normalizeContent(content);
+    for (const item of this.items.values()) {
+      const itemNormalized = this.normalizeContent(item.content || "");
+      if (normalized === itemNormalized) {
+        return true;
+      }
+      const longer = normalized.length > itemNormalized.length ? normalized : itemNormalized;
+      const shorter = normalized.length <= itemNormalized.length ? normalized : itemNormalized;
+      const lengthRatio = shorter.length / longer.length;
+      if (lengthRatio >= similarityThreshold) {
+        if (longer.includes(shorter)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Get context item by ID
+   */
+  get(id) {
+    return this.items.get(id);
+  }
+  /**
+   * Get all tracked context items
+   */
+  getAll() {
+    return Array.from(this.items.values());
+  }
+  /**
+   * Get context items by category
+   */
+  getByCategory(category) {
+    return this.getAll().filter((item) => item.category === category);
+  }
+  /**
+   * Get context items by priority
+   */
+  getByPriority(priority) {
+    return this.getAll().filter((item) => item.priority === priority);
+  }
+  /**
+   * Get context items by source
+   */
+  getBySource(source) {
+    return this.getAll().filter((item) => item.source === source);
+  }
+  /**
+   * Get all categories
+   */
+  getCategories() {
+    const categories = /* @__PURE__ */ new Set();
+    this.items.forEach((item) => {
+      if (item.category) {
+        categories.add(item.category);
+      }
+    });
+    return Array.from(categories).sort();
+  }
+  /**
+   * Get context statistics
+   */
+  getStats() {
+    const byCategory = /* @__PURE__ */ new Map();
+    const byPriority = /* @__PURE__ */ new Map();
+    const bySource = /* @__PURE__ */ new Map();
+    let oldestTimestamp;
+    let newestTimestamp;
+    this.items.forEach((item) => {
+      if (item.category) {
+        byCategory.set(
+          item.category,
+          (byCategory.get(item.category) || 0) + 1
+        );
+      }
+      const priority = item.priority || "medium";
+      byPriority.set(priority, (byPriority.get(priority) || 0) + 1);
+      if (item.source) {
+        bySource.set(item.source, (bySource.get(item.source) || 0) + 1);
+      }
+      if (item.timestamp) {
+        if (!oldestTimestamp || item.timestamp < oldestTimestamp) {
+          oldestTimestamp = item.timestamp;
+        }
+        if (!newestTimestamp || item.timestamp > newestTimestamp) {
+          newestTimestamp = item.timestamp;
+        }
+      }
+    });
+    return {
+      totalItems: this.items.size,
+      byCategory,
+      byPriority,
+      bySource,
+      oldestTimestamp,
+      newestTimestamp
+    };
+  }
+  /**
+   * Remove context item by ID
+   */
+  remove(id) {
+    const item = this.items.get(id);
+    if (item) {
+      this.items.delete(id);
+      this.hashes.delete(item.hash);
+      this.logger.debug("Removed context item", { id });
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Clear all tracked context
+   */
+  clear() {
+    this.items.clear();
+    this.hashes.clear();
+    this.logger.debug("Cleared all context");
+  }
+  generateId() {
+    return `ctx-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+  }
+  hashContent(content) {
+    return crypto.createHash("sha256").update(content).digest("hex").substring(0, 32);
+  }
+  normalizeContent(content) {
+    return content.replace(/\s+/g, " ").trim().toLowerCase();
+  }
+}
+const VERSION = "0.0.1";
+export {
+  ContextManager,
+  DEFAULT_LOGGER,
+  LIBRARY_NAME,
+  ToolGuard,
+  ToolRegistry,
+  ToolSandbox,
+  VERSION,
+  createSecureTool,
+  wrapLogger
+};
+//# sourceMappingURL=index.js.map