genai-lite 0.3.3 → 0.4.1

package/dist/llm/services/PresetManager.test.js

@@ -1,210 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const PresetManager_1 = require("./PresetManager");
-const presets_json_1 = __importDefault(require("../../config/presets.json"));
-describe('PresetManager', () => {
-    describe('Default behavior', () => {
-        it('should load default presets when no options provided', () => {
-            const manager = new PresetManager_1.PresetManager();
-            const presets = manager.getPresets();
-            expect(presets).toHaveLength(presets_json_1.default.length);
-            expect(presets).toEqual(expect.arrayContaining(presets_json_1.default.map(preset => expect.objectContaining({
-                id: preset.id,
-                displayName: preset.displayName,
-                providerId: preset.providerId,
-                modelId: preset.modelId
-            }))));
-        });
-        it('should return a copy of presets to prevent external modification', () => {
-            const manager = new PresetManager_1.PresetManager();
-            const presets1 = manager.getPresets();
-            const presets2 = manager.getPresets();
-            expect(presets1).not.toBe(presets2); // Different array instances
-            expect(presets1).toEqual(presets2); // Same content
-            // Modifying returned array should not affect service
-            presets1.push({
-                id: 'test-preset',
-                displayName: 'Test',
-                providerId: 'openai',
-                modelId: 'gpt-4',
-                settings: {}
-            });
-            const presets3 = manager.getPresets();
-            expect(presets3).toHaveLength(presets_json_1.default.length);
-        });
-    });
-    describe('Extend mode', () => {
-        it('should add new presets to defaults in extend mode', () => {
-            const customPresets = [
-                {
-                    id: 'custom-preset-1',
-                    displayName: 'Custom Preset 1',
-                    providerId: 'openai',
-                    modelId: 'gpt-4',
-                    settings: { temperature: 0.5 }
-                }
-            ];
-            const manager = new PresetManager_1.PresetManager(customPresets, 'extend');
-            const presets = manager.getPresets();
-            expect(presets).toHaveLength(presets_json_1.default.length + 1);
-            expect(presets).toContainEqual(expect.objectContaining({
-                id: 'custom-preset-1',
-                displayName: 'Custom Preset 1'
-            }));
-        });
-        it('should override default presets with same ID in extend mode', () => {
-            const existingPresetId = presets_json_1.default[0].id;
-            const customPresets = [
-                {
-                    id: existingPresetId,
-                    displayName: 'Overridden Preset',
-                    providerId: 'anthropic',
-                    modelId: 'claude-3-5-sonnet-20241022',
-                    settings: { temperature: 0.8 }
-                }
-            ];
-            const manager = new PresetManager_1.PresetManager(customPresets, 'extend');
-            const presets = manager.getPresets();
-            const overriddenPreset = presets.find(p => p.id === existingPresetId);
-            expect(presets).toHaveLength(presets_json_1.default.length);
-            expect(overriddenPreset).toBeDefined();
-            expect(overriddenPreset?.displayName).toBe('Overridden Preset');
-            expect(overriddenPreset?.providerId).toBe('anthropic');
-        });
-        it('should use extend mode by default when mode not specified', () => {
-            const customPresets = [
-                {
-                    id: 'custom-preset-default',
-                    displayName: 'Custom Default',
-                    providerId: 'gemini',
-                    modelId: 'gemini-2.0-flash',
-                    settings: { temperature: 0.3 }
-                }
-            ];
-            const manager = new PresetManager_1.PresetManager(customPresets);
-            const presets = manager.getPresets();
-            expect(presets).toHaveLength(presets_json_1.default.length + 1);
-        });
-    });
-    describe('Replace mode', () => {
-        it('should use only custom presets in replace mode', () => {
-            const customPresets = [
-                {
-                    id: 'replace-preset-1',
-                    displayName: 'Replace Preset 1',
-                    providerId: 'openai',
-                    modelId: 'gpt-4',
-                    settings: { temperature: 0.5 }
-                },
-                {
-                    id: 'replace-preset-2',
-                    displayName: 'Replace Preset 2',
-                    providerId: 'anthropic',
-                    modelId: 'claude-3-5-sonnet-20241022',
-                    settings: { temperature: 0.3 }
-                }
-            ];
-            const manager = new PresetManager_1.PresetManager(customPresets, 'replace');
-            const presets = manager.getPresets();
-            expect(presets).toHaveLength(2);
-            expect(presets).toEqual(expect.arrayContaining([
-                expect.objectContaining({ id: 'replace-preset-1' }),
-                expect.objectContaining({ id: 'replace-preset-2' })
-            ]));
-            // Should not contain any default presets
-            const defaultPresetIds = presets_json_1.default.map(p => p.id);
-            const actualPresetIds = presets.map(p => p.id);
-            expect(actualPresetIds).not.toContain(expect.arrayContaining(defaultPresetIds));
-        });
-        it('should return empty array when replace mode with no custom presets', () => {
-            const manager = new PresetManager_1.PresetManager([], 'replace');
-            const presets = manager.getPresets();
-            expect(presets).toHaveLength(0);
-        });
-        it('should handle undefined presets array in replace mode', () => {
-            const manager = new PresetManager_1.PresetManager(undefined, 'replace');
-            const presets = manager.getPresets();
-            expect(presets).toHaveLength(0);
-        });
-    });
-    describe('Edge cases', () => {
-        it('should handle duplicate IDs within custom presets', () => {
-            const customPresets = [
-                {
-                    id: 'duplicate-id',
-                    displayName: 'First Preset',
-                    providerId: 'openai',
-                    modelId: 'gpt-4',
-                    settings: { temperature: 0.5 }
-                },
-                {
-                    id: 'duplicate-id',
-                    displayName: 'Second Preset',
-                    providerId: 'anthropic',
-                    modelId: 'claude-3-5-sonnet-20241022',
-                    settings: { temperature: 0.3 }
-                }
-            ];
-            const manager = new PresetManager_1.PresetManager(customPresets, 'replace');
-            const presets = manager.getPresets();
-            const duplicatePresets = presets.filter(p => p.id === 'duplicate-id');
-            // Last one should win
-            expect(duplicatePresets).toHaveLength(1);
-            expect(duplicatePresets[0].displayName).toBe('Second Preset');
-        });
-        it('should handle presets with complex settings including gemini safety settings', () => {
-            const customPresets = [
-                {
-                    id: 'gemini-complex',
-                    displayName: 'Gemini Complex',
-                    providerId: 'gemini',
-                    modelId: 'gemini-2.0-flash',
-                    settings: {
-                        temperature: 0.5,
-                        maxTokens: 2000,
-                        geminiSafetySettings: [
-                            { category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'BLOCK_NONE' },
-                            { category: 'HARM_CATEGORY_DANGEROUS_CONTENT', threshold: 'BLOCK_MEDIUM_AND_ABOVE' }
-                        ]
-                    }
-                }
-            ];
-            const manager = new PresetManager_1.PresetManager(customPresets, 'replace');
-            const presets = manager.getPresets();
-            expect(presets).toHaveLength(1);
-            expect(presets[0].settings.geminiSafetySettings).toHaveLength(2);
-        });
-    });
-    describe('resolvePreset', () => {
-        it('should find preset by ID', () => {
-            const customPresets = [
-                {
-                    id: 'test-preset-1',
-                    displayName: 'Test Preset 1',
-                    providerId: 'openai',
-                    modelId: 'gpt-4',
-                    settings: {}
-                }
-            ];
-            const manager = new PresetManager_1.PresetManager(customPresets, 'replace');
-            const preset = manager.resolvePreset('test-preset-1');
-            expect(preset).toBeDefined();
-            expect(preset?.displayName).toBe('Test Preset 1');
-        });
-        it('should return null for non-existent preset', () => {
-            const manager = new PresetManager_1.PresetManager();
-            const preset = manager.resolvePreset('non-existent-preset');
-            expect(preset).toBeNull();
-        });
-        it('should find default preset in extend mode', () => {
-            const manager = new PresetManager_1.PresetManager();
-            const firstDefaultPresetId = presets_json_1.default[0].id;
-            const preset = manager.resolvePreset(firstDefaultPresetId);
-            expect(preset).toBeDefined();
-            expect(preset?.id).toBe(firstDefaultPresetId);
-        });
-    });
-});

package/dist/llm/services/RequestValidator.test.d.ts

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

package/dist/llm/services/RequestValidator.test.js

@@ -1,159 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const RequestValidator_1 = require("./RequestValidator");
-describe('RequestValidator', () => {
-    let validator;
-    beforeEach(() => {
-        validator = new RequestValidator_1.RequestValidator();
-    });
-    describe('validateRequestStructure', () => {
-        it('should return validation error for empty messages', () => {
-            const request = {
-                providerId: 'openai',
-                modelId: 'gpt-4.1',
-                messages: []
-            };
-            const result = validator.validateRequestStructure(request);
-            expect(result).not.toBeNull();
-            expect(result?.error.code).toBe('INVALID_REQUEST');
-            expect(result?.error.message).toContain('Request must contain at least one message');
-        });
-        it('should return validation error for invalid message role', () => {
-            const request = {
-                providerId: 'openai',
-                modelId: 'gpt-4.1',
-                messages: [{ role: 'invalid', content: 'Hello' }]
-            };
-            const result = validator.validateRequestStructure(request);
-            expect(result).not.toBeNull();
-            expect(result?.error.code).toBe('INVALID_MESSAGE_ROLE');
-            expect(result?.error.message).toContain('Invalid message role');
-        });
-        it('should return validation error for empty message content', () => {
-            const request = {
-                providerId: 'openai',
-                modelId: 'gpt-4.1',
-                messages: [{ role: 'user', content: '' }]
-            };
-            const result = validator.validateRequestStructure(request);
-            expect(result).not.toBeNull();
-            expect(result?.error.code).toBe('INVALID_MESSAGE');
-            expect(result?.error.message).toContain('Message at index 0 must have both');
-        });
-        it('should pass validation for valid request', () => {
-            const request = {
-                providerId: 'openai',
-                modelId: 'gpt-4.1',
-                messages: [{ role: 'user', content: 'Hello' }]
-            };
-            const result = validator.validateRequestStructure(request);
-            expect(result).toBeNull();
-        });
-        it('should handle preset requests correctly', () => {
-            const request = {
-                presetId: 'test-preset',
-                messages: []
-            };
-            const result = validator.validateRequestStructure(request);
-            expect(result).not.toBeNull();
-            expect(result?.provider).toBe('test-preset');
-            expect(result?.model).toBe('test-preset');
-        });
-    });
-    describe('validateSettings', () => {
-        it('should return error for invalid temperature', () => {
-            const settings = { temperature: 2.5 };
-            const result = validator.validateSettings(settings, 'openai', 'gpt-4.1');
-            expect(result).not.toBeNull();
-            expect(result?.error.code).toBe('INVALID_SETTINGS');
-            expect(result?.error.message).toContain('temperature must be a number between');
-        });
-        it('should return error for invalid maxTokens', () => {
-            const settings = { maxTokens: 0 };
-            const result = validator.validateSettings(settings, 'openai', 'gpt-4.1');
-            expect(result).not.toBeNull();
-            expect(result?.error.code).toBe('INVALID_SETTINGS');
-            expect(result?.error.message).toContain('maxTokens must be an integer between');
-        });
-        it('should return error for invalid topP', () => {
-            const settings = { topP: -0.1 };
-            const result = validator.validateSettings(settings, 'openai', 'gpt-4.1');
-            expect(result).not.toBeNull();
-            expect(result?.error.code).toBe('INVALID_SETTINGS');
-            expect(result?.error.message).toContain('topP must be a number between 0 and 1');
-        });
-        it('should pass validation for valid settings', () => {
-            const settings = {
-                temperature: 0.7,
-                maxTokens: 1000,
-                topP: 0.9
-            };
-            const result = validator.validateSettings(settings, 'openai', 'gpt-4.1');
-            expect(result).toBeNull();
-        });
-    });
-    describe('validateReasoningSettings', () => {
-        const mockModelWithReasoning = {
-            id: 'gpt-4.1',
-            name: 'GPT-4.1',
-            providerId: 'openai',
-            supportsPromptCache: false,
-            reasoning: { supported: true }
-        };
-        const mockModelWithoutReasoning = {
-            id: 'gpt-4.1',
-            name: 'GPT-4.1',
-            providerId: 'openai',
-            supportsPromptCache: false,
-            reasoning: { supported: false }
-        };
-        const baseRequest = {
-            providerId: 'openai',
-            modelId: 'gpt-4.1',
-            messages: [{ role: 'user', content: 'Hello' }]
-        };
-        it('should pass validation when no reasoning settings provided', () => {
-            const result = validator.validateReasoningSettings(mockModelWithoutReasoning, undefined, baseRequest);
-            expect(result).toBeNull();
-        });
-        it('should reject reasoning settings for non-reasoning models', () => {
-            const reasoning = { enabled: true };
-            const result = validator.validateReasoningSettings(mockModelWithoutReasoning, reasoning, baseRequest);
-            expect(result).not.toBeNull();
-            expect(result?.error.code).toBe('reasoning_not_supported');
-            expect(result?.error.message).toContain('does not support reasoning/thinking');
-        });
-        it('should reject reasoning with effort for non-reasoning models', () => {
-            const reasoning = { effort: 'high' };
-            const result = validator.validateReasoningSettings(mockModelWithoutReasoning, reasoning, baseRequest);
-            expect(result).not.toBeNull();
-            expect(result?.error.code).toBe('reasoning_not_supported');
-        });
-        it('should reject reasoning with maxTokens for non-reasoning models', () => {
-            const reasoning = { maxTokens: 5000 };
-            const result = validator.validateReasoningSettings(mockModelWithoutReasoning, reasoning, baseRequest);
-            expect(result).not.toBeNull();
-            expect(result?.error.code).toBe('reasoning_not_supported');
-        });
-        it('should allow disabled reasoning for non-reasoning models', () => {
-            const reasoning = { enabled: false };
-            const result = validator.validateReasoningSettings(mockModelWithoutReasoning, reasoning, baseRequest);
-            expect(result).toBeNull();
-        });
-        it('should allow reasoning with exclude=true for non-reasoning models', () => {
-            const reasoning = { exclude: true };
-            const result = validator.validateReasoningSettings(mockModelWithoutReasoning, reasoning, baseRequest);
-            expect(result).toBeNull();
-        });
-        it('should allow all reasoning settings for models that support reasoning', () => {
-            const reasoning = {
-                enabled: true,
-                effort: 'high',
-                maxTokens: 5000,
-                exclude: false
-            };
-            const result = validator.validateReasoningSettings(mockModelWithReasoning, reasoning, baseRequest);
-            expect(result).toBeNull();
-        });
-    });
-});

package/dist/llm/services/SettingsManager.test.d.ts

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

package/dist/llm/services/SettingsManager.test.js

@@ -1,266 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const SettingsManager_1 = require("./SettingsManager");
-const config_1 = require("../config");
-jest.mock('../config', () => ({
-    getDefaultSettingsForModel: jest.fn().mockReturnValue({
-        temperature: 0.7,
-        maxTokens: 1000,
-        topP: 0.9,
-        stopSequences: [],
-        frequencyPenalty: 0,
-        presencePenalty: 0,
-        user: '',
-        supportsSystemMessage: true,
-        geminiSafetySettings: [],
-        reasoning: {
-            enabled: false,
-            effort: undefined,
-            maxTokens: undefined,
-            exclude: false,
-        },
-        thinkingExtraction: {
-            enabled: true,
-            tag: 'thinking',
-        },
-    }),
-}));
-describe('SettingsManager', () => {
-    let settingsManager;
-    beforeEach(() => {
-        settingsManager = new SettingsManager_1.SettingsManager();
-        jest.clearAllMocks();
-    });
-    describe('mergeSettingsForModel', () => {
-        it('should return default settings when no request settings provided', () => {
-            const result = settingsManager.mergeSettingsForModel('gpt-4.1', 'openai');
-            expect(config_1.getDefaultSettingsForModel).toHaveBeenCalledWith('gpt-4.1', 'openai');
-            expect(result).toEqual({
-                temperature: 0.7,
-                maxTokens: 1000,
-                topP: 0.9,
-                stopSequences: [],
-                frequencyPenalty: 0,
-                presencePenalty: 0,
-                user: '',
-                supportsSystemMessage: true,
-                geminiSafetySettings: [],
-                reasoning: {
-                    enabled: false,
-                    effort: undefined,
-                    maxTokens: undefined,
-                    exclude: false,
-                },
-                thinkingExtraction: {
-                    enabled: true,
-                    tag: 'thinking',
-                },
-            });
-        });
-        it('should merge user settings with defaults', () => {
-            const userSettings = {
-                temperature: 0.9,
-                maxTokens: 500,
-            };
-            const result = settingsManager.mergeSettingsForModel('gpt-4.1', 'openai', userSettings);
-            expect(result.temperature).toBe(0.9);
-            expect(result.maxTokens).toBe(500);
-            // Other settings should remain as defaults
-            expect(result.topP).toBe(0.9);
-            expect(result.frequencyPenalty).toBe(0);
-        });
-        it('should handle reasoning settings override', () => {
-            const userSettings = {
-                reasoning: {
-                    enabled: true,
-                    effort: 'high',
-                },
-            };
-            const result = settingsManager.mergeSettingsForModel('claude-3-7-sonnet-20250219', 'anthropic', userSettings);
-            expect(result.reasoning).toEqual({
-                enabled: true,
-                effort: 'high',
-                maxTokens: undefined,
-                exclude: false,
-            });
-        });
-        it('should handle complex settings including Gemini safety settings', () => {
-            const userSettings = {
-                temperature: 0.5,
-                geminiSafetySettings: [
-                    { category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'BLOCK_NONE' },
-                ],
-            };
-            const result = settingsManager.mergeSettingsForModel('gemini-2.0-flash', 'gemini', userSettings);
-            expect(result.temperature).toBe(0.5);
-            expect(result.geminiSafetySettings).toHaveLength(1);
-            expect(result.geminiSafetySettings[0]).toEqual({
-                category: 'HARM_CATEGORY_HATE_SPEECH',
-                threshold: 'BLOCK_NONE',
-            });
-        });
-        it('should handle all optional fields being provided', () => {
-            const userSettings = {
-                temperature: 0.8,
-                maxTokens: 2000,
-                topP: 0.95,
-                stopSequences: ['END', 'STOP'],
-                frequencyPenalty: 0.5,
-                presencePenalty: -0.5,
-                user: 'test-user',
-                supportsSystemMessage: false,
-                geminiSafetySettings: [],
-                reasoning: {
-                    enabled: true,
-                    effort: 'medium',
-                    maxTokens: 5000,
-                    exclude: true,
-                },
-                thinkingExtraction: {
-                    enabled: false,
-                    tag: 'scratchpad',
-                },
-            };
-            const result = settingsManager.mergeSettingsForModel('gpt-4.1', 'openai', userSettings);
-            expect(result).toEqual(userSettings);
-        });
-    });
-    describe('filterUnsupportedParameters', () => {
-        const baseSettings = {
-            temperature: 0.7,
-            maxTokens: 1000,
-            topP: 0.9,
-            stopSequences: [],
-            frequencyPenalty: 0,
-            presencePenalty: 0,
-            user: '',
-            supportsSystemMessage: true,
-            geminiSafetySettings: [],
-            reasoning: {
-                enabled: false,
-                effort: undefined,
-                maxTokens: undefined,
-                exclude: false,
-            },
-            thinkingExtraction: {
-                enabled: true,
-                tag: 'thinking',
-            },
-        };
-        const mockModelInfo = {
-            id: 'test-model',
-            providerId: 'test-provider',
-            name: 'Test Model',
-            supportsPromptCache: false,
-            contextWindow: 4096,
-            maxTokens: 1000,
-            reasoning: { supported: true }, // Add reasoning support to prevent it being stripped
-        };
-        const mockProviderInfo = {
-            id: 'test-provider',
-            name: 'Test Provider',
-        };
-        it('should return settings unchanged when no parameters need filtering', () => {
-            const result = settingsManager.filterUnsupportedParameters(baseSettings, mockModelInfo, mockProviderInfo);
-            expect(result).toEqual(baseSettings);
-        });
-        it('should filter out provider-level unsupported parameters', () => {
-            const providerWithExclusions = {
-                ...mockProviderInfo,
-                unsupportedParameters: ['frequencyPenalty', 'presencePenalty'],
-            };
-            const settingsWithPenalties = {
-                ...baseSettings,
-                frequencyPenalty: 0.5,
-                presencePenalty: -0.5,
-            };
-            const result = settingsManager.filterUnsupportedParameters(settingsWithPenalties, mockModelInfo, providerWithExclusions);
-            expect(result.frequencyPenalty).toBeUndefined();
-            expect(result.presencePenalty).toBeUndefined();
-            expect(result.temperature).toBe(0.7); // Should remain unchanged
-        });
-        it('should filter out model-level unsupported parameters', () => {
-            const modelWithExclusions = {
-                ...mockModelInfo,
-                unsupportedParameters: ['stopSequences', 'user'],
-            };
-            const settingsWithExcluded = {
-                ...baseSettings,
-                stopSequences: ['END'],
-                user: 'test-user',
-            };
-            const result = settingsManager.filterUnsupportedParameters(settingsWithExcluded, modelWithExclusions, mockProviderInfo);
-            expect(result.stopSequences).toBeUndefined();
-            expect(result.user).toBeUndefined();
-        });
-        it('should combine provider and model exclusions', () => {
-            const providerWithExclusions = {
-                ...mockProviderInfo,
-                unsupportedParameters: ['frequencyPenalty'],
-            };
-            const modelWithExclusions = {
-                ...mockModelInfo,
-                unsupportedParameters: ['presencePenalty', 'stopSequences'],
-            };
-            const settingsWithAll = {
-                ...baseSettings,
-                frequencyPenalty: 0.5,
-                presencePenalty: -0.5,
-                stopSequences: ['END'],
-            };
-            const result = settingsManager.filterUnsupportedParameters(settingsWithAll, modelWithExclusions, providerWithExclusions);
-            expect(result.frequencyPenalty).toBeUndefined();
-            expect(result.presencePenalty).toBeUndefined();
-            expect(result.stopSequences).toBeUndefined();
-        });
-        it('should remove reasoning settings for non-reasoning models', () => {
-            const nonReasoningModel = {
-                ...mockModelInfo,
-                reasoning: { supported: false },
-            };
-            const settingsWithReasoning = {
-                ...baseSettings,
-                reasoning: {
-                    enabled: true,
-                    effort: 'high',
-                    maxTokens: 5000,
-                    exclude: false,
-                },
-            };
-            const result = settingsManager.filterUnsupportedParameters(settingsWithReasoning, nonReasoningModel, mockProviderInfo);
-            expect(result.reasoning).toBeUndefined();
-        });
-        it('should keep reasoning settings for reasoning-supported models', () => {
-            const reasoningModel = {
-                ...mockModelInfo,
-                reasoning: { supported: true },
-            };
-            const settingsWithReasoning = {
-                ...baseSettings,
-                reasoning: {
-                    enabled: true,
-                    effort: 'high',
-                    maxTokens: 5000,
-                    exclude: false,
-                },
-            };
-            const result = settingsManager.filterUnsupportedParameters(settingsWithReasoning, reasoningModel, mockProviderInfo);
-            expect(result.reasoning).toEqual(settingsWithReasoning.reasoning);
-        });
-        it('should handle geminiSafetySettings appropriately', () => {
-            const geminiProvider = {
-                id: 'gemini',
-                name: 'Google Gemini',
-            };
-            const settingsWithGemini = {
-                ...baseSettings,
-                geminiSafetySettings: [
-                    { category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'BLOCK_NONE' },
-                ],
-            };
-            const result = settingsManager.filterUnsupportedParameters(settingsWithGemini, mockModelInfo, geminiProvider);
-            // Should not be filtered out for Gemini provider
-            expect(result.geminiSafetySettings).toEqual(settingsWithGemini.geminiSafetySettings);
-        });
-    });
-});

package/dist/prompting/builder.d.ts

@@ -1,38 +0,0 @@
-/**
- * Prompt builder utilities for constructing structured LLM messages
- *
- * This module provides functions to construct the final, structured prompts
- * that will be sent to the LLM service. This is the assembly step that turns
- * templates and content into the format required by the LLMService.
- */
-import type { LLMMessage } from '../llm/types';
-/**
- * Builds an array of LLM messages from a template string with role tags.
- *
- * This function takes a template with <SYSTEM>, <USER>, and <ASSISTANT> tags
- * and constructs a properly formatted array of LLMMessage objects ready to be
- * sent to an LLM service.
- *
- * @deprecated Use `LLMService.createMessages` for a more integrated experience that includes
- * model-aware template rendering. For standalone, model-agnostic role tag parsing, consider
- * using the new `parseRoleTags` utility directly.
- *
- * @param template The template string with {{variables}} and <ROLE> tags.
- * @param variables An object with values to substitute into the template.
- * @returns An array of LLMMessage objects.
- *
- * @example
- * const template = `
- * <SYSTEM>You are a helpful assistant specialized in {{expertise}}.</SYSTEM>
- * <USER>Help me with {{task}}</USER>
- * <ASSISTANT>I'll help you with {{task}}. Let me explain...</ASSISTANT>
- * <USER>Can you provide more details?</USER>
- * `;
- *
- * const messages = buildMessagesFromTemplate(template, {
- *   expertise: 'TypeScript',
- *   task: 'understanding generics'
- * });
- * // Returns an array of LLMMessage objects with roles and content
- */
-export declare function buildMessagesFromTemplate(template: string, variables?: Record<string, any>): LLMMessage[];