@tiledesk/tiledesk-server 2.29.0 → 3.0.0

package/test/faqRoute.js

@@ -356,6 +356,89 @@ describe('FaqKBRoute', () => {
         }).timeout(20000);
 
 
+        it('Get faqs without the bot in every row (populate=false)', (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)
+                        .post('/' + savedProject._id + '/faq_kb')
+                        .auth(email, pwd)
+                        .send({ "name": "testbot", type: "tilebot", language: 'en', template: 'blank' })
+                        .end((err, res) => {
+
+                            if (err) { console.error("err: ", err); }
+                            if (log) { console.log("res.body", res.body); }
+
+                            res.should.have.status(200);
+                            let id_faq_kb = res.body._id;
+
+                            // as always: every block carries the bot
+                            chai.request(server)
+                                .get('/' + savedProject._id + '/faq?id_faq_kb=' + id_faq_kb)
+                                .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);
+                                    res.body.should.be.a('array');
+                                    expect(res.body.length).to.be.above(0);
+                                    const blocks = res.body.length;
+                                    res.body.forEach((faq) => {
+                                        expect(faq.faq_kb).to.be.a('array');
+                                        expect(faq.faq_kb[0]._id).to.equal(id_faq_kb);
+                                        expect(faq.faq_kb[0].name).to.equal("testbot");
+                                    });
+
+                                    // populate=false: the same blocks, without the bot
+                                    chai.request(server)
+                                        .get('/' + savedProject._id + '/faq?id_faq_kb=' + id_faq_kb + '&populate=false')
+                                        .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);
+                                            res.body.should.be.a('array');
+                                            expect(res.body.length).to.equal(blocks);
+                                            res.body.forEach((faq) => {
+                                                expect(faq.faq_kb).to.equal(undefined);
+                                                expect(faq.id_faq_kb).to.equal(id_faq_kb);
+                                                expect(faq.intent_display_name).to.be.a('string');
+                                            });
+
+                                            // any other value: as always
+                                            chai.request(server)
+                                                .get('/' + savedProject._id + '/faq?id_faq_kb=' + id_faq_kb + '&populate=true')
+                                                .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(blocks);
+                                                    res.body.forEach((faq) => {
+                                                        expect(faq.faq_kb).to.be.a('array');
+                                                        expect(faq.faq_kb[0]._id).to.equal(id_faq_kb);
+                                                    });
+
+                                                    done();
+                                                });
+                                        });
+                                });
+                        });
+                });
+            });
+
+        }).timeout(20000);
+
+
         it('searchFaqs', (done) => {
     
             var email = "test-signup-" + Date.now() + "@email.com";

package/test/faqkbV3Route.js

@@ -0,0 +1,436 @@
+//During the test the env variable is set to test
+process.env.NODE_ENV = 'test';
+process.env.LOG_LEVEL = 'error';
+
+const Faq_kb = require('../models/faq_kb');
+const projectService = require('../services/projectService');
+const userService = require('../services/userService');
+
+let chai = require('chai');
+let chaiHttp = require('chai-http');
+let server = require('../app');
+let should = chai.should();
+const expect = chai.expect;
+
+chai.use(chaiHttp);
+
+/**
+ * V3 agents on the faq_kb routes (15/10/2026): the version label `ds_version` and the connectors
+ * list `connectors` are fields of the bot. A V3 agent is born in V3 form from its template, keeps
+ * both fields through export, import, fork and restore, and saves its list on a dedicated endpoint.
+ * Every test also checks that an agent created without the label (a V2 agent) sees no difference.
+ */
+describe('FaqKBRoute V3 fields', () => {
+
+    async function signupAndProject(prefix) {
+        const email = "test-signup-" + prefix + "-" + Date.now() + "@email.com";
+        const pwd = "pwd";
+        const savedUser = await userService.signup(email, pwd, "Test Firstname", "Test lastname");
+        const savedProject = await projectService.create("test-faqkb-v3", savedUser._id);
+        return { email, pwd, project: savedProject };
+    }
+
+    function createBot(ctx, body) {
+        return chai.request(server)
+            .post('/' + ctx.project._id + '/faq_kb')
+            .auth(ctx.email, ctx.pwd)
+            .send(body);
+    }
+
+    function getBot(ctx, id) {
+        return chai.request(server).get('/' + ctx.project._id + '/faq_kb/' + id).auth(ctx.email, ctx.pwd);
+    }
+
+    function getConnectors(ctx, id) {
+        return chai.request(server).get('/' + ctx.project._id + '/faq_kb/' + id + '/connectors').auth(ctx.email, ctx.pwd);
+    }
+
+    function putConnectors(ctx, id, collection, ifMatch) {
+        let req = chai.request(server).put('/' + ctx.project._id + '/faq_kb/' + id + '/connectors').auth(ctx.email, ctx.pwd);
+        if (ifMatch) { req = req.set('If-Match', ifMatch); }
+        return req.send(collection);
+    }
+
+    /** The template's blocks are saved right after the bot, without being awaited: wait for them. */
+    async function getIntents(ctx, id, expectedAtLeast) {
+        for (let attempt = 0; attempt < 20; attempt++) {
+            const res = await chai.request(server).get('/' + ctx.project._id + '/faq?id_faq_kb=' + id).auth(ctx.email, ctx.pwd);
+            res.should.have.status(200);
+            if (res.body.length >= (expectedAtLeast || 1)) { return res.body; }
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+        throw new Error("intents of " + id + " not saved in time");
+    }
+
+    function destinationKeysOf(intent) {
+        const keys = [];
+        const next = intent.attributes && intent.attributes.nextBlockAction;
+        if (next && Object.prototype.hasOwnProperty.call(next, 'intentName')) { keys.push('attributes.nextBlockAction.intentName'); }
+        (intent.actions || []).forEach((action, i) => {
+            ['intentName', 'trueIntent', 'falseIntent', 'goToIntent', 'elseIntent', 'fallbackIntent', 'errorIntent'].forEach((field) => {
+                if (Object.prototype.hasOwnProperty.call(action, field)) { keys.push('actions[' + i + '].' + field); }
+            });
+        });
+        return keys;
+    }
+
+    describe('Create', () => {
+
+        it('create-v3-agent-from-blank-template-in-v3-form', async () => {
+            const ctx = await signupAndProject("v3-blank");
+
+            const created = await createBot(ctx, { name: "v3bot", type: "tilebot", language: "en", template: "blank", ds_version: "v3" });
+            created.should.have.status(200);
+            expect(created.body.ds_version).to.equal("v3");
+            const id = created.body._id;
+
+            const bot = await getBot(ctx, id);
+            bot.should.have.status(200);
+            expect(bot.body.ds_version).to.equal("v3");
+            expect(bot.body.connectors).to.be.an('object');
+            expect(bot.body.connectors.version).to.equal(1);
+            expect(bot.body.connectors.items).to.be.an('array').that.is.not.empty;
+
+            const intents = await getIntents(ctx, id, 2);
+            const ids = new Set(intents.map((intent) => intent.intent_id));
+            intents.forEach((intent) => {
+                expect(destinationKeysOf(intent)).to.deep.equal([], intent.intent_display_name + " still carries V2 destinations");
+            });
+            bot.body.connectors.items.forEach((record) => {
+                expect(ids.has(record.from.intentId)).to.equal(true, "record from an unknown block: " + record.id);
+                expect(ids.has(record.to.intentId)).to.equal(true, "record to an unknown block: " + record.id);
+                expect(record.id).to.equal(record.from.intentId + '/' + record.from.actionId + (record.from.slot === 'next' || record.from.slot === 'default' ? '' : '/' + record.from.slot) + '/' + record.to.intentId);
+            });
+            const start = intents.find((intent) => intent.intent_display_name === 'start');
+            expect(start).to.exist;
+            expect(bot.body.connectors.items.some((record) => record.from.intentId === start.intent_id && record.kind === 'action')).to.equal(true, "start has no connector in the list");
+            const fallback = intents.find((intent) => intent.intent_display_name === 'defaultFallback');
+            expect(bot.body.connectors.items.some((record) => record.from.intentId === fallback.intent_id && record.kind === 'block')).to.equal(true, "defaultFallback's dot has no connector in the list");
+
+            // The list of bots never carries the connectors list.
+            const list = await chai.request(server).get('/' + ctx.project._id + '/faq_kb').auth(ctx.email, ctx.pwd);
+            list.should.have.status(200);
+            const row = list.body.find((b) => b._id === id);
+            expect(row).to.exist;
+            expect(row.ds_version).to.equal("v3");
+            expect(row).to.not.have.property('connectors');
+        }).timeout(20000);
+
+        it('create-agent-without-label-is-unchanged', async () => {
+            const ctx = await signupAndProject("v2-blank");
+
+            const created = await createBot(ctx, { name: "v2bot", type: "tilebot", language: "en", template: "blank" });
+            created.should.have.status(200);
+            expect(created.body).to.not.have.property('ds_version');
+            expect(created.body).to.not.have.property('connectors');
+            const id = created.body._id;
+
+            const bot = await getBot(ctx, id);
+            bot.should.have.status(200);
+            expect(bot.body).to.not.have.property('ds_version');
+            expect(bot.body).to.not.have.property('connectors');
+
+            const intents = await getIntents(ctx, id, 2);
+            const start = intents.find((intent) => intent.intent_display_name === 'start');
+            expect(start.actions[0].intentName).to.be.a('string').that.matches(/^#/);
+            const fallback = intents.find((intent) => intent.intent_display_name === 'defaultFallback');
+            expect(fallback.attributes.nextBlockAction.intentName).to.be.a('string').that.matches(/^#/);
+
+            const connectors = await getConnectors(ctx, id);
+            connectors.should.have.status(200);
+            expect(connectors.body).to.equal(null);
+        }).timeout(20000);
+
+        it('create-promotes-the-label-written-inside-attributes', async () => {
+            const ctx = await signupAndProject("legacy-create");
+            const created = await createBot(ctx, { name: "old client", type: "tilebot", language: "en", template: "blank", attributes: { dsVersion: "v3", notes: [] } });
+            created.should.have.status(200);
+            expect(created.body.ds_version).to.equal("v3");
+            expect(created.body.attributes).to.not.have.property('dsVersion');
+            expect(created.body.attributes.notes).to.deep.equal([]);
+            const bot = await getBot(ctx, created.body._id);
+            expect(bot.body.connectors.items).to.be.an('array').that.is.not.empty;
+        }).timeout(20000);
+
+        it('create-ignores-an-unknown-version-label', async () => {
+            const ctx = await signupAndProject("v9");
+            const created = await createBot(ctx, { name: "v9bot", type: "tilebot", language: "en", template: "blank", ds_version: "v9" });
+            created.should.have.status(200);
+            expect(created.body).to.not.have.property('ds_version');
+            expect(created.body).to.not.have.property('connectors');
+        }).timeout(20000);
+    });
+
+    describe('Connectors endpoint', () => {
+
+        it('put-connectors-replaces-the-list-marks-modified-and-detects-conflicts', async () => {
+            const ctx = await signupAndProject("put");
+            const created = await createBot(ctx, { name: "v3bot", type: "tilebot", language: "en", template: "blank", ds_version: "v3" });
+            created.should.have.status(200);
+            const id = created.body._id;
+
+            const first = await getConnectors(ctx, id);
+            first.should.have.status(200);
+            expect(first.body.version).to.equal(1);
+            const firstUpdatedAt = first.body.updatedAt;
+            const items = first.body.items;
+            expect(items.length).to.be.greaterThan(1);
+
+            // a shorter list, saved on top of the one the client last saw
+            const saved = await putConnectors(ctx, id, { version: 1, items: [items[0]] }, firstUpdatedAt);
+            saved.should.have.status(200);
+            expect(saved.body.version).to.equal(1);
+            expect(saved.body.items).to.have.lengthOf(1);
+            expect(saved.body.items[0].id).to.equal(items[0].id);
+            expect(saved.body.updatedAt).to.not.equal(firstUpdatedAt);
+
+            const bot = await getBot(ctx, id);
+            expect(bot.body.modified).to.equal(true);
+            expect(bot.body.connectors.items).to.have.lengthOf(1);
+
+            // the same client saves again with the old updatedAt: conflict, current list returned
+            const conflict = await putConnectors(ctx, id, { version: 1, items: items }, firstUpdatedAt);
+            conflict.should.have.status(409);
+            expect(conflict.body.connectors.items).to.have.lengthOf(1);
+
+            // the same precondition as a query parameter, for clients that cannot send the header
+            const conflictByQuery = await chai.request(server)
+                .put('/' + ctx.project._id + '/faq_kb/' + id + '/connectors?if_match=' + encodeURIComponent(firstUpdatedAt))
+                .auth(ctx.email, ctx.pwd)
+                .send({ version: 1, items: items });
+            conflictByQuery.should.have.status(409);
+
+            // without If-Match the save goes through (last writer wins, as the attributes patch did)
+            const forced = await putConnectors(ctx, id, { version: 1, items: items });
+            forced.should.have.status(200);
+            expect(forced.body.items).to.have.lengthOf(items.length);
+
+            // an empty list is a valid list
+            const emptied = await putConnectors(ctx, id, { version: 1, items: [] }, forced.body.updatedAt);
+            emptied.should.have.status(200);
+            expect(emptied.body.items).to.have.lengthOf(0);
+        }).timeout(20000);
+
+        it('put-connectors-refuses-a-malformed-list-and-a-non-v3-agent', async () => {
+            const ctx = await signupAndProject("put-bad");
+            const v3 = await createBot(ctx, { name: "v3bot", type: "tilebot", language: "en", template: "blank", ds_version: "v3" });
+            const v2 = await createBot(ctx, { name: "v2bot", type: "tilebot", language: "en", template: "blank" });
+
+            const wrongVersion = await putConnectors(ctx, v3.body._id, { version: 2, items: [] });
+            wrongVersion.should.have.status(400);
+            expect(wrongVersion.body.errors).to.be.an('array').that.is.not.empty;
+
+            const wrongRecord = await putConnectors(ctx, v3.body._id, { version: 1, items: [{ id: 'a/b/c', from: { intentId: 'x', actionId: 'b', slot: 'next' }, to: { intentId: 'c' }, kind: 'block' }] });
+            wrongRecord.should.have.status(400);
+
+            const duplicated = await putConnectors(ctx, v3.body._id, { version: 1, items: [
+                { id: 'a/b/c', from: { intentId: 'a', actionId: 'b', slot: 'next' }, to: { intentId: 'c' }, kind: 'block' },
+                { id: 'a/b/c', from: { intentId: 'a', actionId: 'b', slot: 'next' }, to: { intentId: 'c' }, kind: 'block' }
+            ] });
+            duplicated.should.have.status(400);
+
+            const onV2 = await putConnectors(ctx, v2.body._id, { version: 1, items: [] });
+            onV2.should.have.status(400);
+            const v2bot = await getBot(ctx, v2.body._id);
+            expect(v2bot.body).to.not.have.property('connectors');
+            expect(v2bot.body.modified).to.not.equal(true);
+        }).timeout(20000);
+
+        it('patch-attributes-promotes-the-legacy-keys-and-still-merges-the-others', async () => {
+            const ctx = await signupAndProject("patch");
+            const created = await createBot(ctx, { name: "v3bot", type: "tilebot", language: "en", template: "blank", ds_version: "v3" });
+            const id = created.body._id;
+            const url = '/' + ctx.project._id + '/faq_kb/' + id + '/attributes';
+
+            // the list sent the old way lands in the field, not in the attributes
+            const withConnectors = await chai.request(server).patch(url).auth(ctx.email, ctx.pwd).send({ connectors: { version: 1, items: [] }, notes: [{ text: "hello" }] });
+            withConnectors.should.have.status(200);
+            expect(withConnectors.body.attributes).to.not.have.property('connectors');
+            expect(withConnectors.body.attributes.notes).to.have.lengthOf(1);
+            const bot = await getBot(ctx, id);
+            expect(bot.body.connectors.items).to.have.lengthOf(0);
+            expect(bot.body.modified).to.equal(true);
+            expect(bot.body.attributes).to.not.have.property('connectors');
+
+            // a malformed list is refused and nothing changes
+            const bad = await chai.request(server).patch(url).auth(ctx.email, ctx.pwd).send({ connectors: { version: 2, items: [] } });
+            bad.should.have.status(400);
+
+            // the label sent the old way makes an unlabelled agent V3, and never changes a labelled one
+            const v2 = await createBot(ctx, { name: "old", type: "tilebot", language: "en", template: "blank" });
+            const labelled = await chai.request(server).patch('/' + ctx.project._id + '/faq_kb/' + v2.body._id + '/attributes').auth(ctx.email, ctx.pwd).send({ dsVersion: " V3 " });
+            labelled.should.have.status(200);
+            expect(labelled.body.ds_version).to.equal("v3");
+            expect(labelled.body.attributes || {}).to.not.have.property('dsVersion');
+            const relabel = await chai.request(server).patch(url).auth(ctx.email, ctx.pwd).send({ dsVersion: "v4" });
+            relabel.should.have.status(200);
+            expect(relabel.body.ds_version).to.equal("v3");
+            expect(relabel.body.attributes).to.not.have.property('dsVersion');
+
+            // a patch without the legacy keys is the merge it always was
+            const other = await chai.request(server).patch(url).auth(ctx.email, ctx.pwd).send({ globals: [{ key: "x" }] });
+            other.should.have.status(200);
+            expect(other.body.attributes.globals).to.have.lengthOf(1);
+            expect(other.body.attributes.notes).to.have.lengthOf(1);
+        }).timeout(30000);
+
+    });
+
+    describe('Export, import, fork and restore', () => {
+
+        it('export-and-import-keep-the-v3-fields-and-leave-a-v2-export-untouched', async () => {
+            const ctx = await signupAndProject("export");
+            const v3 = await createBot(ctx, { name: "v3bot", type: "tilebot", language: "en", template: "blank", ds_version: "v3" });
+            const v2 = await createBot(ctx, { name: "v2bot", type: "tilebot", language: "en", template: "blank" });
+            await getIntents(ctx, v3.body._id, 2);
+            await getIntents(ctx, v2.body._id, 2);
+
+            const exportedV3 = await chai.request(server).get('/' + ctx.project._id + '/faq_kb/exportjson/' + v3.body._id).auth(ctx.email, ctx.pwd);
+            exportedV3.should.have.status(200);
+            const jsonV3 = JSON.parse(exportedV3.text);
+            expect(jsonV3.ds_version).to.equal("v3");
+            expect(jsonV3.connectors.version).to.equal(1);
+            expect(jsonV3.connectors.items).to.be.an('array').that.is.not.empty;
+            expect(jsonV3.attributes || {}).to.not.have.property('connectors');
+
+            const exportedV2 = await chai.request(server).get('/' + ctx.project._id + '/faq_kb/exportjson/' + v2.body._id).auth(ctx.email, ctx.pwd);
+            exportedV2.should.have.status(200);
+            const jsonV2 = JSON.parse(exportedV2.text);
+            expect(jsonV2).to.not.have.property('ds_version');
+            expect(jsonV2).to.not.have.property('connectors');
+
+            const imported = await chai.request(server)
+                .post('/' + ctx.project._id + '/faq_kb/importjson/null?create=true')
+                .auth(ctx.email, ctx.pwd)
+                .send(jsonV3);
+            imported.should.have.status(200);
+            expect(imported.body.ds_version).to.equal("v3");
+            const copy = await getBot(ctx, imported.body._id);
+            expect(copy.body.connectors.items).to.have.lengthOf(jsonV3.connectors.items.length);
+            expect(copy.body.connectors.items.map((r) => r.id)).to.deep.equal(jsonV3.connectors.items.map((r) => r.id));
+            const copiedIntents = await getIntents(ctx, imported.body._id, 2);
+            copiedIntents.forEach((intent) => expect(destinationKeysOf(intent)).to.deep.equal([]));
+
+            const importedV2 = await chai.request(server)
+                .post('/' + ctx.project._id + '/faq_kb/importjson/null?create=true')
+                .auth(ctx.email, ctx.pwd)
+                .send(jsonV2);
+            importedV2.should.have.status(200);
+            expect(importedV2.body).to.not.have.property('ds_version');
+            expect(importedV2.body).to.not.have.property('connectors');
+        }).timeout(30000);
+
+        it('import-promotes-a-json-exported-with-the-fields-inside-attributes', async () => {
+            const ctx = await signupAndProject("legacy");
+            const legacy = {
+                name: "legacy v3", type: "tilebot", language: "en",
+                attributes: { dsVersion: "V3", connectors: { version: 1, items: [] }, globals: [] },
+                intents: [{ intent_id: "s1", intent_display_name: "start", question: "\\start", actions: [], attributes: { position: { x: 0, y: 0 } } }]
+            };
+            const imported = await chai.request(server)
+                .post('/' + ctx.project._id + '/faq_kb/importjson/null?create=true')
+                .auth(ctx.email, ctx.pwd)
+                .send(legacy);
+            imported.should.have.status(200);
+            expect(imported.body.ds_version).to.equal("v3");
+            const bot = await getBot(ctx, imported.body._id);
+            expect(bot.body.connectors.version).to.equal(1);
+            expect(bot.body.attributes).to.not.have.property('dsVersion');
+            expect(bot.body.attributes).to.not.have.property('connectors');
+            expect(bot.body.attributes.globals).to.deep.equal([]);
+        }).timeout(20000);
+
+        it('import-converts-a-v3-json-that-has-no-list', async () => {
+            const ctx = await signupAndProject("convert-import");
+            const json = {
+                name: "v3 without list", type: "tilebot", language: "en", ds_version: "v3",
+                intents: [
+                    { intent_id: "s1", intent_display_name: "start", question: "\\start", actions: [{ _tdActionId: "a1", _tdActionType: "intent", intentName: "#w1" }], attributes: { position: { x: 0, y: 0 } } },
+                    { intent_id: "w1", intent_display_name: "welcome", actions: [{ _tdActionId: "a2", _tdActionType: "reply", text: "hi", attributes: { commands: [] } }], attributes: { position: { x: 0, y: 0 }, nextBlockAction: { _tdActionId: "d1", _tdActionType: "intent", intentName: "#s1" } } }
+                ]
+            };
+            const imported = await chai.request(server)
+                .post('/' + ctx.project._id + '/faq_kb/importjson/null?create=true')
+                .auth(ctx.email, ctx.pwd)
+                .send(json);
+            imported.should.have.status(200);
+            const bot = await getBot(ctx, imported.body._id);
+            expect(bot.body.connectors.items.map((r) => r.id)).to.deep.equal(["s1/a1/w1", "w1/d1/s1"]);
+            const intents = await getIntents(ctx, imported.body._id, 2);
+            intents.forEach((intent) => expect(destinationKeysOf(intent)).to.deep.equal([]));
+        }).timeout(20000);
+
+        it('import-refuses-a-malformed-connectors-list', async () => {
+            const ctx = await signupAndProject("bad-import");
+            const bad = { name: "bad", type: "tilebot", language: "en", ds_version: "v3", connectors: { version: 1, items: [{ id: "x" }] }, intents: [] };
+            const imported = await chai.request(server)
+                .post('/' + ctx.project._id + '/faq_kb/importjson/null?create=true')
+                .auth(ctx.email, ctx.pwd)
+                .send(bad);
+            imported.should.have.status(400);
+        }).timeout(20000);
+
+        it('fork-and-restore-carry-the-v3-fields', async () => {
+            const ctx = await signupAndProject("fork");
+            const created = await createBot(ctx, { name: "v3bot", type: "tilebot", language: "en", template: "blank", ds_version: "v3" });
+            const draft_id = created.body._id;
+            await getIntents(ctx, draft_id, 2);
+
+            const exported = await chai.request(server).get('/' + ctx.project._id + '/faq_kb/exportjson/' + draft_id).auth(ctx.email, ctx.pwd);
+            exported.should.have.status(200);
+            const json = JSON.parse(exported.text);
+            const originalIds = json.connectors.items.map((r) => r.id);
+
+            const previousService = server.get('chatbot_service');
+            server.set('chatbot_service', { async getBotById() { return JSON.parse(JSON.stringify(json)); } });
+            let forked;
+            try {
+                forked = await chai.request(server)
+                    .post('/' + ctx.project._id + '/faq_kb/fork/' + draft_id + '?public=false&globals=true&projectid=' + ctx.project._id + '&skipSubagents=true')
+                    .auth(ctx.email, ctx.pwd)
+                    .set('Content-Type', 'application/json');
+            } finally {
+                server.set('chatbot_service', previousService);
+            }
+            forked.should.have.status(200);
+            const copy_id = forked.body.bot_id;
+            const copy = await getBot(ctx, copy_id);
+            expect(copy.body.ds_version).to.equal("v3");
+            expect(copy.body.connectors.items.map((r) => r.id)).to.deep.equal(originalIds);
+
+            // The copy stands as a published version of the draft; the draft loses its list, the restore brings it back.
+            await Faq_kb.findByIdAndUpdate(copy_id, { trashed: true, root_id: draft_id }).exec();
+            const emptied = await putConnectors(ctx, draft_id, { version: 1, items: [] });
+            emptied.should.have.status(200);
+
+            const restored = await chai.request(server)
+                .put('/' + ctx.project._id + '/faq_kb/' + draft_id + '/restore/' + copy_id)
+                .auth(ctx.email, ctx.pwd)
+                .send({});
+            restored.should.have.status(200);
+            const draft = await getBot(ctx, draft_id);
+            expect(draft.body.ds_version).to.equal("v3");
+            expect(draft.body.connectors.items.map((r) => r.id)).to.deep.equal(originalIds);
+            expect(draft.body.modified).to.equal(true);
+        }).timeout(30000);
+
+        it('subagent-of-a-v3-agent-is-created-and-exported-with-its-fields', async () => {
+            const ctx = await signupAndProject("subagent");
+            const parent = await createBot(ctx, { name: "parent", type: "tilebot", language: "en", template: "blank", ds_version: "v3" });
+            const sub = await createBot(ctx, { name: "sub", type: "tilebot", subtype: "subagent", template: "blank_subagent", language: "en", parent_id: parent.body._id, ds_version: "v3" });
+            sub.should.have.status(200);
+            expect(sub.body.ds_version).to.equal("v3");
+            const subBot = await getBot(ctx, sub.body._id);
+            expect(subBot.body.connectors.items).to.be.an('array').that.is.not.empty;
+            await getIntents(ctx, sub.body._id, 2);
+            await getIntents(ctx, parent.body._id, 2);
+
+            const exported = await chai.request(server).get('/' + ctx.project._id + '/faq_kb/exportjson/' + parent.body._id).auth(ctx.email, ctx.pwd);
+            exported.should.have.status(200);
+            const json = JSON.parse(exported.text);
+            expect(json.subagents).to.have.lengthOf(1);
+            expect(json.subagents[0].ds_version).to.equal("v3");
+            expect(json.subagents[0].connectors.items.map((r) => r.id)).to.deep.equal(subBot.body.connectors.items.map((r) => r.id));
+        }).timeout(30000);
+    });
+});

package/test/nativemcp.test.js

@@ -40,7 +40,7 @@ describe('NativeMCP', () => {
 
           res.should.have.status(200);
           res.body.should.be.an('array');
-          res.body.should.have.length(2);
+          res.body.should.have.length(3);
 
           expect(res.body[0].id).to.equal("tiledesk-communicator");
           expect(res.body[0].name).to.equal("Tiledesk Communicator");
@@ -52,6 +52,11 @@ describe('NativeMCP', () => {
           expect(res.body[1].native).to.equal(true);
           expect(res.body[1].transport).to.equal("streamable_http");
           expect(res.body[1].url).to.not.exist;
+          expect(res.body[2].id).to.equal("tiledesk-docsparse");
+          expect(res.body[2].name).to.equal("Tiledesk Docsparse");
+          expect(res.body[2].native).to.equal(true);
+          expect(res.body[2].transport).to.equal("streamable_http");
+          expect(res.body[2].url).to.not.exist;
 
           done();
         });