@botpress/zai 1.0.0-beta.2 → 1.0.0-beta.3

package/package.json

@@ -1,10 +1,17 @@
 {
   "name": "@botpress/zai",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.3",
   "type": "module",
   "private": false,
   "description": "Zui AI (zai) – An LLM utility library written on top of Zui and the Botpress API",
-  "main": "src/index.ts",
+  "main": "dist/src/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/src/index.js",
+      "require": "./dist/src/index.js",
+      "types": "./dist/src/index.d.ts"
+    }
+  },
   "scripts": {
     "build": "tsc && tsc --project tsconfig.types.json",
     "build-with-latest-models": "pnpm run update-models && pnpm run build",

package/dist/src/operations/check.test.js

@@ -1,129 +0,0 @@
-import { describe, it, expect, afterAll, beforeEach, afterEach } from 'vitest';
-import { BotpressDocumentation, getClient, getZai, metadata } from './__tests';
-import { TableAdapter } from '../adapters/botpress-table';
-describe('zai.check', { timeout: 60_000 }, () => {
-    const zai = getZai();
-    it('basic check on a string', async () => {
-        const value = await zai.check('This text is very clearly written in English.', 'is an english sentence');
-        expect(value).toBe(true);
-    });
-    it('text that is too long gets truncated', async () => {
-        const isBotpressDocumentation = await zai.check(BotpressDocumentation, 'is about botpress and looks like documentation');
-        const isAboutBirds = await zai.check(BotpressDocumentation, 'is a book about birds and their species');
-        expect(isBotpressDocumentation).toBe(true);
-        expect(isAboutBirds).toBe(false);
-    });
-    it('works with any input type', async () => {
-        const sly = { name: 'Sylvain Perron', age: 30, job: 'CEO', company: 'Botpress', location: 'Quebec' };
-        const american = await zai.check(sly, 'person lives in north america');
-        const european = await zai.check(sly, 'person lives in europe');
-        expect(american).toBe(true);
-        expect(european).toBe(false);
-    });
-    it('check with examples', async () => {
-        const examples = [
-            {
-                input: 'Rasa (framework)',
-                check: true,
-                reason: 'Rasa is a chatbot framework, so it competes with us (Botpress).'
-            },
-            {
-                input: 'Rasa (coffee company)',
-                check: false,
-                reason: 'Rasa (coffee company) is not in the chatbot or AI agent industry, therefore it does not compete with us (Botpress).'
-            },
-            {
-                input: 'Dialogflow',
-                check: true,
-                reason: 'Dialogflow is a chatbot development product, so it competes with us (Botpress).'
-            }
-        ];
-        const moveworks = await zai.check('Moveworks', 'competes with us', { examples });
-        const ada = await zai.check('Ada.cx', 'competes with us', { examples });
-        const voiceflow = await zai.check('Voiceflow', 'competes with us', { examples });
-        const nike = await zai.check('Nike', 'competes with us', { examples });
-        const adidas = await zai.check('Adidas', 'competes with us', { examples });
-        expect(moveworks).toBe(true);
-        expect(ada).toBe(true);
-        expect(voiceflow).toBe(true);
-        expect(nike).toBe(false);
-        expect(adidas).toBe(false);
-    });
-});
-describe('zai.learn.check', { timeout: 60_000 }, () => {
-    const client = getClient();
-    let tableName = 'ZaiTestCheckInternalTable';
-    let taskId = 'check';
-    let zai = getZai();
-    beforeEach(async () => {
-        zai = getZai().with({
-            activeLearning: {
-                enable: true,
-                taskId,
-                tableName
-            }
-        });
-    });
-    afterEach(async () => {
-        try {
-            await client.deleteTableRows({ table: tableName, deleteAllRows: true });
-        }
-        catch (err) { }
-    });
-    afterAll(async () => {
-        try {
-            await client.deleteTable({ table: tableName });
-        }
-        catch (err) { }
-    });
-    it('learns a contradiction from examples', async () => {
-        const adapter = new TableAdapter({
-            client,
-            tableName
-        });
-        const value = await zai.learn(taskId).check(`What's up`, 'is a greeting');
-        expect(value).toBe(true);
-        let rows = await client.findTableRows({ table: tableName });
-        expect(rows.rows.length).toBe(1);
-        expect(rows.rows[0].output.value).toEqual(value);
-        await adapter.saveExample({
-            key: 't1',
-            taskId: `zai/${taskId}`,
-            taskType: 'zai.check',
-            instructions: 'is a greeting',
-            input: 'what is up',
-            output: false,
-            explanation: `"What's up" is our business scenario is NOT considered an official greeting.`,
-            metadata,
-            status: 'approved'
-        });
-        await adapter.saveExample({
-            key: 't2',
-            taskId: `zai/${taskId}`,
-            taskType: 'zai.check',
-            instructions: 'is a greeting',
-            input: 'hello! how are you?',
-            output: true,
-            explanation: `"hello!" is a common greeting in English.`,
-            metadata,
-            status: 'approved'
-        });
-        await adapter.saveExample({
-            key: 't3',
-            taskId: `zai/${taskId}`,
-            taskType: 'zai.check',
-            instructions: 'is a greeting',
-            input: 'wassup',
-            output: false,
-            explanation: `"wassup" is a slang term and not considered a formal greeting. It is therefore NOT considered a greeting.`,
-            metadata,
-            status: 'approved'
-        });
-        const second = await zai.learn(taskId).check(`What's up`, 'is a greeting');
-        expect(second).toBe(false);
-        rows = await client.findTableRows({ table: tableName });
-        expect(rows.rows.length).toBe(4);
-        expect(rows.rows[0].output.value).toEqual(second);
-    });
-});
-//# sourceMappingURL=check.test.js.map

package/dist/src/operations/extract.test.js

@@ -1,163 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, afterAll } from 'vitest';
-import { BotpressDocumentation, getClient, getZai, metadata } from './__tests';
-import { z } from '@bpinternal/zui';
-import { check } from '@botpress/vai';
-import { TableAdapter } from '../adapters/botpress-table';
-describe('zai.extract', () => {
-    const zai = getZai();
-    it('extract simple object from paragraph', async () => {
-        const person = await zai.extract('My name is John Doe, I am 30 years old and I live in Quebec', z.object({
-            name: z.string(),
-            age: z.number(),
-            location: z.string()
-        }));
-        expect(person).toMatchInlineSnapshot(`
-      {
-        "age": 30,
-        "location": "Quebec",
-        "name": "John Doe",
-      }
-    `);
-    });
-    it('extract an array of objects from paragraph', async () => {
-        const people = await zai.extract(`
-      My name is John Doe, I am 30 years old and I live in Quebec.
-      My name is Jane Doe, I am 25 years old and I live in Montreal.
-      His name is Jack Doe, he is 35 years old and he lives in Toronto.
-      Her name is Jill Doe, she is 40 years old and she lives in Vancouver.`, z.array(z.object({
-            name: z.string(),
-            age: z.number(),
-            location: z.string()
-        })));
-        expect(people).toMatchInlineSnapshot(`
-      [
-        {
-          "age": 30,
-          "location": "Quebec",
-          "name": "John Doe",
-        },
-        {
-          "age": 25,
-          "location": "Montreal",
-          "name": "Jane Doe",
-        },
-        {
-          "age": 35,
-          "location": "Toronto",
-          "name": "Jack Doe",
-        },
-        {
-          "age": 40,
-          "location": "Vancouver",
-          "name": "Jill Doe",
-        },
-      ]
-    `);
-    });
-    it('extract an object from anything as input', async () => {
-        const person = await zai.extract({
-            person: { first: 'John', last: 'Doe', age: 30 }
-        }, z.object({
-            a: z.string().describe('The full name of the person in the text'),
-            b: z.number().describe('The age of the person in the text')
-        }));
-        expect(person).toMatchInlineSnapshot(`
-      {
-        "a": "John Doe",
-        "b": 30,
-      }
-    `);
-    });
-    it('extract an array of objects from a super long text', async () => {
-        const features = await zai.extract(BotpressDocumentation, z.array(z
-            .object({
-            feature: z.string().describe('The name of the feature'),
-            parent: z.string().optional().describe('The parent feature').nullable(),
-            description: z.string().describe('The description of the feature')
-        })
-            .describe('A feature of Botpress')), {
-            instructions: 'Extract all things that looks like a Botpress feature in the provided input. You must extract a minimum of one element.'
-        });
-        check(features, 'Contains an element about flows / workflows').toBe(true);
-        check(features, 'Contains an element about tables').toBe(true);
-        check(features, 'Contains an element about webchat').toBe(true);
-        check(features, 'Contains an element about integrations').toBe(true);
-        check(features, 'Contains an element about HITL (human in the loop)').toBe(true);
-        check(features, 'Contains an element about knowledge bases (KB) or Files API').toBe(true);
-    });
-});
-describe('zai.learn.extract', () => {
-    const client = getClient();
-    let tableName = 'ZaiTestExtractInternalTable';
-    let taskId = 'extract';
-    let zai = getZai();
-    beforeEach(async () => {
-        zai = getZai().with({
-            activeLearning: {
-                enable: true,
-                taskId,
-                tableName
-            }
-        });
-    });
-    afterEach(async () => {
-        try {
-            await client.deleteTableRows({ table: tableName, deleteAllRows: true });
-        }
-        catch (err) { }
-    });
-    afterAll(async () => {
-        try {
-            await client.deleteTable({ table: tableName });
-        }
-        catch (err) { }
-    });
-    it('learns a extraction format from examples', async () => {
-        const adapter = new TableAdapter({
-            client,
-            tableName
-        });
-        const value = await zai.learn(taskId).extract(`I really liked Casino Royale`, z.object({
-            name: z.string(),
-            movie: z.string()
-        }), { instructions: 'extract the name of the movie and name of the main character' });
-        check(value, 'extracted james bond and casino royale').toBe(true);
-        check(value, 'the values are NOT IN ALL CAPS').toBe(true);
-        let rows = await client.findTableRows({ table: tableName });
-        expect(rows.rows.length).toBe(1);
-        await adapter.saveExample({
-            key: 't1',
-            taskId: `zai/${taskId}`,
-            taskType: 'zai.extract',
-            instructions: 'extract name of movie and main character',
-            input: `I went to see the Titanic yesterday and I fell asleep`,
-            output: { name: 'JACK DAWSON', movie: 'TITANIC' },
-            metadata,
-            status: 'approved'
-        });
-        await adapter.saveExample({
-            key: 't2',
-            taskId: `zai/${taskId}`,
-            taskType: 'zai.extract',
-            instructions: 'extract name of movie and main character',
-            input: `Did you know that the gladiator movie has a lot of fighting scenes?`,
-            output: { name: 'MAXIMUS DECIMUS MERIDIUS', movie: 'GLADIATOR' },
-            metadata,
-            status: 'approved'
-        });
-        const second = await zai.learn(taskId).extract(`I really liked Casino Royale`, z.object({
-            name: z.string(),
-            movie: z.string()
-        }), { instructions: 'extract the name of the movie and name of the main character' });
-        expect(second).toMatchInlineSnapshot(`
-      {
-        "movie": "CASINO ROYALE",
-        "name": "JAMES BOND",
-      }
-    `);
-        rows = await client.findTableRows({ table: tableName });
-        expect(rows.rows.length).toBe(3);
-        expect(rows.rows[0].output.value).toMatchObject(second);
-    });
-});
-//# sourceMappingURL=extract.test.js.map

package/dist/src/operations/filter.test.js

@@ -1,151 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, afterAll, vi } from 'vitest';
-import { getClient, getZai, metadata } from './__tests';
-import { TableAdapter } from '../adapters/botpress-table';
-describe('zai.filter', { timeout: 60_000 }, () => {
-    let zai = getZai();
-    beforeEach(async () => {
-        zai = getZai();
-    });
-    it('basic filter with small items', async () => {
-        const value = await zai.filter([
-            { name: 'John', description: 'is a bad person' },
-            { name: 'Alice', description: 'is a good person' },
-            { name: 'Bob', description: 'is a good person' },
-            { name: 'Eve', description: 'is a bad person' },
-            { name: 'Alex', description: 'is a good person' },
-            { name: 'Sara', description: 'donates to charity every month' },
-            { name: 'Tom', description: 'commits crimes and is in jail' }
-        ], 'generally good people');
-        const names = value.map((v) => v.name);
-        expect(names).toMatchInlineSnapshot(`
-      [
-        "Alice",
-        "Bob",
-        "Alex",
-        "Sara",
-      ]
-    `);
-    });
-    it('filtering huge array chunks it up', async () => {
-        const callAction = vi.fn();
-        const client = { ...getClient(), callAction };
-        zai = getZai().with({
-            client
-        });
-        const hugeArray = Array.from({ length: 100 }, (_, i) => ({
-            name: `Person #${i}#`,
-            description: 'blah blah '.repeat(50_000)
-        }));
-        try {
-            await zai.filter(hugeArray, 'generally good people', { tokensPerItem: 100_000 });
-        }
-        catch (err) { }
-        expect(callAction.mock.calls.length).toBeGreaterThan(20);
-        expect(JSON.stringify(callAction.mock.calls.at(0))).toContain('Person #0#');
-        expect(JSON.stringify(callAction.mock.calls.at(0))).not.toContain('Person #99#');
-        expect(JSON.stringify(callAction.mock.calls.at(-1))).not.toContain('Person #0#');
-        expect(JSON.stringify(callAction.mock.calls.at(-1))).toContain('Person #99#');
-        callAction.mockReset();
-        try {
-            await zai.filter(hugeArray, 'generally good people', { tokensPerItem: 100 });
-        }
-        catch (err) { }
-        expect(callAction.mock.calls.length).toBe(2);
-    });
-    it('filter with examples', async () => {
-        const examples = [
-            {
-                input: 'Rasa (framework)',
-                filter: true,
-                reason: 'Rasa is a chatbot framework, so it competes with us (Botpress).'
-            },
-            {
-                input: 'Rasa (coffee company)',
-                filter: false,
-                reason: 'Rasa (coffee company) is not in the chatbot or AI agent industry, therefore it does not compete with us (Botpress).'
-            },
-            {
-                input: 'Dialogflow',
-                filter: true,
-                reason: 'Dialogflow is a chatbot development product, so it competes with us (Botpress).'
-            }
-        ];
-        const value = await zai.filter([{ name: 'Moveworks' }, { name: 'Ada.cx' }, { name: 'Nike' }, { name: 'Voiceflow' }, { name: 'Adidas' }], 'competes with us', { examples });
-        const names = value.map((v) => v.name);
-        expect(names).toMatchInlineSnapshot(`
-      [
-        "Moveworks",
-        "Ada.cx",
-        "Voiceflow",
-      ]
-    `);
-    });
-});
-describe('zai.learn.filter', { timeout: 60_000 }, () => {
-    const client = getClient();
-    let tableName = 'ZaiTestFilterInternalTable';
-    let taskId = 'filter';
-    let zai = getZai();
-    beforeEach(async () => {
-        zai = getZai().with({
-            activeLearning: {
-                enable: true,
-                taskId,
-                tableName
-            }
-        });
-    });
-    afterEach(async () => {
-        try {
-            await client.deleteTableRows({ table: tableName, deleteAllRows: true });
-        }
-        catch (err) { }
-    });
-    afterAll(async () => {
-        try {
-            await client.deleteTable({ table: tableName });
-        }
-        catch (err) { }
-    });
-    it('learns a filtering rule from examples', async () => {
-        const adapter = new TableAdapter({
-            client,
-            tableName
-        });
-        await adapter.saveExample({
-            key: 't1',
-            taskId: `zai/${taskId}`,
-            taskType: 'zai.filter',
-            instructions: 'competes with us?',
-            input: ['Rasa (framework)', 'Rasa (coffee company)'],
-            output: ['Rasa (framework)'],
-            explanation: `Rasa is a chatbot framework, so it competes with us (Botpress). We should keep it. Rasa (coffee company) is not in the chatbot or AI agent industry, therefore it does not compete with us (Botpress). We should filter it out.`,
-            metadata,
-            status: 'approved'
-        });
-        await adapter.saveExample({
-            key: 't2',
-            taskId: `zai/${taskId}`,
-            taskType: 'zai.filter',
-            instructions: 'competes with us?',
-            input: ['Voiceflow', 'Dialogflow'],
-            output: ['Voiceflow', 'Dialogflow'],
-            explanation: `Voiceflow is a chatbot development product, so it competes with us (Botpress). We should keep it. Dialogflow is a chatbot development product, so it competes with us (Botpress). We should keep it.`,
-            metadata,
-            status: 'approved'
-        });
-        const second = await zai
-            .learn(taskId)
-            .filter(['Nike', 'Ada.cx', 'Adidas', 'Moveworks', 'Lululemon'], 'competes with us? (botpress)');
-        expect(second).toMatchInlineSnapshot(`
-      [
-        "Ada.cx",
-        "Moveworks",
-      ]
-    `);
-        const rows = await client.findTableRows({ table: tableName });
-        expect(rows.rows.length).toBe(3);
-        expect(rows.rows.at(-1).output.value).toEqual(second);
-    });
-});
-//# sourceMappingURL=filter.test.js.map

package/dist/src/operations/label.test.js

@@ -1,213 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, afterAll } from 'vitest';
-import { BotpressDocumentation, getClient, getZai, metadata } from './__tests';
-import { TableAdapter } from '../adapters/botpress-table';
-import { check } from '@botpress/vai';
-describe('zai.label', { timeout: 60_000 }, () => {
-    const zai = getZai();
-    it('simple labels on small text', async () => {
-        const labels = await zai.label({
-            name: 'John',
-            story: ['John donated to charity last month.', 'John is loved by his community.'],
-            criminal_record: 'John has no criminal record.'
-        }, {
-            is_human: 'is the person a human?',
-            good_person: 'is the person a good person?',
-            bad_person: 'is the person a bad person?',
-            is_criminal: 'is the person a criminal?'
-        });
-        expect(labels).toMatchInlineSnapshot(`
-      {
-        "bad_person": false,
-        "good_person": true,
-        "is_criminal": false,
-        "is_human": true,
-      }
-    `);
-    });
-    it('simple labels with example', async () => {
-        const labels = {
-            is_human: 'is the person a human?',
-            good_person: 'is the person a good person?',
-            bad_person: 'is the person a bad person?',
-            canadian: 'is the person canadian?',
-            is_french: 'is the person french?'
-        };
-        const initial = await zai.label(`Sylvain Perron has no criminal record.`, labels);
-        expect(initial.canadian).toBe(false);
-        expect(initial.is_french).toBe(false);
-        expect(initial.bad_person).toBe(false);
-        expect(initial.is_human).toBe(true);
-        const second = await zai.label(`Sylvain Perron has no criminal record.`, labels, {
-            examples: [
-                {
-                    input: 'Sylvain Pellerin has no criminal record.',
-                    labels: {
-                        is_french: {
-                            label: 'ABSOLUTELY_YES',
-                            explanation: 'Important: Sylvain Pellerin is a common French name.'
-                        },
-                        canadian: {
-                            label: 'ABSOLUTELY_YES',
-                            explanation: 'Important: We assume all person named Sylvain are Canadian (business rule).'
-                        }
-                    }
-                },
-                {
-                    input: 'Sylvain Bouchard is a criminal.',
-                    labels: {
-                        bad_person: {
-                            label: 'PROBABLY_YES',
-                            explanation: 'Important: Sylvain Bouchard is a criminal, so probably a bad person.'
-                        },
-                        is_french: {
-                            label: 'ABSOLUTELY_YES',
-                            explanation: 'Important: Sylvain is a common French name.'
-                        },
-                        canadian: {
-                            label: 'ABSOLUTELY_YES',
-                            explanation: 'Important: We assume all person named Sylvain are Canadian (business rule).'
-                        }
-                    }
-                }
-            ]
-        });
-        expect(second.canadian).toBe(true);
-        expect(second.is_french).toBe(true);
-        expect(second.is_human).toBe(true);
-        expect(second.bad_person).toBe(false);
-    });
-    it('label a huge text', async () => {
-        const labels = await zai.label(BotpressDocumentation, {
-            is_about_animals: 'is the text about animals?',
-            contains_lua_code: 'does the text contain Lua code?',
-            contains_python_code: 'does the text contain Python code?',
-            contains_js_code: 'does the text contain JavaScript code?',
-            is_botpress: 'is the text about Botpress?',
-            is_rasa: 'is the text about Rasa?',
-            has_flows: 'does the text mention flows?',
-            has_api: 'does the text mention the Botpress API?',
-            has_enterprise: 'does the text mention Botpress Enterprise?',
-            has_workspaces: 'does the text mention workspaces?',
-            has_webchat: 'does the text mention the Webchat?',
-            has_hitl: 'does the text mention HITL (human in the loop)?'
-        });
-        expect(labels).toMatchInlineSnapshot(`
-      {
-        "contains_js_code": true,
-        "contains_lua_code": false,
-        "contains_python_code": false,
-        "has_api": true,
-        "has_enterprise": true,
-        "has_flows": true,
-        "has_hitl": true,
-        "has_webchat": true,
-        "has_workspaces": true,
-        "is_about_animals": false,
-        "is_botpress": true,
-        "is_rasa": false,
-      }
-    `);
-    });
-});
-describe('zai.learn.label', { timeout: 60_000 }, () => {
-    const client = getClient();
-    let tableName = 'ZaiTestLabelInternalTable';
-    let taskId = 'label';
-    let zai = getZai();
-    beforeEach(async () => {
-        zai = getZai().with({
-            activeLearning: {
-                enable: true,
-                taskId,
-                tableName
-            }
-        });
-    });
-    afterEach(async () => {
-        try {
-            await client.deleteTableRows({ table: tableName, deleteAllRows: true });
-        }
-        catch (err) { }
-    });
-    afterAll(async () => {
-        try {
-            await client.deleteTable({ table: tableName });
-        }
-        catch (err) { }
-    });
-    it('learns a labelling rule from examples', async () => {
-        const adapter = new TableAdapter({
-            client,
-            tableName
-        });
-        const value = await zai.learn(taskId).label(`Sylvain Perron has no criminal record.`, {
-            is_human: 'is the person a human?',
-            good_person: 'is the person a good person?',
-            bad_person: 'is the person a bad person?',
-            canadian: 'is the person canadian?',
-            is_french: 'is the person french?'
-        });
-        expect(value.is_human).toBe(true);
-        expect(value.is_french).toBe(false);
-        expect(value.canadian).toBe(false);
-        let rows = await client.findTableRows({ table: tableName });
-        expect(rows.rows.length).toBe(1);
-        await adapter.saveExample({
-            key: 't1',
-            taskId: `zai/${taskId}`,
-            taskType: 'zai.label',
-            instructions: 'label the sentence',
-            input: 'Sylvain Pellerin has no criminal record.',
-            output: {
-                is_french: {
-                    label: 'ABSOLUTELY_YES',
-                    explanation: 'Important: Sylvain is a common French name.'
-                },
-                canadian: {
-                    label: 'ABSOLUTELY_YES',
-                    explanation: 'Since we are doing business only in Canada, we assume all users are Canadians.'
-                }
-            },
-            // The below doesn't make sense on purpose, it's just to test the influence of the explanation on the next prediction
-            explanation: `IMPORTANT: Sylvain is a common French name and since we're doing business only in Canada, we assume ALL users are Canadians as soon as they mention a French name.`,
-            metadata,
-            status: 'approved'
-        });
-        await adapter.saveExample({
-            key: 't2',
-            taskId: `zai/${taskId}`,
-            taskType: 'zai.label',
-            instructions: 'label the sentence',
-            input: 'Joannie Côté has a dog.',
-            output: {
-                is_french: {
-                    label: 'ABSOLUTELY_YES',
-                    explanation: 'Important: Joannie is a common French name and Côté is a common French last name.'
-                },
-                canadian: {
-                    label: 'ABSOLUTELY_YES',
-                    explanation: 'Since we are doing business only in Canada, we assume all users are Canadians.'
-                }
-            },
-            metadata,
-            status: 'approved'
-        });
-        rows = await client.findTableRows({ table: tableName });
-        expect(rows.rows.length).toBe(3);
-        const second = await zai.learn(taskId).label(`Sylvain Perron has no criminal record.`, {
-            is_human: 'is the person a human?',
-            good_person: 'is the person a good person?',
-            bad_person: 'is the person a bad person?',
-            canadian: 'is the person canadian?',
-            is_french: 'is the person french?'
-        });
-        expect(second.is_human).toBe(true);
-        expect(second.is_french).toBe(true);
-        expect(second.canadian).toBe(true);
-        rows = await client.findTableRows({ table: tableName });
-        expect(rows.rows.length).toBe(3);
-        check(rows.rows[0].output.value.canadian, 'label is positive (yes) and there is an explanation of why').toBe(true);
-        check(rows.rows[0].output.value.is_french, 'label is positive (yes) and there is an explanation of why').toBe(true);
-    });
-});
-//# sourceMappingURL=label.test.js.map