genai-lite 0.4.0 → 0.4.2

package/dist/prompting/content.test.js

@@ -1,212 +0,0 @@
-"use strict";
-/**
- * Tests for content preparation utilities
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const content_1 = require("./content");
-describe('Content Utilities', () => {
-    describe('countTokens', () => {
-        it('should return 0 for empty string', () => {
-            expect((0, content_1.countTokens)('')).toBe(0);
-        });
-        it('should count tokens for simple text', () => {
-            const text = 'Hello, world!';
-            const count = (0, content_1.countTokens)(text);
-            expect(count).toBeGreaterThan(0);
-            expect(count).toBeLessThan(text.length); // Tokens are typically fewer than characters
-        });
-        it('should count tokens with default gpt-4 model', () => {
-            const text = 'The quick brown fox jumps over the lazy dog';
-            const count = (0, content_1.countTokens)(text);
-            expect(count).toBeGreaterThan(0);
-        });
-        it('should count tokens with different models', () => {
-            const text = 'Testing different models';
-            const gpt4Count = (0, content_1.countTokens)(text, 'gpt-4');
-            const gpt35Count = (0, content_1.countTokens)(text, 'gpt-3.5-turbo');
-            expect(gpt4Count).toBeGreaterThan(0);
-            expect(gpt35Count).toBeGreaterThan(0);
-        });
-        it('should handle special characters and emojis', () => {
-            const text = '🚀 Special chars: @#$% and \n\t newlines';
-            const count = (0, content_1.countTokens)(text);
-            expect(count).toBeGreaterThan(0);
-        });
-        it('should fallback to estimate for invalid model', () => {
-            const text = 'Test fallback behavior';
-            const count = (0, content_1.countTokens)(text, 'invalid-model');
-            // Should fallback to length/4 estimate
-            expect(count).toBe(Math.ceil(text.length / 4));
-        });
-        it('should handle very long text', () => {
-            const longText = 'a'.repeat(10000);
-            const count = (0, content_1.countTokens)(longText);
-            expect(count).toBeGreaterThan(0);
-            expect(count).toBeLessThan(longText.length);
-        });
-    });
-    describe('getSmartPreview', () => {
-        const config = { minLines: 5, maxLines: 10 };
-        it('should return full content if shorter than maxLines', () => {
-            const content = 'Line 1\nLine 2\nLine 3';
-            const preview = (0, content_1.getSmartPreview)(content, config);
-            expect(preview).toBe(content);
-        });
-        it('should truncate at maxLines if no empty lines found', () => {
-            const lines = Array.from({ length: 20 }, (_, i) => `Line ${i + 1}`);
-            const content = lines.join('\n');
-            const preview = (0, content_1.getSmartPreview)(content, config);
-            const previewLines = preview.split('\n');
-            // Should extend up to maxLines when no empty lines are found
-            expect(previewLines.length).toBe(config.maxLines + 1); // +1 for truncation message
-            expect(preview).toContain('... (content truncated)');
-        });
-        it('should extend to next empty line within maxLines', () => {
-            const content = `Line 1
-Line 2
-Line 3
-Line 4
-Line 5
-Line 6
-
-Line 8
-Line 9
-Line 10
-Line 11`;
-            const preview = (0, content_1.getSmartPreview)(content, config);
-            const previewLines = preview.split('\n');
-            // Should include up to line 7 (the empty line)
-            expect(previewLines[6]).toBe('');
-            expect(preview).toContain('... (content truncated)');
-        });
-        it('should handle content exactly at maxLines', () => {
-            const lines = Array.from({ length: config.maxLines }, (_, i) => `Line ${i + 1}`);
-            const content = lines.join('\n');
-            const preview = (0, content_1.getSmartPreview)(content, config);
-            expect(preview).toBe(content);
-        });
-        it('should handle empty content', () => {
-            const preview = (0, content_1.getSmartPreview)('', config);
-            expect(preview).toBe('');
-        });
-        it('should handle content with multiple consecutive empty lines', () => {
-            const content = `Line 1
-Line 2
-
-
-Line 5
-Line 6
-
-Line 8
-Line 9
-Line 10
-Line 11`;
-            const preview = (0, content_1.getSmartPreview)(content, config);
-            const previewLines = preview.split('\n');
-            // Should stop at first empty line after minLines
-            expect(previewLines.length).toBeLessThanOrEqual(config.maxLines + 1);
-            expect(preview).toContain('... (content truncated)');
-        });
-        it('should respect maxLines limit even with empty lines', () => {
-            const lines = Array.from({ length: 15 }, (_, i) => i % 3 === 0 ? '' : `Line ${i + 1}`);
-            const content = lines.join('\n');
-            const preview = (0, content_1.getSmartPreview)(content, config);
-            const previewLines = preview.split('\n');
-            expect(previewLines.length).toBeLessThanOrEqual(config.maxLines + 1);
-        });
-    });
-    describe('extractRandomVariables', () => {
-        it('should extract and flatten random variables', () => {
-            const content = `
-        <RANDOM_GREETING>Hello</RANDOM_GREETING>
-        <RANDOM_GREETING>Hi</RANDOM_GREETING>
-        <RANDOM_GREETING>Hey</RANDOM_GREETING>
-        <RANDOM_FAREWELL>Goodbye</RANDOM_FAREWELL>
-        <RANDOM_FAREWELL>See you</RANDOM_FAREWELL>
-      `;
-            const result = (0, content_1.extractRandomVariables)(content, { maxPerTag: 3 });
-            // Check that we have the right keys
-            expect(Object.keys(result)).toContain('random_greeting_1');
-            expect(Object.keys(result)).toContain('random_greeting_2');
-            expect(Object.keys(result)).toContain('random_greeting_3');
-            expect(Object.keys(result)).toContain('random_farewell_1');
-            expect(Object.keys(result)).toContain('random_farewell_2');
-            expect(Object.keys(result)).toContain('random_farewell_3');
-            // Check that values are from the original set (order is random)
-            const greetings = [result.random_greeting_1, result.random_greeting_2, result.random_greeting_3];
-            expect(greetings).toContain('Hello');
-            expect(greetings).toContain('Hi');
-            expect(greetings).toContain('Hey');
-            const farewells = [result.random_farewell_1, result.random_farewell_2];
-            expect(farewells).toContain('Goodbye');
-            expect(farewells).toContain('See you');
-            // Third farewell should be empty
-            expect(result.random_farewell_3).toBe('');
-        });
-        it('should respect maxPerTag option', () => {
-            const content = `
-        <RANDOM_EXAMPLE>Example 1</RANDOM_EXAMPLE>
-        <RANDOM_EXAMPLE>Example 2</RANDOM_EXAMPLE>
-        <RANDOM_EXAMPLE>Example 3</RANDOM_EXAMPLE>
-        <RANDOM_EXAMPLE>Example 4</RANDOM_EXAMPLE>
-        <RANDOM_EXAMPLE>Example 5</RANDOM_EXAMPLE>
-      `;
-            const result = (0, content_1.extractRandomVariables)(content, { maxPerTag: 2 });
-            expect(Object.keys(result)).toHaveLength(2);
-            expect(result.random_example_1).toBeTruthy();
-            expect(result.random_example_2).toBeTruthy();
-            expect(result.random_example_3).toBeUndefined();
-        });
-        it('should handle content with no random tags', () => {
-            const content = 'This is just regular content without any random tags.';
-            const result = (0, content_1.extractRandomVariables)(content);
-            expect(result).toEqual({});
-        });
-        it('should handle multiple tag types', () => {
-            const content = `
-        <RANDOM_COLOR>red</RANDOM_COLOR>
-        <RANDOM_COLOR>blue</RANDOM_COLOR>
-        <RANDOM_ANIMAL>cat</RANDOM_ANIMAL>
-        <RANDOM_ANIMAL>dog</RANDOM_ANIMAL>
-        <RANDOM_FOOD>pizza</RANDOM_FOOD>
-      `;
-            const result = (0, content_1.extractRandomVariables)(content, { maxPerTag: 2 });
-            // Check we have entries for each type
-            expect(Object.keys(result)).toContain('random_color_1');
-            expect(Object.keys(result)).toContain('random_color_2');
-            expect(Object.keys(result)).toContain('random_animal_1');
-            expect(Object.keys(result)).toContain('random_animal_2');
-            expect(Object.keys(result)).toContain('random_food_1');
-            expect(Object.keys(result)).toContain('random_food_2');
-            // Check food has one value and one empty
-            expect(result.random_food_1).toBe('pizza');
-            expect(result.random_food_2).toBe('');
-        });
-        it('should use default maxPerTag of 30', () => {
-            const content = '<RANDOM_TEST>value</RANDOM_TEST>';
-            const result = (0, content_1.extractRandomVariables)(content);
-            // Should have 30 entries
-            expect(Object.keys(result)).toHaveLength(30);
-            expect(result.random_test_1).toBe('value');
-            expect(result.random_test_30).toBe('');
-        });
-        it('should handle multiline content in random tags', () => {
-            const content = `
-        <RANDOM_EXAMPLE>
-          This is a multiline
-          example with several
-          lines of text
-        </RANDOM_EXAMPLE>
-        <RANDOM_EXAMPLE>Single line</RANDOM_EXAMPLE>
-      `;
-            const result = (0, content_1.extractRandomVariables)(content, { maxPerTag: 2 });
-            const values = [result.random_example_1, result.random_example_2];
-            expect(values).toContain('Single line');
-            expect(values.some(v => v.includes('multiline'))).toBe(true);
-        });
-        it('should handle empty string input', () => {
-            const result = (0, content_1.extractRandomVariables)('');
-            expect(result).toEqual({});
-        });
-    });
-});

package/dist/prompting/parser.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * Tests for response parsing utilities
- */
-export {};

package/dist/prompting/parser.test.js

@@ -1,464 +0,0 @@
-"use strict";
-/**
- * Tests for response parsing utilities
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const parser_1 = require("./parser");
-describe('parseStructuredContent', () => {
-    it('should parse properly closed tags', () => {
-        const content = `
-      <THOUGHT>I need to analyze this problem</THOUGHT>
-      <PLAN>First, I'll break it down into steps</PLAN>
-      <CODE>console.log('Hello, world!');</CODE>
-    `;
-        const result = (0, parser_1.parseStructuredContent)(content, ['THOUGHT', 'PLAN', 'CODE']);
-        expect(result.THOUGHT).toBe('I need to analyze this problem');
-        expect(result.PLAN).toBe("First, I'll break it down into steps");
-        expect(result.CODE).toBe("console.log('Hello, world!');");
-    });
-    it('should handle unclosed tags', () => {
-        const content = `
-      <FIRST>Content 1
-      <SECOND>Content 2
-      <THIRD>Content 3
-    `;
-        const result = (0, parser_1.parseStructuredContent)(content, ['FIRST', 'SECOND', 'THIRD']);
-        expect(result.FIRST).toBe('Content 1');
-        expect(result.SECOND).toBe('Content 2');
-        expect(result.THIRD).toBe('Content 3');
-    });
-    it('should handle missing tags', () => {
-        const content = `
-      <PRESENT>This tag exists</PRESENT>
-      Some other content here
-    `;
-        const result = (0, parser_1.parseStructuredContent)(content, ['PRESENT', 'MISSING', 'ALSOBISSING']);
-        expect(result.PRESENT).toBe('This tag exists');
-        expect(result.MISSING).toBe('');
-        expect(result.ALSOBISSING).toBe('');
-    });
-    it('should handle extra text outside tags', () => {
-        const content = `
-      Some preamble text
-      <TAG1>Content 1</TAG1>
-      Some middle text
-      <TAG2>Content 2</TAG2>
-      Some ending text
-    `;
-        const result = (0, parser_1.parseStructuredContent)(content, ['TAG1', 'TAG2']);
-        expect(result.TAG1).toBe('Content 1');
-        expect(result.TAG2).toBe('Content 2');
-    });
-    it('should extract content up to the next tag for unclosed tags', () => {
-        const content = `
-      <STEP1>First step content
-      <STEP2>Second step content
-      <STEP3>Third step content</STEP3>
-    `;
-        const result = (0, parser_1.parseStructuredContent)(content, ['STEP1', 'STEP2', 'STEP3']);
-        expect(result.STEP1).toBe('First step content');
-        expect(result.STEP2).toBe('Second step content');
-        expect(result.STEP3).toBe('Third step content');
-    });
-    it('should handle empty tag array', () => {
-        const content = '<TAG>Some content</TAG>';
-        const result = (0, parser_1.parseStructuredContent)(content, []);
-        expect(result).toEqual({});
-    });
-    it('should handle multiline content with code', () => {
-        const content = `
-      <ANALYSIS>
-        The code has several issues:
-        1. Memory leak
-        2. Performance problems
-      </ANALYSIS>
-      <SOLUTION>
-        function fixed() {
-          // Clean up resources
-          return result;
-        }
-      </SOLUTION>
-    `;
-        const result = (0, parser_1.parseStructuredContent)(content, ['ANALYSIS', 'SOLUTION']);
-        expect(result.ANALYSIS).toContain('Memory leak');
-        expect(result.ANALYSIS).toContain('Performance problems');
-        expect(result.SOLUTION).toContain('function fixed()');
-        expect(result.SOLUTION).toContain('Clean up resources');
-    });
-    it('should handle tags that appear multiple times (only first occurrence)', () => {
-        const content = `
-      <ITEM>First item</ITEM>
-      <ITEM>Second item</ITEM>
-      <ITEM>Third item</ITEM>
-    `;
-        const result = (0, parser_1.parseStructuredContent)(content, ['ITEM']);
-        expect(result.ITEM).toBe('First item');
-    });
-    it('should preserve order of extraction based on tags array', () => {
-        const content = `
-      <LAST>Last content</LAST>
-      <MIDDLE>Middle content</MIDDLE>
-      <FIRST>First content</FIRST>
-    `;
-        const result = (0, parser_1.parseStructuredContent)(content, ['FIRST', 'MIDDLE', 'LAST']);
-        // Even though LAST appears first in content, it should still extract correctly
-        expect(result.FIRST).toBe('First content');
-        expect(result.MIDDLE).toBe('Middle content');
-        expect(result.LAST).toBe('Last content');
-    });
-    it('should handle empty content', () => {
-        const result = (0, parser_1.parseStructuredContent)('', ['TAG1', 'TAG2']);
-        expect(result).toEqual({
-            TAG1: '',
-            TAG2: ''
-        });
-    });
-});
-describe('extractInitialTaggedContent', () => {
-    it('should extract content from a tag at the beginning', () => {
-        const content = '<thinking>I am thinking about this problem.</thinking>Here is the answer.';
-        const result = (0, parser_1.extractInitialTaggedContent)(content, 'thinking');
-        expect(result.extracted).toBe('I am thinking about this problem.');
-        expect(result.remaining).toBe('Here is the answer.');
-    });
-    it('should handle leading whitespace', () => {
-        const content = '  \n  <thinking>My thoughts here</thinking>The actual response';
-        const result = (0, parser_1.extractInitialTaggedContent)(content, 'thinking');
-        expect(result.extracted).toBe('My thoughts here');
-        expect(result.remaining).toBe('The actual response');
-    });
-    it('should not extract when tag is in the middle', () => {
-        const content = 'Some preamble <thinking>This is in the middle</thinking> and more text';
-        const result = (0, parser_1.extractInitialTaggedContent)(content, 'thinking');
-        expect(result.extracted).toBeNull();
-        expect(result.remaining).toBe('Some preamble <thinking>This is in the middle</thinking> and more text');
-    });
-    it('should handle no tag present', () => {
-        const content = 'This is just regular text without any special tags.';
-        const result = (0, parser_1.extractInitialTaggedContent)(content, 'thinking');
-        expect(result.extracted).toBeNull();
-        expect(result.remaining).toBe('This is just regular text without any special tags.');
-    });
-    it('should work with different tag names', () => {
-        const content = '<scratchpad>Working through the logic...</scratchpad>Final answer is 42.';
-        const result = (0, parser_1.extractInitialTaggedContent)(content, 'scratchpad');
-        expect(result.extracted).toBe('Working through the logic...');
-        expect(result.remaining).toBe('Final answer is 42.');
-    });
-    it('should handle unclosed tag at start', () => {
-        const content = '<thinking>This tag is never closed and continues...';
-        const result = (0, parser_1.extractInitialTaggedContent)(content, 'thinking');
-        expect(result.extracted).toBeNull();
-        expect(result.remaining).toBe('<thinking>This tag is never closed and continues...');
-    });
-    it('should handle multiline content within tags', () => {
-        const content = `<thinking>
-      Step 1: Analyze the problem
-      Step 2: Break it down
-      Step 3: Solve each part
-    </thinking>
-    The solution is to approach it systematically.`;
-        const result = (0, parser_1.extractInitialTaggedContent)(content, 'thinking');
-        expect(result.extracted).toBe(`Step 1: Analyze the problem
-      Step 2: Break it down
-      Step 3: Solve each part`);
-        expect(result.remaining).toBe('The solution is to approach it systematically.');
-    });
-    it('should handle empty tag', () => {
-        const content = '<thinking></thinking>Here is the response.';
-        const result = (0, parser_1.extractInitialTaggedContent)(content, 'thinking');
-        expect(result.extracted).toBe('');
-        expect(result.remaining).toBe('Here is the response.');
-    });
-    it('should handle empty content', () => {
-        const result = (0, parser_1.extractInitialTaggedContent)('', 'thinking');
-        expect(result.extracted).toBeNull();
-        expect(result.remaining).toBe('');
-    });
-    it('should preserve whitespace after the closing tag', () => {
-        const content = '<thinking>Thoughts</thinking>   \n\n   Response here';
-        const result = (0, parser_1.extractInitialTaggedContent)(content, 'thinking');
-        expect(result.extracted).toBe('Thoughts');
-        expect(result.remaining).toBe('Response here');
-    });
-});
-describe('parseRoleTags', () => {
-    it('should parse basic role tags with variables', () => {
-        const template = `
-      <SYSTEM>You are a helpful {{expertise}} assistant.</SYSTEM>
-      <USER>Help me with {{task}}</USER>
-      <ASSISTANT>I'll help you with {{task}}.</ASSISTANT>
-    `;
-        const result = (0, parser_1.parseRoleTags)(template);
-        expect(result).toEqual([
-            { role: 'system', content: 'You are a helpful {{expertise}} assistant.' },
-            { role: 'user', content: 'Help me with {{task}}' },
-            { role: 'assistant', content: "I'll help you with {{task}}." }
-        ]);
-    });
-    it('should handle multiple user/assistant turns', () => {
-        const template = `
-      <USER>First question</USER>
-      <ASSISTANT>First answer</ASSISTANT>
-      <USER>Follow-up question</USER>
-      <ASSISTANT>Follow-up answer</ASSISTANT>
-    `;
-        const result = (0, parser_1.parseRoleTags)(template);
-        expect(result).toEqual([
-            { role: 'user', content: 'First question' },
-            { role: 'assistant', content: 'First answer' },
-            { role: 'user', content: 'Follow-up question' },
-            { role: 'assistant', content: 'Follow-up answer' }
-        ]);
-    });
-    it('should handle template with only system message', () => {
-        const template = '<SYSTEM>You are a coding assistant.</SYSTEM>';
-        const result = (0, parser_1.parseRoleTags)(template);
-        expect(result).toEqual([
-            { role: 'system', content: 'You are a coding assistant.' }
-        ]);
-    });
-    it('should treat content without tags as user message', () => {
-        const template = 'Hello, can you help me with {{problem}}?';
-        const result = (0, parser_1.parseRoleTags)(template);
-        expect(result).toEqual([
-            { role: 'user', content: 'Hello, can you help me with {{problem}}?' }
-        ]);
-    });
-    it('should handle empty template', () => {
-        const result = (0, parser_1.parseRoleTags)('');
-        expect(result).toEqual([]);
-    });
-    it('should handle whitespace-only template', () => {
-        const result = (0, parser_1.parseRoleTags)('   \n\t   ');
-        expect(result).toEqual([]);
-    });
-    it('should preserve multiline content', () => {
-        const template = `<USER>
-      Please help me with:
-      1. {{task1}}
-      2. {{task2}}
-      3. {{task3}}
-    </USER>`;
-        const result = (0, parser_1.parseRoleTags)(template);
-        expect(result).toEqual([
-            { role: 'user', content: 'Please help me with:\n      1. {{task1}}\n      2. {{task2}}\n      3. {{task3}}' }
-        ]);
-    });
-    it('should ignore empty role tags', () => {
-        const template = `
-      <SYSTEM>System prompt</SYSTEM>
-      <USER></USER>
-      <ASSISTANT>   </ASSISTANT>
-      <USER>Real question</USER>
-    `;
-        const result = (0, parser_1.parseRoleTags)(template);
-        expect(result).toEqual([
-            { role: 'system', content: 'System prompt' },
-            { role: 'user', content: 'Real question' }
-        ]);
-    });
-    it('should handle mixed case tags', () => {
-        const template = '<System>System</System><User>User</User><Assistant>Assistant</Assistant>';
-        const result = (0, parser_1.parseRoleTags)(template);
-        // Should only match uppercase tags as per the regex
-        expect(result).toEqual([
-            { role: 'user', content: '<System>System</System><User>User</User><Assistant>Assistant</Assistant>' }
-        ]);
-    });
-    it('should handle complex templates with conditionals', () => {
-        const template = `
-      <SYSTEM>{{ systemPrompt ? systemPrompt : 'Default system prompt' }}</SYSTEM>
-      <USER>{{ hasContext ? 'Context: {{context}}\n\n' : '' }}{{question}}</USER>
-    `;
-        const result = (0, parser_1.parseRoleTags)(template);
-        expect(result).toEqual([
-            { role: 'system', content: "{{ systemPrompt ? systemPrompt : 'Default system prompt' }}" },
-            { role: 'user', content: "{{ hasContext ? 'Context: {{context}}\n\n' : '' }}{{question}}" }
-        ]);
-    });
-    it('should preserve special characters and formatting', () => {
-        const template = `
-      <USER>Code: \`{{code}}\`
-      
-      Error: "{{error}}"</USER>
-      <ASSISTANT>Let me analyze that code...</ASSISTANT>
-    `;
-        const result = (0, parser_1.parseRoleTags)(template);
-        expect(result).toEqual([
-            { role: 'user', content: 'Code: `{{code}}`\n      \n      Error: "{{error}}"' },
-            { role: 'assistant', content: 'Let me analyze that code...' }
-        ]);
-    });
-    it('should handle unclosed tags as regular content', () => {
-        const template = 'This has <USER>unclosed tag content';
-        const result = (0, parser_1.parseRoleTags)(template);
-        expect(result).toEqual([
-            { role: 'user', content: 'This has <USER>unclosed tag content' }
-        ]);
-    });
-    it('should handle nested-looking structures', () => {
-        const template = `<USER>Can you parse <XML>tags</XML> inside content?</USER>`;
-        const result = (0, parser_1.parseRoleTags)(template);
-        expect(result).toEqual([
-            { role: 'user', content: 'Can you parse <XML>tags</XML> inside content?' }
-        ]);
-    });
-    it('should throw error for non-string input', () => {
-        expect(() => (0, parser_1.parseRoleTags)(null)).toThrow('Template must be a string');
-        expect(() => (0, parser_1.parseRoleTags)(undefined)).toThrow('Template must be a string');
-        expect(() => (0, parser_1.parseRoleTags)(123)).toThrow('Template must be a string');
-    });
-    it('should handle text between role tags', () => {
-        const template = `
-      Some intro text
-      <SYSTEM>System message</SYSTEM>
-      Some middle text that should be ignored
-      <USER>User message</USER>
-      Some ending text
-    `;
-        const result = (0, parser_1.parseRoleTags)(template);
-        expect(result).toEqual([
-            { role: 'system', content: 'System message' },
-            { role: 'user', content: 'User message' }
-        ]);
-    });
-});
-describe('parseTemplateWithMetadata', () => {
-    it('should parse template with valid META block', () => {
-        const template = `<META>
-{
-  "settings": {
-    "temperature": 0.9,
-    "thinkingExtraction": { "enabled": true, "tag": "reasoning" }
-  }
-}
-</META>
-<SYSTEM>You are a creative writer.</SYSTEM>
-<USER>Write a story</USER>`;
-        const result = (0, parser_1.parseTemplateWithMetadata)(template);
-        expect(result.metadata).toEqual({
-            settings: {
-                temperature: 0.9,
-                thinkingExtraction: { enabled: true, tag: "reasoning" }
-            }
-        });
-        expect(result.content).toBe('<SYSTEM>You are a creative writer.</SYSTEM>\n<USER>Write a story</USER>');
-    });
-    it('should handle template without META block', () => {
-        const template = `<SYSTEM>You are a helpful assistant.</SYSTEM>
-<USER>Help me understand TypeScript</USER>`;
-        const result = (0, parser_1.parseTemplateWithMetadata)(template);
-        expect(result.metadata).toEqual({ settings: {} });
-        expect(result.content).toBe(template);
-    });
-    it('should handle invalid JSON in META block', () => {
-        const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
-        const template = `<META>
-{
-  "settings": {
-    "temperature": 0.9,
-    invalid json here
-  }
-}
-</META>
-<SYSTEM>Test</SYSTEM>`;
-        const result = (0, parser_1.parseTemplateWithMetadata)(template);
-        expect(result.metadata).toEqual({ settings: {} });
-        expect(result.content).toBe(template); // Original template returned on error
-        expect(consoleWarnSpy).toHaveBeenCalledWith('Could not parse <META> block in template. Treating it as content.', expect.any(Error));
-        consoleWarnSpy.mockRestore();
-    });
-    it('should handle META block with missing settings', () => {
-        const template = `<META>
-{
-  "name": "My Template",
-  "version": "1.0"
-}
-</META>
-<USER>Hello</USER>`;
-        const result = (0, parser_1.parseTemplateWithMetadata)(template);
-        expect(result.metadata).toEqual({ settings: {} });
-        expect(result.content).toBe('<USER>Hello</USER>');
-    });
-    it('should handle META block with non-object settings', () => {
-        const template = `<META>
-{
-  "settings": "not an object"
-}
-</META>
-<USER>Test</USER>`;
-        const result = (0, parser_1.parseTemplateWithMetadata)(template);
-        expect(result.metadata).toEqual({ settings: {} });
-        expect(result.content).toBe('<USER>Test</USER>');
-    });
-    it('should handle empty META block', () => {
-        const template = `<META></META>
-<USER>Test</USER>`;
-        const result = (0, parser_1.parseTemplateWithMetadata)(template);
-        expect(result.metadata).toEqual({ settings: {} });
-        expect(result.content).toBe('<USER>Test</USER>');
-    });
-    it('should handle META block with whitespace', () => {
-        const template = `  <META>
-    {
-      "settings": {
-        "temperature": 0.5
-      }
-    }
-  </META>  
-  <SYSTEM>Assistant</SYSTEM>`;
-        const result = (0, parser_1.parseTemplateWithMetadata)(template);
-        expect(result.metadata).toEqual({
-            settings: { temperature: 0.5 }
-        });
-        expect(result.content).toBe('<SYSTEM>Assistant</SYSTEM>');
-    });
-    it('should handle complex settings in META block', () => {
-        const template = `<META>
-{
-  "settings": {
-    "temperature": 0.8,
-    "maxTokens": 2000,
-    "stopSequences": ["\\n\\n", "END"],
-    "reasoning": {
-      "enabled": true,
-      "effort": "high",
-      "maxTokens": 5000
-    },
-    "thinkingExtraction": {
-      "enabled": false
-    }
-  }
-}
-</META>
-<SYSTEM>Complex template</SYSTEM>`;
-        const result = (0, parser_1.parseTemplateWithMetadata)(template);
-        expect(result.metadata.settings).toEqual({
-            temperature: 0.8,
-            maxTokens: 2000,
-            stopSequences: ["\n\n", "END"],
-            reasoning: {
-                enabled: true,
-                effort: "high",
-                maxTokens: 5000
-            },
-            thinkingExtraction: {
-                enabled: false
-            }
-        });
-    });
-    it('should only parse META at the beginning of the template', () => {
-        const template = `<USER>Some content</USER>
-<META>
-{
-  "settings": { "temperature": 0.5 }
-}
-</META>
-<USER>More content</USER>`;
-        const result = (0, parser_1.parseTemplateWithMetadata)(template);
-        // META block not at start, so it's not parsed
-        expect(result.metadata).toEqual({ settings: {} });
-        expect(result.content).toBe(template);
-    });
-});

package/dist/prompting/template.test.d.ts

@@ -1 +0,0 @@
-export {};