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

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

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

@@ -1,96 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, afterAll } from 'vitest';
-import { check } from '@botpress/vai';
-import { getClient, getZai, metadata, tokenizer } from './__tests';
-import { TableAdapter } from '../adapters/botpress-table';
-const Zoe = `
-Part 1. Zoe walks to the park.
-Part 2. She meets her friend.
-Part 3. They play together.
-Part 4. They have a picnic.
-Part 5. They go home.
-`.trim();
-describe('zai.rewrite', { timeout: 60_000 }, () => {
-    const zai = getZai();
-    it('transforms text to all caps', async () => {
-        const result = await zai.rewrite(`Hello, what is the time today?`, 'write in all caps');
-        expect(result).toBe(`HELLO, WHAT IS THE TIME TODAY?`);
-    });
-    it('transforms text to all caps and respects tokens restrictions', async () => {
-        const result = await zai.rewrite(Zoe, 'write in all caps', { length: 15 });
-        expect(tokenizer.count(result)).toBeLessThanOrEqual(20);
-        expect(result).toContain(`PART 1. ZOE WALKS TO THE PARK`);
-        expect(result).not.toContain(`PART 3`);
-    });
-    it('french translation of the story', async () => {
-        const result = await zai.rewrite(Zoe, 'translate to french');
-        check(result, 'is a french story about Zeo and with 5 parts').toBe(true);
-    });
-    it('Throws if input is bigger than the model max tokens', async () => {
-        await expect(zai.rewrite(Zoe.repeat(100_000), 'translate to french')).rejects.toThrow(/tokens/i);
-    });
-});
-describe('zai.learn.rewrite', { timeout: 60_000 }, () => {
-    const client = getClient();
-    let tableName = 'ZaiTestRewriteInternalTable';
-    let taskId = 'rewrite';
-    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 rewrite rules from examples', async () => {
-        const adapter = new TableAdapter({
-            client,
-            tableName
-        });
-        const value = await zai.learn(taskId).rewrite(`Botpress is awesome`, 'write it like we want it');
-        check(value, `The text means more or less the same as "Botpress is awesome" but slightly different`).toBe(true);
-        let rows = await client.findTableRows({ table: tableName });
-        expect(rows.rows.length).toBe(1);
-        expect(rows.rows[0].output.value).toBe(value);
-        await adapter.saveExample({
-            key: 't1',
-            taskId: `zai/${taskId}`,
-            taskType: 'zai.rewrite',
-            instructions: 'write it like we want it',
-            input: 'Microsoft is a big company',
-            output: `# MICROSOFT IS A BIG COMPANY`,
-            metadata,
-            status: 'approved'
-        });
-        await adapter.saveExample({
-            key: 't2',
-            taskId: `zai/${taskId}`,
-            taskType: 'zai.rewrite',
-            instructions: 'write it like we want it',
-            input: 'Google is an evil company',
-            output: `# GOOGLE IS AN EVIL COMPANY`,
-            metadata,
-            status: 'approved'
-        });
-        const second = await zai.learn(taskId).rewrite(`Botpress is awesome`, 'write it like we want it');
-        rows = await client.findTableRows({ table: tableName });
-        expect(rows.rows.length).toBe(3);
-        check(second, `The text is "BOTPRESS IS AWESOME" and starts with a hashtag`).toBe(true);
-        expect(rows.rows.length).toBe(3);
-        expect(rows.rows[0].output.value).toBe(second);
-    });
-});
-//# sourceMappingURL=rewrite.test.js.map

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

@@ -1,22 +0,0 @@
-import { check } from '@botpress/vai';
-import { describe, it } from 'vitest';
-import { BotpressDocumentation, getZai } from './__tests';
-describe('zai.summarize', () => {
-    const zai = getZai();
-    it.skip('summarize long document to a concise 2000 token summary', async () => {
-        const result = await zai.summarize(BotpressDocumentation, {
-            length: 2000,
-            prompt: `Extract the Table of Contents for the Botpress Documentation. Pay special attention to all the different features. Focus on horizontal coverage of features rather than going in depth into one feature. The goal is to have a complete overview of what the documentation covers.`
-        });
-        check(result, 'The text is a summary of the Botpress documentation').toBe(true);
-        check(result, 'The text explains shortly what botpress is').toBe(true);
-        check(result, 'The text uses markdown format').toBe(true);
-        check(result, 'The text has some information about integrations').toBe(true);
-        check(result, 'The text has a section about Flows (or Workflows)').toBe(true);
-        check(result, 'The text has a section about the Botpress API').toBe(true);
-        check(result, 'The text mentions the notion of workspaces').toBe(true);
-        check(result, 'The text has some information about the Webchat').toBe(true);
-        check(result, 'The text has some information about HITL (human in the loop)').toBe(true);
-    });
-});
-//# sourceMappingURL=summarize.test.js.map

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

@@ -1,51 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { check } from '@botpress/vai';
-import { getZai, tokenizer } from './__tests';
-describe('zai.text', { timeout: 60_000 }, () => {
-    const zai = getZai();
-    it('generate a horror novel with no params', async () => {
-        const story = await zai.text('write a short horror novel');
-        check(story, 'is a short horror story').toBe(true);
-    });
-    it('No fluffy text at the beginning', async () => {
-        const story = await zai.text('write a short horror novel');
-        check(story, 'There is no LLM fluff at the beginning', {
-            examples: [
-                {
-                    value: 'Title: A horror story\nChapter 1: The woods\nOnce upen a time, ...',
-                    expected: true,
-                    reason: 'It begins straight with a story, no fluff at the beginning'
-                },
-                { value: 'Once upon a time, a ...', expected: true, reason: 'The story starts directly' },
-                {
-                    value: 'Sure, I will generate a story.\nOnce upen a time, a...',
-                    expected: false,
-                    reason: 'There is some fluff at the beginning'
-                }
-            ]
-        }).toBe(true);
-    });
-    it('No fluffy text at the end', async () => {
-        const story = await zai.text('write a short horror novel');
-        check(story, 'There is no LLM fluff at the end', {
-            examples: [
-                {
-                    value: 'Title: A horror story\nChapter 1: The woods\nOnce upen a time, ... The End.',
-                    expected: true,
-                    reason: 'The end is clear and direct, no fluff at the end'
-                },
-                {
-                    value: 'Sure, I will generate a story.\nOnce upen a time, a... The End.\nLet me know if you want more or if you are happy with this.',
-                    expected: false,
-                    reason: 'There is some fluff from the assistant at the end.'
-                }
-            ]
-        }).toBe(true);
-    });
-    it('length/max tokens param', async () => {
-        const story = await zai.text('write a short but complete horror story (with conclusion)', { length: 100 });
-        expect(tokenizer.count(story)).toBeLessThanOrEqual(110);
-        check(story, 'could be the beginning of a horror story').toBe(true);
-    });
-});
-//# sourceMappingURL=text.test.js.map

package/dist/src/operations/zai-learn.test.js

@@ -1,71 +0,0 @@
-import { describe, it, expect, afterAll, beforeEach, afterEach, vi } from 'vitest';
-import { getClient, getZai } from './__tests';
-import { check } from '@botpress/vai';
-describe('zai.learn / generic', { timeout: 60_000 }, () => {
-    const client = getClient();
-    let tableName = 'ZaiTestInternalTable';
-    let taskId = 'test';
-    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('saves examples to tables', async () => {
-        const value = await zai
-            .learn(taskId)
-            .check('This text is very clearly written in English.', 'is an english sentence');
-        const { rows } = await client.findTableRows({ table: tableName });
-        expect(value).toBe(true);
-        expect(rows.length).toBe(1);
-        check(rows[0].explanation, 'is an explanation sentence');
-        expect(rows[0].explanation).not.toContain('Final Answer:');
-        expect(rows[0].output).toMatchObject({ value: true });
-        expect(rows[0].input).toMatchInlineSnapshot(`
-      {
-        "value": "This text is very clearly written in English.",
-      }
-    `);
-        expect(rows[0].taskId).toEqual('zai/test');
-        expect(rows[0].taskType).toBe('zai.check');
-    });
-    it('works even if tables are down', async () => {
-        const upsertTableRows = vi.fn(async () => {
-            throw new Error('Table is down');
-        });
-        const findTableRows = vi.fn(async () => {
-            throw new Error('Table is down');
-        });
-        const client = {
-            ...getClient(),
-            findTableRows,
-            upsertTableRows
-        };
-        const value = await zai
-            .with({ client })
-            .learn(taskId)
-            .check('This text is very clearly written in English.', 'is an english sentence');
-        const { rows } = await getClient().findTableRows({ table: tableName });
-        expect(value).toBe(true);
-        expect(rows.length).toBe(0);
-        expect(upsertTableRows).toHaveBeenCalledTimes(1);
-        expect(findTableRows).toHaveBeenCalledTimes(1);
-    });
-});
-//# sourceMappingURL=zai-learn.test.js.map

package/dist/src/operations/zai-retry.test.js

@@ -1,50 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { getClient, getZai } from './__tests';
-describe('zai retry', { timeout: 60_000 }, () => {
-    const client = getClient();
-    let zai = getZai().with({ retry: { maxRetries: 3 } });
-    it('retries 3 times and succeeds', async () => {
-        let retryCount = 0;
-        const throwingClient = {
-            ...client,
-            callAction: vi.fn((input) => {
-                if (++retryCount < 3) {
-                    throw new Error('Failed to call model');
-                }
-                return client.callAction(input);
-            })
-        };
-        const value = await zai
-            .with({ client: throwingClient })
-            .check('This text is very clearly written in English.', 'is an english sentence');
-        expect(value).toBe(true);
-        expect(retryCount).toBe(3);
-    });
-    it('retries 0 times when success', async () => {
-        const fn = vi.fn((input) => client.callAction(input));
-        const throwingClient = {
-            ...client,
-            callAction: fn
-        };
-        const value = await zai
-            .with({ client: throwingClient })
-            .check('This text is very clearly written in English.', 'is an english sentence');
-        expect(value).toBe(true);
-        expect(fn).toHaveBeenCalledOnce();
-    });
-    it('fails when exceeded max', async () => {
-        const fn = vi.fn(() => {
-            throw new Error('Failed to call model');
-        });
-        const throwingClient = {
-            ...client,
-            callAction: fn
-        };
-        const value = zai
-            .with({ client: throwingClient, retry: { maxRetries: 1 } })
-            .check('This text is very clearly written in English.', 'is an english sentence');
-        await expect(value).rejects.toThrowError(/retries/);
-        expect(fn).toHaveBeenCalledTimes(2);
-    });
-});
-//# sourceMappingURL=zai-retry.test.js.map