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

package/dist/esm/routesManager.js

@@ -46,6 +46,7 @@ export const configureRoutes = (router, oasTlmConfig) => {
     });
     // 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());
@@ -58,7 +59,6 @@ export const configureRoutes = (router, oasTlmConfig) => {
     if (oasTlmConfig.ai.openAIKey) {
         telemetryRouter.use("/ai", getAIRoutes(oasTlmConfig));
     }
-    telemetryRouter.use("/utils", getUtilsRoutes(oasTlmConfig));
     telemetryRouter.use("/plugins", getPluginRoutes());
     // Mount the telemetryRouter under telemetryBaseUrl
     router.use(telemetryBaseUrl, telemetryRouter);

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() });
 }

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

@@ -1,46 +1,63 @@
-import { getAgent } from './agent.js';
-import { setKnownMicroservices, getKnownMicroservices } from './knownMicroservices.js';
-import logger from '../utils/logger.js';
-export const answerQuestion = (oasTlmConfig) => async (req, res) => {
+import { getAiService } from './aiService.js';
+export async function createConversation(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 });
-    }
-    catch (error) {
-        logger.error(error);
-        res.status(500).json({ error: 'Internal error' });
-    }
-};
-export const setKnownMicroservicesHandler = () => (req, res) => {
+        const conversation = getAiService().createConversation();
+        res.status(201).json(conversation);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+}
+export async function listConversations(req, res) {
+    try {
+        // Only return id and name for each conversation
+        const conversations = getAiService().listConversationsMinimal();
+        res.json(conversations);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+}
+export async function getConversationHistory(req, res) {
+    try {
+        const { conversationId } = req.params;
+        const conversation = getAiService().getConversation(conversationId);
+        if (!conversation) {
+            res.status(404).json({ error: 'Not found' });
+            return;
+        }
+        res.json(conversation);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+}
+export async function deleteConversation(req, res) {
     try {
-        const { microservices } = req.body;
-        if (!Array.isArray(microservices)) {
-            res.status(400).json({ error: 'Invalid microservices format. Expected an array.' });
+        const { conversationId } = req.params;
+        const deleted = getAiService().deleteConversation(conversationId);
+        if (!deleted) {
+            res.status(404).json({ error: 'Not found' });
             return;
         }
-        setKnownMicroservices(microservices);
-        res.json({
-            message: "Microservices configuration updated successfully.",
-            knownMicroservices: getKnownMicroservices(),
-            note: "In the future, OAS-Telemetry will support autodiscovery, making this configuration unnecessary.",
-        });
-    }
-    catch (error) {
-        logger.error(error);
-        res.status(500).json({ error: 'Internal error' });
-    }
-};
-export const getKnownMicroservicesHandler = () => (req, res) => {
+        res.status(204).send();
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+}
+export async function sendMessage(req, res) {
     try {
-        const microservices = getKnownMicroservices();
-        res.json({ knownMicroservices: microservices });
+        const { conversationId } = req.params;
+        const { content } = req.body;
+        if (!content) {
+            res.status(400).json({ error: 'Missing content' });
+            return;
+        }
+        const messages = await getAiService().sendMessage(conversationId, content);
+        res.json(messages);
     }
-    catch (error) {
-        logger.error(error);
-        res.status(500).json({ error: 'Internal error' });
+    catch (err) {
+        res.status(500).json({ error: err.message });
     }
-};
+}

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

@@ -1,9 +1,16 @@
 import { Router } from 'express';
-import { answerQuestion, setKnownMicroservicesHandler, getKnownMicroservicesHandler } from './aiController.js';
+import { createConversation, deleteConversation, getConversationHistory, listConversations, sendMessage } from './aiController.js';
+import { configureAiService } from './aiService.js';
 export const getAIRoutes = (oasTlmConfig) => {
     const router = Router();
-    router.post('/chat', answerQuestion(oasTlmConfig));
-    router.post('/microservices', setKnownMicroservicesHandler());
-    router.get('/microservices', getKnownMicroservicesHandler());
+    configureAiService(oasTlmConfig); //oasTlmConfig.ai.openAIKey
+    router.get('/chat/health', (req, res) => {
+        res.status(200).send('AI service is healthy');
+    });
+    router.get('/chat', listConversations);
+    router.post('/chat', createConversation);
+    router.get('/chat/:conversationId', getConversationHistory);
+    router.post('/chat/:conversationId/message', sendMessage);
+    router.delete('/chat/:conversationId', deleteConversation);
     return router;
 };