promptfoo 0.95.0 → 0.96.0

package/dist/test/assertions/index.test.js

@@ -31,6 +31,7 @@ const fs = __importStar(require("fs"));
 const node_module_1 = require("node:module");
 const path = __importStar(require("path"));
 const assertions_1 = require("../../src/assertions");
+const xml_1 = require("../../src/assertions/xml");
 const fetch_1 = require("../../src/fetch");
 const openai_1 = require("../../src/providers/openai");
 const replicate_1 = require("../../src/providers/replicate");
@@ -103,30 +104,6 @@ jest.mock('../../src/matchers', () => {
     };
 });
 const Grader = new utils_1.TestGrader();
-describe('createAjv', () => {
-    beforeAll(() => {
-        delete process.env.PROMPTFOO_DISABLE_AJV_STRICT_MODE;
-        jest.resetModules();
-    });
-    afterAll(() => {
-        delete process.env.PROMPTFOO_DISABLE_AJV_STRICT_MODE;
-    });
-    it('should create an Ajv instance with default options', () => {
-        const ajv = (0, assertions_1.createAjv)();
-        expect(ajv).toBeDefined();
-        expect(ajv.opts.strictSchema).toBe(true);
-    });
-    it('should disable strict mode when PROMPTFOO_DISABLE_AJV_STRICT_MODE is set', () => {
-        process.env.PROMPTFOO_DISABLE_AJV_STRICT_MODE = 'true';
-        const ajv = (0, assertions_1.createAjv)();
-        expect(ajv.opts.strictSchema).toBe(false);
-    });
-    it('should add formats to the Ajv instance', () => {
-        const ajv = (0, assertions_1.createAjv)();
-        expect(ajv.formats).toBeDefined();
-        expect(Object.keys(ajv.formats)).not.toHaveLength(0);
-    });
-});
 describe('runAssertions', () => {
     const test = {
         assert: [
@@ -955,278 +932,280 @@ describe('runAssertion', () => {
             reason: 'JSON does not conform to the provided schema. Errors: data/latitude must be number',
         });
     });
-    it('should pass when the is-sql assertion passes', async () => {
-        const output = 'SELECT id, name FROM users';
-        const result = await (0, assertions_1.runAssertion)({
-            prompt: 'Some prompt',
-            provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
-            assertion: isSqlAssertion,
-            test: {},
-            providerResponse: { output },
-        });
-        expect(result).toMatchObject({
-            pass: true,
-            reason: 'Assertion passed',
-        });
-    });
-    it('should fail when the is-sql assertion fails', async () => {
-        const output = 'SELECT * FROM orders ORDERY BY order_date';
-        const result = await (0, assertions_1.runAssertion)({
-            prompt: 'Some prompt',
-            provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
-            assertion: isSqlAssertion,
-            test: {},
-            providerResponse: { output },
-        });
-        expect(result).toMatchObject({
-            pass: false,
-            reason: 'SQL statement does not conform to the provided MySQL database syntax.',
-        });
-    });
-    it('should pass when the not-is-sql assertion passes', async () => {
-        const output = 'SELECT * FROM orders ORDERY BY order_date';
-        const result = await (0, assertions_1.runAssertion)({
-            prompt: 'Some prompt',
-            provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
-            assertion: notIsSqlAssertion,
-            test: {},
-            providerResponse: { output },
-        });
-        expect(result).toMatchObject({
-            pass: true,
-            reason: 'Assertion passed',
-        });
-    });
-    it('should fail when the not-is-sql assertion fails', async () => {
-        const output = 'SELECT id, name FROM users';
-        const result = await (0, assertions_1.runAssertion)({
-            prompt: 'Some prompt',
-            provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
-            assertion: notIsSqlAssertion,
-            test: {},
-            providerResponse: { output },
-        });
-        expect(result).toMatchObject({
-            pass: false,
-            reason: 'The output SQL statement is valid',
-        });
-    });
-    it('should pass when the is-sql assertion passes given MySQL Database syntax', async () => {
-        const output = 'SELECT id, name FROM users';
-        const result = await (0, assertions_1.runAssertion)({
-            prompt: 'Some prompt',
-            provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
-            assertion: isSqlAssertionWithDatabase,
-            test: {},
-            providerResponse: { output },
-        });
-        expect(result).toMatchObject({
-            pass: true,
-            reason: 'Assertion passed',
-        });
-    });
-    it('should fail when the is-sql assertion fails given MySQL Database syntax', async () => {
-        const output = `SELECT first_name, last_name FROM employees WHERE first_name ILIKE 'john%'`;
-        const result = await (0, assertions_1.runAssertion)({
-            prompt: 'Some prompt',
-            provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
-            assertion: isSqlAssertionWithDatabase,
-            test: {},
-            providerResponse: { output },
-        });
-        expect(result).toMatchObject({
-            pass: false,
-            reason: 'SQL statement does not conform to the provided MySQL database syntax.',
-        });
-    });
-    it('should pass when the is-sql assertion passes given MySQL Database syntax and allowedTables', async () => {
-        const output = 'SELECT * FROM departments WHERE department_id = 1';
-        const result = await (0, assertions_1.runAssertion)({
-            prompt: 'Some prompt',
-            provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
-            assertion: isSqlAssertionWithDatabaseAndWhiteTableList,
-            test: {},
-            providerResponse: { output },
-        });
-        expect(result).toMatchObject({
-            pass: true,
-            reason: 'Assertion passed',
-        });
-    });
-    it('should fail when the is-sql assertion fails given MySQL Database syntax and allowedTables', async () => {
-        const output = 'UPDATE employees SET department_id = 2 WHERE employee_id = 1';
-        const result = await (0, assertions_1.runAssertion)({
-            prompt: 'Some prompt',
-            provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
-            assertion: isSqlAssertionWithDatabaseAndWhiteTableList,
-            test: {},
-            providerResponse: { output },
-        });
-        expect(result).toMatchObject({
-            pass: false,
-            reason: `SQL validation failed: authority = 'update::null::employees' is required in table whiteList to execute SQL = 'UPDATE employees SET department_id = 2 WHERE employee_id = 1'.`,
-        });
-    });
-    it('should pass when the is-sql assertion passes given MySQL Database syntax and allowedColumns', async () => {
-        const output = 'SELECT name FROM t';
-        const result = await (0, assertions_1.runAssertion)({
-            prompt: 'Some prompt',
-            provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
-            assertion: isSqlAssertionWithDatabaseAndWhiteColumnList,
-            test: {},
-            providerResponse: { output },
-        });
-        expect(result).toMatchObject({
-            pass: true,
-            reason: 'Assertion passed',
-        });
-    });
-    it('should fail when the is-sql assertion fails given MySQL Database syntax and allowedColumns', async () => {
-        const output = 'SELECT age FROM a WHERE id = 1';
-        const result = await (0, assertions_1.runAssertion)({
-            prompt: 'Some prompt',
-            provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
-            assertion: isSqlAssertionWithDatabaseAndWhiteColumnList,
-            test: {},
-            providerResponse: { output },
-        });
-        expect(result).toMatchObject({
-            pass: false,
-            reason: `SQL validation failed: authority = 'select::null::age' is required in column whiteList to execute SQL = 'SELECT age FROM a WHERE id = 1'.`,
+    describe('SQL assertions', () => {
+        it('should pass when the is-sql assertion passes', async () => {
+            const output = 'SELECT id, name FROM users';
+            const result = await (0, assertions_1.runAssertion)({
+                prompt: 'Some prompt',
+                provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
+                assertion: isSqlAssertion,
+                test: {},
+                providerResponse: { output },
+            });
+            expect(result).toMatchObject({
+                pass: true,
+                reason: 'Assertion passed',
+            });
         });
-    });
-    it('should pass when the is-sql assertion passes given MySQL Database syntax, allowedTables, and allowedColumns', async () => {
-        const output = 'SELECT name FROM departments';
-        const result = await (0, assertions_1.runAssertion)({
-            prompt: 'Some prompt',
-            provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
-            assertion: isSqlAssertionWithDatabaseAndBothList,
-            test: {},
-            providerResponse: { output },
+        it('should fail when the is-sql assertion fails', async () => {
+            const output = 'SELECT * FROM orders ORDERY BY order_date';
+            const result = await (0, assertions_1.runAssertion)({
+                prompt: 'Some prompt',
+                provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
+                assertion: isSqlAssertion,
+                test: {},
+                providerResponse: { output },
+            });
+            expect(result).toMatchObject({
+                pass: false,
+                reason: 'SQL statement does not conform to the provided MySQL database syntax.',
+            });
         });
-        expect(result).toMatchObject({
-            pass: true,
-            reason: 'Assertion passed',
+        it('should pass when the not-is-sql assertion passes', async () => {
+            const output = 'SELECT * FROM orders ORDERY BY order_date';
+            const result = await (0, assertions_1.runAssertion)({
+                prompt: 'Some prompt',
+                provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
+                assertion: notIsSqlAssertion,
+                test: {},
+                providerResponse: { output },
+            });
+            expect(result).toMatchObject({
+                pass: true,
+                reason: 'Assertion passed',
+            });
         });
-    });
-    it('should fail when the is-sql assertion fails given MySQL Database syntax, allowedTables, and allowedColumns', async () => {
-        const output = `INSERT INTO departments (name) VALUES ('HR')`;
-        const result = await (0, assertions_1.runAssertion)({
-            prompt: 'Some prompt',
-            provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
-            assertion: isSqlAssertionWithDatabaseAndBothList,
-            test: {},
-            providerResponse: { output },
+        it('should fail when the not-is-sql assertion fails', async () => {
+            const output = 'SELECT id, name FROM users';
+            const result = await (0, assertions_1.runAssertion)({
+                prompt: 'Some prompt',
+                provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
+                assertion: notIsSqlAssertion,
+                test: {},
+                providerResponse: { output },
+            });
+            expect(result).toMatchObject({
+                pass: false,
+                reason: 'The output SQL statement is valid',
+            });
         });
-        expect(result).toMatchObject({
-            pass: false,
-            reason: `SQL validation failed: authority = 'insert::departments::name' is required in column whiteList to execute SQL = 'INSERT INTO departments (name) VALUES ('HR')'.`,
+        it('should pass when the is-sql assertion passes given MySQL Database syntax', async () => {
+            const output = 'SELECT id, name FROM users';
+            const result = await (0, assertions_1.runAssertion)({
+                prompt: 'Some prompt',
+                provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
+                assertion: isSqlAssertionWithDatabase,
+                test: {},
+                providerResponse: { output },
+            });
+            expect(result).toMatchObject({
+                pass: true,
+                reason: 'Assertion passed',
+            });
         });
-    });
-    it('should fail when the is-sql assertion fails due to missing table authority for MySQL Database syntax', async () => {
-        const output = 'UPDATE a SET id = 1';
-        const result = await (0, assertions_1.runAssertion)({
-            prompt: 'Some prompt',
-            provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
-            assertion: isSqlAssertionWithDatabaseAndBothList,
-            test: {},
-            providerResponse: { output },
+        it('should fail when the is-sql assertion fails given MySQL Database syntax', async () => {
+            const output = `SELECT first_name, last_name FROM employees WHERE first_name ILIKE 'john%'`;
+            const result = await (0, assertions_1.runAssertion)({
+                prompt: 'Some prompt',
+                provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
+                assertion: isSqlAssertionWithDatabase,
+                test: {},
+                providerResponse: { output },
+            });
+            expect(result).toMatchObject({
+                pass: false,
+                reason: 'SQL statement does not conform to the provided MySQL database syntax.',
+            });
         });
-        expect(result).toMatchObject({
-            pass: false,
-            reason: `SQL validation failed: authority = 'update::null::a' is required in table whiteList to execute SQL = 'UPDATE a SET id = 1'.`,
+        it('should pass when the is-sql assertion passes given MySQL Database syntax and allowedTables', async () => {
+            const output = 'SELECT * FROM departments WHERE department_id = 1';
+            const result = await (0, assertions_1.runAssertion)({
+                prompt: 'Some prompt',
+                provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
+                assertion: isSqlAssertionWithDatabaseAndWhiteTableList,
+                test: {},
+                providerResponse: { output },
+            });
+            expect(result).toMatchObject({
+                pass: true,
+                reason: 'Assertion passed',
+            });
         });
-    });
-    it('should fail when the is-sql assertion fails due to missing authorities for DELETE statement in MySQL Database syntax', async () => {
-        const output = `DELETE FROM employees;`;
-        const result = await (0, assertions_1.runAssertion)({
-            prompt: 'Some prompt',
-            provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
-            assertion: isSqlAssertionWithDatabaseAndBothList,
-            test: {},
-            providerResponse: { output },
+        it('should fail when the is-sql assertion fails given MySQL Database syntax and allowedTables', async () => {
+            const output = 'UPDATE employees SET department_id = 2 WHERE employee_id = 1';
+            const result = await (0, assertions_1.runAssertion)({
+                prompt: 'Some prompt',
+                provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
+                assertion: isSqlAssertionWithDatabaseAndWhiteTableList,
+                test: {},
+                providerResponse: { output },
+            });
+            expect(result).toMatchObject({
+                pass: false,
+                reason: `SQL validation failed: authority = 'update::null::employees' is required in table whiteList to execute SQL = 'UPDATE employees SET department_id = 2 WHERE employee_id = 1'.`,
+            });
         });
-        expect(result).toMatchObject({
-            pass: false,
-            reason: `SQL validation failed: authority = 'delete::null::employees' is required in table whiteList to execute SQL = 'DELETE FROM employees;'. SQL validation failed: authority = 'delete::employees::(.*)' is required in column whiteList to execute SQL = 'DELETE FROM employees;'.`,
+        it('should pass when the is-sql assertion passes given MySQL Database syntax and allowedColumns', async () => {
+            const output = 'SELECT name FROM t';
+            const result = await (0, assertions_1.runAssertion)({
+                prompt: 'Some prompt',
+                provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
+                assertion: isSqlAssertionWithDatabaseAndWhiteColumnList,
+                test: {},
+                providerResponse: { output },
+            });
+            expect(result).toMatchObject({
+                pass: true,
+                reason: 'Assertion passed',
+            });
         });
-    });
-    it('should pass when the contains-sql assertion passes', async () => {
-        const output = 'wassup\n```\nSELECT id, name FROM users\n```\nyolo';
-        const result = await (0, assertions_1.runAssertion)({
-            prompt: 'Some prompt',
-            provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
-            assertion: {
-                type: 'contains-sql',
-            },
-            test: {},
-            providerResponse: { output },
+        it('should fail when the is-sql assertion fails given MySQL Database syntax and allowedColumns', async () => {
+            const output = 'SELECT age FROM a WHERE id = 1';
+            const result = await (0, assertions_1.runAssertion)({
+                prompt: 'Some prompt',
+                provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
+                assertion: isSqlAssertionWithDatabaseAndWhiteColumnList,
+                test: {},
+                providerResponse: { output },
+            });
+            expect(result).toMatchObject({
+                pass: false,
+                reason: `SQL validation failed: authority = 'select::null::age' is required in column whiteList to execute SQL = 'SELECT age FROM a WHERE id = 1'.`,
+            });
         });
-        expect(result).toMatchObject({
-            pass: true,
-            reason: 'Assertion passed',
+        it('should pass when the is-sql assertion passes given MySQL Database syntax, allowedTables, and allowedColumns', async () => {
+            const output = 'SELECT name FROM departments';
+            const result = await (0, assertions_1.runAssertion)({
+                prompt: 'Some prompt',
+                provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
+                assertion: isSqlAssertionWithDatabaseAndBothList,
+                test: {},
+                providerResponse: { output },
+            });
+            expect(result).toMatchObject({
+                pass: true,
+                reason: 'Assertion passed',
+            });
         });
-    });
-    it('should pass when the contains-sql assertion sees `sql` in code block', async () => {
-        const output = 'wassup\n```sql\nSELECT id, name FROM users\n```\nyolo';
-        const result = await (0, assertions_1.runAssertion)({
-            prompt: 'Some prompt',
-            provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
-            assertion: {
-                type: 'contains-sql',
-            },
-            test: {},
-            providerResponse: { output },
+        it('should fail when the is-sql assertion fails given MySQL Database syntax, allowedTables, and allowedColumns', async () => {
+            const output = `INSERT INTO departments (name) VALUES ('HR')`;
+            const result = await (0, assertions_1.runAssertion)({
+                prompt: 'Some prompt',
+                provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
+                assertion: isSqlAssertionWithDatabaseAndBothList,
+                test: {},
+                providerResponse: { output },
+            });
+            expect(result).toMatchObject({
+                pass: false,
+                reason: `SQL validation failed: authority = 'insert::departments::name' is required in column whiteList to execute SQL = 'INSERT INTO departments (name) VALUES ('HR')'.`,
+            });
         });
-        expect(result).toMatchObject({
-            pass: true,
-            reason: 'Assertion passed',
+        it('should fail when the is-sql assertion fails due to missing table authority for MySQL Database syntax', async () => {
+            const output = 'UPDATE a SET id = 1';
+            const result = await (0, assertions_1.runAssertion)({
+                prompt: 'Some prompt',
+                provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
+                assertion: isSqlAssertionWithDatabaseAndBothList,
+                test: {},
+                providerResponse: { output },
+            });
+            expect(result).toMatchObject({
+                pass: false,
+                reason: `SQL validation failed: authority = 'update::null::a' is required in table whiteList to execute SQL = 'UPDATE a SET id = 1'.`,
+            });
         });
-    });
-    it('should pass when the contains-sql assertion sees sql without code block', async () => {
-        const output = 'SELECT id, name FROM users';
-        const result = await (0, assertions_1.runAssertion)({
-            prompt: 'Some prompt',
-            provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
-            assertion: {
-                type: 'contains-sql',
-            },
-            test: {},
-            providerResponse: { output },
+        it('should fail when the is-sql assertion fails due to missing authorities for DELETE statement in MySQL Database syntax', async () => {
+            const output = `DELETE FROM employees;`;
+            const result = await (0, assertions_1.runAssertion)({
+                prompt: 'Some prompt',
+                provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
+                assertion: isSqlAssertionWithDatabaseAndBothList,
+                test: {},
+                providerResponse: { output },
+            });
+            expect(result).toMatchObject({
+                pass: false,
+                reason: `SQL validation failed: authority = 'delete::null::employees' is required in table whiteList to execute SQL = 'DELETE FROM employees;'. SQL validation failed: authority = 'delete::employees::(.*)' is required in column whiteList to execute SQL = 'DELETE FROM employees;'.`,
+            });
         });
-        expect(result).toMatchObject({
-            pass: true,
-            reason: 'Assertion passed',
+        it('should pass when the contains-sql assertion passes', async () => {
+            const output = 'wassup\n```\nSELECT id, name FROM users\n```\nyolo';
+            const result = await (0, assertions_1.runAssertion)({
+                prompt: 'Some prompt',
+                provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
+                assertion: {
+                    type: 'contains-sql',
+                },
+                test: {},
+                providerResponse: { output },
+            });
+            expect(result).toMatchObject({
+                pass: true,
+                reason: 'Assertion passed',
+            });
         });
-    });
-    it('should fail when the contains-sql does not contain code block', async () => {
-        const output = 'nothin';
-        const result = await (0, assertions_1.runAssertion)({
-            prompt: 'Some prompt',
-            provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
-            assertion: {
-                type: 'contains-sql',
-            },
-            test: {},
-            providerResponse: { output },
+        it('should pass when the contains-sql assertion sees `sql` in code block', async () => {
+            const output = 'wassup\n```sql\nSELECT id, name FROM users\n```\nyolo';
+            const result = await (0, assertions_1.runAssertion)({
+                prompt: 'Some prompt',
+                provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
+                assertion: {
+                    type: 'contains-sql',
+                },
+                test: {},
+                providerResponse: { output },
+            });
+            expect(result).toMatchObject({
+                pass: true,
+                reason: 'Assertion passed',
+            });
         });
-        expect(result).toMatchObject({
-            pass: false,
+        it('should pass when the contains-sql assertion sees sql without code block', async () => {
+            const output = 'SELECT id, name FROM users';
+            const result = await (0, assertions_1.runAssertion)({
+                prompt: 'Some prompt',
+                provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
+                assertion: {
+                    type: 'contains-sql',
+                },
+                test: {},
+                providerResponse: { output },
+            });
+            expect(result).toMatchObject({
+                pass: true,
+                reason: 'Assertion passed',
+            });
         });
-    });
-    it('should fail when the contains-sql does not contain sql in code block', async () => {
-        const output = '```python\nprint("Hello, World!")\n```';
-        const result = await (0, assertions_1.runAssertion)({
-            prompt: 'Some prompt',
-            provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
-            assertion: {
-                type: 'contains-sql',
-            },
-            test: {},
-            providerResponse: { output },
+        it('should fail when the contains-sql does not contain code block', async () => {
+            const output = 'nothin';
+            const result = await (0, assertions_1.runAssertion)({
+                prompt: 'Some prompt',
+                provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
+                assertion: {
+                    type: 'contains-sql',
+                },
+                test: {},
+                providerResponse: { output },
+            });
+            expect(result).toMatchObject({
+                pass: false,
+            });
         });
-        expect(result).toMatchObject({
-            pass: false,
+        it('should fail when the contains-sql does not contain sql in code block', async () => {
+            const output = '```python\nprint("Hello, World!")\n```';
+            const result = await (0, assertions_1.runAssertion)({
+                prompt: 'Some prompt',
+                provider: new openai_1.OpenAiChatCompletionProvider('gpt-4o-mini'),
+                assertion: {
+                    type: 'contains-sql',
+                },
+                test: {},
+                providerResponse: { output },
+            });
+            expect(result).toMatchObject({
+                pass: false,
+            });
         });
     });
     it('should pass when the contains-json assertion passes', async () => {
@@ -3468,37 +3447,37 @@ describe('runAssertion', () => {
 });
 describe('validateXml', () => {
     it('should validate a simple valid XML string', () => {
-        expect((0, assertions_1.validateXml)('<root><child>Content</child></root>')).toEqual({
+        expect((0, xml_1.validateXml)('<root><child>Content</child></root>')).toEqual({
             isValid: true,
             reason: 'XML is valid and contains all required elements',
         });
     });
     it('should invalidate a malformed XML string', () => {
-        expect((0, assertions_1.validateXml)('<root><child>Content</child></root')).toEqual({
+        expect((0, xml_1.validateXml)('<root><child>Content</child></root')).toEqual({
             isValid: false,
             reason: expect.stringContaining('XML parsing failed'),
         });
     });
     it('should validate XML with attributes', () => {
-        expect((0, assertions_1.validateXml)('<root><child id="1">Content</child></root>')).toEqual({
+        expect((0, xml_1.validateXml)('<root><child id="1">Content</child></root>')).toEqual({
             isValid: true,
             reason: 'XML is valid and contains all required elements',
         });
     });
     it('should validate XML with namespaces', () => {
-        expect((0, assertions_1.validateXml)('<root xmlns:ns="http://example.com"><ns:child>Content</ns:child></root>')).toEqual({
+        expect((0, xml_1.validateXml)('<root xmlns:ns="http://example.com"><ns:child>Content</ns:child></root>')).toEqual({
             isValid: true,
             reason: 'XML is valid and contains all required elements',
         });
     });
     it('should validate when all required elements are present', () => {
-        expect((0, assertions_1.validateXml)('<analysis><classification>T-shirt</classification><color>Red</color></analysis>', ['analysis.classification', 'analysis.color'])).toEqual({
+        expect((0, xml_1.validateXml)('<analysis><classification>T-shirt</classification><color>Red</color></analysis>', ['analysis.classification', 'analysis.color'])).toEqual({
             isValid: true,
             reason: 'XML is valid and contains all required elements',
         });
     });
     it('should invalidate when a required element is missing', () => {
-        expect((0, assertions_1.validateXml)('<analysis><classification>T-shirt</classification></analysis>', [
+        expect((0, xml_1.validateXml)('<analysis><classification>T-shirt</classification></analysis>', [
             'analysis.classification',
             'analysis.color',
         ])).toEqual({
@@ -3507,7 +3486,7 @@ describe('validateXml', () => {
         });
     });
     it('should validate nested elements correctly', () => {
-        expect((0, assertions_1.validateXml)('<root><parent><child><grandchild>Content</grandchild></child></parent></root>', [
+        expect((0, xml_1.validateXml)('<root><parent><child><grandchild>Content</grandchild></child></parent></root>', [
             'root.parent.child.grandchild',
         ])).toEqual({
             isValid: true,
@@ -3515,7 +3494,7 @@ describe('validateXml', () => {
         });
     });
     it('should invalidate when a nested required element is missing', () => {
-        expect((0, assertions_1.validateXml)('<root><parent><child></child></parent></root>', [
+        expect((0, xml_1.validateXml)('<root><parent><child></child></parent></root>', [
             'root.parent.child.grandchild',
         ])).toEqual({
             isValid: false,
@@ -3523,7 +3502,7 @@ describe('validateXml', () => {
         });
     });
     it('should handle empty elements correctly', () => {
-        expect((0, assertions_1.validateXml)('<root><emptyChild></emptyChild><nonEmptyChild>Content</nonEmptyChild></root>', [
+        expect((0, xml_1.validateXml)('<root><emptyChild></emptyChild><nonEmptyChild>Content</nonEmptyChild></root>', [
             'root.emptyChild',
             'root.nonEmptyChild',
         ])).toEqual({
@@ -3532,13 +3511,13 @@ describe('validateXml', () => {
         });
     });
     it('should validate XML with multiple siblings', () => {
-        expect((0, assertions_1.validateXml)('<root><child>Content1</child><child>Content2</child></root>', ['root.child'])).toEqual({
+        expect((0, xml_1.validateXml)('<root><child>Content1</child><child>Content2</child></root>', ['root.child'])).toEqual({
             isValid: true,
             reason: 'XML is valid and contains all required elements',
         });
     });
     it('should handle XML with CDATA sections', () => {
-        expect((0, assertions_1.validateXml)('<root><child><![CDATA[<p>This is CDATA content</p>]]></child></root>', [
+        expect((0, xml_1.validateXml)('<root><child><![CDATA[<p>This is CDATA content</p>]]></child></root>', [
             'root.child',
         ])).toEqual({
             isValid: true,
@@ -3547,13 +3526,13 @@ describe('validateXml', () => {
     });
     it('should validate XML with processing instructions', () => {
         const xml = '<?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet type="text/xsl" href="style.xsl"?><root><child>Content</child></root>';
-        expect((0, assertions_1.validateXml)(xml, ['root.child'])).toEqual({
+        expect((0, xml_1.validateXml)(xml, ['root.child'])).toEqual({
             isValid: true,
             reason: 'XML is valid and contains all required elements',
         });
     });
     it('should handle XML with comments', () => {
-        expect((0, assertions_1.validateXml)('<root><!-- This is a comment --><child>Content</child></root>', ['root.child'])).toEqual({
+        expect((0, xml_1.validateXml)('<root><!-- This is a comment --><child>Content</child></root>', ['root.child'])).toEqual({
             isValid: true,
             reason: 'XML is valid and contains all required elements',
         });
@@ -3569,7 +3548,7 @@ describe('validateXml', () => {
         <reasoning>The image clearly shows a short-sleeved garment with a round neckline, which is characteristic of a T-shirt. The large circular graphic on the front is distinctive and appears to be a stylized smiley face or emoji design, which is popular in contemporary casual fashion. The stark contrast between the white fabric and black print is very clear, leaving little room for misinterpretation. The style is unmistakably modern and aligned with current trends in graphic tees. My confidence is high (9) because all elements of the image are clear and consistent with a typical graphic T-shirt design.</reasoning>
       </analysis>
     `;
-        expect((0, assertions_1.validateXml)(xml, [
+        expect((0, xml_1.validateXml)(xml, [
             'analysis.classification',
             'analysis.color',
             'analysis.features',
@@ -3585,31 +3564,31 @@ describe('validateXml', () => {
 describe('containsXml', () => {
     it('should return true when valid XML is present', () => {
         const input = 'Some text <root><child>Content</child></root> more text';
-        const result = (0, assertions_1.containsXml)(input);
+        const result = (0, xml_1.containsXml)(input);
         expect(result.isValid).toBe(true);
     });
     it('should return false when no XML is present', () => {
         const input = 'This is just plain text';
-        expect((0, assertions_1.containsXml)(input)).toEqual({
+        expect((0, xml_1.containsXml)(input)).toEqual({
             isValid: false,
             reason: 'No XML content found in the output',
         });
     });
     it('should validate required elements', () => {
         const input = 'Text <root><child>Content</child></root> more';
-        const result = (0, assertions_1.containsXml)(input, ['root.child']);
+        const result = (0, xml_1.containsXml)(input, ['root.child']);
         expect(result.isValid).toBe(true);
     });
     it('should return false when required elements are missing', () => {
         const input = 'Text <root><child>Content</child></root> more';
-        expect((0, assertions_1.containsXml)(input, ['root.missing'])).toEqual({
+        expect((0, xml_1.containsXml)(input, ['root.missing'])).toEqual({
             isValid: false,
             reason: 'No valid XML content found matching the requirements',
         });
     });
     it('should handle multiple XML fragments', () => {
         const input = '<root1>Content</root1> text <root2><child>More</child></root2>';
-        const result = (0, assertions_1.containsXml)(input, ['root2.child']);
+        const result = (0, xml_1.containsXml)(input, ['root2.child']);
         expect(result.isValid).toBe(true);
     });
 });