@oas-tools/oas-telemetry 0.7.0-alpha.4 → 0.7.0

package/dist/esm/routesManager.js

@@ -1,4 +1,4 @@
-import { json } from "express";
+import { Router, json } from "express";
 import logger from "./utils/logger.js";
 import cors from 'cors';
 import { getTraceRoutes } from "./tlm-trace/traceRoutes.js";
@@ -16,62 +16,50 @@ export const configureRoutes = (router, oasTlmConfig) => {
     if (bootEnvVariables.OASTLM_BOOT_ENV === 'development') {
         logger.info("Running in development mode, enabling CORS for all origins");
         router.use(cors({
-            origin: '*', // Permitir todas las solicitudes en desarrollo
-            methods: ['GET', 'POST', 'PUT', 'DELETE'],
-            allowedHeaders: ['Content-Type', 'Authorization'],
+            origin: (origin, callback) => {
+                if (!origin || /^http:\/\/localhost:\d+$/.test(origin)) {
+                    callback(null, true);
+                }
+                else {
+                    callback(new Error('Not allowed by CORS'));
+                }
+            },
+            credentials: true
         }));
     }
-    router.use((req, res, next) => {
+    const telemetryBaseUrl = oasTlmConfig.general.baseUrl;
+    // Sub-router for all telemetry endpoints
+    const telemetryRouter = Router();
+    // Body parser for JSON requests
+    telemetryRouter.use((req, res, next) => {
         if (req.body !== undefined) {
             return next(); // Already parsed, no need to parse again.
         }
         return json({ limit: '10mb' })(req, res, next);
     });
-    const allAuthMiddlewares = getWrappedMiddlewares(() => oasTlmConfig.auth.enabled, [cookieParser(), getAuthRoutes(oasTlmConfig), getAuthMiddleware(oasTlmConfig)]);
-    const baseUrl = oasTlmConfig.general.baseUrl;
-    router.use(baseUrl, allAuthMiddlewares);
-    router.use(baseUrl + "/traces", getTraceRoutes());
-    router.use(baseUrl + "/metrics", getMetricsRoutes());
-    router.use(baseUrl + "/logs", getLogRoutes());
-    router.use(baseUrl + "/ai", getWrappedMiddlewares(() => oasTlmConfig.ai.openAIKey !== null, [getAIRoutes(oasTlmConfig)]));
-    // WARNING: This path must be the same as the one used in the UI package App.tsx "oas-telemetry-ui"
-    router.use(baseUrl + "/oas-telemetry-ui", getUIRoutes());
-    router.use(baseUrl + "/utils", getUtilsRoutes(oasTlmConfig));
-    router.use(baseUrl + "/plugins", getPluginRoutes());
-    router.get(baseUrl + '/health', (_req, res) => {
+    telemetryRouter.get('/health', (_req, res) => {
         res.status(200).send({ status: 'OK' });
     });
-    //redirect to the UI when accessing the base URL
-    router.get(baseUrl, (req, res) => {
-        res.redirect(baseUrl + "/oas-telemetry-ui");
+    // Redirect to the UI when accessing the base URL
+    telemetryRouter.get('/', (req, res) => {
+        res.redirect(`${telemetryBaseUrl}/oas-telemetry-ui/`);
     });
+    // WARNING: This path must be the same as the one used in the UI package App.tsx "oas-telemetry-ui"
+    telemetryRouter.use("/oas-telemetry-ui", getUIRoutes());
+    telemetryRouter.use("/utils", getUtilsRoutes(oasTlmConfig));
+    // Auth routes must be registered. If authentication is not enabled, all requests will be allowed.
+    // Frontend will use these endpoints;
+    telemetryRouter.use(cookieParser());
+    // Refresh token uses /auth/refresh path, careful if you change it
+    telemetryRouter.use('/auth', getAuthRoutes(oasTlmConfig));
+    telemetryRouter.use(getAuthMiddleware(oasTlmConfig));
+    telemetryRouter.use("/traces", getTraceRoutes());
+    telemetryRouter.use("/metrics", getMetricsRoutes());
+    telemetryRouter.use("/logs", getLogRoutes());
+    if (oasTlmConfig.ai.openAIKey) {
+        telemetryRouter.use("/ai", getAIRoutes(oasTlmConfig));
+    }
+    telemetryRouter.use("/plugins", getPluginRoutes());
+    // Mount the telemetryRouter under telemetryBaseUrl
+    router.use(telemetryBaseUrl, telemetryRouter);
 };
-/**
- * This function wraps the provided middleware functions with a condition callback.
- * If the condition callback returns true, the middleware/router will be executed.
- * If the condition callback returns false, the middleware/router will be skipped.
- *
- * @callback {function} conditionCallback A callback function that returns a boolean to determine if the middleware should be used.
- * @param {Array} middlewares An array of middleware or routers to be wrapped.
- * @returns {Array} An array of wrapped middleware functions.
- */
-function getWrappedMiddlewares(conditionCallback, middlewares) {
-    return middlewares.map(middleware => {
-        return function (req, res, next) {
-            if (conditionCallback()) {
-                if (typeof middleware === 'function') {
-                    // look for handle property, if it exists, it's a router. If not call middleware
-                    if (middleware.handle) {
-                        middleware.handle(req, res, next);
-                    }
-                    else {
-                        middleware(req, res, next);
-                    }
-                }
-            }
-            else {
-                next();
-            }
-        };
-    });
-}

package/dist/esm/telemetry/custom-implementations/exporters/InMemoryDbLogExporter.js

@@ -5,6 +5,7 @@ import MiniSearch from 'minisearch';
 import { applyNesting, removeCircularRefs } from '../utils/circular.js';
 import { Enabler } from '../wrappers.js';
 import logger from '../../../utils/logger.js';
+import { pluginService } from '../../../tlm-plugin/pluginService.js';
 export class InMemoryDbLogExporter extends Enabler {
     constructor(retentionTimeInSeconds = 3600) {
         super();
@@ -30,10 +31,6 @@ export class InMemoryDbLogExporter extends Enabler {
      * @param resultCallback
      */
     export(logs, resultCallback) {
-        if (!this.isEnabled()) {
-            resultCallback({ code: ExportResultCode.SUCCESS });
-            return;
-        }
         const logsToInsert = logs.map(logRecord => {
             // Remove circular references first, then apply nesting, then export info
             const formattedLog = this._formatLogRecord(logRecord);
@@ -41,7 +38,14 @@ export class InMemoryDbLogExporter extends Enabler {
             const nestedLog = applyNesting(cleanedLog);
             return nestedLog;
         });
-        this._insertLogs(logsToInsert, resultCallback);
+        logsToInsert.forEach(log => {
+            pluginService.broadcastLog(log);
+        });
+        // ENABLED only affect storage not plugin broadcasting
+        if (this.isEnabled()) {
+            this._insertLogs(logsToInsert, resultCallback);
+        }
+        resultCallback({ code: ExportResultCode.SUCCESS });
     }
     reset() {
         this._db = new Datastore();
@@ -58,15 +62,28 @@ export class InMemoryDbLogExporter extends Enabler {
         this._db = null;
         this._miniSearch = null;
     }
-    find(query, messageSearch, callback) {
+    async find(findConfig) {
+        const { query, messageSearch, limit, sortOrder } = findConfig;
+        const finalQuery = { ...query };
+        const effectiveSortOrder = sortOrder || { timestamp: -1 };
         if (messageSearch) {
-            const searchResults = this._miniSearch.search(messageSearch);
+            const searchResults = this._miniSearch.search(messageSearch, { prefix: true, fuzzy: 0.2 });
             const ids = searchResults.map((result) => result._id);
             logger.debug(`MiniSearch found ${ids.length} results for search term "${messageSearch}"`, { depth: 3 });
-            // Add MiniSearch results to the query
-            query._id = { $in: ids };
+            finalQuery._id = { $in: ids };
         }
-        this._db.find(query, callback);
+        const docs = await new Promise((resolve, reject) => {
+            this._db.find(finalQuery)
+                .sort(effectiveSortOrder)
+                .limit(limit)
+                .exec((err, docs) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(docs);
+            });
+        });
+        return docs;
     }
     insert(data, callback) {
         this._insertLogs(data, (result) => {
@@ -100,7 +117,8 @@ export class InMemoryDbLogExporter extends Enabler {
                 attributes: logRecord.resource.attributes,
             },
             instrumentationScope: logRecord.instrumentationScope,
-            timestamp: hrTimeToMicroseconds(logRecord.hrTime) || Date.now(),
+            timestamp: hrTimeToMicroseconds(logRecord.hrTime) ?? Date.now(),
+            observedTimestamp: hrTimeToMicroseconds(logRecord.hrTimeObserved) ?? Date.now(),
             traceId: logRecord.spanContext?.traceId,
             spanId: logRecord.spanContext?.spanId,
             traceFlags: logRecord.spanContext?.traceFlags,
@@ -114,6 +132,9 @@ export class InMemoryDbLogExporter extends Enabler {
         this._retentionTimeInSeconds = retentionTimeInSeconds;
         logger.info(`InMemoryDbLogExporter retention time set to ${this._retentionTimeInSeconds} seconds`);
     }
+    get retentionTimeInSeconds() {
+        return this._retentionTimeInSeconds;
+    }
     _insertLogs(logsToInsert, resultCallback) {
         this._db.insert(logsToInsert, (err, newDocs) => {
             if (err) {

package/dist/esm/telemetry/custom-implementations/exporters/InMemoryDbMetricExporter.js

@@ -3,6 +3,7 @@ import dataStore from '@seald-io/nedb';
 import { applyNesting } from '../utils/circular.js';
 import { Enabler } from '../wrappers.js';
 import logger from '../../../utils/logger.js';
+import { pluginService } from '../../../tlm-plugin/pluginService.js';
 export class InMemoryDbMetricExporter extends Enabler {
     constructor(retentionTimeInSeconds = 3600) {
         super();
@@ -13,9 +14,13 @@ export class InMemoryDbMetricExporter extends Enabler {
     }
     export(metrics, resultCallback) {
         try {
+            const scopeMetrics = metrics?.scopeMetrics;
+            const cleanMetrics = applyNesting(scopeMetrics);
+            cleanMetrics.forEach((metric) => {
+                pluginService.broadcastMetric(metric);
+            });
+            // Insert only if exporter is enabled
             if (this.isEnabled()) {
-                const scopeMetrics = metrics?.scopeMetrics;
-                const cleanMetrics = applyNesting(scopeMetrics);
                 this._metrics.insert(cleanMetrics, (err, _newDoc) => {
                     if (err) {
                         logger.error('Insertion Error:', err);
@@ -62,6 +67,9 @@ export class InMemoryDbMetricExporter extends Enabler {
         this._retentionTimeInSeconds = retentionTimeInSeconds;
         logger.info(`InMemoryDbMetricExporter retention time set to ${this._retentionTimeInSeconds} seconds`);
     }
+    get retentionTimeInSeconds() {
+        return this._retentionTimeInSeconds;
+    }
     _startCleanupJob() {
         const interval = 1000;
         setInterval(() => {

package/dist/esm/telemetry/custom-implementations/exporters/InMemoryDbSpanExporter.js

@@ -3,6 +3,7 @@ import dataStore from '@seald-io/nedb';
 import logger from '../../../utils/logger.js';
 import { applyNesting, removeCircularRefs } from '../utils/circular.js';
 import { Enabler } from '../wrappers.js';
+import { pluginService } from '../../../tlm-plugin/pluginService.js';
 export class InMemoryDbSpanExporter extends Enabler {
     constructor(retentionTimeInSeconds = 3600) {
         super();
@@ -20,32 +21,38 @@ export class InMemoryDbSpanExporter extends Enabler {
         this._retentionTimeInSeconds = retentionTimeInSeconds;
         logger.info(`InMemoryDbSpanExporter retention time set to ${this._retentionTimeInSeconds} seconds`);
     }
+    get retentionTimeInSeconds() {
+        return this._retentionTimeInSeconds;
+    }
     export(readableSpans, resultCallback) {
         logger.debug('InMemoryDbSpanExporter.export called with spans: ', readableSpans.length);
         try {
-            if (!this.isEnabled()) {
-                logger.debug('InMemoryDbSpanExporter is not enabled. Skipping export.');
-                return resultCallback({ code: ExportResultCode.SUCCESS });
-            }
             // Prepare spans to be inserted into the in-memory database (remove circular references and convert to nested objects)
             const cleanSpans = readableSpans
                 .map(nestedSpan => removeCircularRefs(nestedSpan)) // to avoid JSON parsing error
                 .map(span => applyNesting(span)) // to avoid dot notation in keys (neDB does not support dot notation in keys)
                 .filter(span => {
-                const target = span?.attributes?.http?.target; // Exclude spans where target includes 'telemetry' but NOT 'telemetry/utils'
+                const target = span?.attributes?.http?.target;
+                // Exclude spans where target includes 'telemetry' but NOT 'telemetry/utils/generate-log' or 'telemetry/utils/generate-wait'
                 if (target && target.includes(this._baseUrl)) {
-                    return target.includes(this._baseUrl + '/utils');
+                    return (target.includes("generate"));
                 }
                 return true;
             });
-            // Insert spans into the in-memory database
-            this._spans.insert(cleanSpans, (err, _newDoc) => {
-                if (err) {
-                    logger.error(err);
-                    return;
-                }
+            cleanSpans.forEach(span => {
+                pluginService.broadcastTrace(span);
             });
-            setTimeout(() => resultCallback({ code: ExportResultCode.SUCCESS }), 0);
+            // 
+            if (this.isEnabled()) {
+                // Insert spans into the in-memory database
+                this._spans.insert(cleanSpans, (err, _newDoc) => {
+                    if (err) {
+                        logger.error(err);
+                        return;
+                    }
+                });
+            }
+            return resultCallback({ code: ExportResultCode.SUCCESS });
         }
         catch (error) {
             logger.error('Error exporting spans\n' + error.message + '\n' + error.stack);

package/dist/esm/telemetry/initializeTelemetry.js

@@ -1,11 +1,12 @@
 import { HttpInstrumentation } from '@opentelemetry/instrumentation-http';
 import logger from '../utils/logger.js';
 import { registerInstrumentations } from '@opentelemetry/instrumentation';
-import { dynamicMultiLogProcessor, dynamicMultiSpanProcessor, oasTelemetryResource } from './telemetryRegistry.js';
+import { dynamicMultiLogProcessor, dynamicMultiSpanProcessor, oasTelemetryResource, originalConsoleMethods } from './telemetryRegistry.js';
 import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
 import { SeverityNumber } from '@opentelemetry/api-logs';
 import { LoggerProvider } from '@opentelemetry/sdk-logs';
 import { bootEnvVariables } from '../config/bootConfig.js';
+import util from 'util';
 // 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
@@ -41,22 +42,15 @@ function initializeLogs() {
     });
     // Get a logger instance
     const loggerInstance = loggerProvider.getLogger('oas-telemetry'); // Use loggerProvider to get the logger
-    // Override console methods to emit logs via OpenTelemetry, like an instrumentation
-    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) => {
+            const severity = getSeverityForMethod(method);
             loggerInstance.emit({
-                severityNumber: SeverityNumber[method.toUpperCase()] || SeverityNumber.INFO,
-                severityText: method.toUpperCase(),
-                body: args.join(' '),
-                attributes: { 'source.source': `console.${method}` },
+                severityNumber: severity.number,
+                severityText: severity.text,
+                body: util.format(...args),
+                attributes: { 'source': `console.${method}`, "library": "oas-telemetry" },
             });
             // @ts-expect-error yes
             originalConsoleMethods[method](...args);
@@ -65,7 +59,21 @@ function initializeLogs() {
 }
 function initializeMetrics() {
     logger.info('📈 Initializing MeterProvider');
-    // WARN: This is a custom provider that allows adding readers dynamically at runtime.
     // 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
 }
+function getSeverityForMethod(method) {
+    switch (method) {
+        case "log":
+        case "info":
+            return { number: SeverityNumber.INFO, text: "INFO" };
+        case "debug":
+            return { number: SeverityNumber.DEBUG, text: "DEBUG" };
+        case "warn":
+            return { number: SeverityNumber.WARN, text: "WARN" };
+        case "error":
+            return { number: SeverityNumber.ERROR, text: "ERROR" };
+        default:
+            return { number: SeverityNumber.INFO, text: "INFO" };
+    }
+}

package/dist/esm/telemetry/telemetryConfigurator.js

@@ -1,23 +1,27 @@
 import { BatchSpanProcessor, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-node';
-import { dynamicMultiLogProcessor, dynamicMultiSpanProcessor, inMemoryDbLogExporter, inMemoryDbMetricExporter, inMemoryDbSpanExporter, multiLogExporter, multiSpanExporter, oasTelemetryResource, pluginLogExporter, pluginMetricExporter, pluginSpanExporter } from './telemetryRegistry.js';
+import { dynamicMultiLogProcessor, dynamicMultiSpanProcessor, inMemoryDbLogExporter, inMemoryDbMetricExporter, inMemoryDbSpanExporter, multiLogExporter, multiSpanExporter, oasTelemetryResource } from './telemetryRegistry.js';
 import logger from '../utils/logger.js';
 import { BatchLogRecordProcessor, SimpleLogRecordProcessor } from '@opentelemetry/sdk-logs';
 import { MeterProvider, PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';
 import { HostMetrics } from '@opentelemetry/host-metrics';
 import { bootEnvVariables } from '../config/bootConfig.js';
+import { pluginService } from '../tlm-plugin/pluginService.js';
 export const configureTelemetry = (oasTlmConfig) => {
+    configurePlugins(oasTlmConfig);
     configureTraces(oasTlmConfig);
     configureMetrics(oasTlmConfig);
     configureLogs(oasTlmConfig);
     logger.info("✅ Telemetry configured successfully. All exporters are ready");
 };
+function configurePlugins(oasTlmConfig) {
+    pluginService.enabled = oasTlmConfig.plugins.enabled;
+}
 function configureTraces(oasTlmConfig) {
     // TRACES CONFIGURATION
     // [OT]Provider -> [OT]SpanProcessor(multiSpan) -> n Processors(eg mainProcessor, extra) -> 1 SpanExporter
     inMemoryDbSpanExporter.baseUrl = oasTlmConfig.general.baseUrl; // TODO this will be done with filters
     inMemoryDbSpanExporter.retentionTimeInSeconds = oasTlmConfig.traces.memoryExporter.retentionTimeSeconds;
     inMemoryDbSpanExporter.setEnabledValue(oasTlmConfig.traces.memoryExporter.enabled);
-    pluginSpanExporter.setEnabledValue(oasTlmConfig.plugins.enabled);
     const mainExporter = multiSpanExporter;
     let mainProcessor = new BatchSpanProcessor(mainExporter);
     if (bootEnvVariables.OASTLM_BOOT_ENV !== 'production') {
@@ -25,7 +29,6 @@ function configureTraces(oasTlmConfig) {
         mainProcessor = new SimpleSpanProcessor(mainExporter);
     }
     mainExporter.addExporters(inMemoryDbSpanExporter); // Main exporter have at least the in-memory exporter used by the traces controller
-    mainExporter.addExporters(pluginSpanExporter);
     mainExporter.addExporters(oasTlmConfig.traces.extraExporters);
     dynamicMultiSpanProcessor.addProcessors(mainProcessor);
     dynamicMultiSpanProcessor.addProcessors(oasTlmConfig.traces.extraProcessors);
@@ -43,7 +46,6 @@ function configureLogs(oasTlmConfig) {
     }
     mainExporter.addExporters(inMemoryDbLogExporter); // Main exporter have at least the in-memory exporter used by the logs controller
     mainExporter.addExporters(oasTlmConfig.logs.extraExporters);
-    mainExporter.addExporters(pluginLogExporter); // Allow logs to be sent to plugins too
     dynamicMultiLogProcessor.addProcessors(mainProcessor);
     dynamicMultiLogProcessor.addProcessors(oasTlmConfig.logs.extraProcessors);
 }
@@ -57,14 +59,9 @@ function configureMetrics(oasTlmConfig) {
         exportIntervalMillis: oasTlmConfig.metrics.mainMetricReaderOptions.exportIntervalMillis,
         metricProducers: oasTlmConfig.metrics.mainMetricReaderOptions.metricProducers
     });
-    const pluginReader = new PeriodicExportingMetricReader({
-        exporter: pluginMetricExporter,
-        exportIntervalMillis: oasTlmConfig.metrics.mainMetricReaderOptions.exportIntervalMillis,
-        metricProducers: oasTlmConfig.metrics.mainMetricReaderOptions.metricProducers
-    });
     const meterProvider = new MeterProvider({
         resource: oasTelemetryResource,
-        readers: [mainReader, pluginReader, ...oasTlmConfig.metrics.extraReaders],
+        readers: [mainReader, ...oasTlmConfig.metrics.extraReaders],
         views: oasTlmConfig.metrics.extraViews || []
     });
     // TODO maybe hostMetrics are too much, consider using only a subset of them.

package/dist/esm/telemetry/telemetryRegistry.js

@@ -6,12 +6,10 @@ import { DynamicMultiSpanProcessor } from "./custom-implementations/processors/d
 import { DynamicMultiLogRecordProcessor } from "./custom-implementations/processors/dynamicMultiLogProcessor.js";
 import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
 import { resourceFromAttributes } from "@opentelemetry/resources";
-import { PluginSpanExporter } from "./custom-implementations/exporters/PluginSpanExporter.js";
-import { PluginLogExporter } from "./custom-implementations/exporters/PluginLogExporter.js";
-import { PluginMetricExporter } from "./custom-implementations/exporters/PluginMetricExporter.js";
+import { bootEnvVariables } from "../config/bootConfig.js";
 // GLOBAL REGISTRY of telemetry components, used by SDKs and controllers.
 export const oasTelemetryResource = resourceFromAttributes({
-    [ATTR_SERVICE_NAME]: 'oas-telemetry-service'
+    [ATTR_SERVICE_NAME]: bootEnvVariables.OASTLM_BOOT_SERVICE_NAME
 });
 // TRACES -------------------------------------------------------------------------------------
 // This is the main exporter for oas-telemetry spans. (Used by the traces controller)
@@ -20,15 +18,20 @@ export const inMemoryDbSpanExporter = new InMemoryDbSpanExporter();
 export const multiSpanExporter = new EnablerMultiSpanExporter();
 // This allows the addition of more processors at runtime
 export const dynamicMultiSpanProcessor = new DynamicMultiSpanProcessor();
-export const pluginSpanExporter = new PluginSpanExporter(); // This exporter sends spans to the plugin module.
 // LOGS ----------------------------------------------------------------------------------------
 export const inMemoryDbLogExporter = new InMemoryDbLogExporter();
 export const multiLogExporter = new EnablerMultiLogExporter();
 export const dynamicMultiLogProcessor = new DynamicMultiLogRecordProcessor();
-export const pluginLogExporter = new PluginLogExporter(); // This exporter sends logs to the plugin module.
+// Override console methods to emit logs via OpenTelemetry, like an instrumentation
+export const originalConsoleMethods = {
+    log: console.log,
+    warn: console.warn,
+    error: console.error,
+    info: console.info,
+    debug: console.debug,
+};
 // METRICS -------------------------------------------------------------------------------------
 // Metrics follow a different pattern in OpenTelemetry
 export const inMemoryDbMetricExporter = new InMemoryDbMetricExporter();
-export const pluginMetricExporter = new PluginMetricExporter(); // This exporter sends metrics to the plugin module.
 // Readers and their exporters cannot be grouped together in a MultiReader or similar construct
 // due to differences in aggregation temporality and aggregation selection.

package/dist/esm/tlm-ai/agent.js

@@ -1,86 +1,45 @@
-import OpenAI from 'openai';
 import { tools, availableTools } from './tools.js';
 import logger from '../utils/logger.js';
-export function getAgent(oasTlmConfig) {
-    let openai;
-    try {
-        if (!oasTlmConfig.ai.openAIKey) {
-            openai = null;
-        }
-        else {
-            openai = new OpenAI({
-                apiKey: oasTlmConfig.ai.openAIKey ?? undefined,
-                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."
-        },
-    ];
-    // Add extra context prompts if provided
-    if (oasTlmConfig.ai.extraContextPrompts) {
-        for (const prompt of oasTlmConfig.ai.extraContextPrompts) {
-            messages.push({
-                role: "system",
-                content: prompt,
-            });
-        }
-    }
-    async function agent(userInput) {
-        if (!openai) {
-            logger.error("OpenAI client is not initialized. Please check your OpenAI API key.");
-            return { content: "OpenAI client is not initialized. Please check your OpenAI API key." };
-        }
-        messages.push({
-            role: "user",
-            content: userInput,
+export 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,
         });
-        for (let i = 0; i < 5; i++) {
-            const response = await (openai?.chat?.completions?.create?.({
-                model: oasTlmConfig.ai.openAIModel,
-                messages: messages,
-                tools: tools,
-            }));
-            const { finish_reason, message } = response.choices[0];
-            if (finish_reason === "tool_calls" && message.tool_calls) {
-                logger.debug("Tool calls detected:", message.tool_calls);
-                const results = [];
-                for (const toolCall of message.tool_calls) {
-                    const functionName = toolCall.function.name;
-                    const functionToCall = 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,
+        const { finish_reason, message } = modelResponse.choices[0];
+        if (finish_reason === "tool_calls" && message.tool_calls) {
+            logger.debug("Tool calls detected:", message.tool_calls);
+            const results = [];
+            for (const toolCall of message.tool_calls) {
+                const functionName = toolCall.function.name;
+                const functionToCall = 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,
                 });
             }
-            else if (finish_reason === "stop") {
-                messages.push(message);
-                return message;
-            }
+            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({ ...message, timestamp: new Date().toISOString() });
+            return;
         }
-        return { content: "Se alcanzó el número máximo de iteraciones sin una respuesta adecuada. Intenta con una consulta más específica." };
     }
-    return async function getAgentResponse(question) {
-        const response = await agent(question);
-        logger.debug("Response from agent:", response);
-        return response.content;
-    };
+    messages.push({ role: "assistant", content: "Maximum iterations reached without a suitable response. Try a more specific query.", timestamp: new Date().toISOString() });
 }