@nyaruka/temba-components 0.129.8 → 0.129.9

package/out-tsc/test/actions/call_llm.test.js

@@ -0,0 +1,103 @@
+import { expect } from '@open-wc/testing';
+import { call_llm } from '../../src/flow/actions/call_llm';
+import { ActionTest } from '../ActionHelper';
+/**
+ * Test suite for the call_llm action configuration.
+ */
+describe('call_llm action config', () => {
+    const helper = new ActionTest(call_llm, 'call_llm');
+    describe('basic properties', () => {
+        helper.testBasicProperties();
+        it('has correct name', () => {
+            expect(call_llm.name).to.equal('Call AI');
+        });
+        it('has form configuration', () => {
+            expect(call_llm.form).to.exist;
+            expect(call_llm.form.llm).to.exist;
+            expect(call_llm.form.instructions).to.exist;
+            expect(call_llm.form.input).to.exist;
+        });
+        it('has layout configuration', () => {
+            expect(call_llm.layout).to.exist;
+            expect(call_llm.layout).to.deep.equal(['llm', 'input', 'instructions']);
+        });
+        it('has data transformation functions', () => {
+            expect(call_llm.toFormData).to.be.a('function');
+            expect(call_llm.fromFormData).to.be.a('function');
+        });
+    });
+    describe('data transformations', () => {
+        it('converts action to form data correctly', () => {
+            const action = {
+                uuid: 'test-llm-1',
+                type: 'call_llm',
+                input: '@input',
+                llm: { uuid: 'gpt-4', name: 'GPT 4.1' },
+                instructions: 'Translate to French',
+                result_name: 'translated_text'
+            };
+            const formData = call_llm.toFormData(action);
+            expect(formData.uuid).to.equal('test-llm-1');
+            expect(formData.llm).to.deep.equal([{ value: 'gpt-4', name: 'GPT 4.1' }]);
+            expect(formData.instructions).to.equal('Translate to French');
+            expect(formData.input).to.equal('@input');
+        });
+        it('converts form data to action correctly', () => {
+            const formData = {
+                uuid: 'test-llm-2',
+                llm: [{ value: 'gpt-5', name: 'GPT 5' }],
+                instructions: 'Summarize the following text',
+                input: '@input'
+            };
+            const action = call_llm.fromFormData(formData);
+            expect(action.uuid).to.equal('test-llm-2');
+            expect(action.type).to.equal('call_llm');
+            expect(action.llm).to.deep.equal({ uuid: 'gpt-5', name: 'GPT 5' });
+            expect(action.instructions).to.equal('Summarize the following text');
+            expect(action.input).to.equal('@input');
+        });
+        it('handles empty form data', () => {
+            const formData = {
+                uuid: 'test-llm-3',
+                llm: [],
+                instructions: '',
+                input: ''
+            };
+            const action = call_llm.fromFormData(formData);
+            expect(action.llm).to.deep.equal({ uuid: '', name: '' });
+            expect(action.instructions).to.equal('');
+            expect(action.input).to.equal('@input');
+        });
+    });
+    describe('action scenarios', () => {
+        helper.testAction({
+            uuid: 'test-action-1',
+            type: 'call_llm',
+            llm: { uuid: 'gpt-4', name: 'GPT 4.1' },
+            instructions: 'Translate to French',
+            input: '@input'
+        }, 'translation-task');
+        helper.testAction({
+            uuid: 'test-action-2',
+            type: 'call_llm',
+            llm: { uuid: 'gpt-5', name: 'GPT 5' },
+            instructions: 'Analyze the sentiment of the following message and classify it as positive, negative, or neutral. Provide a brief explanation for your classification.',
+            input: '@input'
+        }, 'sentiment-analysis');
+        helper.testAction({
+            uuid: 'test-action-3',
+            type: 'call_llm',
+            llm: { uuid: 'gpt-4', name: 'GPT 4.1' },
+            instructions: 'Summarize the key points from the conversation above in bullet format.',
+            input: '@input'
+        }, 'summarization');
+        helper.testAction({
+            uuid: 'test-action-4',
+            type: 'call_llm',
+            llm: { uuid: 'gpt-5', name: 'GPT 5' },
+            instructions: 'Extract any contact information (phone numbers, email addresses) from the text and format them as a JSON object.',
+            input: '@input'
+        }, 'information-extraction');
+    });
+});
+//# sourceMappingURL=call_llm.test.js.map

package/out-tsc/test/actions/call_llm.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"call_llm.test.js","sourceRoot":"","sources":["../../../test/actions/call_llm.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { expect } from '@open-wc/testing';\nimport { call_llm } from '../../src/flow/actions/call_llm';\nimport { CallLLM } from '../../src/store/flow-definition';\nimport { ActionTest } from '../ActionHelper';\n\n/**\n * Test suite for the call_llm action configuration.\n */\ndescribe('call_llm action config', () => {\n  const helper = new ActionTest(call_llm, 'call_llm');\n\n  describe('basic properties', () => {\n    helper.testBasicProperties();\n\n    it('has correct name', () => {\n      expect(call_llm.name).to.equal('Call AI');\n    });\n\n    it('has form configuration', () => {\n      expect(call_llm.form).to.exist;\n      expect(call_llm.form.llm).to.exist;\n      expect(call_llm.form.instructions).to.exist;\n      expect(call_llm.form.input).to.exist;\n    });\n\n    it('has layout configuration', () => {\n      expect(call_llm.layout).to.exist;\n      expect(call_llm.layout).to.deep.equal(['llm', 'input', 'instructions']);\n    });\n\n    it('has data transformation functions', () => {\n      expect(call_llm.toFormData).to.be.a('function');\n      expect(call_llm.fromFormData).to.be.a('function');\n    });\n  });\n\n  describe('data transformations', () => {\n    it('converts action to form data correctly', () => {\n      const action: CallLLM = {\n        uuid: 'test-llm-1',\n        type: 'call_llm',\n        input: '@input',\n        llm: { uuid: 'gpt-4', name: 'GPT 4.1' },\n        instructions: 'Translate to French',\n        result_name: 'translated_text'\n      };\n\n      const formData = call_llm.toFormData(action);\n\n      expect(formData.uuid).to.equal('test-llm-1');\n      expect(formData.llm).to.deep.equal([{ value: 'gpt-4', name: 'GPT 4.1' }]);\n      expect(formData.instructions).to.equal('Translate to French');\n      expect(formData.input).to.equal('@input');\n    });\n\n    it('converts form data to action correctly', () => {\n      const formData = {\n        uuid: 'test-llm-2',\n        llm: [{ value: 'gpt-5', name: 'GPT 5' }],\n        instructions: 'Summarize the following text',\n        input: '@input'\n      };\n\n      const action = call_llm.fromFormData(formData) as CallLLM;\n\n      expect(action.uuid).to.equal('test-llm-2');\n      expect(action.type).to.equal('call_llm');\n      expect(action.llm).to.deep.equal({ uuid: 'gpt-5', name: 'GPT 5' });\n      expect(action.instructions).to.equal('Summarize the following text');\n      expect(action.input).to.equal('@input');\n    });\n\n    it('handles empty form data', () => {\n      const formData = {\n        uuid: 'test-llm-3',\n        llm: [],\n        instructions: '',\n        input: ''\n      };\n\n      const action = call_llm.fromFormData(formData) as CallLLM;\n\n      expect(action.llm).to.deep.equal({ uuid: '', name: '' });\n      expect(action.instructions).to.equal('');\n      expect(action.input).to.equal('@input');\n    });\n  });\n\n  describe('action scenarios', () => {\n    helper.testAction(\n      {\n        uuid: 'test-action-1',\n        type: 'call_llm',\n        llm: { uuid: 'gpt-4', name: 'GPT 4.1' },\n        instructions: 'Translate to French',\n        input: '@input'\n      } as CallLLM,\n      'translation-task'\n    );\n\n    helper.testAction(\n      {\n        uuid: 'test-action-2',\n        type: 'call_llm',\n        llm: { uuid: 'gpt-5', name: 'GPT 5' },\n        instructions:\n          'Analyze the sentiment of the following message and classify it as positive, negative, or neutral. Provide a brief explanation for your classification.',\n        input: '@input'\n      } as CallLLM,\n      'sentiment-analysis'\n    );\n\n    helper.testAction(\n      {\n        uuid: 'test-action-3',\n        type: 'call_llm',\n        llm: { uuid: 'gpt-4', name: 'GPT 4.1' },\n        instructions:\n          'Summarize the key points from the conversation above in bullet format.',\n        input: '@input'\n      } as CallLLM,\n      'summarization'\n    );\n\n    helper.testAction(\n      {\n        uuid: 'test-action-4',\n        type: 'call_llm',\n        llm: { uuid: 'gpt-5', name: 'GPT 5' },\n        instructions:\n          'Extract any contact information (phone numbers, email addresses) from the text and format them as a JSON object.',\n        input: '@input'\n      } as CallLLM,\n      'information-extraction'\n    );\n  });\n});\n"]}

package/out-tsc/test/nodes/split_by_llm_categorize.test.js

@@ -0,0 +1,532 @@
+import { expect } from '@open-wc/testing';
+import { split_by_llm_categorize } from '../../src/flow/nodes/split_by_llm_categorize';
+import { NodeTest } from '../NodeHelper';
+// Helper function to create routers with proper cases and exits
+function createSplitRouter(categoryNames) {
+    const categories = [];
+    const exits = [];
+    const cases = [];
+    // Add user categories
+    categoryNames.forEach((categoryName) => {
+        const categoryUuid = `category-${categoryName
+            .toLowerCase()
+            .replace(/\s+/g, '-')}`;
+        const exitUuid = `exit-${categoryName.toLowerCase().replace(/\s+/g, '-')}`;
+        const caseUuid = `case-${categoryName.toLowerCase().replace(/\s+/g, '-')}`;
+        categories.push({
+            uuid: categoryUuid,
+            name: categoryName,
+            exit_uuid: exitUuid
+        });
+        exits.push({
+            uuid: exitUuid,
+            destination_uuid: null
+        });
+        cases.push({
+            uuid: caseUuid,
+            type: 'has_only_text',
+            arguments: [categoryName],
+            category_uuid: categoryUuid
+        });
+    });
+    // Add "Other" category (default)
+    const otherCategoryUuid = 'category-other';
+    const otherExitUuid = 'exit-other';
+    categories.push({
+        uuid: otherCategoryUuid,
+        name: 'Other',
+        exit_uuid: otherExitUuid
+    });
+    exits.push({
+        uuid: otherExitUuid,
+        destination_uuid: null
+    });
+    // Add "Failure" category
+    const failureCategoryUuid = 'category-failure';
+    const failureExitUuid = 'exit-failure';
+    const failureCaseUuid = 'case-failure';
+    categories.push({
+        uuid: failureCategoryUuid,
+        name: 'Failure',
+        exit_uuid: failureExitUuid
+    });
+    exits.push({
+        uuid: failureExitUuid,
+        destination_uuid: null
+    });
+    // Add failure case for <ERROR>
+    cases.push({
+        uuid: failureCaseUuid,
+        type: 'has_only_text',
+        arguments: ['<ERROR>'],
+        category_uuid: failureCategoryUuid
+    });
+    return {
+        router: {
+            type: 'switch',
+            categories: categories,
+            default_category_uuid: otherCategoryUuid,
+            operand: '@locals._llm_output',
+            cases: cases
+        },
+        exits: exits
+    };
+}
+/**
+ * Test suite for the split_by_llm_categorize node configuration.
+ */
+describe('split_by_llm_categorize node config', () => {
+    const helper = new NodeTest(split_by_llm_categorize, 'split_by_llm_categorize');
+    describe('basic properties', () => {
+        helper.testBasicProperties();
+        it('has correct name', () => {
+            expect(split_by_llm_categorize.name).to.equal('Split by AI');
+        });
+        it('has correct type', () => {
+            expect(split_by_llm_categorize.type).to.equal('split_by_llm_categorize');
+        });
+    });
+    describe('node scenarios', () => {
+        const basicRouter = createSplitRouter(['Greeting', 'Question']);
+        helper.testNode({
+            uuid: 'test-node-1',
+            actions: [
+                {
+                    uuid: 'call-llm-uuid',
+                    type: 'call_llm',
+                    llm: { uuid: 'llm-123', name: 'Claude' },
+                    input: '@input',
+                    instructions: '@(prompt("categorize", slice(node.categories, 0, -2)))',
+                    output_local: '_llm_output'
+                }
+            ],
+            router: basicRouter.router,
+            exits: basicRouter.exits
+        }, { type: 'split_by_llm_categorize' }, 'basic-categorization');
+        const premiumRouter = createSplitRouter(['Premium', 'Regular', 'VIP']);
+        helper.testNode({
+            uuid: 'test-node-2',
+            actions: [
+                {
+                    uuid: 'call-llm-uuid-2',
+                    type: 'call_llm',
+                    llm: { uuid: 'llm-456', name: 'GPT-4' },
+                    input: '@contact.name',
+                    instructions: '@(prompt("categorize", slice(node.categories, 0, -2)))',
+                    output_local: '_llm_output'
+                }
+            ],
+            router: premiumRouter.router,
+            exits: premiumRouter.exits
+        }, { type: 'split_by_llm_categorize' }, 'custom-input-and-result-name');
+        const priorityRouter = createSplitRouter([
+            'High',
+            'Medium',
+            'Low',
+            'Critical',
+            'Urgent'
+        ]);
+        helper.testNode({
+            uuid: 'test-node-3',
+            actions: [
+                {
+                    uuid: 'call-llm-uuid-3',
+                    type: 'call_llm',
+                    llm: { uuid: 'llm-789', name: 'Gemini' },
+                    input: '@fields.priority',
+                    instructions: '@(prompt("categorize", slice(node.categories, 0, -2)))',
+                    output_local: '_llm_output'
+                }
+            ],
+            router: priorityRouter.router,
+            exits: priorityRouter.exits
+        }, { type: 'split_by_llm_categorize' }, 'many-categories');
+        const minimalRouter = createSplitRouter(['Yes']);
+        helper.testNode({
+            uuid: 'test-node-4',
+            actions: [
+                {
+                    uuid: 'call-llm-uuid-4',
+                    type: 'call_llm',
+                    llm: { uuid: 'llm-minimal', name: 'Basic LLM' },
+                    input: '@input',
+                    instructions: '@(prompt("categorize", slice(node.categories, 0, -2)))',
+                    output_local: '_llm_output'
+                }
+            ],
+            router: minimalRouter.router,
+            exits: minimalRouter.exits
+        }, { type: 'split_by_llm_categorize' }, 'minimal-categories');
+        const feedbackRouter = createSplitRouter([
+            'Bug Report',
+            'Feature Request',
+            'General Feedback',
+            'Support Request'
+        ]);
+        helper.testNode({
+            uuid: 'test-node-5',
+            actions: [
+                {
+                    uuid: 'call-llm-uuid-5',
+                    type: 'call_llm',
+                    llm: { uuid: 'llm-special', name: 'Special Characters LLM' },
+                    input: '@contact.fields.feedback',
+                    instructions: '@(prompt("categorize", slice(node.categories, 0, -2)))',
+                    output_local: '_llm_output'
+                }
+            ],
+            router: feedbackRouter.router,
+            exits: feedbackRouter.exits
+        }, { type: 'split_by_llm_categorize' }, 'feedback-categorization');
+    });
+    describe('round-trip conversion validation', () => {
+        it('converts to form data correctly', () => {
+            const testRouter = createSplitRouter(['Greeting', 'Question']);
+            const node = {
+                uuid: 'test-node',
+                actions: [
+                    {
+                        uuid: 'call-llm-uuid',
+                        type: 'call_llm',
+                        llm: { uuid: 'llm-123', name: 'Test LLM' },
+                        input: '@input',
+                        instructions: '@(prompt("categorize", slice(node.categories, 0, -2)))',
+                        output_local: '_llm_output'
+                    }
+                ],
+                router: testRouter.router,
+                exits: testRouter.exits
+            };
+            const formData = split_by_llm_categorize.toFormData(node);
+            expect(formData.uuid).to.equal('test-node');
+            expect(formData.llm).to.deep.equal([
+                { value: 'llm-123', name: 'Test LLM' }
+            ]);
+            expect(formData.input).to.equal('@input');
+            expect(formData.categories).to.deep.equal([
+                { name: 'Greeting' },
+                { name: 'Question' }
+            ]);
+        });
+        it('converts from form data correctly', () => {
+            const formData = {
+                uuid: 'test-node',
+                llm: [{ value: 'llm-456', name: 'GPT-4' }],
+                input: '@contact.name',
+                categories: [{ name: 'Premium' }, { name: 'Regular' }]
+            };
+            const originalNode = {
+                uuid: 'test-node',
+                actions: [],
+                exits: []
+            };
+            const result = split_by_llm_categorize.fromFormData(formData, originalNode);
+            expect(result.uuid).to.equal('test-node');
+            expect(result.actions).to.have.length(1);
+            expect(result.actions[0].type).to.equal('call_llm');
+            expect(result.actions[0].llm.uuid).to.equal('llm-456');
+            expect(result.actions[0].llm.name).to.equal('GPT-4');
+            expect(result.actions[0].input).to.equal('@contact.name');
+            // Should have user categories plus Other and Failure
+            expect(result.router.categories).to.have.length(4);
+            const categoryNames = result.router.categories.map((cat) => cat.name);
+            expect(categoryNames).to.include.members([
+                'Premium',
+                'Regular',
+                'Other',
+                'Failure'
+            ]);
+            // Should have corresponding exits
+            expect(result.exits).to.have.length(4);
+        });
+    });
+    describe('edge cases and validation', () => {
+        it('handles categories with empty names correctly', () => {
+            const formData = {
+                uuid: 'test-node-uuid',
+                llm: [{ value: 'llm-uuid-123', name: 'Claude' }],
+                input: '@input',
+                categories: [
+                    { name: 'Valid Category' },
+                    { name: '' }, // empty name
+                    { name: '   ' }, // only whitespace
+                    { name: 'Another Valid' }
+                ],
+                result_name: 'Intent'
+            };
+            const originalNode = {
+                uuid: 'test-node-uuid',
+                actions: [],
+                exits: []
+            };
+            const result = split_by_llm_categorize.fromFormData(formData, originalNode);
+            // Should only include non-empty categories
+            const userCategories = result.router.categories.filter((cat) => cat.name !== 'Other' && cat.name !== 'Failure');
+            expect(userCategories).to.have.length(2);
+            expect(userCategories.map((cat) => cat.name)).to.deep.equal([
+                'Valid Category',
+                'Another Valid'
+            ]);
+        });
+        it('handles categories with special characters', () => {
+            const formData = {
+                uuid: 'test-node-uuid',
+                llm: [{ value: 'llm-uuid-123', name: 'Claude' }],
+                input: '@input',
+                categories: [
+                    { name: 'Category-1' },
+                    { name: 'Category_2' },
+                    { name: 'Category@3' },
+                    { name: 'Category with spaces' }
+                ],
+                result_name: 'Intent'
+            };
+            const originalNode = {
+                uuid: 'test-node-uuid',
+                actions: [],
+                exits: []
+            };
+            const result = split_by_llm_categorize.fromFormData(formData, originalNode);
+            // Should preserve all special characters in category names
+            const userCategories = result.router.categories.filter((cat) => cat.name !== 'Other' && cat.name !== 'Failure');
+            expect(userCategories).to.have.length(4);
+            expect(userCategories.map((cat) => cat.name)).to.include.members([
+                'Category-1',
+                'Category_2',
+                'Category@3',
+                'Category with spaces'
+            ]);
+            // Verify cases also have correct names
+            const caseNames = result
+                .router.cases.filter((c) => c.arguments[0] !== '<ERROR>')
+                .map((c) => c.arguments[0]);
+            expect(caseNames).to.include.members([
+                'Category-1',
+                'Category_2',
+                'Category@3',
+                'Category with spaces'
+            ]);
+        });
+        it('maintains UUID consistency between categories, cases, and exits', () => {
+            const formData = {
+                uuid: 'test-node-uuid',
+                llm: [{ value: 'llm-uuid-123', name: 'Claude' }],
+                input: '@input',
+                categories: [{ name: 'Test Category' }],
+                result_name: 'Intent'
+            };
+            const originalNode = {
+                uuid: 'test-node-uuid',
+                actions: [],
+                exits: []
+            };
+            const result = split_by_llm_categorize.fromFormData(formData, originalNode);
+            // Find the test category
+            const testCategory = result.router.categories.find((cat) => cat.name === 'Test Category');
+            const testCase = result.router.cases.find((c) => c.arguments[0] === 'Test Category');
+            const testExit = result.exits.find((exit) => exit.uuid === testCategory.exit_uuid);
+            // Verify UUID consistency
+            expect(testCase.category_uuid).to.equal(testCategory.uuid);
+            expect(testExit.uuid).to.equal(testCategory.exit_uuid);
+        });
+        it('generates unique UUIDs for each run', () => {
+            const formData = {
+                uuid: 'test-node-uuid',
+                llm: [{ value: 'llm-uuid-123', name: 'Claude' }],
+                input: '@input',
+                categories: [{ name: 'Test' }],
+                result_name: 'Intent'
+            };
+            const originalNode = {
+                uuid: 'test-node-uuid',
+                actions: [],
+                exits: []
+            };
+            const result1 = split_by_llm_categorize.fromFormData(formData, originalNode);
+            const result2 = split_by_llm_categorize.fromFormData(formData, originalNode);
+            // UUIDs should be different for each generation
+            expect(result1.actions[0].uuid).to.not.equal(result2.actions[0].uuid);
+            expect(result1.router.categories[0].uuid).to.not.equal(result2.router.categories[0].uuid);
+            expect(result1.exits[0].uuid).to.not.equal(result2.exits[0].uuid);
+        });
+        it('roundtrip conversion (fromFormData -> toFormData) works correctly', () => {
+            const originalFormData = {
+                uuid: 'test-node-uuid',
+                llm: [{ value: 'llm-uuid-123', name: 'Claude' }],
+                input: '@custom.input',
+                categories: [{ name: 'Category1' }, { name: 'Category2' }],
+                result_name: 'CustomResult'
+            };
+            const originalNode = {
+                uuid: 'test-node-uuid',
+                actions: [],
+                exits: []
+            };
+            // Convert form data to node
+            const node = split_by_llm_categorize.fromFormData(originalFormData, originalNode);
+            // Convert back to form data
+            const recoveredFormData = split_by_llm_categorize.toFormData(node);
+            // Should match original data
+            expect(recoveredFormData.uuid).to.equal(originalFormData.uuid);
+            expect(recoveredFormData.llm).to.deep.equal(originalFormData.llm);
+            expect(recoveredFormData.input).to.equal(originalFormData.input);
+            expect(recoveredFormData.categories).to.deep.equal(originalFormData.categories);
+        });
+        it('handles max 10 categories requirement', () => {
+            // Create 12 categories to test the limit
+            const categories = Array.from({ length: 12 }, (_, i) => ({
+                name: `Category${i + 1}`
+            }));
+            const formData = {
+                uuid: 'test-node-uuid',
+                llm: [{ value: 'llm-uuid-123', name: 'Claude' }],
+                input: '@input',
+                categories: categories,
+                result_name: 'Intent'
+            };
+            const originalNode = {
+                uuid: 'test-node-uuid',
+                actions: [],
+                exits: []
+            };
+            const result = split_by_llm_categorize.fromFormData(formData, originalNode);
+            // Should process all categories provided (fromFormData doesn't enforce the limit, validation should)
+            const userCategories = result.router.categories.filter((cat) => cat.name !== 'Other' && cat.name !== 'Failure');
+            expect(userCategories).to.have.length(12);
+            // Note: The actual 10-category limit should be enforced by the UI validation
+            // which uses the maxItems: 10 property in the form configuration
+        });
+        it('preserves original node UUID', () => {
+            const formData = {
+                uuid: 'should-be-ignored',
+                llm: [{ value: 'llm-uuid-123', name: 'Claude' }],
+                input: '@input',
+                categories: [{ name: 'Test' }],
+                result_name: 'Intent'
+            };
+            const originalNode = {
+                uuid: 'original-node-uuid',
+                actions: [],
+                exits: []
+            };
+            const result = split_by_llm_categorize.fromFormData(formData, originalNode);
+            // Should use original node UUID, not the one from form data
+            expect(result.uuid).to.equal('original-node-uuid');
+        });
+    });
+    describe('validation', () => {
+        it('should validate duplicate category names', () => {
+            const formData = {
+                uuid: 'test-node-uuid',
+                llm: [{ value: 'llm-uuid-123', name: 'Claude' }],
+                input: '@input',
+                categories: [
+                    { name: 'Category1' },
+                    { name: 'Category2' },
+                    { name: 'Category1' }, // duplicate
+                    { name: 'category2' }, // case insensitive duplicate
+                    { name: 'Category3' }
+                ]
+            };
+            const validationResult = split_by_llm_categorize.validate(formData);
+            expect(validationResult.valid).to.be.false;
+            expect(validationResult.errors.categories).to.include('Duplicate category names found');
+            expect(validationResult.errors.categories).to.include('Category1');
+            expect(validationResult.errors.categories).to.include('Category2');
+            expect(validationResult.errors.categories).to.include('category2');
+        });
+        it('should pass validation with unique category names', () => {
+            const formData = {
+                uuid: 'test-node-uuid',
+                llm: [{ value: 'llm-uuid-123', name: 'Claude' }],
+                input: '@input',
+                categories: [
+                    { name: 'Category1' },
+                    { name: 'Category2' },
+                    { name: 'Category3' }
+                ]
+            };
+            const validationResult = split_by_llm_categorize.validate(formData);
+            expect(validationResult.valid).to.be.true;
+            expect(Object.keys(validationResult.errors)).to.have.length(0);
+        });
+        it('should ignore empty categories in validation', () => {
+            const formData = {
+                uuid: 'test-node-uuid',
+                llm: [{ value: 'llm-uuid-123', name: 'Claude' }],
+                input: '@input',
+                categories: [
+                    { name: 'Category1' },
+                    { name: '' }, // empty
+                    { name: '   ' }, // whitespace only
+                    { name: 'Category2' }
+                ]
+            };
+            const validationResult = split_by_llm_categorize.validate(formData);
+            expect(validationResult.valid).to.be.true;
+            expect(Object.keys(validationResult.errors)).to.have.length(0);
+        });
+    });
+    describe('JSON output verification', () => {
+        it('generates JSON matching the exact format from the issue', () => {
+            const formData = {
+                uuid: '145eb3d3-b841-4e66-abac-297ae525c7ad',
+                llm: [
+                    { value: '1c06c884-39dd-4ce4-ad9f-9a01cbe6c000', name: 'Claude' }
+                ],
+                input: '@input',
+                categories: [{ name: 'Flights' }, { name: 'Hotels' }],
+                result_name: 'Intent'
+            };
+            const originalNode = {
+                uuid: '145eb3d3-b841-4e66-abac-297ae525c7ad',
+                actions: [],
+                exits: []
+            };
+            const result = split_by_llm_categorize.fromFormData(formData, originalNode);
+            // Verify the call_llm action
+            const callLlmAction = result.actions[0];
+            expect(callLlmAction.type).to.equal('call_llm');
+            expect(callLlmAction.llm.uuid).to.equal('1c06c884-39dd-4ce4-ad9f-9a01cbe6c000');
+            expect(callLlmAction.llm.name).to.equal('Claude');
+            expect(callLlmAction.instructions).to.equal('@(prompt("categorize", slice(node.categories, 0, -2)))');
+            expect(callLlmAction.input).to.equal('@input');
+            expect(callLlmAction.output_local).to.equal('_llm_output');
+            // Verify the router structure
+            const router = result.router;
+            expect(router.type).to.equal('switch');
+            expect(router.operand).to.equal('@locals._llm_output');
+            // Verify categories structure
+            expect(router.categories).to.have.length(4);
+            const categoryNames = router.categories.map((cat) => cat.name);
+            expect(categoryNames).to.include.members([
+                'Flights',
+                'Hotels',
+                'Other',
+                'Failure'
+            ]);
+            // Verify cases structure
+            expect(router.cases).to.have.length(3);
+            const caseArguments = router.cases.map((c) => c.arguments[0]);
+            expect(caseArguments).to.include.members([
+                'Flights',
+                'Hotels',
+                '<ERROR>'
+            ]);
+            // Verify all cases use has_only_text
+            router.cases.forEach((caseItem) => {
+                expect(caseItem.type).to.equal('has_only_text');
+            });
+            // Verify exits match categories
+            expect(result.exits).to.have.length(4);
+            router.categories.forEach((category) => {
+                const matchingExit = result.exits.find((exit) => exit.uuid === category.exit_uuid);
+                expect(matchingExit).to.exist;
+            });
+            // Verify default category is "Other"
+            const otherCategory = router.categories.find((cat) => cat.name === 'Other');
+            expect(router.default_category_uuid).to.equal(otherCategory.uuid);
+        });
+    });
+});
+//# sourceMappingURL=split_by_llm_categorize.test.js.map