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

package/dist/esm/telemetry/custom-implementations/utils/circular.js

@@ -0,0 +1,76 @@
+export function removeCircularRefs(obj) {
+    // const seen = new WeakMap(); // Used to keep track of visited objects
+    // Replacer function to handle circular references
+    function replacer(key, value) {
+        if (key === "_spanProcessor") {
+            return "oas-telemetry skips this field to avoid circular reference";
+        }
+        // GENERIC CIRCULAR REFERENCE HANDLING
+        // if (typeof value === "object" && value !== null) {
+        //     // If the object has been visited before, return the name prefixed with "CIRCULAR+"
+        //     if (seen.has(value)) {
+        //         return `CIRCULAR${key}`;
+        //     }
+        //     seen.set(value, key); // Mark the object as visited with its name
+        // }
+        return value;
+    }
+    // Convert the object to a string and then parse it back
+    // This will trigger the replacer function to handle circular references
+    const jsonString = JSON.stringify(obj, replacer);
+    return JSON.parse(jsonString);
+}
+/**
+ * Recursively converts dot-separated keys in an object to nested objects.
+ *
+ * @param {any} obj - The object to process.
+ * @returns {any} - The object with all dot-separated keys converted to nested objects.
+ * @example
+ *  Input:
+ *  {
+ *    "http.method": "GET",
+ *    "http.url": "http://example.com",
+ *    "nested.obj.key": "value"
+ *  }
+ *  Output:
+ *  {
+ *    "http": {
+ *      "method": "GET",
+ *      "url": "http://example.com"
+ *    },
+ *    "nested": {
+ *      "obj": {
+ *        "key": "value"
+ *      }
+ *    }
+ *  }
+ */
+export function applyNesting(obj) {
+    if (Array.isArray(obj)) {
+        return obj.map(item => applyNesting(item));
+    }
+    else if (typeof obj === 'object' && obj !== null) {
+        const result = {};
+        for (const key in obj) {
+            const value = applyNesting(obj[key]);
+            const keys = key.split('.');
+            let temp = result;
+            for (let i = 0; i < keys.length; i++) {
+                const currentKey = keys[i];
+                if (i === keys.length - 1) {
+                    temp[currentKey] = value;
+                }
+                else {
+                    if (!temp[currentKey]) {
+                        temp[currentKey] = {};
+                    }
+                    temp = temp[currentKey];
+                }
+            }
+        }
+        return result;
+    }
+    else {
+        return obj;
+    }
+}

package/dist/esm/telemetry/custom-implementations/wrappers.js

@@ -0,0 +1,163 @@
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import logger from "../../utils/logger.js";
+export class Enabler {
+    constructor(enabled) {
+        this._enabled = true;
+        if (typeof enabled === 'boolean') {
+            this._enabled = enabled;
+        }
+    }
+    setEnabledValue(value) {
+        this._enabled = value;
+    }
+    enable() {
+        this._enabled = true;
+    }
+    disable() {
+        this._enabled = false;
+    }
+    isEnabled() {
+        return this._enabled;
+    }
+    toggle() {
+        this._enabled = !this._enabled;
+    }
+}
+/*
+ * Classes for enabler exporters, allowing enable/disable toggling of exporters at runtime.
+ *
+ * This class is designed to work for trace and log exporters, where multiple exporters can be active simultaneously
+ * (e.g., via a MultiExporter and one processor). By toggling the exporter, you can dynamically enable or
+ * disable the export operation without removing the exporter from the pipeline.
+ *
+ * For metrics, the OpenTelemetry model is different: there are two types of readers. PullMetricExporters do not have
+ * an exporter instance, and PushMetricExporters do, but only allow a single exporter per reader (with optional
+ * `selectAggregationTemporality` and `selectAggregation` attributes). Therefore, multiple exporters per reader are not
+ * supported for metrics.
+ *
+ * For metrics readers, a separate `DeactivableReader` class is recommended, which is even more efficient: when
+ * disabled, the reader's `collect` method is not called at all, saving additional resources compared to disabling the exporter.
+ *
+ */
+export class EnablerSpanExporter extends Enabler {
+    constructor(exporter) {
+        super();
+        this.exporter = exporter;
+    }
+    export(spans, resultCallback) {
+        if (this.isEnabled()) {
+            this.exporter.export(spans, resultCallback);
+        }
+    }
+    shutdown() {
+        return this.exporter.shutdown();
+    }
+    forceFlush() {
+        if (typeof this.exporter.forceFlush === 'function') {
+            return this.exporter.forceFlush();
+        }
+        return Promise.resolve();
+    }
+}
+export class EnablerLogExporter extends Enabler {
+    constructor(exporter) {
+        super();
+        this.exporter = exporter;
+    }
+    export(logs, resultCallback) {
+        if (this.isEnabled()) {
+            this.exporter.export(logs, resultCallback);
+        }
+    }
+    shutdown() {
+        return this.exporter.shutdown();
+    }
+}
+class EnablerMultiExporter extends Enabler {
+    constructor(exporters) {
+        super();
+        this._exporters = [];
+        if (exporters && Array.isArray(exporters)) {
+            this._exporters = exporters;
+        }
+    }
+    addExporters(exporter) {
+        if (!this._exporters) {
+            this._exporters = [];
+        }
+        if (Array.isArray(exporter)) {
+            this._exporters.push(...exporter);
+        }
+        else {
+            this._exporters.push(exporter);
+        }
+    }
+}
+export class EnablerMultiSpanExporter extends EnablerMultiExporter {
+    export(spans, resultCallback) {
+        logger.debug(`EnablerMultiSpanExporter.export called with ${spans.length} spans, exporters: ${this._exporters?.length ?? 0}, enabled: ${this.isEnabled()}`);
+        if (this.isEnabled() && this._exporters) {
+            this._exporters.forEach((exporter) => exporter.export(spans, resultCallback));
+        }
+    }
+    async shutdown() {
+        if (this._exporters) {
+            await Promise.all(this._exporters.map((exporter) => exporter.shutdown()));
+        }
+        return;
+    }
+}
+export class EnablerMultiLogExporter extends EnablerMultiExporter {
+    export(logs, resultCallback) {
+        if (this.isEnabled() && this._exporters) {
+            this._exporters.forEach((exporter) => exporter.export(logs, resultCallback));
+        }
+    }
+    async shutdown() {
+        if (this._exporters) {
+            await Promise.all(this._exporters.map((exporter) => exporter.shutdown()));
+        }
+        return;
+    }
+}
+export class EnablerMetricReader extends Enabler {
+    constructor(reader) {
+        super();
+        this.reader = reader;
+    }
+    forceFlush(options) {
+        if (this.isEnabled()) {
+            return this.reader.forceFlush(options);
+        }
+        return Promise.resolve();
+    }
+    setMetricProducer(metricProducer) {
+        if (this.isEnabled()) {
+            this.reader.setMetricProducer(metricProducer);
+        }
+    }
+    selectAggregation(instrumentType) {
+        return this.reader.selectAggregation(instrumentType);
+    }
+    selectAggregationTemporality(instrumentType) {
+        return this.reader.selectAggregationTemporality(instrumentType);
+    }
+    selectCardinalityLimit(instrumentType) {
+        return this.reader.selectCardinalityLimit(instrumentType);
+    }
+    async collect(options) {
+        if (this.isEnabled()) {
+            return await this.reader.collect(options);
+        }
+        return {
+            resourceMetrics: {
+                resource: resourceFromAttributes({}),
+                scopeMetrics: [],
+            },
+            errors: [],
+        };
+    }
+    shutdown(options) {
+        return this.reader.shutdown(options);
+    }
+}

package/dist/esm/telemetry/initializeTelemetry.js

@@ -0,0 +1,71 @@
+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 { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
+import { SeverityNumber } from '@opentelemetry/api-logs';
+import { LoggerProvider } from '@opentelemetry/sdk-logs';
+import { bootEnvVariables } from '../config/bootConfig.js';
+// 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 (bootEnvVariables.OASTLM_BOOT_MODULE_DISABLED) {
+    logger.info('🚫 OASTLM module is disabled, Providers not initialized.');
+}
+else {
+    logger.info('🚀 Initializing Open Telemetry');
+    initializeTraces();
+    initializeMetrics();
+    initializeLogs();
+    registerInstrumentations({
+        instrumentations: [
+            new HttpInstrumentation(),
+            // new ExpressInstrumentation(),
+        ],
+    });
+}
+function initializeTraces() {
+    logger.info('📊 Initializing TracerProvider');
+    const tracerProvider = new NodeTracerProvider({
+        resource: oasTelemetryResource,
+        spanProcessors: [dynamicMultiSpanProcessor]
+    });
+    tracerProvider.register();
+}
+function initializeLogs() {
+    logger.info('📜 Initializing LoggerProvider');
+    // Create and configure LoggerProvider
+    const loggerProvider = new LoggerProvider({
+        resource: oasTelemetryResource,
+        processors: [dynamicMultiLogProcessor]
+    });
+    // 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) => {
+            loggerInstance.emit({
+                severityNumber: SeverityNumber[method.toUpperCase()] || SeverityNumber.INFO,
+                severityText: method.toUpperCase(),
+                body: args.join(' '),
+                attributes: { 'source.source': `console.${method}` },
+            });
+            // @ts-expect-error yes
+            originalConsoleMethods[method](...args);
+        };
+    });
+}
+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
+}

package/dist/esm/telemetry/telemetryConfigurator.js

@@ -0,0 +1,74 @@
+import { BatchSpanProcessor, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-node';
+import { dynamicMultiLogProcessor, dynamicMultiSpanProcessor, inMemoryDbLogExporter, inMemoryDbMetricExporter, inMemoryDbSpanExporter, multiLogExporter, multiSpanExporter, oasTelemetryResource, pluginLogExporter, pluginMetricExporter, pluginSpanExporter } 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';
+export const configureTelemetry = (oasTlmConfig) => {
+    configureTraces(oasTlmConfig);
+    configureMetrics(oasTlmConfig);
+    configureLogs(oasTlmConfig);
+    logger.info("✅ Telemetry configured successfully. All exporters are ready");
+};
+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') {
+        logger.info('Not in production, using SimpleSpanProcessor for traces');
+        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);
+}
+function configureLogs(oasTlmConfig) {
+    // LOGS CONFIGURATION
+    // [OT]LoggerProvider -> [OT]LogRecordProcessor(multiLogProcessor) -> n Processors(eg mainProcessor, extra) -> 1 LogExporter
+    inMemoryDbLogExporter.setEnabledValue(oasTlmConfig.logs.memoryExporter.enabled);
+    inMemoryDbLogExporter.retentionTimeInSeconds = oasTlmConfig.logs.memoryExporter.retentionTimeSeconds;
+    const mainExporter = multiLogExporter;
+    let mainProcessor = new BatchLogRecordProcessor(mainExporter);
+    if (bootEnvVariables.OASTLM_BOOT_ENV !== 'production') {
+        logger.info('Not in production, using SimpleLogRecordProcessor for logs');
+        mainProcessor = new SimpleLogRecordProcessor(mainExporter);
+    }
+    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);
+}
+function configureMetrics(oasTlmConfig) {
+    // METRICS CONFIGURATION
+    // [CUSTOM]MeterProvider -> n [OTel]MetricReader -> (0-1) MetricExporter (only if push-based reader)
+    inMemoryDbMetricExporter.setEnabledValue(oasTlmConfig.metrics.memoryExporter.enabled);
+    inMemoryDbMetricExporter.retentionTimeInSeconds = oasTlmConfig.metrics.memoryExporter.retentionTimeSeconds;
+    const mainReader = new PeriodicExportingMetricReader({
+        exporter: inMemoryDbMetricExporter,
+        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],
+        views: oasTlmConfig.metrics.extraViews || []
+    });
+    // TODO maybe hostMetrics are too much, consider using only a subset of them.
+    const hostMetrics = new HostMetrics({ meterProvider: meterProvider });
+    // AFTER adding all readers, start the instrumentations
+    hostMetrics.start();
+}

package/dist/esm/telemetry/telemetryRegistry.js

@@ -0,0 +1,34 @@
+import { InMemoryDbSpanExporter } from "./custom-implementations/exporters/InMemoryDbSpanExporter.js";
+import { EnablerMultiLogExporter, EnablerMultiSpanExporter } from "./custom-implementations/wrappers.js";
+import { InMemoryDbLogExporter } from "./custom-implementations/exporters/InMemoryDbLogExporter.js";
+import { InMemoryDbMetricExporter } from "./custom-implementations/exporters/InMemoryDbMetricExporter.js";
+import { DynamicMultiSpanProcessor } from "./custom-implementations/processors/dynamicMultiSpanProcessor.js";
+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";
+// GLOBAL REGISTRY of telemetry components, used by SDKs and controllers.
+export const oasTelemetryResource = resourceFromAttributes({
+    [ATTR_SERVICE_NAME]: 'oas-telemetry-service'
+});
+// TRACES -------------------------------------------------------------------------------------
+// This is the main exporter for oas-telemetry spans. (Used by the traces controller)
+export const inMemoryDbSpanExporter = new InMemoryDbSpanExporter();
+// This allows to add more exporter in the future without changing the code
+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.
+// 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,68 +1,86 @@
 import OpenAI from 'openai';
-import dotenv from 'dotenv';
 import { tools, availableTools } from './tools.js';
 import logger from '../utils/logger.js';
-dotenv.config();
-let openai;
-try {
-    openai = new OpenAI({
-        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,
-        }));
-        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");
+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: "function",
-                name: "multiple_tool_calls",
-                content: resultMessage,
+                role: "system",
+                content: prompt,
             });
         }
-        else if (finish_reason === "stop") {
-            messages.push(message);
-            return message;
+    }
+    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,
+        });
+        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,
+                });
+            }
+            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." };
     }
-    return { content: "Se alcanzó el número máximo de iteraciones sin una respuesta adecuada. Intenta con una consulta más específica." };
-}
-export async function getAgentResponse(question) {
-    const response = await agent(question);
-    logger.debug("Response from agent:", response);
-    return response.content;
+    return async function getAgentResponse(question) {
+        const response = await agent(question);
+        logger.debug("Response from agent:", response);
+        return response.content;
+    };
 }

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

@@ -1,11 +1,12 @@
-import { getAgentResponse } from './agent.js';
+import { getAgent } from './agent.js';
 import { setKnownMicroservices, getKnownMicroservices } from './knownMicroservices.js';
 import logger from '../utils/logger.js';
-export const answerQuestion = async (req, res) => {
+export const answerQuestion = (oasTlmConfig) => async (req, res) => {
     try {
         const { question } = req.body;
         if (!question)
             res.status(400).json({ error: 'Missing question' });
+        const getAgentResponse = getAgent(oasTlmConfig);
         const answer = await getAgentResponse(question);
         res.json({ answer });
     }
@@ -14,7 +15,7 @@ export const answerQuestion = async (req, res) => {
         res.status(500).json({ error: 'Internal error' });
     }
 };
-export const setKnownMicroservicesHandler = (req, res) => {
+export const setKnownMicroservicesHandler = () => (req, res) => {
     try {
         const { microservices } = req.body;
         if (!Array.isArray(microservices)) {
@@ -33,7 +34,7 @@ export const setKnownMicroservicesHandler = (req, res) => {
         res.status(500).json({ error: 'Internal error' });
     }
 };
-export const getKnownMicroservicesHandler = (req, res) => {
+export const getKnownMicroservicesHandler = () => (req, res) => {
     try {
         const microservices = getKnownMicroservices();
         res.json({ knownMicroservices: microservices });

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

@@ -1,7 +1,9 @@
 import { Router } from 'express';
 import { answerQuestion, setKnownMicroservicesHandler, getKnownMicroservicesHandler } from './aiController.js';
-export const aiRoutes = Router();
-aiRoutes.post('/chat', answerQuestion);
-aiRoutes.post('/microservices', setKnownMicroservicesHandler); // New route for configuring microservices
-aiRoutes.get('/microservices', getKnownMicroservicesHandler); // Route to retrieve the list of known microservices
-export default aiRoutes;
+export const getAIRoutes = (oasTlmConfig) => {
+    const router = Router();
+    router.post('/chat', answerQuestion(oasTlmConfig));
+    router.post('/microservices', setKnownMicroservicesHandler());
+    router.get('/microservices', getKnownMicroservicesHandler());
+    return router;
+};