genai-lite 0.2.0 → 0.3.0

package/dist/llm/services/SettingsManager.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettingsManager = void 0;
+const config_1 = require("../config");
+/**
+ * Manages LLM settings including merging with defaults and filtering unsupported parameters
+ */
+class SettingsManager {
+    /**
+     * Merges request settings with model-specific and global defaults
+     *
+     * @param modelId - The model ID to get defaults for
+     * @param providerId - The provider ID to get defaults for
+     * @param requestSettings - Settings from the request
+     * @returns Complete settings object with all required fields
+     */
+    mergeSettingsForModel(modelId, providerId, requestSettings) {
+        // Get model-specific defaults
+        const modelDefaults = (0, config_1.getDefaultSettingsForModel)(modelId, providerId);
+        // Merge with user-provided settings (user settings take precedence)
+        const mergedSettings = {
+            temperature: requestSettings?.temperature ?? modelDefaults.temperature,
+            maxTokens: requestSettings?.maxTokens ?? modelDefaults.maxTokens,
+            topP: requestSettings?.topP ?? modelDefaults.topP,
+            stopSequences: requestSettings?.stopSequences ?? modelDefaults.stopSequences,
+            frequencyPenalty: requestSettings?.frequencyPenalty ?? modelDefaults.frequencyPenalty,
+            presencePenalty: requestSettings?.presencePenalty ?? modelDefaults.presencePenalty,
+            user: requestSettings?.user ?? modelDefaults.user,
+            supportsSystemMessage: requestSettings?.supportsSystemMessage ??
+                modelDefaults.supportsSystemMessage,
+            geminiSafetySettings: requestSettings?.geminiSafetySettings ??
+                modelDefaults.geminiSafetySettings,
+            reasoning: {
+                ...modelDefaults.reasoning,
+                ...requestSettings?.reasoning,
+            },
+            thinkingExtraction: {
+                ...modelDefaults.thinkingExtraction,
+                ...requestSettings?.thinkingExtraction,
+            },
+        };
+        // Log the final settings for debugging
+        console.log(`Merged settings for ${providerId}/${modelId}:`, {
+            temperature: mergedSettings.temperature,
+            maxTokens: mergedSettings.maxTokens,
+            topP: mergedSettings.topP,
+            hasStopSequences: mergedSettings.stopSequences.length > 0,
+            frequencyPenalty: mergedSettings.frequencyPenalty,
+            presencePenalty: mergedSettings.presencePenalty,
+            hasUser: !!mergedSettings.user,
+            geminiSafetySettingsCount: mergedSettings.geminiSafetySettings.length,
+            reasoning: mergedSettings.reasoning,
+        });
+        return mergedSettings;
+    }
+    /**
+     * Filters out unsupported parameters based on model and provider configuration
+     *
+     * @param settings - The settings to filter
+     * @param modelInfo - Model information including unsupported parameters
+     * @param providerInfo - Provider information including unsupported parameters
+     * @returns Filtered settings object
+     */
+    filterUnsupportedParameters(settings, modelInfo, providerInfo) {
+        // Create a mutable copy
+        const filteredSettings = { ...settings };
+        const paramsToExclude = new Set();
+        // Add provider-level exclusions
+        if (providerInfo.unsupportedParameters) {
+            providerInfo.unsupportedParameters.forEach((param) => paramsToExclude.add(param));
+        }
+        // Add model-level exclusions (these will be added to any provider-level ones)
+        if (modelInfo.unsupportedParameters) {
+            modelInfo.unsupportedParameters.forEach((param) => paramsToExclude.add(param));
+        }
+        if (paramsToExclude.size > 0) {
+            console.log(`LLMService: Potential parameters to exclude for provider '${providerInfo.id}', model '${modelInfo.id}':`, Array.from(paramsToExclude));
+        }
+        paramsToExclude.forEach((param) => {
+            // Check if the parameter key actually exists in filteredSettings before trying to delete
+            if (param in filteredSettings) {
+                console.log(`LLMService: Removing excluded parameter '${String(param)}' for provider '${providerInfo.id}', model '${modelInfo.id}'. Value was:`, filteredSettings[param]);
+                delete filteredSettings[param]; // Cast to allow deletion
+            }
+            else {
+                // This case should ideally not happen if settings truly is Required<LLMSettings>
+                console.log(`LLMService: Parameter '${String(param)}' marked for exclusion was not found in settings for provider '${providerInfo.id}', model '${modelInfo.id}'.`);
+            }
+        });
+        // Handle reasoning settings for models that don't support it
+        // This happens after validateReasoningSettings so we know it's safe to strip
+        if (!modelInfo.reasoning?.supported && filteredSettings.reasoning) {
+            console.log(`LLMService: Removing reasoning settings for non-reasoning model ${modelInfo.id}`);
+            delete filteredSettings.reasoning;
+        }
+        return filteredSettings;
+    }
+    /**
+     * Validates settings extracted from templates, warning about invalid fields
+     * and returning only valid settings
+     *
+     * @param settings - The settings to validate (e.g., from template metadata)
+     * @returns Validated settings with invalid fields removed
+     */
+    validateTemplateSettings(settings) {
+        const validated = {};
+        const knownFields = [
+            'temperature',
+            'maxTokens',
+            'topP',
+            'stopSequences',
+            'frequencyPenalty',
+            'presencePenalty',
+            'user',
+            'supportsSystemMessage',
+            'geminiSafetySettings',
+            'reasoning',
+            'thinkingExtraction'
+        ];
+        // Check each setting field
+        for (const [key, value] of Object.entries(settings)) {
+            // Check if it's a known field
+            if (!knownFields.includes(key)) {
+                console.warn(`Unknown setting "${key}" in template metadata. Ignoring.`);
+                continue;
+            }
+            // Type-specific validation
+            if (key === 'temperature') {
+                if (typeof value !== 'number' || value < 0 || value > 2) {
+                    console.warn(`Invalid temperature value in template: ${value}. Must be a number between 0 and 2.`);
+                    continue;
+                }
+            }
+            if (key === 'maxTokens') {
+                if (typeof value !== 'number' || value <= 0) {
+                    console.warn(`Invalid maxTokens value in template: ${value}. Must be a positive number.`);
+                    continue;
+                }
+            }
+            if (key === 'topP') {
+                if (typeof value !== 'number' || value < 0 || value > 1) {
+                    console.warn(`Invalid topP value in template: ${value}. Must be a number between 0 and 1.`);
+                    continue;
+                }
+            }
+            if (key === 'stopSequences') {
+                if (!Array.isArray(value) || !value.every(v => typeof v === 'string')) {
+                    console.warn(`Invalid stopSequences value in template. Must be an array of strings.`);
+                    continue;
+                }
+            }
+            if ((key === 'frequencyPenalty' || key === 'presencePenalty')) {
+                if (typeof value !== 'number' || value < -2 || value > 2) {
+                    console.warn(`Invalid ${key} value in template: ${value}. Must be a number between -2 and 2.`);
+                    continue;
+                }
+            }
+            if (key === 'user' && typeof value !== 'string') {
+                console.warn(`Invalid user value in template. Must be a string.`);
+                continue;
+            }
+            if (key === 'supportsSystemMessage' && typeof value !== 'boolean') {
+                console.warn(`Invalid supportsSystemMessage value in template. Must be a boolean.`);
+                continue;
+            }
+            // Nested object validation
+            if (key === 'reasoning' && typeof value === 'object' && value !== null) {
+                const reasoningValidated = {};
+                if ('enabled' in value && typeof value.enabled !== 'boolean') {
+                    console.warn(`Invalid reasoning.enabled value in template. Must be a boolean.`);
+                }
+                else if ('enabled' in value) {
+                    reasoningValidated.enabled = value.enabled;
+                }
+                if ('effort' in value && !['low', 'medium', 'high'].includes(value.effort)) {
+                    console.warn(`Invalid reasoning.effort value in template: ${value.effort}. Must be 'low', 'medium', or 'high'.`);
+                }
+                else if ('effort' in value) {
+                    reasoningValidated.effort = value.effort;
+                }
+                if ('maxTokens' in value && (typeof value.maxTokens !== 'number' || value.maxTokens <= 0)) {
+                    console.warn(`Invalid reasoning.maxTokens value in template. Must be a positive number.`);
+                }
+                else if ('maxTokens' in value) {
+                    reasoningValidated.maxTokens = value.maxTokens;
+                }
+                if ('exclude' in value && typeof value.exclude !== 'boolean') {
+                    console.warn(`Invalid reasoning.exclude value in template. Must be a boolean.`);
+                }
+                else if ('exclude' in value) {
+                    reasoningValidated.exclude = value.exclude;
+                }
+                if (Object.keys(reasoningValidated).length > 0) {
+                    validated.reasoning = reasoningValidated;
+                }
+                continue;
+            }
+            if (key === 'thinkingExtraction' && typeof value === 'object' && value !== null) {
+                const thinkingValidated = {};
+                if ('enabled' in value && typeof value.enabled !== 'boolean') {
+                    console.warn(`Invalid thinkingExtraction.enabled value in template. Must be a boolean.`);
+                }
+                else if ('enabled' in value) {
+                    thinkingValidated.enabled = value.enabled;
+                }
+                if ('tag' in value && typeof value.tag !== 'string') {
+                    console.warn(`Invalid thinkingExtraction.tag value in template. Must be a string.`);
+                }
+                else if ('tag' in value) {
+                    thinkingValidated.tag = value.tag;
+                }
+                if (Object.keys(thinkingValidated).length > 0) {
+                    validated.thinkingExtraction = thinkingValidated;
+                }
+                continue;
+            }
+            // If we made it here, the field is valid
+            validated[key] = value;
+        }
+        return validated;
+    }
+}
+exports.SettingsManager = SettingsManager;

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

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

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

@@ -0,0 +1,266 @@
+"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/llm/types.d.ts

@@ -29,6 +29,43 @@ export interface GeminiSafetySetting {
     category: GeminiHarmCategory;
     threshold: GeminiHarmBlockThreshold;
 }
+/**
+ * Reasoning/thinking configuration for LLM requests
+ */
+export interface LLMReasoningSettings {
+    /** Enable reasoning/thinking mode */
+    enabled?: boolean;
+    /** Effort-based control (OpenAI style) */
+    effort?: 'high' | 'medium' | 'low';
+    /** Token-based control (Anthropic/Gemini style) */
+    maxTokens?: number;
+    /** Exclude reasoning from response (keep internal only) */
+    exclude?: boolean;
+}
+/**
+ * Settings for extracting 'thinking' content from the start of a response
+ */
+export interface LLMThinkingExtractionSettings {
+    /**
+     * If true, enables the automatic extraction of content from a specified XML tag.
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * The XML tag name to look for (e.g., 'thinking', 'reasoning', 'scratchpad').
+     * @default 'thinking'
+     */
+    tag?: string;
+    /**
+     * Defines behavior when the tag is not found. 'auto' is the recommended default.
+     * - 'ignore': Silently continue without a warning or error.
+     * - 'warn': Log a console warning but return the response as-is.
+     * - 'error': Return an LLMFailureResponse, treating it as a failed request.
+     * - 'auto': Becomes 'error' unless the model has active native reasoning. If native reasoning is active, this becomes 'ignore'.
+     * @default 'auto'
+     */
+    onMissing?: 'ignore' | 'warn' | 'error' | 'auto';
+}
 /**
  * Configurable settings for LLM requests
  */
@@ -51,6 +88,13 @@ export interface LLMSettings {
     supportsSystemMessage?: boolean;
     /** Gemini-specific safety settings for content filtering */
     geminiSafetySettings?: GeminiSafetySetting[];
+    /** Universal reasoning/thinking configuration */
+    reasoning?: LLMReasoningSettings;
+    /**
+     * Configuration for automatically extracting 'thinking' blocks from responses.
+     * Enabled by default.
+     */
+    thinkingExtraction?: LLMThinkingExtractionSettings;
 }
 /**
  * Request structure for chat completion
@@ -62,6 +106,17 @@ export interface LLMChatRequest {
     systemMessage?: string;
     settings?: LLMSettings;
 }
+/**
+ * Extended request structure that supports preset IDs
+ */
+export interface LLMChatRequestWithPreset extends Omit<LLMChatRequest, 'providerId' | 'modelId'> {
+    /** Provider ID (required if not using presetId) */
+    providerId?: ApiProviderId;
+    /** Model ID (required if not using presetId) */
+    modelId?: string;
+    /** Preset ID (alternative to providerId/modelId) */
+    presetId?: string;
+}
 /**
  * Individual choice in an LLM response
  */
@@ -69,6 +124,10 @@ export interface LLMChoice {
     message: LLMMessage;
     finish_reason: string | null;
     index?: number;
+    /** Reasoning/thinking content (if available and not excluded) */
+    reasoning?: string;
+    /** Provider-specific reasoning details that need to be preserved */
+    reasoning_details?: any;
 }
 /**
  * Token usage information from LLM APIs
@@ -117,6 +176,34 @@ export interface ProviderInfo {
     name: string;
     unsupportedParameters?: (keyof LLMSettings)[];
 }
+/**
+ * Reasoning/thinking capabilities for a model
+ */
+export interface ModelReasoningCapabilities {
+    /** Does this model support reasoning/thinking? */
+    supported: boolean;
+    /** Is reasoning enabled by default? */
+    enabledByDefault?: boolean;
+    /** Can reasoning be disabled? (e.g., Gemini Pro can't) */
+    canDisable?: boolean;
+    /** Minimum token budget for reasoning */
+    minBudget?: number;
+    /** Maximum token budget for reasoning */
+    maxBudget?: number;
+    /** Default token budget if not specified */
+    defaultBudget?: number;
+    /** Special budget values (e.g., -1 for Gemini's dynamic) */
+    dynamicBudget?: {
+        value: number;
+        description: string;
+    };
+    /** Price per 1M reasoning tokens (optional - if not set, uses regular outputPrice) */
+    outputPrice?: number;
+    /** What type of reasoning output is returned */
+    outputType?: 'full' | 'summary' | 'none';
+    /** Token count above which streaming is required */
+    requiresStreamingAbove?: number;
+}
 /**
  * Information about a supported LLM model
  */
@@ -132,10 +219,13 @@ export interface ModelInfo {
     maxTokens?: number;
     supportsImages?: boolean;
     supportsPromptCache: boolean;
+    /** @deprecated Use reasoning instead */
     thinkingConfig?: {
         maxBudget?: number;
         outputPrice?: number;
     };
+    /** Reasoning/thinking capabilities */
+    reasoning?: ModelReasoningCapabilities;
     cacheWritesPrice?: number;
     cacheReadsPrice?: number;
     unsupportedParameters?: (keyof LLMSettings)[];
@@ -153,3 +243,20 @@ export declare const LLM_IPC_CHANNELS: {
  * Type for LLM IPC channel names
  */
 export type LLMIPCChannelName = (typeof LLM_IPC_CHANNELS)[keyof typeof LLM_IPC_CHANNELS];
+/**
+ * Model context variables injected into templates
+ */
+export interface ModelContext {
+    /** Whether reasoning/thinking is enabled for this request */
+    thinking_enabled: boolean;
+    /** Whether the model supports reasoning/thinking */
+    thinking_available: boolean;
+    /** The resolved model ID */
+    model_id: string;
+    /** The resolved provider ID */
+    provider_id: string;
+    /** Reasoning effort level if specified */
+    reasoning_effort?: string;
+    /** Reasoning max tokens if specified */
+    reasoning_max_tokens?: number;
+}

package/dist/prompting/builder.d.ts

@@ -13,6 +13,10 @@ import type { LLMMessage } from '../llm/types';
  * 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.