@oas-tools/oas-telemetry 0.7.1 → 0.8.0-alpha.0

package/dist/cjs/telemetry/initializeTelemetry.cjs

@@ -1,98 +1,42 @@
 "use strict";
-
-var _instrumentationHttp = require("@opentelemetry/instrumentation-http");
-var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
-var _instrumentation = require("@opentelemetry/instrumentation");
-var _telemetryRegistry = require("./telemetryRegistry.cjs");
-var _sdkTraceNode = require("@opentelemetry/sdk-trace-node");
-var _apiLogs = require("@opentelemetry/api-logs");
-var _sdkLogs = require("@opentelemetry/sdk-logs");
-var _bootConfig = require("../config/bootConfig.cjs");
-var _util = _interopRequireDefault(require("util"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_js_1 = __importDefault(require("../utils/logger.cjs"));
+const bootConfig_js_1 = require("../config/bootConfig.cjs");
+const instrumentation_http_1 = require("@opentelemetry/instrumentation-http");
+const telemetryRegistry_js_1 = require("./telemetryRegistry.cjs");
+const logsInstrumentation_js_1 = require("./custom-implementations/instrumentations/logsInstrumentation.cjs");
+const instrumentation_runtime_node_1 = require("@opentelemetry/instrumentation-runtime-node");
 // THIS INSTRUMENTATIONS NEED TO BE LOADED BEFORE ANYTHING ELSE
 // They use monkey-patching to instrument the HTTP server and client.
 // THIS FILE MUST BE CALLED BEFORE ANYTHING ELSE
-if (_bootConfig.bootEnvVariables.OASTLM_BOOT_MODULE_DISABLED) {
-  _logger.default.info('🚫 OASTLM module is disabled, Providers not initialized.');
-} else {
-  _logger.default.info('🚀 Initializing Open Telemetry');
-  initializeTraces();
-  initializeMetrics();
-  initializeLogs();
-  (0, _instrumentation.registerInstrumentations)({
-    instrumentations: [new _instrumentationHttp.HttpInstrumentation()
-    // new ExpressInstrumentation(),
-    ]
-  });
+if (bootConfig_js_1.bootEnvVariables.OASTLM_BOOT_MODULE_DISABLED) {
+    logger_js_1.default.info('🚫 OASTLM module is disabled, Auto Instrumentations not initialized.');
 }
-function initializeTraces() {
-  _logger.default.info('📊 Initializing TracerProvider');
-  const tracerProvider = new _sdkTraceNode.NodeTracerProvider({
-    resource: _telemetryRegistry.oasTelemetryResource,
-    spanProcessors: [_telemetryRegistry.dynamicMultiSpanProcessor]
-  });
-  tracerProvider.register();
-}
-function initializeLogs() {
-  _logger.default.info('📜 Initializing LoggerProvider');
-  // Create and configure LoggerProvider
-  const loggerProvider = new _sdkLogs.LoggerProvider({
-    resource: _telemetryRegistry.oasTelemetryResource,
-    processors: [_telemetryRegistry.dynamicMultiLogProcessor]
-  });
-  // Get a logger instance
-  const loggerInstance = loggerProvider.getLogger('oas-telemetry'); // Use loggerProvider to get the logger
-  Object.keys(_telemetryRegistry.originalConsoleMethods).forEach(method => {
-    // @ts-expect-error yes
-    console[method] = (...args) => {
-      const severity = getSeverityForMethod(method);
-      loggerInstance.emit({
-        severityNumber: severity.number,
-        severityText: severity.text,
-        body: _util.default.format(...args),
-        attributes: {
-          'source': `console.${method}`,
-          "library": "oas-telemetry"
+else {
+    if (!(0, telemetryRegistry_js_1.isBootInitialized)()) {
+        // Only HTTP instrumentation por ahora
+        const httpInstrumentation = new instrumentation_http_1.HttpInstrumentation({
+            // Ignore internal telemetry routes
+            ignoreIncomingRequestHook: (req) => {
+                const url = req.url || '';
+                const path = url.split('?')[0]; // Remove query params
+                // Ignore all baseUrl routes except those with 'generate'
+                if (path.includes(bootConfig_js_1.bootEnvVariables.OASTLM_BOOT_BASE_URL)) {
+                    return !path.includes('generate');
+                }
+                return false;
+            }
+        });
+        if (!bootConfig_js_1.bootEnvVariables.OASTLM_BOOT_AUTOINSTRUMENTATIONS_NODE_DISABLED) {
+            telemetryRegistry_js_1.instrumentations.push(httpInstrumentation, new instrumentation_runtime_node_1.RuntimeNodeInstrumentation());
         }
-      });
-      // @ts-expect-error yes
-      _telemetryRegistry.originalConsoleMethods[method](...args);
-    };
-  });
-}
-function initializeMetrics() {
-  _logger.default.info('📈 Initializing MeterProvider');
-  // WARN: Default PeriodicExportingMetricReader is added post initialization (see telemetryConfigurator.ts)
-  // The in memory exporter is added by default to that reader. More readers are allowed to be added dynamically
+        if (!bootConfig_js_1.bootEnvVariables.OASTLM_BOOT_AUTOINSTRUMENTATIONS_LOGS_DISABLED) {
+            telemetryRegistry_js_1.instrumentations.push(new logsInstrumentation_js_1.LogsInstrumentation());
+        }
+        (0, telemetryRegistry_js_1.setBootInitialized)(true);
+        logger_js_1.default.info('✅ Auto Instrumentations created successfully');
+    }
 }
-function getSeverityForMethod(method) {
-  switch (method) {
-    case "log":
-    case "info":
-      return {
-        number: _apiLogs.SeverityNumber.INFO,
-        text: "INFO"
-      };
-    case "debug":
-      return {
-        number: _apiLogs.SeverityNumber.DEBUG,
-        text: "DEBUG"
-      };
-    case "warn":
-      return {
-        number: _apiLogs.SeverityNumber.WARN,
-        text: "WARN"
-      };
-    case "error":
-      return {
-        number: _apiLogs.SeverityNumber.ERROR,
-        text: "ERROR"
-      };
-    default:
-      return {
-        number: _apiLogs.SeverityNumber.INFO,
-        text: "INFO"
-      };
-  }
-}

package/dist/cjs/telemetry/telemetryConfigurator.cjs

@@ -1,81 +1,79 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.configureTelemetry = void 0;
-var _sdkTraceNode = require("@opentelemetry/sdk-trace-node");
-var _telemetryRegistry = require("./telemetryRegistry.cjs");
-var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
-var _sdkLogs = require("@opentelemetry/sdk-logs");
-var _sdkMetrics = require("@opentelemetry/sdk-metrics");
-var _hostMetrics = require("@opentelemetry/host-metrics");
-var _bootConfig = require("../config/bootConfig.cjs");
-var _pluginService = require("../tlm-plugin/pluginService.cjs");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const configureTelemetry = oasTlmConfig => {
-  configurePlugins(oasTlmConfig);
-  configureTraces(oasTlmConfig);
-  configureMetrics(oasTlmConfig);
-  configureLogs(oasTlmConfig);
-  _logger.default.info("✅ Telemetry configured successfully. All exporters are ready");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.configureTelemetry = configureTelemetry;
+const sdk_logs_1 = require("@opentelemetry/sdk-logs");
+const sdk_metrics_1 = require("@opentelemetry/sdk-metrics");
+const sdk_trace_node_1 = require("@opentelemetry/sdk-trace-node");
+const logger_js_1 = __importDefault(require("../utils/logger.cjs"));
+const telemetryRegistry_js_1 = require("./telemetryRegistry.cjs");
+const sdk_node_1 = require("@opentelemetry/sdk-node");
+const bootConfig_js_1 = require("../config/bootConfig.cjs");
+const pluginService_js_1 = require("../tlm-plugin/pluginService.cjs");
+function configureTelemetry(oasTlmConfig) {
+    logger_js_1.default.info("🚀 Configuring Telemetry...");
+    if (oasTlmConfig.instrumentations) {
+        telemetryRegistry_js_1.instrumentations.push(...oasTlmConfig.instrumentations);
+    }
+    configurePlugins(oasTlmConfig);
+    const mainTraceProcessor = configureTraces(oasTlmConfig);
+    const mainMetricReader = configureMetrics(oasTlmConfig);
+    const mainLogProcessor = configureLogs(oasTlmConfig);
+    const sdk = new sdk_node_1.NodeSDK({
+        instrumentations: telemetryRegistry_js_1.instrumentations,
+        resource: telemetryRegistry_js_1.oasTelemetryResource,
+        traceExporter: telemetryRegistry_js_1.inMemoryDbSpanExporter,
+        spanProcessors: [mainTraceProcessor, ...oasTlmConfig.traces.extraProcessors || []],
+        metricReaders: [mainMetricReader, ...(oasTlmConfig.metrics.extraReaders || [])],
+        logRecordProcessors: [mainLogProcessor, ...oasTlmConfig.logs.extraProcessors || []],
+    });
+    sdk.start();
+    logger_js_1.default.info("✅ Node SDK started with telemetry configuration");
+    return true;
+}
 function configurePlugins(oasTlmConfig) {
-  _pluginService.pluginService.enabled = oasTlmConfig.plugins.enabled;
+    pluginService_js_1.pluginService.enabled = oasTlmConfig.plugins.enabled;
 }
 function configureTraces(oasTlmConfig) {
-  // TRACES CONFIGURATION
-  // [OT]Provider -> [OT]SpanProcessor(multiSpan) -> n Processors(eg mainProcessor, extra) -> 1 SpanExporter
-  _telemetryRegistry.inMemoryDbSpanExporter.baseUrl = oasTlmConfig.general.baseUrl; // TODO this will be done with filters
-  _telemetryRegistry.inMemoryDbSpanExporter.retentionTimeInSeconds = oasTlmConfig.traces.memoryExporter.retentionTimeSeconds;
-  _telemetryRegistry.inMemoryDbSpanExporter.setEnabledValue(oasTlmConfig.traces.memoryExporter.enabled);
-  const mainExporter = _telemetryRegistry.multiSpanExporter;
-  let mainProcessor = new _sdkTraceNode.BatchSpanProcessor(mainExporter);
-  if (_bootConfig.bootEnvVariables.OASTLM_BOOT_ENV !== 'production') {
-    _logger.default.info('Not in production, using SimpleSpanProcessor for traces');
-    mainProcessor = new _sdkTraceNode.SimpleSpanProcessor(mainExporter);
-  }
-  mainExporter.addExporters(_telemetryRegistry.inMemoryDbSpanExporter); // Main exporter have at least the in-memory exporter used by the traces controller
-  mainExporter.addExporters(oasTlmConfig.traces.extraExporters);
-  _telemetryRegistry.dynamicMultiSpanProcessor.addProcessors(mainProcessor);
-  _telemetryRegistry.dynamicMultiSpanProcessor.addProcessors(oasTlmConfig.traces.extraProcessors);
+    // TRACES CONFIGURATION
+    // [OT]Provider -> [OT]SpanProcessor(multiSpan) -> n Processors(eg mainProcessor, extra) -> 1 SpanExporter
+    telemetryRegistry_js_1.inMemoryDbSpanExporter.retentionTimeInSeconds = oasTlmConfig.traces.memoryExporter.retentionTimeSeconds;
+    telemetryRegistry_js_1.inMemoryDbSpanExporter.setEnabledValue(oasTlmConfig.traces.memoryExporter.enabled);
+    const mainExporter = telemetryRegistry_js_1.multiSpanExporter;
+    let mainProcessor = new sdk_trace_node_1.BatchSpanProcessor(mainExporter);
+    if (bootConfig_js_1.bootEnvVariables.OASTLM_BOOT_ENV !== 'production') {
+        logger_js_1.default.info('Not in production, using SimpleSpanProcessor for traces');
+        mainProcessor = new sdk_trace_node_1.SimpleSpanProcessor(mainExporter);
+    }
+    mainExporter.addExporters(telemetryRegistry_js_1.inMemoryDbSpanExporter); // Main exporter have at least the in-memory exporter used by the traces controller
+    mainExporter.addExporters(oasTlmConfig.traces.extraExporters);
+    return mainProcessor;
+}
+function configureMetrics(oasTlmConfig) {
+    // METRICS CONFIGURATION
+    telemetryRegistry_js_1.inMemoryDbMetricExporter.setEnabledValue(oasTlmConfig.metrics.memoryExporter.enabled);
+    telemetryRegistry_js_1.inMemoryDbMetricExporter.retentionTimeInSeconds = oasTlmConfig.metrics.memoryExporter.retentionTimeSeconds;
+    const mainReader = new sdk_metrics_1.PeriodicExportingMetricReader({
+        exporter: telemetryRegistry_js_1.inMemoryDbMetricExporter,
+        exportIntervalMillis: oasTlmConfig.metrics.mainMetricReaderOptions.exportIntervalMillis,
+        metricProducers: oasTlmConfig.metrics.mainMetricReaderOptions.metricProducers
+    });
+    return mainReader;
 }
 function configureLogs(oasTlmConfig) {
-  // LOGS CONFIGURATION
-  // [OT]LoggerProvider -> [OT]LogRecordProcessor(multiLogProcessor) -> n Processors(eg mainProcessor, extra) -> 1 LogExporter
-  _telemetryRegistry.inMemoryDbLogExporter.setEnabledValue(oasTlmConfig.logs.memoryExporter.enabled);
-  _telemetryRegistry.inMemoryDbLogExporter.retentionTimeInSeconds = oasTlmConfig.logs.memoryExporter.retentionTimeSeconds;
-  const mainExporter = _telemetryRegistry.multiLogExporter;
-  let mainProcessor = new _sdkLogs.BatchLogRecordProcessor(mainExporter);
-  if (_bootConfig.bootEnvVariables.OASTLM_BOOT_ENV !== 'production') {
-    _logger.default.info('Not in production, using SimpleLogRecordProcessor for logs');
-    mainProcessor = new _sdkLogs.SimpleLogRecordProcessor(mainExporter);
-  }
-  mainExporter.addExporters(_telemetryRegistry.inMemoryDbLogExporter); // Main exporter have at least the in-memory exporter used by the logs controller
-  mainExporter.addExporters(oasTlmConfig.logs.extraExporters);
-  _telemetryRegistry.dynamicMultiLogProcessor.addProcessors(mainProcessor);
-  _telemetryRegistry.dynamicMultiLogProcessor.addProcessors(oasTlmConfig.logs.extraProcessors);
+    // LOGS CONFIGURATION
+    // [OT]LoggerProvider -> [OT]LogRecordProcessor(multiLogProcessor) -> n Processors(eg mainProcessor, extra) -> 1 LogExporter
+    telemetryRegistry_js_1.inMemoryDbLogExporter.setEnabledValue(oasTlmConfig.logs.memoryExporter.enabled);
+    telemetryRegistry_js_1.inMemoryDbLogExporter.retentionTimeInSeconds = oasTlmConfig.logs.memoryExporter.retentionTimeSeconds;
+    const mainExporter = telemetryRegistry_js_1.multiLogExporter;
+    let mainProcessor = new sdk_logs_1.BatchLogRecordProcessor(mainExporter);
+    if (bootConfig_js_1.bootEnvVariables.OASTLM_BOOT_ENV !== 'production') {
+        logger_js_1.default.info('Not in production, using SimpleLogRecordProcessor for logs');
+        mainProcessor = new sdk_logs_1.SimpleLogRecordProcessor(mainExporter);
+    }
+    mainExporter.addExporters(telemetryRegistry_js_1.inMemoryDbLogExporter); // Main exporter have at least the in-memory exporter used by the logs controller
+    mainExporter.addExporters(oasTlmConfig.logs.extraExporters);
+    return mainProcessor;
 }
-function configureMetrics(oasTlmConfig) {
-  // METRICS CONFIGURATION
-  // [CUSTOM]MeterProvider -> n [OTel]MetricReader -> (0-1) MetricExporter (only if push-based reader)
-  _telemetryRegistry.inMemoryDbMetricExporter.setEnabledValue(oasTlmConfig.metrics.memoryExporter.enabled);
-  _telemetryRegistry.inMemoryDbMetricExporter.retentionTimeInSeconds = oasTlmConfig.metrics.memoryExporter.retentionTimeSeconds;
-  const mainReader = new _sdkMetrics.PeriodicExportingMetricReader({
-    exporter: _telemetryRegistry.inMemoryDbMetricExporter,
-    exportIntervalMillis: oasTlmConfig.metrics.mainMetricReaderOptions.exportIntervalMillis,
-    metricProducers: oasTlmConfig.metrics.mainMetricReaderOptions.metricProducers
-  });
-  const meterProvider = new _sdkMetrics.MeterProvider({
-    resource: _telemetryRegistry.oasTelemetryResource,
-    readers: [mainReader, ...oasTlmConfig.metrics.extraReaders],
-    views: oasTlmConfig.metrics.extraViews || []
-  });
-  // TODO maybe hostMetrics are too much, consider using only a subset of them.
-  const hostMetrics = new _hostMetrics.HostMetrics({
-    meterProvider: meterProvider
-  });
-  // AFTER adding all readers, start the instrumentations
-  hostMetrics.start();
-}

package/dist/cjs/telemetry/telemetryRegistry.cjs

@@ -1,43 +1,57 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.originalConsoleMethods = exports.oasTelemetryResource = exports.multiSpanExporter = exports.multiLogExporter = exports.inMemoryDbSpanExporter = exports.inMemoryDbMetricExporter = exports.inMemoryDbLogExporter = exports.dynamicMultiSpanProcessor = exports.dynamicMultiLogProcessor = void 0;
-var _InMemoryDbSpanExporter = require("./custom-implementations/exporters/InMemoryDbSpanExporter.cjs");
-var _wrappers = require("./custom-implementations/wrappers.cjs");
-var _InMemoryDbLogExporter = require("./custom-implementations/exporters/InMemoryDbLogExporter.cjs");
-var _InMemoryDbMetricExporter = require("./custom-implementations/exporters/InMemoryDbMetricExporter.cjs");
-var _dynamicMultiSpanProcessor = require("./custom-implementations/processors/dynamicMultiSpanProcessor.cjs");
-var _dynamicMultiLogProcessor = require("./custom-implementations/processors/dynamicMultiLogProcessor.cjs");
-var _semanticConventions = require("@opentelemetry/semantic-conventions");
-var _resources = require("@opentelemetry/resources");
-var _bootConfig = require("../config/bootConfig.cjs");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instrumentations = exports.inMemoryDbMetricExporter = exports.originalConsoleMethods = exports.dynamicMultiLogProcessor = exports.multiLogExporter = exports.inMemoryDbLogExporter = exports.dynamicMultiSpanProcessor = exports.multiSpanExporter = exports.inMemoryDbSpanExporter = exports.oasTelemetryResource = void 0;
+exports.isBootInitialized = isBootInitialized;
+exports.setBootInitialized = setBootInitialized;
+exports.isTelemetryConfigured = isTelemetryConfigured;
+exports.setTelemetryConfigured = setTelemetryConfigured;
+exports.setTelemetryRouter = setTelemetryRouter;
+exports.getTelemetryRouter = getTelemetryRouter;
+const InMemoryDbSpanExporter_js_1 = require("./custom-implementations/exporters/InMemoryDbSpanExporter.cjs");
+const wrappers_js_1 = require("./custom-implementations/wrappers.cjs");
+const InMemoryDbLogExporter_js_1 = require("./custom-implementations/exporters/InMemoryDbLogExporter.cjs");
+const InMemoryDbMetricExporter_js_1 = require("./custom-implementations/exporters/InMemoryDbMetricExporter.cjs");
+const dynamicMultiSpanProcessor_js_1 = require("./custom-implementations/processors/dynamicMultiSpanProcessor.cjs");
+const dynamicMultiLogProcessor_js_1 = require("./custom-implementations/processors/dynamicMultiLogProcessor.cjs");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const resources_1 = require("@opentelemetry/resources");
+const bootConfig_js_1 = require("../config/bootConfig.cjs");
 // GLOBAL REGISTRY of telemetry components, used by SDKs and controllers.
-const oasTelemetryResource = exports.oasTelemetryResource = (0, _resources.resourceFromAttributes)({
-  [_semanticConventions.ATTR_SERVICE_NAME]: _bootConfig.bootEnvVariables.OASTLM_BOOT_SERVICE_NAME
+let _bootInitialized = false;
+let _telemetryConfigured = false;
+let _router = undefined;
+function isBootInitialized() { return _bootInitialized; }
+function setBootInitialized(v) { _bootInitialized = v; }
+function isTelemetryConfigured() { return _telemetryConfigured; }
+function setTelemetryConfigured(v) { _telemetryConfigured = v; }
+function setTelemetryRouter(router) { _router = router; }
+function getTelemetryRouter() { return _router; }
+exports.oasTelemetryResource = (0, resources_1.resourceFromAttributes)({
+    [semantic_conventions_1.ATTR_SERVICE_NAME]: bootConfig_js_1.bootEnvVariables.OASTLM_BOOT_SERVICE_NAME
 });
 // TRACES -------------------------------------------------------------------------------------
 // This is the main exporter for oas-telemetry spans. (Used by the traces controller)
-const inMemoryDbSpanExporter = exports.inMemoryDbSpanExporter = new _InMemoryDbSpanExporter.InMemoryDbSpanExporter();
+exports.inMemoryDbSpanExporter = new InMemoryDbSpanExporter_js_1.InMemoryDbSpanExporter();
 // This allows to add more exporter in the future without changing the code
-const multiSpanExporter = exports.multiSpanExporter = new _wrappers.EnablerMultiSpanExporter();
+exports.multiSpanExporter = new wrappers_js_1.EnablerMultiSpanExporter();
 // This allows the addition of more processors at runtime
-const dynamicMultiSpanProcessor = exports.dynamicMultiSpanProcessor = new _dynamicMultiSpanProcessor.DynamicMultiSpanProcessor();
+exports.dynamicMultiSpanProcessor = new dynamicMultiSpanProcessor_js_1.DynamicMultiSpanProcessor();
 // LOGS ----------------------------------------------------------------------------------------
-const inMemoryDbLogExporter = exports.inMemoryDbLogExporter = new _InMemoryDbLogExporter.InMemoryDbLogExporter();
-const multiLogExporter = exports.multiLogExporter = new _wrappers.EnablerMultiLogExporter();
-const dynamicMultiLogProcessor = exports.dynamicMultiLogProcessor = new _dynamicMultiLogProcessor.DynamicMultiLogRecordProcessor();
-// Override console methods to emit logs via OpenTelemetry, like an instrumentation
-const originalConsoleMethods = exports.originalConsoleMethods = {
-  log: console.log,
-  warn: console.warn,
-  error: console.error,
-  info: console.info,
-  debug: console.debug
+exports.inMemoryDbLogExporter = new InMemoryDbLogExporter_js_1.InMemoryDbLogExporter();
+exports.multiLogExporter = new wrappers_js_1.EnablerMultiLogExporter();
+exports.dynamicMultiLogProcessor = new dynamicMultiLogProcessor_js_1.DynamicMultiLogRecordProcessor();
+// For custom log instrumentation, and lib logging
+exports.originalConsoleMethods = {
+    log: console.log,
+    warn: console.warn,
+    error: console.error,
+    info: console.info,
+    debug: console.debug,
 };
 // METRICS -------------------------------------------------------------------------------------
 // Metrics follow a different pattern in OpenTelemetry
-const inMemoryDbMetricExporter = exports.inMemoryDbMetricExporter = new _InMemoryDbMetricExporter.InMemoryDbMetricExporter();
+exports.inMemoryDbMetricExporter = new InMemoryDbMetricExporter_js_1.InMemoryDbMetricExporter();
 // Readers and their exporters cannot be grouped together in a MultiReader or similar construct
-// due to differences in aggregation temporality and aggregation selection.
+// due to differences in aggregation temporality and aggregation selection.
+// INSTRUMENTATIONS -----------------------------------------------------------------------
+exports.instrumentations = [];

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

@@ -1,68 +1,53 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.agent = agent;
-var _tools = require("./tools.cjs");
-var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-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); }
-async function agent(openai, messages, model = "gpt-3.5-turbo", extraPrompts = []) {
-  for (let i = 0; i < 5; i++) {
-    const modelResponse = await openai.chat.completions.create({
-      model,
-      messages,
-      tools: _tools.tools
-    });
-    const {
-      finish_reason,
-      message
-    } = modelResponse.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 tools_js_1 = require("./tools.cjs");
+const logger_js_1 = __importDefault(require("../utils/logger.cjs"));
+async function agent(openai, messages, model = "gpt-3.5-turbo") {
+    for (let i = 0; i < 5; i++) {
+        const modelResponse = await openai.chat.completions.create({
+            model,
+            messages,
+            tools: tools_js_1.tools,
         });
-      }
-      const resultMessage = results.map(({
-        name,
-        response
-      }, idx) => {
-        const toolCall = message.tool_calls?.[idx];
-        const params = toolCall ? JSON.parse(toolCall.function.arguments) : {};
-        return `Tool "${name}" called with parameters:\n${JSON.stringify(params, null, 2)}\nResult:\n${JSON.stringify(response, null, 2)}`;
-      }).join("\n\n");
-      messages.push({
-        role: "function",
-        name: "multiple_tool_calls",
-        content: resultMessage,
-        timestamp: new Date().toISOString()
-      });
-    } else if (finish_reason === "stop") {
-      messages.push(_objectSpread(_objectSpread({}, message), {}, {
-        timestamp: new Date().toISOString()
-      }));
-      return;
+        const { finish_reason, message } = modelResponse.choices[0];
+        if (finish_reason === "tool_calls" && message.tool_calls) {
+            logger_js_1.default.debug("Tool calls detected:", message.tool_calls);
+            const results = [];
+            for (const toolCall of message.tool_calls) {
+                // Type guard for tool_calls
+                if (toolCall.type !== 'function' || !toolCall.function)
+                    continue;
+                const functionName = toolCall.function.name;
+                const functionToCall = tools_js_1.availableTools[functionName];
+                const functionArgs = JSON.parse(toolCall.function.arguments);
+                const functionArgsArr = Object.values(functionArgs);
+                // 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 }, idx) => {
+                const toolCall = message.tool_calls?.[idx];
+                const params = toolCall && toolCall.type === 'function' && toolCall.function ? JSON.parse(toolCall.function.arguments) : {};
+                return `Tool "${name}" called with parameters:\n${JSON.stringify(params, null, 2)}\nResult:\n${JSON.stringify(response, null, 2)}`;
+            }).join("\n\n");
+            messages.push({
+                role: "function",
+                name: "multiple_tool_calls",
+                content: resultMessage,
+                timestamp: new Date().toISOString()
+            });
+        }
+        else if (finish_reason === "stop") {
+            messages.push({ ...message, timestamp: new Date().toISOString() });
+            return;
+        }
     }
-  }
-  messages.push({
-    role: "assistant",
-    content: "Maximum iterations reached without a suitable response. Try a more specific query.",
-    timestamp: new Date().toISOString()
-  });
-}
+    messages.push({ role: "assistant", content: "Maximum iterations reached without a suitable response. Try a more specific query.", timestamp: new Date().toISOString() });
+}