@tiledesk/tiledesk-server 2.19.7 → 2.19.10

package/CHANGELOG.md

@@ -5,7 +5,16 @@
 🚀        IN PRODUCTION                        🚀
 (https://www.npmjs.com/package/@tiledesk/tiledesk-server/v/2.3.77) 
 
-# 2.19.6
+# 2.19.10
+- Fixed bug on add answered question route.
+
+# 2.19.9
+- Fixed an issue with the handling of situated_context during namespace import
+
+# 2.19.8
+- Fix analytics integration
+
+# 2.19.7
 - Added TTL for events collection
 
 # 2.19.6
@@ -2606,4 +2615,4 @@ Added email notification setting for each teammate (also in 2.1.14.3)
 - Websocket performance fix with lean and removing populate 
 - Added kubernetes sample config file
 - Added required firstname and lastname to signup endpoint
-- Removed message.request.messages and message.request.department.bot for message.create event  
+- Removed message.request.messages and message.request.department.bot for message.create event  

package/lib/analyticsClient.js

@@ -21,9 +21,9 @@ const client = axios.create({
  * produce identical envelope shapes, enabling event_id-based deduplication
  * in the consumer.
  */
-function _buildEnvelope(eventType, idProject, payload) {
+function _buildEnvelope(eventType, idProject, payload, eventId) {
   return {
-    event_id: crypto.randomUUID(),
+    event_id: eventId || crypto.randomUUID(),
     event_type: eventType,
     timestamp: new Date().toISOString(),
     id_project: idProject,
@@ -39,12 +39,15 @@ function _buildEnvelope(eventType, idProject, payload) {
  * @param {string} eventType   - e.g. 'conversation.created'
  * @param {string} idProject   - Tiledesk project ID
  * @param {object} payload     - event-specific fields
+ * @param {string} [eventId]   - optional caller-supplied UUID for idempotency
+ *                               (deterministic id so live + backfill events for
+ *                               the same entity dedupe). Random when omitted.
  */
-function track(eventType, idProject, payload) {
+function track(eventType, idProject, payload, eventId) {
   if (!INGEST_BASE_URL) return;
   if (!idProject) return;
 
-  var body = _buildEnvelope(eventType, idProject, payload);
+  var body = _buildEnvelope(eventType, idProject, payload, eventId);
 
   client.post("/events", body).catch(function (err) {
     var status = err.response && err.response.status;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiledesk/tiledesk-server",
   "description": "The Tiledesk server module",
-  "version": "2.19.7",
+  "version": "2.19.10",
   "scripts": {
     "start": "node ./bin/www",
     "pretest": "mongodb-runner start",

package/pubmodules/analytics-publisher/index.js

@@ -22,6 +22,17 @@ var kbEvent = require("../../event/kbEvent");
 var departmentEvent = require("../../event/departmentEvent");
 var botEvent = require("../../event/botEvent");
 var { track } = require("../../lib/analyticsClient");
+var uuidv5 = require("uuid/v5");
+
+// Deterministic event_id namespace — MUST match apps/backfill
+// BACKFILL_UUID_NAMESPACE so a live event and its backfilled twin collapse to a
+// single row (idempotency / no double-count). Applied only to the event types
+// the backfill also produces.
+var ANALYTICS_UUID_NAMESPACE = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
+
+function eventIdFor(key) {
+  return uuidv5(String(key), ANALYTICS_UUID_NAMESPACE);
+}
 
 // ─── helpers ────────────────────────────────────────────────────────────────
 
@@ -46,6 +57,7 @@ function availabilityLabel(boolVal) {
  * to 'user', misclassifying agent messages.
  */
 function senderType(sender, request) {
+  if (!request) return "user"; // direct/group messages carry no request
   let bot, agent = undefined;
   if(request.participantsBots)
    bot = request.participantsBots.find(participant => participant.includes(sender));
@@ -101,6 +113,18 @@ function toStringId(doc) {
   return (doc._id || doc.id || doc).toString() || null;
 }
 
+/**
+ * Extract the tag string from a request.updated TAG_ADD patch.
+ * The tag may be a bare string or a { tag: "..." } sub-document — the shape
+ * varies by call site (see requestService.addTagByRequestId).
+ */
+function tagString(t) {
+  if (!t) return null;
+  if (typeof t === "string") return t;
+  if (typeof t.tag === "string") return t.tag;
+  return null;
+}
+
 // ─── listeners ──────────────────────────────────────────────────────────────
 
 function listen() {
@@ -120,16 +144,17 @@ function listen() {
     if (request.preflight === true) return;
 
     var dept = request.department;
+    var requestId = request.request_id || toStringId(request);
 
     track("conversation.created", request.id_project, {
-      id_request: request.request_id || toStringId(request),
-      request_id: request.request_id || toStringId(request),
+      id_request: requestId,
+      request_id: requestId,
       department: departmentId(dept),
       channel: (request.channel && request.channel.name) || "web",
       first_response_time: null,
       with_bot: request.hasBot || false,
       visitor_id: firstVisitorId(request.participants),
-    });
+    }, eventIdFor(requestId));
   }
 
   requestEvent.on("request.update.preflight", function (request) {
@@ -149,6 +174,10 @@ function listen() {
   //   duration_seconds     number
   //   waiting_time_seconds number|null
   //   satisfaction_rating  number 1-5 | null
+  // Satisfaction is intentionally NOT included here: ratings are submitted
+  // asynchronously (after close) and emitted as a separate conversation.satisfaction
+  // event below. The conversation-closed contract has no satisfaction field, so
+  // any rating sent here would be stripped by the ingest validator anyway.
   requestEvent.on("request.close", function (request) {
     var createdAt = new Date(request.createdAt);
     var closedAt = request.closed_at ? new Date(request.closed_at) : new Date();
@@ -157,18 +186,10 @@ function listen() {
         ? Math.round(request.duration / 1000)
         : Math.round((closedAt - createdAt) / 1000);
 
-    // Normalise rating: must be an integer 1–5 or null.
-    var rawRating = request.rating;
-    var satisfactionRating = null;
-    if (rawRating != null) {
-      var r = parseInt(rawRating, 10);
-      satisfactionRating = r >= 1 && r <= 5 ? r : null;
-    }
-
-    // TODO: da splittare rispetto al rating
+    var requestId = request.request_id || toStringId(request);
     track("conversation.closed", request.id_project, {
-      id_request: request.request_id || toStringId(request),
-      request_id: request.request_id || toStringId(request),
+      id_request: requestId,
+      request_id: requestId,
       closed_by: request.closed_by || "system",
       close_reason: null,
       duration_seconds: durationSeconds,
@@ -176,8 +197,52 @@ function listen() {
         request.waiting_time != null
           ? Math.round(request.waiting_time / 1000)
           : null,
-      satisfaction_rating: satisfactionRating,
-    });
+    }, eventIdFor(requestId + ":closed"));
+  });
+
+  // ── conversation.satisfaction ─────────────────────────────────────────────
+  // Emitted by routes/request.js ("request.satisfaction") when a visitor submits
+  // a rating — asynchronously, after the conversation is already closed.
+  // Contract: packages/contracts/src/payloads/conversation-satisfaction.ts
+  //   id_request     string  (required)
+  //   request_id     string  (required)
+  //   rating         number  (required, integer 1-5)
+  //   rating_message string|null
+  requestEvent.on("request.satisfaction", function (data) {
+    var request = (data && data.request) || {};
+    if (request.rating == null) return;
+
+    var r = parseInt(request.rating, 10);
+    if (!(r >= 1 && r <= 5)) return; // contract requires an integer 1-5
+
+    var requestId = request.request_id || toStringId(request);
+    track("conversation.satisfaction", request.id_project, {
+      id_request: requestId,
+      request_id: requestId,
+      rating: r,
+      rating_message: request.rating_message || null,
+    }, eventIdFor(requestId + ":satisfaction"));
+  });
+
+  // ── conversation.tag_added ────────────────────────────────────────────────
+  // Tags are added via requestService.addTagByRequestId, which emits the generic
+  // "request.updated" event with comment === "TAG_ADD" and the added tag in
+  // patch.tags. One analytics event per added tag.
+  // Contract: packages/contracts/src/payloads/conversation-tag-added.ts
+  //   id_request string (required)
+  //   tag        string (required)
+  requestEvent.on("request.updated", function (data) {
+    if (!data || data.comment !== "TAG_ADD") return;
+
+    var request = data.request || {};
+    var tag = tagString(data.patch && data.patch.tags);
+    if (!tag) return; // nothing usable to record
+
+    var requestId = request.request_id || toStringId(request);
+    track("conversation.tag_added", request.id_project, {
+      id_request: requestId,
+      tag: tag,
+    }, eventIdFor(requestId + ":" + tag));
   });
 
   // ── 3. message.sent ────────────────────────────────────────────────────────
@@ -198,64 +263,37 @@ function listen() {
     var idRequest = messageJson.recipient || null;
     if (!idRequest) return; // cannot emit without a conversation reference
 
+    // Denormalise department (id) and channel (name) from the parent request so
+    // the messages MVs can filter without a query-time join. Mirrors the
+    // backfill message mapper (department = id, channel = name). Optional in the
+    // contract, so null is fine when the message carries no populated request.
+    var msgRequest = messageJson.request || null;
+    var msgChannel =
+      (msgRequest && msgRequest.channel && msgRequest.channel.name) ||
+      (messageJson.channel && messageJson.channel.name) ||
+      null;
+
+    var idMessage = (messageJson._id || messageJson.id || "").toString();
     track("message.sent", messageJson.id_project, {
-      id_message: (messageJson._id || messageJson.id || "").toString(),
+      id_message: idMessage,
       id_request: idRequest,
       sender_id: sender || "unknown", // required non-null — fallback to 'unknown'
-      sender_type: senderType(sender, messageJson.request),
+      sender_type: senderType(sender, msgRequest),
       message_type: messageJson.type || "text", // required non-null — fallback to 'text'
       has_attachment: !!(messageJson.metadata && messageJson.metadata.src),
       language: messageJson.language || null,
-    });
-  });
-
-  // ── 5. handover_to_human ──────────────────────────────────────────────────
-  // Contract: packages/contracts/src/payloads/handover-to-human.ts
-  //   id_request           string   (required)
-  //   human_id             string|null
-  //   reason               string|null
-  //   department_id        string|null
-  //   waiting_time_seconds number int>=0 | null
-  //   agent_id             string|null (optional)
-  //   trigger_intent       string|null (optional)
-  requestEvent.on("request.participants.update", function (data) {
-    var request = data.request || {};
-    var removedParticipants = data.removedParticipants || [];
-    var addedParticipants = data.addedParticipants || [];
-
-    var botRemoved = removedParticipants.some(function (p) {
-      return p.startsWith("bot_");
-    });
-    var humanAdded = addedParticipants.some(function (p) {
-      return !p.startsWith("bot_");
-    });
-    if (!botRemoved || !humanAdded) return;
-
-    var botId =
-      removedParticipants.find(function (p) {
-        return p.startsWith("bot_");
-      }) || null;
-    var humanId =
-      addedParticipants.find(function (p) {
-        return !p.startsWith("bot_");
-      }) || null;
-
-    var waitingTimeSecs = null;
-    if (request.waiting_time != null) {
-      waitingTimeSecs = Math.round(request.waiting_time / 1000);
-    }
-
-    track("handover_to_human", request.id_project, {
-      id_request: request.request_id || toStringId(request),
-      human_id: humanId,
-      reason: null,
-      department_id: departmentId(request.department),
-      waiting_time_seconds: waitingTimeSecs,
-      agent_id: null,
-      trigger_intent: null,
-    });
+      department: departmentId(msgRequest && msgRequest.department),
+      channel: msgChannel,
+    }, eventIdFor(idMessage));
   });
 
+  // ── handover_to_human: intentionally NOT emitted here ─────────────────────
+  // Owned by tiledesk-chatbot (DirMoveToAgent), which fires it reliably at
+  // handover time with full context (reason / agent_id / trigger_intent). The
+  // participants-diff signal that used to live here was routing-dependent — it
+  // required the bot to be removed and a human added in the SAME update, so
+  // queue/pool handovers (bot removed first, agent assigned later) were missed —
+  // and it double-counted bot escalations the chatbot already records.
 
   // ── 5. project_user.activated ─────────────────────────────────────────────
   // Contract: packages/contracts/src/payloads/project-user-activated.ts
@@ -284,7 +322,7 @@ function listen() {
       user_email: email,
       role: pu.role || "agent",
       invited_by: (event.req && event.req.user && event.req.user.id) || null,
-    });
+    }, eventIdFor(pu.id_project + ":" + toStringId(pu) + ":activated"));
   });
 
   // ── 7. human.status_changed ───────────────────────────────────────────────
@@ -413,22 +451,30 @@ function listen() {
   // ── 13. agent.metadata_updated ────────────────────────────────────────────
   // Emitted by routes/faq_kb.js on bot create and update (rename, attribute
   // changes, language, etc.).
-  // agent_id   = Faq_kb._id.toString()
+  // agent_id   = Faq_kb.root_id  (the canonical/root agent id)
   // agent_name = Faq_kb.name
   // The consumer writes these into the agent_dimensions ReplacingMergeTree so
   // that dashboard queries always resolve the current bot name.
+  //
+  // Only PUBLISHED chatbots are tracked. Publishing forks the chatbot into a
+  // trashed faq_kb that carries root_id (-> the editable draft); the draft/root
+  // copy never has root_id. Gating on root_id therefore: (a) excludes drafts
+  // that were never published, (b) keys the dimension on the canonical root id
+  // — the same id the chatbot stamps on its runtime events — and (c) makes the
+  // name reflect the *published* name (a draft rename only lands here on the
+  // next publish, when a fresh fork fires faqbot.update).
   botEvent.on("faqbot.create", function (savedBot) {
-    if (!savedBot || !savedBot.id_project || !savedBot.name) return;
+    if (!savedBot || !savedBot.id_project || !savedBot.name || !savedBot.root_id) return;
     track("agent.metadata_updated", savedBot.id_project, {
-      agent_id:   savedBot.root_id || savedBot._id.toString(),
+      agent_id:   savedBot.root_id,
       agent_name: savedBot.name,
     });
   });
 
   botEvent.on("faqbot.update", function (updatedBot) {
-    if (!updatedBot || !updatedBot.id_project || !updatedBot.name) return;
+    if (!updatedBot || !updatedBot.id_project || !updatedBot.name || !updatedBot.root_id) return;
     track("agent.metadata_updated", updatedBot.id_project, {
-      agent_id:   updatedBot.root_id || updatedBot._id.toString(),
+      agent_id:   updatedBot.root_id,
       agent_name: updatedBot.name,
     });
   });

package/pubmodules/analytics-publisher/test/analytics-publisher.test.js

@@ -0,0 +1,247 @@
+// During the test the env variable is set to test
+process.env.NODE_ENV = 'test';
+
+const { expect } = require('chai');
+
+// Intercept analyticsClient.track BEFORE requiring the publisher so the
+// reference destructured inside the module body is our spy. No DB or broker
+// is touched: the publisher's listeners are pure (event in -> track() out).
+const analyticsClient = require('../../../lib/analyticsClient');
+const uuidv5 = require('uuid/v5');
+
+// Must match apps/backfill BACKFILL_UUID_NAMESPACE.
+const NS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+
+const calls = [];
+analyticsClient.track = function (eventType, idProject, payload, eventId) {
+  calls.push({ eventType: eventType, idProject: idProject, payload: payload, eventId: eventId });
+};
+
+// Fresh require so the module captures the patched track().
+delete require.cache[require.resolve('../index')];
+const publisher = require('../index');
+
+const requestEvent = require('../../../event/requestEvent');
+const messageEvent = require('../../../event/messageEvent');
+const authEvent = require('../../../event/authEvent');
+
+function callsFor(type) {
+  return calls.filter((c) => c.eventType === type);
+}
+
+describe('analytics-publisher', function () {
+  before(function () {
+    publisher.listen();
+  });
+
+  beforeEach(function () {
+    calls.length = 0;
+  });
+
+  describe('message.sent', function () {
+    it('propagates department (id) and channel (name) from the populated request', function () {
+      messageEvent.emit('message.create', {
+        _id: 'msg-1',
+        id_project: 'proj-1',
+        recipient: 'req-1',
+        sender: 'agent-1',
+        type: 'text',
+        request: {
+          participantsAgents: ['agent-1'],
+          participantsBots: [],
+          department: { _id: 'dept-9', name: 'Sales' },
+          channel: { name: 'whatsapp' },
+        },
+      });
+
+      const sent = callsFor('message.sent');
+      expect(sent).to.have.length(1);
+      expect(sent[0].payload.department).to.equal('dept-9');
+      expect(sent[0].payload.channel).to.equal('whatsapp');
+    });
+
+    it('sets department/channel to null when the message has no request', function () {
+      messageEvent.emit('message.create', {
+        _id: 'msg-2',
+        id_project: 'proj-1',
+        recipient: 'req-2',
+        sender: 'visitor-1',
+        type: 'text',
+        // no .request (direct/group message)
+      });
+
+      const sent = callsFor('message.sent');
+      expect(sent).to.have.length(1);
+      expect(sent[0].payload.department).to.equal(null);
+      expect(sent[0].payload.channel).to.equal(null);
+    });
+  });
+
+  describe('conversation.satisfaction', function () {
+    it('emits on request.satisfaction with a valid 1-5 rating', function () {
+      requestEvent.emit('request.satisfaction', {
+        request: {
+          request_id: 'req-3',
+          id_project: 'proj-1',
+          rating: 4,
+          rating_message: 'good',
+        },
+        patch: { rating: 4 },
+      });
+
+      const sat = callsFor('conversation.satisfaction');
+      expect(sat).to.have.length(1);
+      expect(sat[0].idProject).to.equal('proj-1');
+      expect(sat[0].payload).to.deep.equal({
+        id_request: 'req-3',
+        request_id: 'req-3',
+        rating: 4,
+        rating_message: 'good',
+      });
+    });
+
+    it('does not emit for an out-of-range rating', function () {
+      requestEvent.emit('request.satisfaction', {
+        request: { request_id: 'req-4', id_project: 'proj-1', rating: 9 },
+        patch: { rating: 9 },
+      });
+      expect(callsFor('conversation.satisfaction')).to.have.length(0);
+    });
+  });
+
+  describe('conversation.closed', function () {
+    it('omits the (stripped, superseded) satisfaction_rating field', function () {
+      requestEvent.emit('request.close', {
+        request_id: 'req-5',
+        id_project: 'proj-1',
+        createdAt: new Date(Date.now() - 60000),
+        closed_at: new Date(),
+        rating: 5,
+      });
+
+      const closed = callsFor('conversation.closed');
+      expect(closed).to.have.length(1);
+      expect(closed[0].payload).to.not.have.property('satisfaction_rating');
+    });
+  });
+
+  describe('conversation.tag_added', function () {
+    it('emits on request.updated with comment TAG_ADD (object tag)', function () {
+      requestEvent.emit('request.updated', {
+        comment: 'TAG_ADD',
+        request: { request_id: 'req-6', id_project: 'proj-1' },
+        patch: { tags: { tag: 'urgent' } },
+      });
+
+      const tagged = callsFor('conversation.tag_added');
+      expect(tagged).to.have.length(1);
+      expect(tagged[0].payload).to.deep.equal({ id_request: 'req-6', tag: 'urgent' });
+    });
+
+    it('extracts a plain string tag from the patch', function () {
+      requestEvent.emit('request.updated', {
+        comment: 'TAG_ADD',
+        request: { request_id: 'req-7', id_project: 'proj-1' },
+        patch: { tags: 'vip' },
+      });
+
+      const tagged = callsFor('conversation.tag_added');
+      expect(tagged).to.have.length(1);
+      expect(tagged[0].payload.tag).to.equal('vip');
+    });
+
+    it('does not emit for TAG_REMOVE or other comments', function () {
+      requestEvent.emit('request.updated', {
+        comment: 'TAG_REMOVE',
+        request: { request_id: 'req-8', id_project: 'proj-1' },
+        patch: { tags: { tag: 'urgent' } },
+      });
+      requestEvent.emit('request.updated', {
+        comment: 'PATCH',
+        request: { request_id: 'req-9', id_project: 'proj-1' },
+        patch: { status: 200 },
+      });
+      expect(callsFor('conversation.tag_added')).to.have.length(0);
+    });
+  });
+
+  // handover_to_human is owned by tiledesk-chatbot (DirMoveToAgent), which emits
+  // it reliably with full context (reason / agent_id / trigger_intent). The
+  // server's participants-diff signal was routing-dependent (missed queue/pool
+  // handovers) and double-counted bot escalations, so it is intentionally NOT
+  // emitted here.
+  describe('handover_to_human (owned by tiledesk-chatbot)', function () {
+    it('does not emit handover_to_human on a bot->human participants update', function () {
+      requestEvent.emit('request.participants.update', {
+        request: { request_id: 'req-h1', id_project: 'proj-1', department: 'dept-1' },
+        removedParticipants: ['bot_5e9d'],
+        addedParticipants: ['agent_7f2a'],
+      });
+      expect(callsFor('handover_to_human')).to.have.length(0);
+    });
+  });
+
+  // Deterministic event_ids let live + backfill events for the same entity
+  // collapse to one row (idempotency). Keys must match the backfill mappers.
+  describe('deterministic event_ids', function () {
+    it('conversation.created -> uuidv5(request_id)', function () {
+      requestEvent.emit('request.create', {
+        request_id: 'req-c1', id_project: 'proj-1', participants: [], hasBot: false,
+        channel: { name: 'web' },
+      });
+      const c = callsFor('conversation.created');
+      expect(c).to.have.length(1);
+      expect(c[0].eventId).to.equal(uuidv5('req-c1', NS));
+    });
+
+    it('conversation.closed -> uuidv5(request_id:closed)', function () {
+      requestEvent.emit('request.close', {
+        request_id: 'req-c2', id_project: 'proj-1',
+        createdAt: new Date(Date.now() - 1000), closed_at: new Date(),
+      });
+      const c = callsFor('conversation.closed');
+      expect(c).to.have.length(1);
+      expect(c[0].eventId).to.equal(uuidv5('req-c2:closed', NS));
+    });
+
+    it('conversation.satisfaction -> uuidv5(request_id:satisfaction)', function () {
+      requestEvent.emit('request.satisfaction', {
+        request: { request_id: 'req-c3', id_project: 'proj-1', rating: 5 },
+      });
+      const c = callsFor('conversation.satisfaction');
+      expect(c).to.have.length(1);
+      expect(c[0].eventId).to.equal(uuidv5('req-c3:satisfaction', NS));
+    });
+
+    it('conversation.tag_added -> uuidv5(request_id:tag)', function () {
+      requestEvent.emit('request.updated', {
+        comment: 'TAG_ADD', request: { request_id: 'req-c4', id_project: 'proj-1' },
+        patch: { tags: { tag: 'vip' } },
+      });
+      const c = callsFor('conversation.tag_added');
+      expect(c).to.have.length(1);
+      expect(c[0].eventId).to.equal(uuidv5('req-c4:vip', NS));
+    });
+
+    it('message.sent -> uuidv5(id_message)', function () {
+      messageEvent.emit('message.create', {
+        _id: 'msg-c5', id_project: 'proj-1', recipient: 'req-c5', sender: 'u1', type: 'text',
+      });
+      const c = callsFor('message.sent');
+      expect(c).to.have.length(1);
+      expect(c[0].eventId).to.equal(uuidv5('msg-c5', NS));
+    });
+
+    it('project_user.activated -> uuidv5(id_project:pu_id:activated)', function () {
+      authEvent.emit('project_user.invite', {
+        savedProject_userPopulated: {
+          _id: 'pu-c6', id_project: 'proj-1', role: 'agent',
+          id_user: { _id: 'user-c6', email: 'a@b.com' },
+        },
+      });
+      const c = callsFor('project_user.activated');
+      expect(c).to.have.length(1);
+      expect(c[0].eventId).to.equal(uuidv5('proj-1:pu-c6:activated', NS));
+    });
+  });
+});

package/routes/answered.js

@@ -3,6 +3,7 @@ const router = express.Router();
 const { Namespace, AnsweredQuestion } = require('../models/kb_setting');
 const winston = require('../config/winston');
 var fastCsv = require('fast-csv');
+const kbQuestionService = require('../services/kbQuestionService');
 
 // Add a new unanswerd question
 router.post('/', async (req, res) => {
@@ -11,7 +12,7 @@ router.post('/', async (req, res) => {
     const data = req.body;
     const id_project = req.projectid;
 
-    const savedQuestion = await KbQuestionService.createAnsweredQuestion(
+    const savedQuestion = await kbQuestionService.createAnsweredQuestion(
       id_project, 
       data
     );

package/routes/kb.js

@@ -1267,6 +1267,10 @@ router.post('/namespace/import/:id', upload.single('uploadFile'), async (req, re
       }
     }
 
+    if (e.situated_context === true && (e.type !== "url" || content.scrape_type === 0)) {
+      content.situated_context = true;
+    }
+
     addingContents.push(content);
   })
 
@@ -1291,8 +1295,6 @@ router.post('/namespace/import/:id', upload.single('uploadFile'), async (req, re
   let engine = ns.engine || default_engine;
   let embedding = aiManager.normalizeEmbedding(ns.embedding);
   let hybrid = ns.hybrid;
-  const situated_context = normalizeSituatedContext();
-
 
   if (process.env.NODE_ENV !== "test") {
     await aiService.deleteNamespace({
@@ -1327,14 +1329,15 @@ router.post('/namespace/import/:id', upload.single('uploadFile'), async (req, re
     return res.status(500).send({ success: false, error: "Unable to get new content" });
   }
 
-  let resources = new_contents.map(({ name, status, __v, createdAt, updatedAt, id_project, ...keepAttrs }) => keepAttrs)
-  resources = resources.map(({ _id, scrape_options, ...rest }) => {
+  let resources = new_contents.map(({ name, status, __v, createdAt, updatedAt, ...keepAttrs }) => keepAttrs)
+  resources = resources.map(({ _id, scrape_options, situated_context, ...rest }) => {
+    const situated_context_obj = aiManager.normalizeSituatedContext(situated_context);
     return {
       id: _id,
       parameters_scrape_type_4: scrape_options,
       embedding: embedding,
       engine: engine,
-      ...(situated_context && { situated_context: situated_context }),
+      ...(situated_context_obj && { situated_context: situated_context_obj }),
       ...rest
     }
   });
@@ -1731,6 +1734,7 @@ router.post('/', async (req, res) => {
 
       const json = {
         id: saved_kb._id,
+        id_project: saved_kb.id_project,
         type: saved_kb.type,
         source: saved_kb.source,
         content: saved_kb.content || "",
@@ -1909,7 +1913,7 @@ router.post('/csv', upload.single('uploadFile'), async (req, res) => {
           situated_context_obj = normalizeSituatedContext(situated_context);
         }
 
-        let resources = result.map(({ name, status, __v, createdAt, updatedAt, id_project, situated_context, ...keepAttrs }) => keepAttrs)
+        let resources = result.map(({ name, status, __v, createdAt, updatedAt, situated_context, ...keepAttrs }) => keepAttrs)
         resources = resources.map(({ _id, ...rest }) => {
           return {
             id: _id,
@@ -2200,6 +2204,7 @@ router.put('/:kb_id', async (req, res) => {
 
   const json = {
     id: updated_content._id,
+    id_project: updated_content.id_project,
     type: updated_content.type,
     source: updated_content.source,
     content: updated_content.content || "",

package/routes/request.js

@@ -456,6 +456,12 @@ router.put('/:requestid/replace', async (req, res) => {
   let id;
   let name;
   let slug;
+  // Canonical (root) id of the target bot, returned to the caller so analytics
+  // (agent.bot_switched.to_agent_id) can attribute the switch to the root agent
+  // — matching agent_dimensions and the target bot's own runtime events. A
+  // published bot is forked to a trashed copy with its own _id; root_id points
+  // back to the editable root, so root_id || _id is the canonical agent id.
+  let replacedRootId = null;
 
   if (req.body.id) {
     id = "bot_" + req.body.id;
@@ -478,6 +484,7 @@ router.put('/:requestid/replace', async (req, res) => {
     }
 
     id = "bot_" + chatbot._id;
+    replacedRootId = (chatbot.root_id || chatbot._id).toString();
     winston.verbose("Chatbot found: ", id);
   }
 
@@ -492,16 +499,29 @@ router.put('/:requestid/replace', async (req, res) => {
     }
 
     id = "bot_" + chatbot._id;
+    replacedRootId = (chatbot.root_id || chatbot._id).toString();
     winston.verbose("Chatbot found: " + id);
   }
 
+  // Replacing by raw id: normalize a possibly-published (fork) id to its root.
+  if (req.body.id) {
+    let chatbot = await faq_kb.findById(req.body.id).catch((err) => {
+      winston.error("Error finding bot by id ", err);
+      return null;
+    });
+    replacedRootId = ((chatbot && (chatbot.root_id || chatbot._id)) || req.body.id).toString();
+  }
+
   let participants = [];
   participants.push(id);
   winston.verbose("participants to be set: ", participants);
 
   requestService.setParticipantsByRequestId(req.params.requestid, req.projectid, participants).then((updatedRequest) => {
     winston.debug("SetParticipant response: ", updatedRequest);
-    res.status(200).send(updatedRequest);
+    // Additive: include the resolved canonical (root) bot id for analytics
+    // attribution. Existing consumers ignore the extra field.
+    const requestObj = (updatedRequest && updatedRequest.toJSON) ? updatedRequest.toJSON() : updatedRequest;
+    res.status(200).send({ ...requestObj, replaced_bot_root_id: replacedRootId });
   }).catch((err) => {
     winston.error("Error setting participants ", err);
     res.status(500).send({ success: false, error: "Error setting participants to request"})

package/routes/webhook.js

@@ -166,6 +166,7 @@ router.post('/kb/reindex', async (req, res) => {
 
     let json = {
       id: kb._id,
+      id_project: kb.id_project,
       type: kb.type,
       source: kb.source,
       content: "",
@@ -311,7 +312,11 @@ router.all('/:webhook_id', async (req, res) => {
   //webhookService.run(webhook, payload)
   // To delete - End
   webhookService.run(webhook, payload, dev, redis_client).then((response) => {
-    webhookEvent.emit("webhook.triggered", { webhook: webhook, payload: payload });
+    // Only count production runs: a dev/test invocation (?dev=true here, or the
+    // dedicated /:webhook_id/dev route below) must not emit analytics.
+    if (dev !== true && dev !== 'true') {
+      webhookEvent.emit("webhook.triggered", { webhook: webhook, payload: payload });
+    }
     return res.status(200).send(response);
   }).catch((err) => {
     if (err.code === errorCodes.WEBHOOK.ERRORS.NO_PRELOADED_DEV_REQUEST) {
@@ -321,7 +326,7 @@ router.all('/:webhook_id', async (req, res) => {
       return res.status(status).send(err.data);
     }
   })
-  
+
 })
 
 router.all('/:webhook_id/dev', async (req, res) => {

package/services/aiManager.js

@@ -104,7 +104,7 @@ class AiManager {
 
         let webhook = apiUrl + '/webhook/kb/status?token=' + KB_WEBHOOK_TOKEN;
 
-        let resources = result.map(({ name, status, __v, createdAt, updatedAt, id_project, situated_context, ...keepAttrs }) => keepAttrs)
+        let resources = result.map(({ name, status, __v, createdAt, updatedAt, situated_context, ...keepAttrs }) => keepAttrs)
         resources = resources.map(({ _id, scrape_options, ...rest }) => {
           return { 
             id: _id, 
@@ -139,6 +139,7 @@ class AiManager {
 
       let kb = {
         id: sitemap_content._id,
+        id_project: namespace.id_project,
         source: sitemap_content.source,
         type: 'sitemap',
         content: "",

package/test/kbRoute.js

@@ -244,7 +244,7 @@ describe('KbRoute', () => {
                                             expect(res.body.embedding.name).to.equal('text-embedding-ada-002')
                                             expect(res.body.embedding.dimension).to.equal(1536)
                                             expect(res.body.embedding.api_key).to.equal('')
-                
+
                                             done();
                                         })
                                 })
@@ -321,7 +321,7 @@ describe('KbRoute', () => {
                                                 .end((err, res) => {
                                                     if (err) { console.error("err: ", err); }
                                                     if (log) { console.log("get all namespaces res.body: ", res.body); }
-                                                    
+
                                                     res.should.have.status(200);
                                                     res.body.should.be.a('array');
                                                     expect(res.body.length).to.equal(1);
@@ -633,6 +633,7 @@ describe('KbRoute', () => {
 
                                     let scheduleJson = res.body.schedule_json;
                                     expect(scheduleJson.namespace).to.equal(namespace_id)
+                                    expect(scheduleJson.id_project).to.equal(namespace_id)
                                     expect(scheduleJson.type).to.equal("url")
                                     expect(scheduleJson.source).to.equal("https://www.exampleurl5.com")
                                     expect(scheduleJson.hybrid).to.equal(false);
@@ -1180,6 +1181,7 @@ describe('KbRoute', () => {
                                     scheduleJson.should.be.a('array');
                                     expect(scheduleJson.length).to.equal(2);
                                     expect(scheduleJson[0].namespace).to.equal(namespace_id);
+                                    expect(scheduleJson[0].id_project).to.equal(namespace_id);
                                     expect(scheduleJson[0].type).to.equal('faq');
                                     expect(scheduleJson[0].source).to.equal('Question 1');
                                     should.exist(scheduleJson[0].engine)
@@ -1344,6 +1346,7 @@ describe('KbRoute', () => {
                                     let scheduleJson = res.body.schedule_json;
                                     expect(scheduleJson.length).to.equal(4);
                                     expect(scheduleJson[0].namespace).to.equal(namespace_id);
+                                    expect(scheduleJson[0].id_project).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');
@@ -1546,6 +1549,7 @@ describe('KbRoute', () => {
                                     scheduleJson.should.be.a('array');
                                     should.exist(scheduleJson[0].engine)
                                     should.exist(scheduleJson[0].embedding)
+                                    expect(scheduleJson[0].id_project).to.equal(namespace_id)
                                     expect(scheduleJson[0].embedding.api_key).to.equal('fakegptkey');
 
                                     done();