@oas-tools/oas-telemetry 0.6.2 → 0.7.0-alpha.1

package/dist/{config.cjs → cjs/config.cjs}

@@ -4,18 +4,18 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.globalOasTlmConfig = exports.default = void 0;
-var _api = require("@opentelemetry/api");
 var _dynamicExporter = _interopRequireDefault(require("./exporters/dynamicExporter.cjs"));
 var _InMemoryDBMetricsExporter = require("./exporters/InMemoryDBMetricsExporter.cjs");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _InMemoryLogRecordExporter = require("./exporters/InMemoryLogRecordExporter.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 //Environment variables
 //OASTLM_MODULE_DISABLED = 'true' //Disables the module (empty middleware and no tracing)
-
 const globalOasTlmConfig = exports.globalOasTlmConfig = {
-  dynamicExporter: new _dynamicExporter.default(),
+  dynamicSpanExporter: new _dynamicExporter.default(),
   metricsExporter: new _InMemoryDBMetricsExporter.InMemoryDBMetricsExporter(),
-  systemMetricsInterval: 1000 * 5,
-  // 5 seconds
+  logExporter: new _InMemoryLogRecordExporter.InMemoryLogRecordExporter(),
+  metricsExporterInterval: 1000 * 30,
+  // milliseconds
   baseURL: "/telemetry",
   spec: null,
   specFileName: "",
@@ -26,7 +26,6 @@ const globalOasTlmConfig = exports.globalOasTlmConfig = {
   password: "oas-telemetry-password",
   jwtSecret: "oas-telemetry-secret"
 };
-//5 name alternatives. one for globals 
 var _default = exports.default = {
   globalOasTlmConfig
 };

package/dist/{exporters → cjs/exporters}/InMemoryDBMetricsExporter.cjs

@@ -6,7 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 exports.InMemoryDBMetricsExporter = void 0;
 var _core = require("@opentelemetry/core");
 var _nedb = _interopRequireDefault(require("@seald-io/nedb"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _circular = require("../utils/circular.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 class InMemoryDBMetricsExporter {
   constructor() {
     this._metrics = new _nedb.default();
@@ -16,8 +17,8 @@ class InMemoryDBMetricsExporter {
     try {
       if (!this._stopped) {
         // metrics = metrics?.scopeMetrics;
-        // const cleanMetrics = metrics.map(metric => applyNesting(metric));
-        this._metrics.insert(metrics, (err, newDoc) => {
+        const cleanMetrics = (0, _circular.applyNesting)(metrics);
+        this._metrics.insert(cleanMetrics, (err, _newDoc) => {
           if (err) {
             console.error('Insertion Error:', err);
             return;
@@ -62,40 +63,4 @@ class InMemoryDBMetricsExporter {
     return this._metrics.getAllData();
   }
 }
-exports.InMemoryDBMetricsExporter = InMemoryDBMetricsExporter;
-function convertToNestedObject(obj) {
-  const result = {};
-  for (const key in obj) {
-    const keys = key.split('.');
-    let temp = result;
-    for (let i = 0; i < keys.length; i++) {
-      const currentKey = keys[i];
-      if (i === keys.length - 1) {
-        // Last key, set the value
-        temp[currentKey] = obj[key];
-      } else {
-        // Intermediate key, ensure the object exists
-        if (!temp[currentKey]) {
-          temp[currentKey] = {};
-        }
-        temp = temp[currentKey];
-      }
-    }
-  }
-  return result;
-}
-
-/**
- * Applies nesting to all dot-separated keys within an object.
- * 
- * @param {Object} obj - The object to apply nesting to.
- * @returns {Object} - The transformed object with nested structures.
- */
-function applyNesting(obj) {
-  for (const key in obj) {
-    if (typeof obj[key] === 'object' && obj[key] !== null) {
-      obj[key] = applyNesting(obj[key]);
-    }
-  }
-  return obj;
-}
+exports.InMemoryDBMetricsExporter = InMemoryDBMetricsExporter;

package/dist/cjs/exporters/InMemoryDbExporter.cjs

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InMemoryExporter = void 0;
+var _core = require("@opentelemetry/core");
+var _nedb = _interopRequireDefault(require("@seald-io/nedb"));
+var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
+var _circular = require("../utils/circular.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+//import in memory database
+
+class InMemoryExporter {
+  constructor() {
+    // Overrided by dynamic exporter
+    this.plugins = [];
+    this._spans = new _nedb.default();
+    this._stopped = true;
+  }
+  export(readableSpans, resultCallback) {
+    try {
+      if (!this._stopped) {
+        // Prepare spans to be inserted into the in-memory database (remove circular references and convert to nested objects)
+        const cleanSpans = readableSpans.map(nestedSpan => (0, _circular.removeCircularRefs)(nestedSpan)) // to avoid JSON parsing error
+        .map(span => (0, _circular.applyNesting)(span)) // to avoid dot notation in keys (neDB does not support dot notation in keys)
+        .filter(span => !span?.attributes?.http?.target?.includes("/telemetry")); // to avoid telemetry spans
+        // Insert spans into the in-memory database
+        this._spans.insert(cleanSpans, (err, _newDoc) => {
+          // p = {name, plugin
+          this.plugins.forEach((pluginResource, i) => {
+            cleanSpans.forEach(span => {
+              _logger.default.debug(`Sending span <${span._id}> to plugin (Plugin #${i}) <${pluginResource.name}>`);
+              _logger.default.debug(`Span: \n<${JSON.stringify(span, null, 2)}`);
+              //TODO: This should be called newSpan instead of newTrace
+              pluginResource.plugin.newTrace(span);
+            });
+          });
+          if (err) {
+            console.error(err);
+            return;
+          }
+        });
+      }
+      setTimeout(() => resultCallback({
+        code: _core.ExportResultCode.SUCCESS
+      }), 0);
+    } catch (error) {
+      console.error('Error exporting spans\n' + error.message + '\n' + error.stack);
+      return resultCallback({
+        code: _core.ExportResultCode.FAILED,
+        error: new Error('Error exporting spans\n' + error.message + '\n' + error.stack)
+      });
+    }
+  }
+  start() {
+    this._stopped = false;
+  }
+  stop() {
+    this._stopped = true;
+  }
+  isRunning() {
+    return !this._stopped;
+  }
+  shutdown() {
+    this._stopped = true;
+    this._spans = new _nedb.default();
+    return this.forceFlush();
+  }
+  /**
+   * Exports any pending spans in the exporter
+   */
+  forceFlush() {
+    return Promise.resolve();
+  }
+  //err,docs
+  find(search, callback) {
+    this._spans.find(search, callback);
+  }
+  reset() {
+    this._spans = new _nedb.default();
+  }
+  getFinishedSpans() {
+    return this._spans.getAllData();
+  }
+}
+exports.InMemoryExporter = InMemoryExporter;

package/dist/cjs/exporters/InMemoryLogRecordExporter.cjs

@@ -0,0 +1,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InMemoryLogRecordExporter = void 0;
+var _core = require("@opentelemetry/core");
+var _circular = require("../utils/circular.cjs");
+var _nedb = _interopRequireDefault(require("@seald-io/nedb"));
+var _minisearch = _interopRequireDefault(require("minisearch"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class InMemoryLogRecordExporter {
+  constructor() {
+    this._db = new _nedb.default();
+    this._miniSearch = new _minisearch.default({
+      fields: ['body'],
+      storeFields: ['_id'],
+      idField: '_id'
+    });
+  }
+  /*
+  * SUPER WARNING:
+  * Do NOT use console.log, console.error, or any logger inside this class's export function.
+  * Doing so will cause an infinite loop.
+  * Only console.dir is allowed, as it is not tracked by our log export implementation.
+  */
+  /**
+   * Export logs.
+   * @param logs
+   * @param resultCallback
+   */
+  export(logs, resultCallback) {
+    const logsToInsert = logs.map(logRecord => {
+      // Remove circular references first, then apply nesting, then export info
+      const formattedLog = this._formatLogRecord(logRecord);
+      const cleanedLog = (0, _circular.removeCircularRefs)(formattedLog);
+      const nestedLog = (0, _circular.applyNesting)(cleanedLog);
+      return nestedLog;
+    });
+    this._db.insert(logsToInsert, (err, newDocs) => {
+      if (err) {
+        console.dir(err);
+        resultCallback({
+          code: _core.ExportResultCode.FAILED
+        });
+        return;
+      }
+      // console.dir(newDocs, { depth: 3 });
+      newDocs.forEach(doc => this._miniSearch.add(doc));
+      resultCallback({
+        code: _core.ExportResultCode.SUCCESS
+      });
+    });
+  }
+  reset() {
+    this._db = new _nedb.default();
+    this._miniSearch = new _minisearch.default({
+      fields: ['body'],
+      storeFields: ['_id'],
+      idField: '_id'
+    });
+  }
+  /**
+   * Shutdown the exporter.
+   */
+  async shutdown() {
+    this._db = null;
+    this._miniSearch = null;
+  }
+  find(query, messageSearch, callback) {
+    if (messageSearch) {
+      const searchResults = this._miniSearch.search(messageSearch);
+      const ids = searchResults.map(result => result._id);
+      console.dir(`MiniSearch found ${ids.length} results for search term "${messageSearch}"`, {
+        depth: 3
+      });
+      // Add MiniSearch results to the query
+      query._id = {
+        $in: ids
+      };
+    }
+    this._db.find(query, callback);
+  }
+  getFinishedSpans() {
+    return this._db.getAllData();
+  }
+  /**
+   *  @copyright The OpenTelemetry Authors
+   *  @license Apache-2.0
+   * converts logRecord info into more readable format
+   * @param logRecord
+   */
+  _formatLogRecord(logRecord) {
+    return {
+      resource: {
+        attributes: logRecord.resource.attributes
+      },
+      instrumentationScope: logRecord.instrumentationScope,
+      timestamp: (0, _core.hrTimeToMicroseconds)(logRecord.hrTime) || Date.now(),
+      traceId: logRecord.spanContext?.traceId,
+      spanId: logRecord.spanContext?.spanId,
+      traceFlags: logRecord.spanContext?.traceFlags,
+      severityText: logRecord.severityText,
+      severityNumber: logRecord.severityNumber,
+      body: logRecord.body,
+      attributes: logRecord.attributes
+    };
+  }
+}
+exports.InMemoryLogRecordExporter = InMemoryLogRecordExporter;

package/dist/{exporters → cjs/exporters}/consoleExporter.cjs

@@ -4,13 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.ConsoleExporter = void 0;
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 class ConsoleExporter {
   constructor() {
     // PLUGIN SYSTEM -----------------------------------------------------------
-    _defineProperty(this, "plugins", []);
+    this.plugins = [];
   }
   // OPEN TELEMETRY EXPORTER INTERFACE ---------------------------------------
   export(readableSpans, resultCallback) {
@@ -25,9 +22,7 @@ class ConsoleExporter {
   forceFlush() {
     return Promise.resolve();
   }
-
   // OAS-TOOLS OAS-TELEMETRY EXPORTER INTERFACE ---------------------------------------
-
   start() {
     console.log("Exporter started");
   }
@@ -45,7 +40,7 @@ class ConsoleExporter {
     callback(null, []);
     return [];
   }
-  async getFinishedSpans() {
+  getFinishedSpans() {
     return [];
   }
 }

package/dist/{exporters → cjs/exporters}/dynamicExporter.cjs

@@ -5,26 +5,20 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = exports.DynamicExporter = void 0;
 var _consoleExporter = require("./consoleExporter.cjs");
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-/**
- * DynamicExporter is a class that can be used to dynamically change the exporter used by OpenTelemetry.
- * This is useful when you want to change the exporter at runtime.
- * Links start, stop and export methods to the Real exporter.
+/**
+ * DynamicExporter is a class that can be used to dynamically change the exporter used by OpenTelemetry.
+ * This is useful when you want to change the exporter at runtime.
+ * Links start, stop and export methods to the Real exporter.
  */
 class DynamicExporter {
-  /** 
-   * @returns {Array<PluginResource>} Returns the list of plugins registered in the exporter
+  /**
+   * Returns the list of plugins registered in the exporter
    */
   getPlugins() {
     return this.exporter.plugins;
   }
-
-  /**
-   * Registers a plugin in the exporter
-   * @param {PluginResource} pluginResource The plugin to be registered
-   * @returns {void}
+  /**
+   * Registers a plugin in the exporter
    */
   pushPlugin(pluginResource) {
     if (!this.exporter.plugins) {
@@ -33,7 +27,7 @@ class DynamicExporter {
     this.exporter.plugins.push(pluginResource);
   }
   activatePlugin(pluginId) {
-    let plugins = this.exporter.plugins;
+    const plugins = this.exporter.plugins;
     if (plugins) {
       // plugin.active = true;
       plugins.forEach(plugin => {
@@ -44,8 +38,7 @@ class DynamicExporter {
     }
   }
   constructor() {
-    _defineProperty(this, "exporter", void 0);
-    let defaultExporter = new _consoleExporter.ConsoleExporter();
+    const defaultExporter = new _consoleExporter.ConsoleExporter();
     this.exporter = defaultExporter;
     this.export = (readableSpans, resultCallback) => defaultExporter.export(readableSpans, resultCallback);
     this.shutdown = () => defaultExporter.shutdown();
@@ -54,10 +47,10 @@ class DynamicExporter {
   changeExporter(newExporter) {
     this.exporter = newExporter;
     // OpenTelemetry methods
-    this.export = (readableSpans, resultCallback) => newExporter.export(readableSpans, resultCallback);
+    this.export = (readableSpan, resultCallback) => newExporter.export(readableSpan, resultCallback);
     this.shutdown = () => newExporter.shutdown();
     this.forceFlush = () => newExporter.forceFlush();
-    // Other methods should be called directly from the exporter: globalOasTlmConfig.dynamicExporter.exporter.method()
+    // Other methods should be called directly from the exporter: globalOasTlmConfig.dynamicSpanExporter.exporter.method()
   }
 }
 exports.DynamicExporter = DynamicExporter;

package/dist/cjs/index.cjs

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = oasTelemetry;
+require("./instrumentation/index.cjs");
+var _config = require("./config.cjs");
+var _express = require("express");
+var _InMemoryDbExporter = require("./exporters/InMemoryDbExporter.cjs");
+var _logger = _interopRequireDefault(require("./utils/logger.cjs"));
+var _tlmRoutes = require("./tlmRoutes.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Returns the Oas Telemetry middleware. The parameters are the same as `globalOasTlmConfig`.
+ * All parameters are optional. However, either `spec` or `specFileName` must be provided to enable endpoint filtering.
+ */
+function oasTelemetry(oasTlmInputConfig) {
+  const router = (0, _express.Router)();
+  if (process.env.OASTLM_MODULE_DISABLED === 'true') {
+    return router;
+  }
+  if (oasTlmInputConfig) {
+    _logger.default.info("User provided config");
+    // Override global config with user provided config
+    for (const key in _config.globalOasTlmConfig) {
+      _config.globalOasTlmConfig[key] = oasTlmInputConfig[key] ?? _config.globalOasTlmConfig[key];
+    }
+  }
+  _logger.default.info("BaseURL: ", _config.globalOasTlmConfig.baseURL);
+  _config.globalOasTlmConfig.dynamicSpanExporter.changeExporter(_config.globalOasTlmConfig.exporter ?? new _InMemoryDbExporter.InMemoryExporter());
+  if (_config.globalOasTlmConfig.spec) _logger.default.info(`Spec content provided`);else {
+    if (_config.globalOasTlmConfig.specFileName != "") _logger.default.info(`Spec file used for telemetry: ${_config.globalOasTlmConfig.specFileName}`);else {
+      console.error("No spec available !");
+    }
+  }
+  if (_config.globalOasTlmConfig.autoActivate) {
+    _config.globalOasTlmConfig.dynamicSpanExporter.exporter?.start();
+  }
+  (0, _tlmRoutes.configureRoutes)(router);
+  return router;
+}
+module.exports = exports.default;

package/dist/cjs/instrumentation/index.cjs

@@ -0,0 +1,28 @@
+"use strict";
+
+var _resources = require("@opentelemetry/resources");
+var _instrumentationHttp = require("@opentelemetry/instrumentation-http");
+var _semanticConventions = require("@opentelemetry/semantic-conventions");
+var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
+var _logs = require("./logs.cjs");
+var _traces = require("./traces.cjs");
+var _instrumentation = require("@opentelemetry/instrumentation");
+var _metrics = require("./metrics.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// import { NodeSDK } from '@opentelemetry/sdk-node';
+
+const oasTelemetryResource = (0, _resources.resourceFromAttributes)({
+  [_semanticConventions.ATTR_SERVICE_NAME]: 'oas-telemetry-service'
+});
+if (process.env.OASTLM_MODULE_DISABLED !== 'true') {
+  (0, _traces.initializeTraces)(oasTelemetryResource);
+  (0, _metrics.initializeMetrics)(oasTelemetryResource);
+  (0, _logs.initializeLogs)(oasTelemetryResource);
+  (0, _instrumentation.registerInstrumentations)({
+    instrumentations: [new _instrumentationHttp.HttpInstrumentation()
+    // new ExpressInstrumentation(),
+    ]
+  });
+} else {
+  _logger.default.info('🚫 OASTLM module is disabled, SDKs not initialized.');
+}

package/dist/cjs/instrumentation/logs.cjs

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initializeLogs = initializeLogs;
+var _sdkLogs = require("@opentelemetry/sdk-logs");
+var _apiLogs = require("@opentelemetry/api-logs");
+var _config = require("../config.cjs");
+var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function initializeLogs(resource) {
+  // Create and configure LoggerProvider
+  const logExporter = _config.globalOasTlmConfig.logExporter;
+  const logRecordProcessor = new _sdkLogs.SimpleLogRecordProcessor(logExporter);
+  const loggerProvider = new _sdkLogs.LoggerProvider({
+    resource: resource,
+    processors: [logRecordProcessor]
+  });
+  // Get a logger instance
+  const loggerInstance = loggerProvider.getLogger('oas-telemetry'); // Use loggerProvider to get the logger
+  // Override console methods to emit logs via OpenTelemetry
+  const originalConsoleMethods = {
+    log: console.log,
+    warn: console.warn,
+    error: console.error,
+    info: console.info,
+    debug: console.debug
+  };
+  Object.keys(originalConsoleMethods).forEach(method => {
+    // @ts-expect-error yes
+    console[method] = (...args) => {
+      loggerInstance.emit({
+        severityNumber: _apiLogs.SeverityNumber[method.toUpperCase()] || _apiLogs.SeverityNumber.INFO,
+        severityText: method.toUpperCase(),
+        body: args.join(' '),
+        attributes: {
+          'source.source': `console.${method}`
+        }
+      });
+      // @ts-expect-error yes
+      originalConsoleMethods[method](...args);
+    };
+  });
+  _logger.default.info('✅ OpenTelemetry Logs initialized.');
+}

package/dist/cjs/instrumentation/metrics.cjs

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initializeMetrics = initializeMetrics;
+var _sdkMetrics = require("@opentelemetry/sdk-metrics");
+var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
+var _config = require("../config.cjs");
+var _hostMetrics = require("@opentelemetry/host-metrics");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function initializeMetrics(resource) {
+  const metricReader = new _sdkMetrics.PeriodicExportingMetricReader({
+    // exporter: new ConsoleMetricExporter(),
+    exporter: _config.globalOasTlmConfig.metricsExporter,
+    exportIntervalMillis: _config.globalOasTlmConfig.metricsExporterInterval
+  });
+  const meterProvider = new _sdkMetrics.MeterProvider({
+    resource: resource,
+    readers: [metricReader]
+  });
+  const hostMetrics = new _hostMetrics.HostMetrics({
+    meterProvider
+  });
+  hostMetrics.start();
+  _logger.default.info('✅ OpenTelemetry Metrics initialized.');
+}

package/dist/cjs/instrumentation/traces.cjs

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initializeTraces = initializeTraces;
+var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
+var _sdkTraceNode = require("@opentelemetry/sdk-trace-node");
+var _config = require("../config.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function initializeTraces(resource) {
+  const tracerProvider = new _sdkTraceNode.NodeTracerProvider({
+    resource: resource,
+    spanProcessors: [new _sdkTraceNode.BatchSpanProcessor(_config.globalOasTlmConfig.dynamicSpanExporter)]
+  });
+  // tracerProvider.addSpanProcessor();
+  tracerProvider.register();
+  _logger.default.info('✅ OpenTelemetry Traces initialized.');
+}

package/dist/cjs/tlm-ai/agent.cjs

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAgentResponse = getAgentResponse;
+var _openai = _interopRequireDefault(require("openai"));
+var _dotenv = _interopRequireDefault(require("dotenv"));
+var _tools = require("./tools.cjs");
+var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+_dotenv.default.config();
+let openai;
+try {
+  openai = new _openai.default({
+    apiKey: process.env.OASTLM_AI_OPENAI_API_KEY,
+    dangerouslyAllowBrowser: true
+  });
+} catch {
+  openai = null;
+}
+const messages = [{
+  role: "assistant",
+  content: "You are a helpful telemetry assistant. Only use the functions you have been provided with. If the question is not related to the functions, respond with 'I cannot help with that.'. If you need to call to other agents, do so using the tools provided."
+}];
+async function agent(userInput) {
+  messages.push({
+    role: "user",
+    content: userInput
+  });
+  for (let i = 0; i < 5; i++) {
+    const response = await openai?.chat?.completions?.create?.({
+      model: process.env.OASTLM_AI_OPENAI_MODEL_NAME || "gpt-4o-mini",
+      messages: messages,
+      tools: _tools.tools
+    });
+    const {
+      finish_reason,
+      message
+    } = response.choices[0];
+    if (finish_reason === "tool_calls" && message.tool_calls) {
+      _logger.default.debug("Tool calls detected:", message.tool_calls);
+      const results = [];
+      for (const toolCall of message.tool_calls) {
+        const functionName = toolCall.function.name;
+        const functionToCall = _tools.availableTools[functionName];
+        const functionArgs = JSON.parse(toolCall.function.arguments);
+        const functionArgsArr = Object.values(functionArgs);
+        // @ts-expect-error yes
+        // eslint-disable-next-line prefer-spread
+        const functionResponse = await functionToCall.apply(null, functionArgsArr);
+        results.push({
+          name: functionName,
+          response: functionResponse
+        });
+      }
+      const resultMessage = results.map(({
+        name,
+        response
+      }) => `Result from "${name}":\n${JSON.stringify(response, null, 2)}`).join("\n\n");
+      messages.push({
+        role: "function",
+        name: "multiple_tool_calls",
+        content: resultMessage
+      });
+    } else if (finish_reason === "stop") {
+      messages.push(message);
+      return message;
+    }
+  }
+  return {
+    content: "Se alcanzó el número máximo de iteraciones sin una respuesta adecuada. Intenta con una consulta más específica."
+  };
+}
+async function getAgentResponse(question) {
+  const response = await agent(question);
+  _logger.default.debug("Response from agent:", response);
+  return response.content;
+}