@tiledesk/tiledesk-server 2.15.6 → 2.15.8

package/CHANGELOG.md

@@ -5,6 +5,13 @@
 🚀        IN PRODUCTION                        🚀
 (https://www.npmjs.com/package/@tiledesk/tiledesk-server/v/2.3.77) 
 
+# 2.15.8
+- Updated tybot-connector to 2.0.45
+- Added support for tags management in knowledge base routes
+
+# 2.15.7
+- Updated whatsapp-connector to 1.0.26
+
 # 2.15.6
 - Updated voice-twilio-connector to 0.3.2
 - Updated vxml-connector to 0.1.91

package/models/kb_setting.js

@@ -175,6 +175,11 @@ var KBSchema = new Schema({
   last_error: {
     type: Object,
     required: false
+  },
+  tags: {
+    type: Array,
+    default: undefined,
+    required: false
   }
 }, {
   timestamps: true

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiledesk/tiledesk-server",
   "description": "The Tiledesk server module",
-  "version": "2.15.6",
+  "version": "2.15.8",
   "scripts": {
     "start": "node ./bin/www",
     "pretest": "mongodb-runner start",
@@ -49,10 +49,10 @@
     "@tiledesk/tiledesk-rasa-connector": "^1.0.10",
     "@tiledesk/tiledesk-sms-connector": "^0.1.13",
     "@tiledesk/tiledesk-telegram-connector": "^0.1.14",
-    "@tiledesk/tiledesk-tybot-connector": "^2.0.44",
+    "@tiledesk/tiledesk-tybot-connector": "^2.0.45",
     "@tiledesk/tiledesk-voice-twilio-connector": "^0.3.2",
     "@tiledesk/tiledesk-vxml-connector": "^0.1.91",
-    "@tiledesk/tiledesk-whatsapp-connector": "1.0.25",
+    "@tiledesk/tiledesk-whatsapp-connector": "1.0.26",
     "@tiledesk/tiledesk-whatsapp-jobworker": "^0.0.13",
     "amqplib": "^0.5.5",
     "app-root-path": "^3.0.0",

package/routes/kb.js

@@ -13,6 +13,7 @@ const faq = require('../models/faq');
 const faq_kb = require('../models/faq_kb');
 
 const { MODELS_MULTIPLIER } = require('../utils/aiUtils');
+const { parseStringArrayField } = require('../utils/arrayUtil');
 const { kbTypes } = require('../models/kbConstants');
 const Sitemapper = require('sitemapper');
 
@@ -80,6 +81,13 @@ const default_engine = require('../config/kb/engine');
 const default_engine_hybrid = require('../config/kb/engine.hybrid');
 const default_embedding = require('../config/kb/embedding');
 
+function normalizeEmbedding(embedding) {
+  const normalizedEmbedding = (embedding && typeof embedding.toObject === 'function')
+    ? embedding.toObject()
+    : (embedding || default_embedding);
+  return { ...normalizedEmbedding };
+}
+
 let contexts = {
   "gpt-3.5-turbo":        process.env.GPT_3_5_CONTEXT       || "You are an helpful assistant for question-answering tasks.\nUse ONLY the pieces of retrieved context delimited by #### and the chat history to answer the question.\nIf you don't know the answer, just say: \"I don't know<NOANS>\"\n\n####{context}####",
   "gpt-4":                process.env.GPT_4_CONTEXT         || "You are an helpful assistant for question-answering tasks.\nUse ONLY the pieces of retrieved context delimited by #### and the chat history to answer the question.\nIf you don't know the answer, just say that you don't know.\nIf and only if none of the retrieved context is useful for your task, add this word to the end <NOANS>\n\n####{context}####",
@@ -170,7 +178,8 @@ router.post('/scrape/single', async (req, res) => {
         sitemap_origin: sitemapKb.source,
         scrape_type: sitemapKb.scrape_type,
         scrape_options: sitemapKb.scrape_options,
-        refresh_rate: sitemapKb.refresh_rate
+        refresh_rate: sitemapKb.refresh_rate,
+        tags: sitemapKb.tags
       }
       aiManager.addMultipleUrls(namespace, addedUrls, options).catch((err) => {
         winston.error("(webhook) error adding multiple urls contents: ", err);
@@ -215,8 +224,12 @@ router.post('/scrape/single', async (req, res) => {
         }
       }
 
+      if (kb.tags) {
+        json.tags = kb.tags;
+      }
+
       json.engine = namespace.engine || default_engine;
-      json.embedding = namespace.embedding || default_embedding;
+      json.embedding = normalizeEmbedding(namespace.embedding);
       json.embedding.api_key = process.env.EMBEDDING_API_KEY || process.env.GPTKEY;
 
       if (namespace.hybrid === true) {
@@ -357,7 +370,7 @@ router.post('/qa', async (req, res) => {
   }
 
   data.engine = namespace.engine || default_engine;
-  data.embedding = namespace.embedding || default_embedding;
+  data.embedding = normalizeEmbedding(namespace.embedding);
   data.embedding.api_key = process.env.EMBEDDING_API_KEY || process.env.GPTKEY;
 
   if (namespace.hybrid === true) {
@@ -989,7 +1002,8 @@ router.post('/namespace/import/:id', upload.single('uploadFile'), async (req, re
       type: e.type,
       content: e.content,
       namespace: namespace_id,
-      status: -1
+      status: -1,
+      ...(e.tags && { tags: e.tags })
     }
 
     const optionalFields = ['scrape_type', 'scrape_options', 'refresh_rate'];
@@ -1022,7 +1036,7 @@ router.post('/namespace/import/:id', upload.single('uploadFile'), async (req, re
   //          import operation the content's limit is respected
   let ns = namespaces.find(n => n.id === namespace_id);
   let engine = ns.engine || default_engine;
-  let embedding = ns.embedding || default_embedding;
+  let embedding = normalizeEmbedding(ns.embedding);
   embedding.api_key = process.env.EMBEDDING_API_KEY || process.env.GPTKEY;
   let hybrid = ns.hybrid;
 
@@ -1044,10 +1058,13 @@ router.post('/namespace/import/:id', upload.single('uploadFile'), async (req, re
 
   winston.verbose("Content deletetion response: ", deleteResponse);
 
-  await KB.insertMany(addingContents).catch((err) => {
+  try {
+    let addedContents = await KB.insertMany(addingContents);
+    winston.debug("addedContents: ", addedContents);
+  } catch (err) {
     winston.error("Error adding contents with insertMany: ", err);
     return res.status(500).send({ success: true, error: "Error importing contents" });
-  })
+  }
 
   let new_contents;
   try {
@@ -1362,59 +1379,63 @@ router.get('/:kb_id', async (req, res) => {
 
 router.post('/', async (req, res) => {
 
-  let project_id = req.projectid;
-  let body = req.body;
-  let namespace_id = body.namespace;
+  const id_project = req.projectid;
+  const project = req.project
 
-  if (!body.namespace) {
+  const { name, type, source, content, refresh_rate, scrape_type, scrape_options, tags } = req.body;
+  const namespace_id = req.body?.namespace;
+  
+  if (!namespace_id) {
     return res.status(400).send({ success: false, error: "parameter 'namespace' is not defined" });
   }
 
   let namespace;
   try {
-    namespace = await aiManager.checkNamespace(project_id, namespace_id);
+    namespace = await aiManager.checkNamespace(id_project, namespace_id);
   } catch (err) {
     let errorCode = err?.errorCode ?? 500;
     return res.status(errorCode).send({ success: false, error: err.error });
   }
   
-  let quoteManager = req.app.get('quote_manager');
+  const quoteManager = req.app.get('quote_manager');
   try {
-    await aiManager.checkQuotaAvailability(quoteManager, req.project, 1)
+    await aiManager.checkQuotaAvailability(quoteManager, project, 1)
   } catch(err) {
     let errorCode = err?.errorCode ?? 500;
     return res.status(errorCode).send({ success: false, error: err.error, plan_limit: err.plan_limit })
   }
 
   let new_kb = {
-    id_project: project_id,
-    name: body.name,
-    type: body.type,
-    source: body.source,
-    content: body.content,
-    namespace: body.namespace,
+    id_project,
+    name,
+    type,
+    source,
+    content,
+    namespace: namespace_id,
     status: -1
   }
-  if (!new_kb.namespace) {
-    new_kb.namespace = project_id;
-  }
-  if (new_kb.type === 'txt') {
+
+  if (type === 'txt') {
     new_kb.scrape_type = 1;
   }
-  if (new_kb.type === 'url') {
-    new_kb.refresh_rate = body.refresh_rate;
-    if (!body.scrape_type || body.scrape_type === 2) {
+  if (type === 'url') {
+    new_kb.refresh_rate = refresh_rate || 'never';
+    if (!scrape_type || scrape_type === 2) {
       new_kb.scrape_type = 2;
       new_kb.scrape_options = aiManager.setDefaultScrapeOptions();
     } else {
-      new_kb.scrape_type = body.scrape_type;
-      new_kb.scrape_options = body.scrape_options;
+      new_kb.scrape_type = scrape_type;
+      new_kb.scrape_options = scrape_options;
     }
   }
 
+  if (tags && Array.isArray(tags) && tags.every(tag => typeof tag === "string")) {
+    new_kb.tags = tags;
+  }
+
   winston.debug("adding kb: ", new_kb);
 
-  KB.findOneAndUpdate({ id_project: project_id, type: 'url', source: new_kb.source }, new_kb, { upsert: true, new: true, rawResult: true }, async (err, raw_content) => {
+  KB.findOneAndUpdate({ id_project, type, source }, new_kb, { upsert: true, new: true, rawResult: true }, async (err, raw_content) => {
     if (err) {
       winston.error("findOneAndUpdate with upsert error: ", err);
       res.status(500).send({ success: false, error: err });
@@ -1425,44 +1446,33 @@ router.post('/', async (req, res) => {
       delete raw_content.$clusterTime;
       delete raw_content.operationTime;
       
-      let saved_kb = raw_content.value;
-      let webhook = apiUrl + '/webhook/kb/status?token=' + KB_WEBHOOK_TOKEN;
+      const saved_kb = raw_content.value;
+      const webhook = apiUrl + '/webhook/kb/status?token=' + KB_WEBHOOK_TOKEN;
+      const embedding = normalizeEmbedding(namespace.embedding);
+      embedding.api_key = process.env.EMBEDDING_API_KEY || process.env.GPTKEY;
 
-      let json = {
+      const json = {
         id: saved_kb._id,
         type: saved_kb.type,
         source: saved_kb.source,
-        content: "",
+        content: saved_kb.content || "",
         namespace: saved_kb.namespace,
-        webhook: webhook
+        webhook: webhook,
+        hybrid: namespace.hybrid,
+        engine: namespace.engine || default_engine,
+        embedding: embedding,
+        ...(saved_kb.scrape_type && { scrape_type: saved_kb.scrape_type }),
+        ...(saved_kb.scrape_options && { parameters_scrape_type_4: saved_kb.scrape_options }),
+        ...(saved_kb.tags && { tags: saved_kb.tags }),
       }
-      winston.debug("json: ", json);
 
-      if (saved_kb.content) {
-        json.content = saved_kb.content;
-      }
-      if (saved_kb.scrape_type) {
-        json.scrape_type = saved_kb.scrape_type;
-      }
-      if (saved_kb.scrape_options) {
-        json.parameters_scrape_type_4 = saved_kb.scrape_options;
-      }
-      json.engine = namespace.engine || default_engine;
-      json.hybrid = namespace.hybrid;
-      
-      let embedding = namespace.embedding || default_embedding;
-      embedding.api_key = process.env.EMBEDDING_API_KEY || process.env.GPTKEY;
-      json.embedding = embedding;
-
-      let resources = [];
+      winston.debug("json: ", json);
 
-      resources.push(json);
-      
       if (process.env.NODE_ENV === 'test') {
         return res.status(200).send({ success: true, message: "Schedule scrape skipped in test environment", data: raw_content, schedule_json: json });
       }
         
-      aiManager.scheduleScrape(resources, namespace.hybrid);
+      aiManager.scheduleScrape([json], namespace.hybrid);
       return res.status(200).send(raw_content);
 
     }
@@ -1480,30 +1490,37 @@ router.post('/multi', upload.single('uploadFile'), async (req, res) => {
     list = req.body.list;
   }
 
-  let project_id = req.projectid;
-  let refresh_rate = req.body.refresh_rate;
-  let scrape_type = req.body.scrape_type ?? 2;
-  let scrape_options = req.body.scrape_options;
-  if (scrape_type === 2 && scrape_options == null) {
-    scrape_options = aiManager.setDefaultScrapeOptions();
+  const id_project = req.projectid;
+  const project = req.project;
+  let { refresh_rate = 'never', scrape_type = 2, scrape_options } = req.body;
+  let tags = parseStringArrayField(req.body.tags);
+
+
+  if (scrape_type === 2 && !scrape_options) {
+    try {
+      scrape_options = aiManager.setDefaultScrapeOptions();
+    } catch (err) {
+      winston.error("Error setting default scrape options: ", err);
+      return res.status(500).send({ success: false, error: err.error });
+    }
   }
 
-  let namespace_id = req.query.namespace;
+  const namespace_id = req.query.namespace;
   if (!namespace_id) {
     return res.status(400).send({ success: false, error: "queryParam 'namespace' is not defined" })
   }
-
   let namespace;
   try {
-    namespace = await aiManager.checkNamespace(project_id, namespace_id);
+    namespace = await aiManager.checkNamespace(id_project, namespace_id);
   } catch (err) {
+    winston.error("Error checking namespace: ", err);
     let errorCode = err?.errorCode ?? 500;
     return res.status(errorCode).send({ success: false, error: err.error });
   }
 
-  let quoteManager = req.app.get('quote_manager');
+  const quoteManager = req.app.get('quote_manager');
   try {
-    await aiManager.checkQuotaAvailability(quoteManager, req.project, list.length)
+    await aiManager.checkQuotaAvailability(quoteManager, project, list.length)
   } catch(err) {
     let errorCode = err?.errorCode ?? 500;
     return res.status(errorCode).send({ success: false, error: err.error, plan_limit: err.plan_limit })
@@ -1515,14 +1532,14 @@ router.post('/multi', upload.single('uploadFile'), async (req, res) => {
   }
 
   const options = {
-    scrape_type: scrape_type,
-    scrape_options: scrape_options,
-    refresh_rate: refresh_rate
+    scrape_type,
+    scrape_options,
+    refresh_rate,
+    ...(Array.isArray(tags) && tags.length > 0 ? { tags } : {})
   }
 
-  let result;
   try {
-    result = await aiManager.addMultipleUrls(namespace, list, options);
+    const result = await aiManager.addMultipleUrls(namespace, list, options);
     return res.status(200).send(result);
   } catch (err) {
     winston.error("addMultipleUrls error: ", err)
@@ -1539,8 +1556,9 @@ router.post('/csv', upload.single('uploadFile'), async (req, res) => {
   let csv = req.file.buffer.toString('utf8');
   winston.debug("csv: ", csv);
 
-  let delimiter = req.body.delimiter || ";";
-  winston.debug("delimiter: ", delimiter);
+  const { delimiter = ';' } = req.body;
+  let tags = parseStringArrayField(req.body.tags);
+
 
   let namespace;
   try {
@@ -1567,14 +1585,15 @@ router.post('/csv', upload.single('uploadFile'), async (req, res) => {
         type: 'faq',
         content: question + "\n" + answer,
         namespace: namespace_id,
-        status: -1
+        status: -1,
+        ...(Array.isArray(tags) && tags.length > 0 ? { tags } : {})
       })
     })
     .on("end", async () => {
       winston.debug("kbs after CSV parsing: ", kbs);
 
+      const quoteManager = req.app.get('quote_manager');
       try {
-        let quoteManager = req.app.get('quote_manager');
         await aiManager.checkQuotaAvailability(quoteManager, req.project, kbs.length)
       } catch(err) {
         let errorCode = err?.errorCode ?? 500;
@@ -1595,7 +1614,7 @@ router.post('/csv', upload.single('uploadFile'), async (req, res) => {
       aiManager.saveBulk(operations, kbs, project_id, namespace_id).then((result) => {
 
         let engine = namespace.engine || default_engine;
-        let embedding = namespace.embedding || default_embedding;
+        let embedding = normalizeEmbedding(namespace.embedding);
         embedding.api_key = process.env.EMBEDDING_API_KEY || process.env.GPTKEY;
         let hybrid = namespace.hybrid;
 
@@ -1648,11 +1667,15 @@ router.post('/sitemap', async (req, res) => {
 
 router.post('/sitemap/import', async (req, res) => {
 
-  let project_id = req.projectid;
-  let namespace_id = req.query.namespace;
-  let content = req.body;
+  const id_project = req.projectid;
+  const namespace_id = req.query.namespace;
+
+  let { type, source, refresh_rate = 'never', scrape_type = 2, scrape_options, tags } = req.body;
+  if (scrape_type === 2 && !scrape_options) {
+    scrape_options = aiManager.setDefaultScrapeOptions();
+  }
 
-  if (content.type !== "sitemap") {
+  if (type !== "sitemap") {
     return res.status(403).send({success: false, error: "Endpoint available for sitemap type only." });
   }
 
@@ -1662,13 +1685,12 @@ router.post('/sitemap/import', async (req, res) => {
   
   let namespace;
   try {
-    namespace = await aiManager.checkNamespace(project_id, namespace_id);
+    namespace = await aiManager.checkNamespace(id_project, namespace_id);
   } catch (err) {
     let errorCode = err?.errorCode ?? 500;
     return res.status(errorCode).send({ success: false, error: err.error });
   }
 
-  let sitemap_url = req.body.source;
 
   // let quoteManager = req.app.get('quote_manager');
   // let limits = await quoteManager.getPlanLimits(req.project);
@@ -1679,7 +1701,7 @@ router.post('/sitemap/import', async (req, res) => {
   // winston.verbose("Kbs count: " + kbs_count);
 
   const sitemap = new Sitemapper({
-    url: sitemap_url,
+    url: source,
     timeout: 15000,
     debug: false
   });
@@ -1704,41 +1726,34 @@ router.post('/sitemap/import', async (req, res) => {
   //   return res.status(403).send({ success: false, error: "Cannot exceed the number of resources in the current plan", plan_limit: kbs_limit })
   // }
 
-  let refresh_rate = req.body.refresh_rate;
-  let scrape_type = req.body.scrape_type ?? 2;
-  let scrape_options = req.body.scrape_options;
-  if (scrape_type === 2 && scrape_options == null) {
-    scrape_options = aiManager.setDefaultScrapeOptions();
-  }
-
   let sitemap_content = {
-    id_project: project_id,
-    name: sitemap_url,
-    source: sitemap_url,
+    id_project,
+    name: source,
+    source: source,
     type: 'sitemap',
     content: "",
     namespace: namespace_id,
-    scrape_type: scrape_type,
-    scrape_options: scrape_options,
-    refresh_rate: refresh_rate
+    scrape_type,
+    scrape_options,
+    refresh_rate,
+    ...(Array.isArray(tags) && tags.length > 0 ? { tags } : {})
   }
 
   let saved_content;
   try {
-    saved_content = await KB.findOneAndUpdate({ id_project: project_id, type: 'sitemap', source: sitemap_url, namespace: namespace_id }, sitemap_content, { upsert: true, new: true }).lean().exec();
+    saved_content = await KB.findOneAndUpdate({ id_project, type: 'sitemap', source, namespace: namespace_id }, sitemap_content, { upsert: true, new: true }).lean().exec();
   } catch (err) {
     winston.error("Error saving content: ", err);
     return res.status(500).send({ success: false, error: err });
   }
 
-
-
   const options = {
     sitemap_origin_id: saved_content._id,
     sitemap_origin: saved_content.source,
-    scrape_type: saved_content.scrape_type,
-    scrape_options: saved_content.scrape_options,
-    refresh_rate: saved_content.refresh_rate
+    scrape_type,
+    scrape_options,
+    refresh_rate,
+    ...(Array.isArray(tags) && tags.length > 0 ? { tags } : {})
   }
   
   try {

package/services/aiManager.js

@@ -66,11 +66,12 @@ class AiManager {
           content: "",
           namespace: namespace.id,
           status: -1,
-          sitemap_origin_id: options.sitemap_origin_id,
-          sitemap_origin: options.sitemap_origin,
           scrape_type: options.scrape_type,
           scrape_options: options.scrape_options,
-          refresh_rate: options.refresh_rate
+          refresh_rate: options.refresh_rate,
+          ...(options.sitemap_origin_id && { sitemap_origin_id: options.sitemap_origin_id }),
+          ...(options.sitemap_origin && { sitemap_origin: options.sitemap_origin }),
+          ...(options.tags && { tags: options.tags }),
         }
         return kb;
       })

package/test/fixtures/example-kb-faqs.csv

@@ -1,2 +1,2 @@
-Question 1;Question 1 Answer 1
-Question 2;Question 2 Answer 2
+Question 1;Answer 1
+Question 2;Answer 2

package/test/fixtures/exported_namespace.json

@@ -19,7 +19,8 @@
             "name": "Example content",
             "namespace": "6835be87d0a352002d806f73",
             "status": -1,
-            "updatedAt": "2025-05-27T13:32:18.078Z"
+            "updatedAt": "2025-05-27T13:32:18.078Z",
+            "tags": ["tag1", "tag2"]
         },
         {
             "_id": "6835bed02c061f7021f46e99",

package/test/kbRoute.js

@@ -273,7 +273,7 @@ describe('KbRoute', () => {
                             chai.request(server)
                                 .post('/' + savedProject._id + '/kb/namespace/import/' + namespace_id)
                                 .auth(email, pwd)
-                                .set('Content-Type', 'text/plain')
+                                //.set('Content-Type', 'text/plain')
                                 .attach('uploadFile', fs.readFileSync(path.resolve(__dirname, './fixtures/exported_namespace.json')), 'exported_namespace.json')
                                 .end((err, res) => {
 
@@ -285,7 +285,28 @@ describe('KbRoute', () => {
                                     expect(res.body.success).to.equal(true);
                                     expect(res.body.message).to.equal("Contents imported successfully");
 
-                                    done();
+                                    chai.request(server)
+                                        .get('/' + savedProject._id + '/kb/?namespace=' + namespace_id)
+                                        .auth(email, pwd)
+                                        .end((err, res) => {
+                                            if (err) { console.error("err: ", err); }
+                                            if (log) { console.log("get namespace res.body: ", res.body); }
+                                            
+                                            res.should.have.status(200);
+                                            res.body.should.be.a('object');
+                                            expect(res.body.count).to.equal(3);
+                                            expect(res.body.kbs.length).to.equal(3);
+
+                                            let content_with_tags = res.body.kbs.find(kb => kb.source === 'Example content');
+                                            expect(content_with_tags.tags.length).to.equal(2);
+                                            expect(content_with_tags.tags[0]).to.equal('tag1');
+                                            expect(content_with_tags.tags[1]).to.equal('tag2');
+                                            
+                                            let content_without_tags = res.body.kbs.find(kb => kb.source !== 'Example content');
+                                            expect(content_without_tags.tags).to.equal(undefined);
+                                            
+                                            done();
+                                        })
 
                                 })
 
@@ -514,7 +535,8 @@ describe('KbRoute', () => {
                                 type: "url",
                                 source: "https://www.exampleurl5.com",
                                 content: "",
-                                namespace: namespace_id
+                                namespace: namespace_id,
+                                tags: ["test", "example"]
                             }
 
                             chai.request(server)
@@ -539,6 +561,9 @@ describe('KbRoute', () => {
                                     expect(realResponse.value.type).to.equal("url")
                                     expect(realResponse.value.source).to.equal("https://www.exampleurl5.com")
                                     expect(realResponse.value.status).to.equal(-1)
+                                    expect(realResponse.value.tags.length).to.equal(2);
+                                    expect(realResponse.value.tags[0]).to.equal("test");
+                                    expect(realResponse.value.tags[1]).to.equal("example");
                                     should.not.exist(realResponse.engine)
                                     should.not.exist(realResponse.value.engine)
                                     should.not.exist(realResponse.embedding)
@@ -549,6 +574,9 @@ describe('KbRoute', () => {
                                     expect(scheduleJson.type).to.equal("url")
                                     expect(scheduleJson.source).to.equal("https://www.exampleurl5.com")
                                     expect(scheduleJson.hybrid).to.equal(false);
+                                    expect(scheduleJson.tags.length).to.equal(2);
+                                    expect(scheduleJson.tags[0]).to.equal("test");
+                                    expect(scheduleJson.tags[1]).to.equal("example");
                                     should.exist(scheduleJson.engine)
                                     should.exist(scheduleJson.embedding)
 
@@ -587,7 +615,8 @@ describe('KbRoute', () => {
                                 type: "text",
                                 source: "example_text1",
                                 content: "Example text",
-                                namespace: namespace_id
+                                namespace: namespace_id,
+                                tags: ["test", "example"]
                             }
 
                             chai.request(server)
@@ -603,6 +632,7 @@ describe('KbRoute', () => {
                                     res.body.should.be.a('object');
 
                                     let realResponse = res.body.data;
+                                    console.log("realResponse: ", realResponse);
                                     expect(realResponse.value.id_project).to.equal(namespace_id)
                                     expect(realResponse.value.name).to.equal("example_text1")
                                     expect(realResponse.value.type).to.equal("text")
@@ -610,7 +640,10 @@ describe('KbRoute', () => {
                                     expect(realResponse.value.status).to.equal(-1)
                                     expect(typeof realResponse.value.scrape_type === "undefined").to.be.true;
                                     expect(typeof realResponse.value.scrape_options === "undefined").to.be.true;
-
+                                    expect(realResponse.value.tags.length).to.equal(2);
+                                    expect(realResponse.value.tags[0]).to.equal("test");
+                                    expect(realResponse.value.tags[1]).to.equal("example");
+                                    
                                     done();
                                 })
                         })
@@ -885,6 +918,66 @@ describe('KbRoute', () => {
             })
         }).timeout(20000)
 
+        it('add-single-faq-success', (done) => {
+            var email = "test-signup-" + Date.now() + "@email.com";
+            var pwd = "pwd";
+
+            userService.signup(email, pwd, "Test Firstname", "Test lastname").then(function (savedUser) {
+                projectService.create("test-faqkb-create", savedUser._id).then(function (savedProject) {
+
+                    chai.request(server)
+                        .get('/' + savedProject._id + '/kb/namespace/all')
+                        .auth(email, pwd)
+                        .end((err, res) => {
+                            if (err) { console.error("err: ", err); }
+                            if (log) { console.log("res.body: ", res.body) }
+
+                            res.should.have.status(200);
+                            expect(res.body.length).to.equal(1);
+
+                            let namespace_id = res.body[0].id;
+
+                            let content = {
+                                name: "Sample question",
+                                source: "Sample question",
+                                content: "Sample question\nSample answer",
+                                type: "faq",
+                                tags: ["tag1", "tag2"],
+                                namespace: namespace_id
+                            }
+
+                            chai.request(server)
+                                .post('/' + savedProject._id + '/kb')
+                                .auth(email, pwd)
+                                .send(content)
+                                .end((err, res) => {
+                                    if (err) { console.error("err: ", err); }
+                                    if (log) { console.log("res.body: ", res.body) }
+
+                                    res.should.have.status(200);
+                                    res.body.should.be.a('object');
+
+                                    let realResponse = res.body.data;
+                                    expect(realResponse.value.namespace).to.equal(namespace_id);
+                                    expect(realResponse.value.type).to.equal("faq");
+                                    expect(realResponse.value.source).to.equal("Sample question");
+                                    expect(realResponse.value.content).to.equal("Sample question\nSample answer");
+                                    expect(realResponse.value.tags.length).to.equal(2);
+                                    expect(realResponse.value.tags[0]).to.equal("tag1");
+                                    expect(realResponse.value.tags[1]).to.equal("tag2");
+
+                                    done();
+
+
+                                });
+
+                        });
+
+
+                    })
+                });
+        })
+
         it('add-multiple-faqs-with-csv', (done) => {
 
             var email = "test-signup-" + Date.now() + "@email.com";
@@ -916,14 +1009,15 @@ describe('KbRoute', () => {
                             chai.request(server)
                                 .post('/' + savedProject._id + '/kb/csv?namespace=' + namespace_id)
                                 .auth(email, pwd)
-                                .set('Content-Type', 'text/csv')
-                                .attach('uploadFile', fs.readFileSync(path.resolve(__dirname, './fixtures/example-kb-faqs.csv')), 'example-kb-faqs.csv')
+                                //.set('Content-Type', 'text/csv')
                                 .field('delimiter', ';')
+                                .field('tags', JSON.stringify(['tag1', 'tag2']))
+                                .attach('uploadFile', fs.readFileSync(path.resolve(__dirname, './fixtures/example-kb-faqs.csv')), 'example-kb-faqs.csv')
                                 .end((err, res) => {
 
                                     if (err) { console.error("err: ", err); }
                                     if (log) { console.log("res.body: ", res.body) }
-
+                                    console.log("res.body: ", res.body)
                                     res.should.have.status(200);
                                     res.body.should.be.a('object');
                                     expect(res.body.success).to.equal(true);
@@ -931,6 +1025,7 @@ describe('KbRoute', () => {
 
                                     let realResponse = res.body.data;
                                     realResponse.should.be.a('array');
+                                    console.log("realResponse: ", realResponse[0]);
                                     expect(realResponse.length).to.equal(2);
                                     expect(realResponse[0].namespace).to.equal(namespace_id);
                                     expect(realResponse[0].type).to.equal('faq');
@@ -983,7 +1078,7 @@ describe('KbRoute', () => {
                     chai.request(server)
                         .post('/' + savedProject._id + '/kb/multi?namespace=123456')
                         .auth(email, pwd)
-                        .set('Content-Type', 'text/plain')
+                        //.set('Content-Type', 'text/plain')
                         .attach('uploadFile', fs.readFileSync(path.resolve(__dirname, './fixtures/kbUrlsList.txt')), 'kbUrlsList.txt')
                         .end((err, res) => {
 
@@ -1030,7 +1125,7 @@ describe('KbRoute', () => {
                             chai.request(server)
                                 .post('/' + savedProject._id + '/kb/multi?namespace=fakenamespaceid')
                                 .auth(email, pwd)
-                                .set('Content-Type', 'text/plain')
+                                //.set('Content-Type', 'text/plain')
                                 .attach('uploadFile', fs.readFileSync(path.resolve(__dirname, './fixtures/kbUrlsList.txt')), 'kbUrlsList.txt')
                                 .end((err, res) => {
 
@@ -1077,8 +1172,14 @@ describe('KbRoute', () => {
                             chai.request(server)
                                 .post('/' + savedProject._id + '/kb/multi?namespace=' + namespace_id)
                                 .auth(email, pwd)
-                                .set('Content-Type', 'text/plain')
-                                .attach('uploadFile', fs.readFileSync(path.resolve(__dirname, './fixtures/kbUrlsList.txt')), 'kbUrlsList.txt')
+                                .field('refresh_rate', 'never')
+                                .field('scrape_type', '2')
+                                .field('tags', JSON.stringify(['tag1', 'tag2']))
+                                .attach(
+                                    'uploadFile',
+                                    fs.readFileSync(path.resolve(__dirname, './fixtures/kbUrlsList.txt')),
+                                    'kbUrlsList.txt'
+                                )
                                 .end((err, res) => {
 
                                     if (err) { console.error("err: ", err); }
@@ -1090,15 +1191,24 @@ describe('KbRoute', () => {
                                     expect(realResponse.length).to.equal(4);
                                     expect(realResponse[0].namespace).to.equal(namespace_id);
                                     expect(realResponse[0].source).to.equal('https://gethelp.tiledesk.com/articles/article1');
+                                    expect(realResponse[0].tags.length).to.equal(2);
+                                    expect(realResponse[0].tags[0]).to.equal('tag1');
+                                    expect(realResponse[0].tags[1]).to.equal('tag2');
                                     should.not.exist(realResponse[0].engine);
                                     should.not.exist(realResponse[0].embedding);
                                     expect(realResponse[1].namespace).to.equal(namespace_id);
                                     expect(realResponse[1].source).to.equal('https://gethelp.tiledesk.com/articles/article2');
+                                    expect(realResponse[1].tags.length).to.equal(2);
+                                    expect(realResponse[1].tags[0]).to.equal('tag1');
+                                    expect(realResponse[1].tags[1]).to.equal('tag2');
 
                                     let scheduleJson = res.body.schedule_json;
                                     expect(scheduleJson.length).to.equal(4);
                                     expect(scheduleJson[0].namespace).to.equal(namespace_id);
                                     expect(scheduleJson[0].source).to.equal('https://gethelp.tiledesk.com/articles/article1');
+                                    expect(scheduleJson[0].tags.length).to.equal(2);
+                                    expect(scheduleJson[0].tags[0]).to.equal('tag1');
+                                    expect(scheduleJson[0].tags[1]).to.equal('tag2');
                                     should.exist(scheduleJson[0].engine);
                                     should.exist(scheduleJson[0].embedding);
                                     expect(scheduleJson[0].engine.index_name).to.equal(namespace.engine.index_name);
@@ -1107,6 +1217,9 @@ describe('KbRoute', () => {
 
                                     expect(scheduleJson[1].namespace).to.equal(namespace_id);
                                     expect(scheduleJson[1].source).to.equal('https://gethelp.tiledesk.com/articles/article2');
+                                    expect(scheduleJson[1].tags.length).to.equal(2);
+                                    expect(scheduleJson[1].tags[0]).to.equal('tag1');
+                                    expect(scheduleJson[1].tags[1]).to.equal('tag2');
 
                                     done();
 

package/utils/arrayUtil.js

@@ -13,4 +13,38 @@ function arraysEqual(a, b) {
       if (a[i] !== b[i]) return false;
     }
     return true;
-  }
+  }
+
+/**
+ * Parse a field as an array of strings.
+ * Returns the array if valid, otherwise undefined.
+ */
+function parseStringArrayField(field) {
+  if (!field) return undefined;
+
+  let arr;
+
+  if (typeof field === 'string') {
+    try {
+      arr = JSON.parse(field); // prova a parsare come JSON
+    } catch {
+      return undefined; // se malformato, skippa
+    }
+  } else if (Array.isArray(field)) {
+    arr = field;
+  } else {
+    return undefined; // non stringa né array
+  }
+
+  // controlla che tutti gli elementi siano stringhe
+  if (Array.isArray(arr) && arr.every(e => typeof e === 'string')) {
+    return arr;
+  }
+
+  return undefined; // non è un array di stringhe
+}
+
+module.exports = {
+  arraysEqual,
+  parseStringArrayField
+};