@nekzus/liop 2.4.0-alpha.23 → 2.4.0-alpha.25

package/dist/chunk-JPWC6XG6.js

@@ -0,0 +1,941 @@
+import { tokensInputTotal, tokensOutputTotal, tokensSavedTotal, operationDurationMs } from './chunk-Q3FKHJ3B.js';
+import { log } from './chunk-K3DGJLUY.js';
+import { countTokens, setMergeCacheSize } from 'gpt-tokenizer/model/gpt-4o';
+import * as fs from 'fs';
+import * as grpc from '@grpc/grpc-js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import * as protoLoader from '@grpc/proto-loader';
+
+var RealTokenEstimator = class {
+  name = "o200k_base";
+  countFn;
+  constructor(countFn, setMergeCacheSizeFn) {
+    this.countFn = countFn;
+    if (setMergeCacheSizeFn) {
+      try {
+        setMergeCacheSizeFn(1e4);
+      } catch {
+      }
+    }
+  }
+  countTokens(text) {
+    if (text.length === 0) return 0;
+    return this.countFn(text);
+  }
+};
+var HeuristicTokenEstimator = class {
+  name = "heuristic (chars/4)";
+  countTokens(text) {
+    if (text.length === 0) return 0;
+    return Math.ceil(text.length / 4);
+  }
+};
+async function createTokenEstimator() {
+  try {
+    const estimator = new RealTokenEstimator(countTokens, setMergeCacheSize);
+    log.debug("[LIOP-Economy] Token estimator initialized: o200k_base");
+    return estimator;
+  } catch {
+    log.info(
+      "[LIOP-Economy] Inlined tokenizer initialization error, falling back to heuristic estimator"
+    );
+    return new HeuristicTokenEstimator();
+  }
+}
+function createSyncTokenEstimator() {
+  try {
+    return new RealTokenEstimator(countTokens, setMergeCacheSize);
+  } catch {
+    return new HeuristicTokenEstimator();
+  }
+}
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/version.js
+var VERSION = "1.9.1";
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/internal/semver.js
+var re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
+function _makeCompatibilityCheck(ownVersion) {
+  const acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
+  const rejectedVersions = /* @__PURE__ */ new Set();
+  const myVersionMatch = ownVersion.match(re);
+  if (!myVersionMatch) {
+    return () => false;
+  }
+  const ownVersionParsed = {
+    major: +myVersionMatch[1],
+    minor: +myVersionMatch[2],
+    patch: +myVersionMatch[3],
+    prerelease: myVersionMatch[4]
+  };
+  if (ownVersionParsed.prerelease != null) {
+    return function isExactmatch(globalVersion) {
+      return globalVersion === ownVersion;
+    };
+  }
+  function _reject(v) {
+    rejectedVersions.add(v);
+    return false;
+  }
+  function _accept(v) {
+    acceptedVersions.add(v);
+    return true;
+  }
+  return function isCompatible2(globalVersion) {
+    if (acceptedVersions.has(globalVersion)) {
+      return true;
+    }
+    if (rejectedVersions.has(globalVersion)) {
+      return false;
+    }
+    const globalVersionMatch = globalVersion.match(re);
+    if (!globalVersionMatch) {
+      return _reject(globalVersion);
+    }
+    const globalVersionParsed = {
+      major: +globalVersionMatch[1],
+      minor: +globalVersionMatch[2],
+      patch: +globalVersionMatch[3],
+      prerelease: globalVersionMatch[4]
+    };
+    if (globalVersionParsed.prerelease != null) {
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.major !== globalVersionParsed.major) {
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.major === 0) {
+      if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) {
+        return _accept(globalVersion);
+      }
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.minor <= globalVersionParsed.minor) {
+      return _accept(globalVersion);
+    }
+    return _reject(globalVersion);
+  };
+}
+var isCompatible = _makeCompatibilityCheck(VERSION);
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/internal/global-utils.js
+var major = VERSION.split(".")[0];
+var GLOBAL_OPENTELEMETRY_API_KEY = /* @__PURE__ */ Symbol.for(`opentelemetry.js.api.${major}`);
+var _global = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
+function registerGlobal(type, instance, diag, allowOverride = false) {
+  var _a;
+  const api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
+    version: VERSION
+  };
+  if (!allowOverride && api[type]) {
+    const err = new Error(`@opentelemetry/api: Attempted duplicate registration of API: ${type}`);
+    diag.error(err.stack || err.message);
+    return false;
+  }
+  if (api.version !== VERSION) {
+    const err = new Error(`@opentelemetry/api: Registration of version v${api.version} for ${type} does not match previously registered API v${VERSION}`);
+    diag.error(err.stack || err.message);
+    return false;
+  }
+  api[type] = instance;
+  diag.debug(`@opentelemetry/api: Registered a global for ${type} v${VERSION}.`);
+  return true;
+}
+function getGlobal(type) {
+  var _a, _b;
+  const globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
+  if (!globalVersion || !isCompatible(globalVersion)) {
+    return;
+  }
+  return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
+}
+function unregisterGlobal(type, diag) {
+  diag.debug(`@opentelemetry/api: Unregistering a global for ${type} v${VERSION}.`);
+  const api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
+  if (api) {
+    delete api[type];
+  }
+}
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js
+var DiagComponentLogger = class {
+  constructor(props) {
+    this._namespace = props.namespace || "DiagComponentLogger";
+  }
+  debug(...args) {
+    return logProxy("debug", this._namespace, args);
+  }
+  error(...args) {
+    return logProxy("error", this._namespace, args);
+  }
+  info(...args) {
+    return logProxy("info", this._namespace, args);
+  }
+  warn(...args) {
+    return logProxy("warn", this._namespace, args);
+  }
+  verbose(...args) {
+    return logProxy("verbose", this._namespace, args);
+  }
+};
+function logProxy(funcName, namespace, args) {
+  const logger = getGlobal("diag");
+  if (!logger) {
+    return;
+  }
+  return logger[funcName](namespace, ...args);
+}
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/diag/types.js
+var DiagLogLevel;
+(function(DiagLogLevel2) {
+  DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
+  DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
+  DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
+  DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
+  DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
+  DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
+  DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
+})(DiagLogLevel || (DiagLogLevel = {}));
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js
+function createLogLevelDiagLogger(maxLevel, logger) {
+  if (maxLevel < DiagLogLevel.NONE) {
+    maxLevel = DiagLogLevel.NONE;
+  } else if (maxLevel > DiagLogLevel.ALL) {
+    maxLevel = DiagLogLevel.ALL;
+  }
+  logger = logger || {};
+  function _filterFunc(funcName, theLevel) {
+    const theFunc = logger[funcName];
+    if (typeof theFunc === "function" && maxLevel >= theLevel) {
+      return theFunc.bind(logger);
+    }
+    return function() {
+    };
+  }
+  return {
+    error: _filterFunc("error", DiagLogLevel.ERROR),
+    warn: _filterFunc("warn", DiagLogLevel.WARN),
+    info: _filterFunc("info", DiagLogLevel.INFO),
+    debug: _filterFunc("debug", DiagLogLevel.DEBUG),
+    verbose: _filterFunc("verbose", DiagLogLevel.VERBOSE)
+  };
+}
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/api/diag.js
+var API_NAME = "diag";
+var DiagAPI = class _DiagAPI {
+  /** Get the singleton instance of the DiagAPI API */
+  static instance() {
+    if (!this._instance) {
+      this._instance = new _DiagAPI();
+    }
+    return this._instance;
+  }
+  /**
+   * Private internal constructor
+   * @private
+   */
+  constructor() {
+    function _logProxy(funcName) {
+      return function(...args) {
+        const logger = getGlobal("diag");
+        if (!logger)
+          return;
+        return logger[funcName](...args);
+      };
+    }
+    const self2 = this;
+    const setLogger = (logger, optionsOrLogLevel = { logLevel: DiagLogLevel.INFO }) => {
+      var _a, _b, _c;
+      if (logger === self2) {
+        const err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+        self2.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+        return false;
+      }
+      if (typeof optionsOrLogLevel === "number") {
+        optionsOrLogLevel = {
+          logLevel: optionsOrLogLevel
+        };
+      }
+      const oldLogger = getGlobal("diag");
+      const newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger);
+      if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+        const stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
+        oldLogger.warn(`Current logger will be overwritten from ${stack}`);
+        newLogger.warn(`Current logger will overwrite one already registered from ${stack}`);
+      }
+      return registerGlobal("diag", newLogger, self2, true);
+    };
+    self2.setLogger = setLogger;
+    self2.disable = () => {
+      unregisterGlobal(API_NAME, self2);
+    };
+    self2.createComponentLogger = (options) => {
+      return new DiagComponentLogger(options);
+    };
+    self2.verbose = _logProxy("verbose");
+    self2.debug = _logProxy("debug");
+    self2.info = _logProxy("info");
+    self2.warn = _logProxy("warn");
+    self2.error = _logProxy("error");
+  }
+};
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/metrics/NoopMeter.js
+var NoopMeter = class {
+  constructor() {
+  }
+  /**
+   * @see {@link Meter.createGauge}
+   */
+  createGauge(_name, _options) {
+    return NOOP_GAUGE_METRIC;
+  }
+  /**
+   * @see {@link Meter.createHistogram}
+   */
+  createHistogram(_name, _options) {
+    return NOOP_HISTOGRAM_METRIC;
+  }
+  /**
+   * @see {@link Meter.createCounter}
+   */
+  createCounter(_name, _options) {
+    return NOOP_COUNTER_METRIC;
+  }
+  /**
+   * @see {@link Meter.createUpDownCounter}
+   */
+  createUpDownCounter(_name, _options) {
+    return NOOP_UP_DOWN_COUNTER_METRIC;
+  }
+  /**
+   * @see {@link Meter.createObservableGauge}
+   */
+  createObservableGauge(_name, _options) {
+    return NOOP_OBSERVABLE_GAUGE_METRIC;
+  }
+  /**
+   * @see {@link Meter.createObservableCounter}
+   */
+  createObservableCounter(_name, _options) {
+    return NOOP_OBSERVABLE_COUNTER_METRIC;
+  }
+  /**
+   * @see {@link Meter.createObservableUpDownCounter}
+   */
+  createObservableUpDownCounter(_name, _options) {
+    return NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
+  }
+  /**
+   * @see {@link Meter.addBatchObservableCallback}
+   */
+  addBatchObservableCallback(_callback, _observables) {
+  }
+  /**
+   * @see {@link Meter.removeBatchObservableCallback}
+   */
+  removeBatchObservableCallback(_callback) {
+  }
+};
+var NoopMetric = class {
+};
+var NoopCounterMetric = class extends NoopMetric {
+  add(_value, _attributes) {
+  }
+};
+var NoopUpDownCounterMetric = class extends NoopMetric {
+  add(_value, _attributes) {
+  }
+};
+var NoopGaugeMetric = class extends NoopMetric {
+  record(_value, _attributes) {
+  }
+};
+var NoopHistogramMetric = class extends NoopMetric {
+  record(_value, _attributes) {
+  }
+};
+var NoopObservableMetric = class {
+  addCallback(_callback) {
+  }
+  removeCallback(_callback) {
+  }
+};
+var NoopObservableCounterMetric = class extends NoopObservableMetric {
+};
+var NoopObservableGaugeMetric = class extends NoopObservableMetric {
+};
+var NoopObservableUpDownCounterMetric = class extends NoopObservableMetric {
+};
+var NOOP_METER = new NoopMeter();
+var NOOP_COUNTER_METRIC = new NoopCounterMetric();
+var NOOP_GAUGE_METRIC = new NoopGaugeMetric();
+var NOOP_HISTOGRAM_METRIC = new NoopHistogramMetric();
+var NOOP_UP_DOWN_COUNTER_METRIC = new NoopUpDownCounterMetric();
+var NOOP_OBSERVABLE_COUNTER_METRIC = new NoopObservableCounterMetric();
+var NOOP_OBSERVABLE_GAUGE_METRIC = new NoopObservableGaugeMetric();
+var NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new NoopObservableUpDownCounterMetric();
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/metrics/NoopMeterProvider.js
+var NoopMeterProvider = class {
+  getMeter(_name, _version, _options) {
+    return NOOP_METER;
+  }
+};
+var NOOP_METER_PROVIDER = new NoopMeterProvider();
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/api/metrics.js
+var API_NAME2 = "metrics";
+var MetricsAPI = class _MetricsAPI {
+  /** Empty private constructor prevents end users from constructing a new instance of the API */
+  constructor() {
+  }
+  /** Get the singleton instance of the Metrics API */
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _MetricsAPI();
+    }
+    return this._instance;
+  }
+  /**
+   * Set the current global meter provider.
+   * Returns true if the meter provider was successfully registered, else false.
+   */
+  setGlobalMeterProvider(provider) {
+    return registerGlobal(API_NAME2, provider, DiagAPI.instance());
+  }
+  /**
+   * Returns the global meter provider.
+   */
+  getMeterProvider() {
+    return getGlobal(API_NAME2) || NOOP_METER_PROVIDER;
+  }
+  /**
+   * Returns a meter from the global meter provider.
+   */
+  getMeter(name, version, options) {
+    return this.getMeterProvider().getMeter(name, version, options);
+  }
+  /** Remove the global meter provider */
+  disable() {
+    unregisterGlobal(API_NAME2, DiagAPI.instance());
+  }
+};
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/metrics-api.js
+var metrics = MetricsAPI.getInstance();
+
+// src/economy/otel.ts
+var METER_NAME = "@nekzus/liop";
+var METER_VERSION = "1.2.0-alpha.9";
+var TOKEN_USAGE_BUCKETS = [
+  1,
+  4,
+  16,
+  64,
+  256,
+  1024,
+  4096,
+  16384,
+  65536,
+  262144,
+  1048576,
+  4194304,
+  16777216,
+  67108864
+];
+var DURATION_BUCKETS = [
+  0.01,
+  0.02,
+  0.04,
+  0.08,
+  0.16,
+  0.32,
+  0.64,
+  1.28,
+  2.56,
+  5.12,
+  10.24,
+  20.48,
+  40.96,
+  81.92
+];
+var LiopOTelBridge = class {
+  tokenUsage;
+  operationDuration;
+  active = false;
+  constructor() {
+    try {
+      const meter = metrics.getMeter(METER_NAME, METER_VERSION);
+      this.tokenUsage = meter.createHistogram("gen_ai.client.token.usage", {
+        description: "Number of tokens used in LIOP Logic-on-Origin operations",
+        unit: "{token}",
+        advice: { explicitBucketBoundaries: TOKEN_USAGE_BUCKETS }
+      });
+      this.operationDuration = meter.createHistogram(
+        "gen_ai.client.operation.duration",
+        {
+          description: "Duration of LIOP operations",
+          unit: "s",
+          advice: { explicitBucketBoundaries: DURATION_BUCKETS }
+        }
+      );
+      this.active = true;
+      log.debug("[LIOP-OTel] gen_ai.* metrics bridge initialized");
+    } catch (err) {
+      log.debug(
+        `[LIOP-OTel] Bridge disabled: ${err instanceof Error ? err.message : String(err)}`
+      );
+      const noopHistogram = {
+        record: () => {
+        }
+      };
+      this.tokenUsage = noopHistogram;
+      this.operationDuration = noopHistogram;
+    }
+  }
+  /**
+   * Record token usage with gen_ai.* standard attributes.
+   *
+   * @param tokens - Number of tokens consumed
+   * @param tokenType - "input" or "output" (gen_ai.token.type)
+   * @param operationName - gen_ai.operation.name (e.g., "execute_tool", "chat")
+   * @param toolName - Optional LIOP-specific tool name for attribution
+   */
+  recordTokens(tokens, tokenType, operationName, toolName) {
+    this.tokenUsage.record(tokens, {
+      "gen_ai.system": "liop",
+      "gen_ai.operation.name": operationName,
+      "gen_ai.token.type": tokenType,
+      "gen_ai.request.model": "liop-mesh",
+      ...toolName ? { "liop.tool.name": toolName } : {}
+    });
+  }
+  /**
+   * Record operation duration with gen_ai.* standard attributes.
+   *
+   * @param durationMs - Duration in milliseconds (converted to seconds for OTel)
+   * @param operationName - gen_ai.operation.name
+   * @param error - Optional error type string if the operation failed
+   */
+  recordDuration(durationMs, operationName, error) {
+    this.operationDuration.record(durationMs / 1e3, {
+      "gen_ai.system": "liop",
+      "gen_ai.operation.name": operationName,
+      ...error ? { "error.type": error } : {}
+    });
+  }
+  /** Whether the OTel bridge is actively connected to a MeterProvider */
+  isActive() {
+    return this.active;
+  }
+};
+
+// src/economy/telemetry.ts
+var OTEL_OPERATION_MAP = {
+  tools_list: "chat",
+  tool_call: "execute_tool",
+  resource_read: "chat",
+  resource_list: "chat",
+  prompt_get: "chat",
+  prompt_list: "chat",
+  diagnostic: "chat"
+};
+var TokenTelemetryEngine = class _TokenTelemetryEngine {
+  static instance = null;
+  operations = [];
+  sessionId;
+  startedAt;
+  estimator;
+  otelBridge;
+  constructor() {
+    this.sessionId = crypto.randomUUID();
+    this.startedAt = Date.now();
+    this.estimator = createSyncTokenEstimator();
+    this.otelBridge = new LiopOTelBridge();
+    this.initRealEstimator();
+  }
+  /** Async upgrade from heuristic to real BPE tokenizer */
+  initRealEstimator() {
+    createTokenEstimator().then((real) => {
+      this.estimator = real;
+    }).catch(() => {
+    });
+  }
+  static getInstance() {
+    if (!_TokenTelemetryEngine.instance) {
+      _TokenTelemetryEngine.instance = new _TokenTelemetryEngine();
+    }
+    return _TokenTelemetryEngine.instance;
+  }
+  /**
+   * Count tokens in a string using the active estimator.
+   * Delegates to o200k_base BPE tokenizer (or heuristic fallback).
+   */
+  countTokens(content) {
+    try {
+      return this.estimator.countTokens(content);
+    } catch {
+      return Math.ceil(content.length / 4);
+    }
+  }
+  /**
+   * Record a single MCP operation's token footprint.
+   * Emits both internal metrics and OTel gen_ai.* histograms.
+   */
+  record(metric) {
+    const fullMetric = {
+      ...metric,
+      timestamp: Date.now()
+    };
+    this.operations.push(fullMetric);
+    try {
+      const otelOp = OTEL_OPERATION_MAP[metric.type] || "chat";
+      if (metric.estimatedInputTokens > 0) {
+        this.otelBridge.recordTokens(
+          metric.estimatedInputTokens,
+          "input",
+          otelOp,
+          metric.toolName
+        );
+      }
+      if (metric.estimatedOutputTokens > 0) {
+        this.otelBridge.recordTokens(
+          metric.estimatedOutputTokens,
+          "output",
+          otelOp,
+          metric.toolName
+        );
+      }
+      if (metric.durationMs !== void 0) {
+        this.otelBridge.recordDuration(metric.durationMs, otelOp);
+      }
+    } catch {
+    }
+    try {
+      const promLabels = {
+        type: metric.type,
+        method: metric.method,
+        tool: metric.toolName || "none"
+      };
+      if (metric.estimatedInputTokens > 0) {
+        tokensInputTotal.inc(promLabels, metric.estimatedInputTokens);
+      }
+      if (metric.estimatedOutputTokens > 0) {
+        tokensOutputTotal.inc(promLabels, metric.estimatedOutputTokens);
+      }
+      if (metric.originDatasetTokens !== void 0 && metric.originDatasetTokens > metric.estimatedOutputTokens) {
+        const actualSaved = metric.originDatasetTokens - metric.estimatedOutputTokens;
+        tokensSavedTotal.inc({ tool: metric.toolName || "none" }, actualSaved);
+      }
+      if (metric.durationMs !== void 0 && metric.durationMs >= 0) {
+        operationDurationMs.observe(promLabels, metric.durationMs);
+      }
+    } catch {
+    }
+  }
+  /**
+   * @deprecated Use countTokens() instead. Kept for backward compatibility.
+   */
+  estimateTokens(content) {
+    return this.countTokens(content);
+  }
+  /** Generate the full session report */
+  getReport() {
+    return {
+      sessionId: this.sessionId,
+      operations: [...this.operations],
+      totalInputTokens: this.operations.reduce(
+        (sum, op) => sum + op.estimatedInputTokens,
+        0
+      ),
+      totalOutputTokens: this.operations.reduce(
+        (sum, op) => sum + op.estimatedOutputTokens,
+        0
+      ),
+      estimatorName: this.estimator.name,
+      sessionUptimeMs: Date.now() - this.startedAt
+    };
+  }
+  /** Get per-tool token breakdown for diagnostic display */
+  getPerToolReport() {
+    const breakdown = /* @__PURE__ */ new Map();
+    for (const op of this.operations) {
+      const key = op.toolName || op.method;
+      const existing = breakdown.get(key) || {
+        input: 0,
+        output: 0,
+        calls: 0,
+        avgDurationMs: 0
+      };
+      const totalDuration = existing.avgDurationMs * existing.calls + (op.durationMs || 0);
+      const newCalls = existing.calls + 1;
+      breakdown.set(key, {
+        input: existing.input + op.estimatedInputTokens,
+        output: existing.output + op.estimatedOutputTokens,
+        calls: newCalls,
+        avgDurationMs: newCalls > 0 ? totalDuration / newCalls : 0
+      });
+    }
+    return breakdown;
+  }
+  /**
+   * Format a rich, human-readable summary block for LiopMeshStatus diagnostic.
+   * Returns empty string when no operations have been recorded.
+   */
+  formatStatusBlock() {
+    const report = this.getReport();
+    if (report.operations.length === 0) return "";
+    const uptimeStr = this.formatUptime(report.sessionUptimeMs);
+    const totalCombined = report.totalInputTokens + report.totalOutputTokens;
+    const byType = /* @__PURE__ */ new Map();
+    for (const op of report.operations) {
+      const key = op.type;
+      const existing = byType.get(key) || {
+        count: 0,
+        input: 0,
+        output: 0
+      };
+      byType.set(key, {
+        count: existing.count + 1,
+        input: existing.input + op.estimatedInputTokens,
+        output: existing.output + op.estimatedOutputTokens
+      });
+    }
+    const typeEntries = Array.from(byType.entries());
+    const typeLines = typeEntries.map(([type, data], idx) => {
+      const prefix = idx === typeEntries.length - 1 ? "\u2502  \u2514\u2500" : "\u2502  \u251C\u2500";
+      const outputPart = data.output > 0 ? ` / ${data.output.toLocaleString()} out` : "";
+      return `${prefix} ${type} \xD7${data.count} \u2192 ${data.input.toLocaleString()} in${outputPart}`;
+    });
+    const toolReport = this.getPerToolReport();
+    const toolEntries = Array.from(toolReport.entries()).filter(
+      ([key]) => key !== "tools/list" && key !== "LiopMeshStatus"
+    );
+    const toolLines = [];
+    if (toolEntries.length > 0) {
+      toolLines.push("\u251C\u2500 By Tool:");
+      toolEntries.forEach(([name, data], idx) => {
+        const prefix = idx === toolEntries.length - 1 ? "\u2502  \u2514\u2500" : "\u2502  \u251C\u2500";
+        const outputPart = data.output > 0 ? ` / ${data.output.toLocaleString()} out` : "";
+        const durationPart = data.avgDurationMs > 0 ? ` ~${Math.round(data.avgDurationMs)}ms` : "";
+        toolLines.push(
+          `${prefix} ${name}: ${data.input.toLocaleString()} in${outputPart} (\xD7${data.calls})${durationPart}`
+        );
+      });
+    }
+    const timedOps = report.operations.filter(
+      (op) => op.durationMs !== void 0
+    );
+    const avgLatency = timedOps.length > 0 ? Math.round(
+      timedOps.reduce((sum, op) => sum + (op.durationMs || 0), 0) / timedOps.length
+    ) : 0;
+    const otelStatus = this.otelBridge.isActive() ? "gen_ai.client.token.usage \u2192 active" : "disabled";
+    const lines = [
+      "\nToken Economy:",
+      `\u251C\u2500 Session: ${report.sessionId.slice(0, 8)} (${uptimeStr})`,
+      `\u251C\u2500 Estimator: ${report.estimatorName}`,
+      `\u251C\u2500 Operations: ${report.operations.length}`,
+      ...typeLines,
+      `\u251C\u2500 Total: ${report.totalInputTokens.toLocaleString()} in / ${report.totalOutputTokens.toLocaleString()} out (${totalCombined.toLocaleString()} combined)`,
+      ...toolLines,
+      ...avgLatency > 0 ? [`\u251C\u2500 Avg Latency: ${avgLatency}ms`] : [],
+      `\u2514\u2500 OTel: ${otelStatus}`
+    ];
+    return lines.join("\n");
+  }
+  /** Format milliseconds into human-readable uptime string */
+  formatUptime(ms) {
+    const seconds = Math.floor(ms / 1e3);
+    if (seconds < 60) return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    if (minutes < 60) return `${minutes}m ${remainingSeconds}s`;
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return `${hours}h ${remainingMinutes}m`;
+  }
+  /** Reset all recorded metrics (used in tests) */
+  reset() {
+    this.operations = [];
+  }
+  /** Destroy the singleton (used in tests to guarantee isolation) */
+  static destroy() {
+    _TokenTelemetryEngine.instance = null;
+  }
+};
+var isTlsEnforced = () => process.env.NODE_ENV === "production" || process.env.LIOP_ENFORCE_TLS === "true";
+var isTlsWarningSuppressed = (tls) => tls?.insecure === true || tls?.suppressWarning === true || process.env.LIOP_SUPPRESS_TLS_WARNING === "true";
+var hasWarnedInsecureServer = false;
+var hasWarnedInsecureChannel = false;
+function createServerCredentials(tls) {
+  if (tls?.mutualTls && !tls.rootCert && !tls.certManager?.getRootCert()) {
+    throw new Error(
+      "[LIOP-TLS] FATAL: Mutual TLS (mTLS) enabled but no root CA certificate (rootCert) provided to verify client certificates."
+    );
+  }
+  if (tls?.certManager) {
+    try {
+      const certChain = tls.certManager.getCertChain();
+      const privateKey = tls.certManager.getPrivateKey();
+      const rootCert = tls.certManager.getRootCert();
+      if (tls.mutualTls && !rootCert) {
+        throw new Error(
+          "[LIOP-TLS] FATAL: Mutual TLS (mTLS) enabled but CertManager has no root CA certificate loaded."
+        );
+      }
+      return grpc.ServerCredentials.createSsl(
+        rootCert,
+        [{ cert_chain: certChain, private_key: privateKey }],
+        Boolean(tls.mutualTls)
+      );
+    } catch (error) {
+      if (isTlsEnforced()) {
+        throw new Error(
+          `[LIOP-TLS] FATAL: CertManager server credential creation failed in enforced mode: ${error}`
+        );
+      }
+      log.warn(
+        `[LIOP-TLS] CertManager failed, falling back to insecure: ${error}`
+      );
+      return grpc.ServerCredentials.createInsecure();
+    }
+  }
+  if (!tls?.certChain || !tls?.privateKey) {
+    if (isTlsEnforced()) {
+      throw new Error(
+        "[LIOP-TLS] FATAL: TLS certificates required in production or when LIOP_ENFORCE_TLS=true."
+      );
+    }
+    if (!isTlsWarningSuppressed(tls) && !hasWarnedInsecureServer) {
+      hasWarnedInsecureServer = true;
+      log.debug(
+        "[LIOP-TLS] No TLS certificates configured \u2014 using insecure server credentials"
+      );
+    }
+    return grpc.ServerCredentials.createInsecure();
+  }
+  try {
+    const rootCert = tls.rootCert ? fs.readFileSync(tls.rootCert) : null;
+    const certChain = fs.readFileSync(tls.certChain);
+    const privateKey = fs.readFileSync(tls.privateKey);
+    if (tls.mutualTls && !rootCert) {
+      throw new Error(
+        "[LIOP-TLS] FATAL: Mutual TLS (mTLS) enabled but no root CA certificate (rootCert) provided to verify client certificates."
+      );
+    }
+    return grpc.ServerCredentials.createSsl(
+      rootCert,
+      [{ cert_chain: certChain, private_key: privateKey }],
+      Boolean(tls.mutualTls)
+    );
+  } catch (error) {
+    if (isTlsEnforced()) {
+      throw new Error(
+        `[LIOP-TLS] FATAL: Server certificate loading failed in production or enforced mode. Refusing insecure fallback to prevent MITM/eavesdropping: ${error}`
+      );
+    }
+    log.warn(
+      `[LIOP-TLS] Server certificate loading failed, falling back to insecure (dev mode): ${error}`
+    );
+    return grpc.ServerCredentials.createInsecure();
+  }
+}
+function createChannelCredentials(tls) {
+  if (tls?.certManager) {
+    try {
+      const rootCert = tls.certManager.getRootCert();
+      if (!rootCert) {
+        throw new Error(
+          "[LIOP-TLS] FATAL: Channel TLS requires a root CA certificate in CertManager."
+        );
+      }
+      const certChain = tls.certManager.getCertChain();
+      const privateKey = tls.certManager.getPrivateKey();
+      return grpc.credentials.createSsl(rootCert, privateKey, certChain);
+    } catch (error) {
+      if (isTlsEnforced()) {
+        throw new Error(
+          `[LIOP-TLS] FATAL: Channel certificate loading failed in enforced mode: ${error}`
+        );
+      }
+      log.warn(
+        `[LIOP-TLS] Channel CertManager failed, falling back to insecure: ${error}`
+      );
+      return grpc.credentials.createInsecure();
+    }
+  }
+  if (!tls?.rootCert) {
+    if (isTlsEnforced()) {
+      throw new Error(
+        "[LIOP-TLS] FATAL: TLS root certificate required in production or when LIOP_ENFORCE_TLS=true."
+      );
+    }
+    if (!isTlsWarningSuppressed(tls) && !hasWarnedInsecureChannel) {
+      hasWarnedInsecureChannel = true;
+      log.debug(
+        "[LIOP-TLS] No TLS root certificate configured \u2014 using insecure channel credentials"
+      );
+    }
+    return grpc.credentials.createInsecure();
+  }
+  try {
+    const rootCert = fs.readFileSync(tls.rootCert);
+    const certChain = tls.certChain ? fs.readFileSync(tls.certChain) : void 0;
+    const privateKey = tls.privateKey ? fs.readFileSync(tls.privateKey) : void 0;
+    return grpc.credentials.createSsl(rootCert, privateKey, certChain);
+  } catch (error) {
+    if (isTlsEnforced()) {
+      throw new Error(
+        `[LIOP-TLS] FATAL: Channel certificate loading failed in production or enforced mode. Refusing insecure fallback to prevent MITM/eavesdropping: ${error}`
+      );
+    }
+    log.warn(
+      `[LIOP-TLS] Channel certificate loading failed, falling back to insecure (dev mode): ${error}`
+    );
+    return grpc.credentials.createInsecure();
+  }
+}
+
+// src/rpc/channel-options.ts
+var GRPC_CHANNEL_OPTIONS = {
+  "grpc.keepalive_time_ms": 3e4,
+  "grpc.keepalive_timeout_ms": 1e4,
+  "grpc.keepalive_permit_without_calls": 1,
+  "grpc.max_send_message_length": -1,
+  "grpc.max_receive_message_length": -1,
+  "grpc.enable_retries": 1
+};
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path.dirname(__filename2);
+var PROD_PATHS = [
+  path.resolve(__dirname2, "./protocol/liop_core.proto"),
+  // Flat dist/ (tsup)
+  path.resolve(__dirname2, "../protocol/liop_core.proto")
+  // dist/rpc/ (tsc)
+];
+var DEV_PROTO_PATH = path.resolve(
+  __dirname2,
+  "../../../../protocol/proto/liop_core.proto"
+);
+var PROTO_PATH = PROD_PATHS.find((p) => fs.existsSync(p)) || DEV_PROTO_PATH;
+if (!fs.existsSync(PROTO_PATH)) {
+  log.error(`[LIOP-Proto] CRITICAL: Proto file not found at ${PROTO_PATH}`);
+}
+var packageDefinition = protoLoader.loadSync(PROTO_PATH, {
+  keepCase: true,
+  longs: String,
+  enums: String,
+  defaults: true,
+  oneofs: true
+});
+var liopProto = grpc.loadPackageDefinition(packageDefinition);
+var liopV1 = liopProto.liop.v1;
+
+export { GRPC_CHANNEL_OPTIONS, HeuristicTokenEstimator, LiopOTelBridge, RealTokenEstimator, TokenTelemetryEngine, createChannelCredentials, createServerCredentials, createSyncTokenEstimator, createTokenEstimator, liopV1 };
+//# sourceMappingURL=chunk-JPWC6XG6.js.map
+//# sourceMappingURL=chunk-JPWC6XG6.js.map