genai-lite 0.2.0 → 0.3.0

package/dist/prompting/parser.test.js

@@ -114,3 +114,351 @@ describe('parseStructuredContent', () => {
         });
     });
 });
+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.d.ts

@@ -12,9 +12,17 @@
  * - Simple variable substitution: {{ variableName }}
  * - Conditional rendering: {{ condition ? `true result` : `false result` }}
  * - Conditional with only true branch: {{ condition ? `true result` }}
+ * - Logical operators in conditions:
+ *   - NOT: {{ !isDisabled ? `enabled` : `disabled` }}
+ *   - AND: {{ hasPermission && isActive ? `show` : `hide` }}
+ *   - OR: {{ isAdmin || isOwner ? `allow` : `deny` }}
+ *   - Combined: {{ !isDraft && isPublished ? `public` : `private` }}
  * - Multi-line strings in backticks
  * - Intelligent newline handling (removes empty lines when result is empty)
  *
+ * Note: Logical operators support up to 2 operands. Complex expressions
+ * (parentheses, mixing && and ||, or 3+ operands) are not supported.
+ *
  * @param template The template string containing placeholders
  * @param variables Object containing variable values
  * @returns The rendered template string

package/dist/prompting/template.js

@@ -15,9 +15,17 @@ exports.renderTemplate = renderTemplate;
  * - Simple variable substitution: {{ variableName }}
  * - Conditional rendering: {{ condition ? `true result` : `false result` }}
  * - Conditional with only true branch: {{ condition ? `true result` }}
+ * - Logical operators in conditions:
+ *   - NOT: {{ !isDisabled ? `enabled` : `disabled` }}
+ *   - AND: {{ hasPermission && isActive ? `show` : `hide` }}
+ *   - OR: {{ isAdmin || isOwner ? `allow` : `deny` }}
+ *   - Combined: {{ !isDraft && isPublished ? `public` : `private` }}
  * - Multi-line strings in backticks
  * - Intelligent newline handling (removes empty lines when result is empty)
  *
+ * Note: Logical operators support up to 2 operands. Complex expressions
+ * (parentheses, mixing && and ||, or 3+ operands) are not supported.
+ *
  * @param template The template string containing placeholders
  * @param variables Object containing variable values
  * @returns The rendered template string
@@ -87,6 +95,53 @@ function renderTemplate(template, variables) {
     }
     return result;
 }
+/**
+ * Evaluates a condition string that may contain logical operators (&&, ||, !)
+ * Supports:
+ * - Simple variable: varName
+ * - Negation: !varName
+ * - AND: varName1 && varName2, !varName1 && varName2
+ * - OR: varName1 || varName2, !varName1 || varName2
+ *
+ * Does NOT support:
+ * - Parentheses for grouping
+ * - Mixing && and || in same expression
+ * - More than 2 operands
+ */
+function evaluateCondition(condition, variables) {
+    condition = condition.trim();
+    // Check for AND operator
+    if (condition.includes('&&')) {
+        const parts = condition.split('&&').map(p => p.trim());
+        if (parts.length !== 2) {
+            // Fallback to simple variable lookup for complex expressions
+            return !!variables[condition];
+        }
+        return evaluateSimpleCondition(parts[0], variables) && evaluateSimpleCondition(parts[1], variables);
+    }
+    // Check for OR operator
+    if (condition.includes('||')) {
+        const parts = condition.split('||').map(p => p.trim());
+        if (parts.length !== 2) {
+            // Fallback to simple variable lookup for complex expressions
+            return !!variables[condition];
+        }
+        return evaluateSimpleCondition(parts[0], variables) || evaluateSimpleCondition(parts[1], variables);
+    }
+    // Simple condition (possibly with negation)
+    return evaluateSimpleCondition(condition, variables);
+}
+/**
+ * Evaluates a simple condition that may have a ! prefix
+ */
+function evaluateSimpleCondition(condition, variables) {
+    condition = condition.trim();
+    if (condition.startsWith('!')) {
+        const varName = condition.substring(1).trim();
+        return !variables[varName];
+    }
+    return !!variables[condition];
+}
 function processExpression(expression, variables, leadingNewline, trailingNewline) {
     const conditionalMarkerIndex = expression.indexOf('?');
     let result;
@@ -104,7 +159,7 @@ function processExpression(expression, variables, leadingNewline, trailingNewlin
     }
     else {
         // --- Conditional 'ternary' substitution ---
-        const conditionKey = expression.substring(0, conditionalMarkerIndex).trim();
+        const conditionStr = expression.substring(0, conditionalMarkerIndex).trim();
         const rest = expression.substring(conditionalMarkerIndex + 1).trim();
         // Parse ternary expression with backtick-delimited strings
         // We need to handle nested {{ }} within backticks
@@ -165,8 +220,31 @@ function processExpression(expression, variables, leadingNewline, trailingNewlin
             }
         }
         else {
-            // Fallback to old quote-based parsing for backward compatibility
-            const elseMarkerIndex = rest.indexOf(':');
+            // Fallback to quote-based parsing for backward compatibility
+            // Need to find the ':' that separates true/false parts, not one inside quotes
+            let elseMarkerIndex = -1;
+            let inSingleQuote = false;
+            let inDoubleQuote = false;
+            for (let i = 0; i < rest.length; i++) {
+                const char = rest[i];
+                const prevChar = i > 0 ? rest[i - 1] : '';
+                // Track quote state (ignoring escaped quotes)
+                if (char === "'" && prevChar !== '\\') {
+                    if (!inDoubleQuote) {
+                        inSingleQuote = !inSingleQuote;
+                    }
+                }
+                else if (char === '"' && prevChar !== '\\') {
+                    if (!inSingleQuote) {
+                        inDoubleQuote = !inDoubleQuote;
+                    }
+                }
+                else if (char === ':' && !inSingleQuote && !inDoubleQuote) {
+                    // Found the separator outside of quotes
+                    elseMarkerIndex = i;
+                    break;
+                }
+            }
             if (elseMarkerIndex === -1) {
                 trueText = rest;
             }
@@ -176,15 +254,20 @@ function processExpression(expression, variables, leadingNewline, trailingNewlin
             }
             // Remove quotes from the start and end of the text parts
             const unquote = (text) => {
-                if ((text.startsWith('"') && text.endsWith('"')) || (text.startsWith("'") && text.endsWith("'"))) {
-                    return text.slice(1, -1);
+                if (text.startsWith('"') && text.endsWith('"')) {
+                    // Remove the outer double quotes and unescape inner quotes
+                    return text.slice(1, -1).replace(/\\"/g, '"');
+                }
+                else if (text.startsWith("'") && text.endsWith("'")) {
+                    // Remove the outer single quotes and unescape inner quotes
+                    return text.slice(1, -1).replace(/\\'/g, "'");
                 }
                 return text;
             };
             trueText = unquote(trueText);
             falseText = unquote(falseText);
         }
-        const conditionValue = !!variables[conditionKey]; // Evaluate truthiness
+        const conditionValue = evaluateCondition(conditionStr, variables);
         result = conditionValue ? trueText : falseText;
         // Recursively process the result to handle nested variables
         if (result.includes('{{')) {

package/dist/prompting/template.test.js

@@ -131,4 +131,120 @@ End
         const result = (0, template_1.renderTemplate)(template, { any: 'value' });
         expect(result).toBe('Just plain text');
     });
+    describe('colon handling in quoted strings', () => {
+        it('should handle colon in double-quoted true branch', () => {
+            const template = '{{ isDraft ? "Note: This is a draft" : "Published" }}';
+            expect((0, template_1.renderTemplate)(template, { isDraft: true })).toBe('Note: This is a draft');
+            expect((0, template_1.renderTemplate)(template, { isDraft: false })).toBe('Published');
+        });
+        it('should handle colon in single-quoted true branch', () => {
+            const template = "{{ isDraft ? 'Note: This is a draft' : 'Published' }}";
+            expect((0, template_1.renderTemplate)(template, { isDraft: true })).toBe('Note: This is a draft');
+            expect((0, template_1.renderTemplate)(template, { isDraft: false })).toBe('Published');
+        });
+        it('should handle colon in both branches', () => {
+            const template = '{{ isDraft ? "Status: Draft" : "Status: Published" }}';
+            expect((0, template_1.renderTemplate)(template, { isDraft: true })).toBe('Status: Draft');
+            expect((0, template_1.renderTemplate)(template, { isDraft: false })).toBe('Status: Published');
+        });
+        it('should handle multiple colons in quoted strings', () => {
+            const template = '{{ showTime ? "Time: 10:30:45" : "Time: Not available" }}';
+            expect((0, template_1.renderTemplate)(template, { showTime: true })).toBe('Time: 10:30:45');
+            expect((0, template_1.renderTemplate)(template, { showTime: false })).toBe('Time: Not available');
+        });
+        it('should handle escaped quotes with colons', () => {
+            const template = '{{ useAdvanced ? "He said: \\"Hello\\"" : "Simple greeting" }}';
+            expect((0, template_1.renderTemplate)(template, { useAdvanced: true })).toBe('He said: "Hello"');
+        });
+        it('should handle mixed quote types', () => {
+            const template = `{{ showBoth ? "Bob's message: 'Hi there'" : 'Alice said: "Hello"' }}`;
+            expect((0, template_1.renderTemplate)(template, { showBoth: true })).toBe("Bob's message: 'Hi there'");
+            expect((0, template_1.renderTemplate)(template, { showBoth: false })).toBe('Alice said: "Hello"');
+        });
+        it('should handle URL-like strings with colons', () => {
+            const template = '{{ useHttps ? "https://example.com" : "http://example.com" }}';
+            expect((0, template_1.renderTemplate)(template, { useHttps: true })).toBe('https://example.com');
+            expect((0, template_1.renderTemplate)(template, { useHttps: false })).toBe('http://example.com');
+        });
+        it('should work with backtick syntax (regression test)', () => {
+            const template = '{{ isDraft ? `Note: This is a draft` : `Status: Published` }}';
+            expect((0, template_1.renderTemplate)(template, { isDraft: true })).toBe('Note: This is a draft');
+            expect((0, template_1.renderTemplate)(template, { isDraft: false })).toBe('Status: Published');
+        });
+        it('should handle no false branch with colon in true branch', () => {
+            const template = '{{ showNote ? "Note: Important information" }}';
+            expect((0, template_1.renderTemplate)(template, { showNote: true })).toBe('Note: Important information');
+            expect((0, template_1.renderTemplate)(template, { showNote: false })).toBe('');
+        });
+        it('should handle colons with logical operators', () => {
+            const template = '{{ isActive && hasAccess ? "Status: Active" : "Status: Inactive" }}';
+            expect((0, template_1.renderTemplate)(template, { isActive: true, hasAccess: true })).toBe('Status: Active');
+            expect((0, template_1.renderTemplate)(template, { isActive: false, hasAccess: true })).toBe('Status: Inactive');
+        });
+    });
+    describe('logical operators in conditions', () => {
+        it('should handle NOT operator (!)', () => {
+            const template = '{{ !isDisabled ? `Enabled` : `Disabled` }}';
+            expect((0, template_1.renderTemplate)(template, { isDisabled: false })).toBe('Enabled');
+            expect((0, template_1.renderTemplate)(template, { isDisabled: true })).toBe('Disabled');
+        });
+        it('should handle AND operator (&&)', () => {
+            const template = '{{ hasPermission && isActive ? `Show button` : `Hide button` }}';
+            expect((0, template_1.renderTemplate)(template, { hasPermission: true, isActive: true })).toBe('Show button');
+            expect((0, template_1.renderTemplate)(template, { hasPermission: true, isActive: false })).toBe('Hide button');
+            expect((0, template_1.renderTemplate)(template, { hasPermission: false, isActive: true })).toBe('Hide button');
+            expect((0, template_1.renderTemplate)(template, { hasPermission: false, isActive: false })).toBe('Hide button');
+        });
+        it('should handle OR operator (||)', () => {
+            const template = '{{ isAdmin || isOwner ? `Has access` : `No access` }}';
+            expect((0, template_1.renderTemplate)(template, { isAdmin: true, isOwner: false })).toBe('Has access');
+            expect((0, template_1.renderTemplate)(template, { isAdmin: false, isOwner: true })).toBe('Has access');
+            expect((0, template_1.renderTemplate)(template, { isAdmin: true, isOwner: true })).toBe('Has access');
+            expect((0, template_1.renderTemplate)(template, { isAdmin: false, isOwner: false })).toBe('No access');
+        });
+        it('should handle NOT with AND', () => {
+            const template = '{{ !isDraft && isPublished ? `Show public` : `Hide` }}';
+            expect((0, template_1.renderTemplate)(template, { isDraft: false, isPublished: true })).toBe('Show public');
+            expect((0, template_1.renderTemplate)(template, { isDraft: true, isPublished: true })).toBe('Hide');
+        });
+        it('should handle NOT with OR', () => {
+            const template = '{{ !isBlocked || isAdmin ? `Allow` : `Deny` }}';
+            expect((0, template_1.renderTemplate)(template, { isBlocked: false, isAdmin: false })).toBe('Allow');
+            expect((0, template_1.renderTemplate)(template, { isBlocked: true, isAdmin: true })).toBe('Allow');
+            expect((0, template_1.renderTemplate)(template, { isBlocked: true, isAdmin: false })).toBe('Deny');
+        });
+        it('should handle NOT on both sides of AND', () => {
+            const template = '{{ !isLoading && !hasError ? `Ready` : `Not ready` }}';
+            expect((0, template_1.renderTemplate)(template, { isLoading: false, hasError: false })).toBe('Ready');
+            expect((0, template_1.renderTemplate)(template, { isLoading: true, hasError: false })).toBe('Not ready');
+            expect((0, template_1.renderTemplate)(template, { isLoading: false, hasError: true })).toBe('Not ready');
+        });
+        it('should handle whitespace around operators', () => {
+            const template = '{{  !isDisabled   &&   isVisible  ?  `Show`  :  `Hide`  }}';
+            expect((0, template_1.renderTemplate)(template, { isDisabled: false, isVisible: true })).toBe('Show');
+        });
+        it('should handle undefined variables in logical expressions', () => {
+            const template = '{{ undefinedVar && definedVar ? `Both true` : `At least one false` }}';
+            expect((0, template_1.renderTemplate)(template, { definedVar: true })).toBe('At least one false');
+        });
+        it('should handle falsy values in logical expressions', () => {
+            const template = '{{ nullVar || zero ? `Has truthy` : `All falsy` }}';
+            expect((0, template_1.renderTemplate)(template, { nullVar: null, zero: 0 })).toBe('All falsy');
+            const template2 = '{{ emptyString || text ? `Has truthy` : `All falsy` }}';
+            expect((0, template_1.renderTemplate)(template2, { emptyString: '', text: 'hello' })).toBe('Has truthy');
+        });
+        it('should fallback to simple lookup for complex expressions', () => {
+            // More than 2 operands should fallback
+            const template = '{{ a && b && c ? `True` : `False` }}';
+            const result = (0, template_1.renderTemplate)(template, { 'a && b && c': true });
+            expect(result).toBe('True');
+        });
+        it('should handle nested templates with logical operators', () => {
+            const template = '{{ showDetails && hasData ? `Details: {{data}}` : `No details` }}';
+            expect((0, template_1.renderTemplate)(template, { showDetails: true, hasData: true, data: 'Important info' }))
+                .toBe('Details: Important info');
+            expect((0, template_1.renderTemplate)(template, { showDetails: false, hasData: true, data: 'Important info' }))
+                .toBe('No details');
+        });
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genai-lite",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "A lightweight, portable toolkit for interacting with various Generative AI APIs.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -38,7 +38,8 @@
     "build": "tsc",
     "test": "jest --coverage",
     "test:watch": "jest --watch",
-    "test:e2e": "npm run build && jest --config jest.e2e.config.js"
+    "test:e2e": "npm run build && jest --config jest.e2e.config.js",
+    "test:e2e:reasoning": "npm run build && jest --config jest.e2e.config.js reasoning.e2e.test.ts"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.56.0",