genai-lite 0.2.0 → 0.2.1

package/dist/llm/clients/GeminiClientAdapter.js

@@ -133,6 +133,42 @@ class GeminiClientAdapter {
                 stopSequences: request.settings.stopSequences,
             }),
         };
+        // Handle reasoning/thinking configuration
+        if (request.settings.reasoning && !request.settings.reasoning.exclude) {
+            const reasoning = request.settings.reasoning;
+            let thinkingBudget;
+            // Convert reasoning settings to Gemini's thinkingConfig
+            if (reasoning.maxTokens !== undefined) {
+                thinkingBudget = reasoning.maxTokens;
+            }
+            else if (reasoning.effort) {
+                // Convert effort levels to token budgets
+                // Get model info to determine max budget
+                const modelId = request.modelId;
+                const maxBudget = modelId.includes('flash') ? 24576 : 65536; // Default max budgets
+                switch (reasoning.effort) {
+                    case 'high':
+                        thinkingBudget = Math.floor(maxBudget * 0.8);
+                        break;
+                    case 'medium':
+                        thinkingBudget = Math.floor(maxBudget * 0.5);
+                        break;
+                    case 'low':
+                        thinkingBudget = Math.floor(maxBudget * 0.2);
+                        break;
+                }
+            }
+            else if (reasoning.enabled !== false) {
+                // Use model default or dynamic budget (-1)
+                thinkingBudget = -1; // Let model decide
+            }
+            if (thinkingBudget !== undefined) {
+                generationConfig.thinkingConfig = {
+                    thinkingBudget: thinkingBudget,
+                    includeThoughts: true // Request thought summaries in response
+                };
+            }
+        }
         // Map safety settings from Athanor format to Gemini SDK format
         const safetySettings = request.settings.geminiSafetySettings?.map((setting) => ({
             category: setting.category,
@@ -155,25 +191,48 @@ class GeminiClientAdapter {
     createSuccessResponse(response, request) {
         // Extract content from the response object
         const candidate = response.candidates?.[0];
-        const content = candidate?.content?.parts?.[0]?.text || "";
+        let content = "";
+        let reasoning;
+        // Process all parts to extract content and thought summaries
+        if (candidate?.content?.parts) {
+            const thoughtParts = [];
+            const contentParts = [];
+            for (const part of candidate.content.parts) {
+                if (part.thought) {
+                    // This is a thought summary
+                    thoughtParts.push(part.text || "");
+                }
+                else if (part.text) {
+                    // Regular content
+                    contentParts.push(part.text);
+                }
+            }
+            content = contentParts.join("");
+            if (thoughtParts.length > 0) {
+                reasoning = thoughtParts.join("\n\n");
+            }
+        }
         // Extract usage data if available
         const usageMetadata = response.usageMetadata || {};
         const finishReason = this.mapGeminiFinishReason(candidate?.finishReason || null);
+        const choice = {
+            message: {
+                role: "assistant",
+                content: content,
+            },
+            finish_reason: finishReason,
+            index: 0,
+        };
+        // Include reasoning if available and not excluded
+        if (reasoning && request.settings.reasoning && !request.settings.reasoning.exclude) {
+            choice.reasoning = reasoning;
+        }
         return {
             id: this.generateResponseId(),
             provider: request.providerId,
             model: response.modelUsed || request.modelId,
             created: Math.floor(Date.now() / 1000),
-            choices: [
-                {
-                    message: {
-                        role: "assistant",
-                        content: content,
-                    },
-                    finish_reason: finishReason,
-                    index: 0,
-                },
-            ],
+            choices: [choice],
             usage: usageMetadata
                 ? {
                     prompt_tokens: usageMetadata.promptTokenCount || 0,

package/dist/llm/clients/GeminiClientAdapter.test.js

@@ -37,7 +37,13 @@ describe('GeminiClientAdapter', () => {
                 stopSequences: [],
                 user: 'test-user',
                 geminiSafetySettings: [],
-                supportsSystemMessage: true
+                supportsSystemMessage: true,
+                reasoning: {
+                    enabled: false,
+                    effort: undefined,
+                    maxTokens: undefined,
+                    exclude: false
+                }
             }
         };
     });
@@ -195,6 +201,120 @@ describe('GeminiClientAdapter', () => {
                 expect(successResponse.choices[0].finish_reason).toBe(expected);
             }
         });
+        describe('reasoning/thinking configuration', () => {
+            it('should add thinking config when reasoning is enabled with maxTokens', async () => {
+                const requestWithReasoning = {
+                    ...basicRequest,
+                    settings: {
+                        ...basicRequest.settings,
+                        reasoning: {
+                            enabled: true,
+                            maxTokens: 5000,
+                            effort: undefined,
+                            exclude: false
+                        }
+                    }
+                };
+                mockGenerateContent.mockResolvedValueOnce({
+                    text: () => 'Response with thinking',
+                    candidates: [{
+                            finishReason: 'STOP',
+                            content: {
+                                parts: [{ text: 'Response with thinking' }]
+                            }
+                        }],
+                    usageMetadata: {}
+                });
+                await adapter.sendMessage(requestWithReasoning, 'test-api-key');
+                const callArgs = mockGenerateContent.mock.calls[0][0];
+                expect(callArgs.config.thinkingConfig).toEqual({
+                    thinkingBudget: 5000,
+                    includeThoughts: true
+                });
+            });
+            it('should convert effort levels to thinking budget', async () => {
+                const requestWithEffort = {
+                    ...basicRequest,
+                    settings: {
+                        ...basicRequest.settings,
+                        reasoning: {
+                            enabled: true,
+                            effort: 'high',
+                            maxTokens: undefined,
+                            exclude: false
+                        }
+                    }
+                };
+                mockGenerateContent.mockResolvedValueOnce({
+                    text: () => 'Response',
+                    candidates: [{
+                            finishReason: 'STOP',
+                            content: {
+                                parts: [{ text: 'Response' }]
+                            }
+                        }],
+                    usageMetadata: {}
+                });
+                await adapter.sendMessage(requestWithEffort, 'test-api-key');
+                const callArgs = mockGenerateContent.mock.calls[0][0];
+                // For gemini-2.5-pro (not flash), max budget is 65536, high effort = 80%
+                expect(callArgs.config.thinkingConfig?.thinkingBudget).toBe(Math.floor(65536 * 0.8));
+            });
+            it('should use dynamic budget (-1) when reasoning enabled without specific settings', async () => {
+                const requestWithBasicReasoning = {
+                    ...basicRequest,
+                    settings: {
+                        ...basicRequest.settings,
+                        reasoning: {
+                            enabled: true,
+                            effort: undefined,
+                            maxTokens: undefined,
+                            exclude: false
+                        }
+                    }
+                };
+                mockGenerateContent.mockResolvedValueOnce({
+                    text: () => 'Response',
+                    candidates: [{
+                            finishReason: 'STOP',
+                            content: {
+                                parts: [{ text: 'Response' }]
+                            }
+                        }],
+                    usageMetadata: {}
+                });
+                await adapter.sendMessage(requestWithBasicReasoning, 'test-api-key');
+                const callArgs = mockGenerateContent.mock.calls[0][0];
+                expect(callArgs.config.thinkingConfig?.thinkingBudget).toBe(-1);
+            });
+            it('should exclude thinking config when reasoning.exclude is true', async () => {
+                const requestWithExclude = {
+                    ...basicRequest,
+                    settings: {
+                        ...basicRequest.settings,
+                        reasoning: {
+                            enabled: true,
+                            maxTokens: 5000,
+                            effort: undefined,
+                            exclude: true
+                        }
+                    }
+                };
+                mockGenerateContent.mockResolvedValueOnce({
+                    text: () => 'Response',
+                    candidates: [{
+                            finishReason: 'STOP',
+                            content: {
+                                parts: [{ text: 'Response' }]
+                            }
+                        }],
+                    usageMetadata: {}
+                });
+                await adapter.sendMessage(requestWithExclude, 'test-api-key');
+                const callArgs = mockGenerateContent.mock.calls[0][0];
+                expect(callArgs.config.thinkingConfig).toBeUndefined();
+            });
+        });
         describe('error handling', () => {
             it('should handle API key errors', async () => {
                 const apiError = new Error('API key not valid');

package/dist/llm/clients/MockClientAdapter.test.js

@@ -20,7 +20,13 @@ describe('MockClientAdapter', () => {
                 stopSequences: [],
                 user: 'test-user',
                 geminiSafetySettings: [],
-                supportsSystemMessage: true
+                supportsSystemMessage: true,
+                reasoning: {
+                    enabled: false,
+                    effort: undefined,
+                    maxTokens: undefined,
+                    exclude: false
+                }
             }
         };
     });

package/dist/llm/clients/OpenAIClientAdapter.js

@@ -64,6 +64,18 @@ class OpenAIClientAdapter {
                     user: request.settings.user,
                 }),
             };
+            // Handle reasoning configuration for OpenAI models (o-series)
+            if (request.settings.reasoning && !request.settings.reasoning.exclude) {
+                const reasoning = request.settings.reasoning;
+                // OpenAI uses reasoning_effort for o-series models
+                if (reasoning.effort) {
+                    completionParams.reasoning_effort = reasoning.effort;
+                }
+                else if (reasoning.enabled !== false) {
+                    // Default to medium effort if reasoning is enabled
+                    completionParams.reasoning_effort = 'medium';
+                }
+            }
             console.log(`OpenAI API parameters:`, {
                 model: completionParams.model,
                 temperature: completionParams.temperature,
@@ -163,21 +175,25 @@ class OpenAIClientAdapter {
         if (!choice || !choice.message) {
             throw new Error("Invalid completion structure from OpenAI API");
         }
+        const responseChoice = {
+            message: {
+                role: choice.message.role,
+                content: choice.message.content || "",
+            },
+            finish_reason: choice.finish_reason,
+            index: choice.index,
+        };
+        // Check for reasoning content if OpenAI starts returning it
+        // (Currently o-series models don't return reasoning tokens)
+        if (choice.reasoning && request.settings.reasoning && !request.settings.reasoning.exclude) {
+            responseChoice.reasoning = choice.reasoning;
+        }
         return {
             id: completion.id,
             provider: request.providerId,
             model: completion.model || request.modelId,
             created: completion.created,
-            choices: [
-                {
-                    message: {
-                        role: choice.message.role,
-                        content: choice.message.content || "",
-                    },
-                    finish_reason: choice.finish_reason,
-                    index: choice.index,
-                },
-            ],
+            choices: [responseChoice],
             usage: completion.usage
                 ? {
                     prompt_tokens: completion.usage.prompt_tokens,

package/dist/llm/clients/OpenAIClientAdapter.test.js

@@ -38,7 +38,13 @@ describe('OpenAIClientAdapter', () => {
                 stopSequences: [],
                 user: 'test-user',
                 geminiSafetySettings: [],
-                supportsSystemMessage: true
+                supportsSystemMessage: true,
+                reasoning: {
+                    enabled: false,
+                    effort: undefined,
+                    maxTokens: undefined,
+                    exclude: false
+                }
             }
         };
     });

package/dist/llm/config.js

@@ -57,6 +57,12 @@ exports.DEFAULT_LLM_SETTINGS = {
         { category: "HARM_CATEGORY_DANGEROUS_CONTENT", threshold: "BLOCK_NONE" },
         { category: "HARM_CATEGORY_HARASSMENT", threshold: "BLOCK_NONE" },
     ],
+    reasoning: {
+        enabled: false,
+        effort: undefined,
+        maxTokens: undefined,
+        exclude: false,
+    },
 };
 /**
  * Per-provider default setting overrides
@@ -126,6 +132,16 @@ exports.SUPPORTED_MODELS = [
         supportsPromptCache: true,
         cacheWritesPrice: 3.75,
         cacheReadsPrice: 0.3,
+        reasoning: {
+            supported: true,
+            enabledByDefault: false,
+            canDisable: true,
+            minBudget: 1024,
+            maxBudget: 32000,
+            defaultBudget: 10000,
+            outputType: 'summary',
+            requiresStreamingAbove: 21333,
+        },
     },
     {
         id: "claude-opus-4-20250514",
@@ -140,6 +156,16 @@ exports.SUPPORTED_MODELS = [
         supportsPromptCache: true,
         cacheWritesPrice: 18.75,
         cacheReadsPrice: 1.5,
+        reasoning: {
+            supported: true,
+            enabledByDefault: false,
+            canDisable: true,
+            minBudget: 1024,
+            maxBudget: 32000,
+            defaultBudget: 10000,
+            outputType: 'summary',
+            requiresStreamingAbove: 21333,
+        },
     },
     {
         id: "claude-3-7-sonnet-20250219",
@@ -154,6 +180,16 @@ exports.SUPPORTED_MODELS = [
         supportsPromptCache: true,
         cacheWritesPrice: 3.75,
         cacheReadsPrice: 0.3,
+        reasoning: {
+            supported: true,
+            enabledByDefault: false,
+            canDisable: true,
+            minBudget: 1024,
+            maxBudget: 32000,
+            defaultBudget: 10000,
+            outputType: 'full',
+            requiresStreamingAbove: 21333,
+        },
     },
     {
         id: "claude-3-5-sonnet-20241022",
@@ -196,6 +232,19 @@ exports.SUPPORTED_MODELS = [
         supportsImages: true,
         supportsPromptCache: true,
         cacheReadsPrice: 0.31,
+        reasoning: {
+            supported: true,
+            enabledByDefault: true,
+            canDisable: false,
+            minBudget: 1024,
+            maxBudget: 65536,
+            defaultBudget: -1,
+            dynamicBudget: {
+                value: -1,
+                description: "Let model decide based on query complexity",
+            },
+            outputType: 'summary',
+        },
     },
     {
         id: "gemini-2.5-flash",
@@ -208,9 +257,18 @@ exports.SUPPORTED_MODELS = [
         maxTokens: 65536,
         supportsImages: true,
         supportsPromptCache: true,
-        thinkingConfig: {
+        reasoning: {
+            supported: true,
+            enabledByDefault: true,
+            canDisable: true,
+            minBudget: 1024,
             maxBudget: 24576,
-            outputPrice: 2.5,
+            defaultBudget: -1,
+            dynamicBudget: {
+                value: -1,
+                description: "Let model decide based on query complexity",
+            },
+            outputType: 'summary',
         },
     },
     {
@@ -224,6 +282,19 @@ exports.SUPPORTED_MODELS = [
         maxTokens: 64000,
         supportsImages: true,
         supportsPromptCache: true,
+        reasoning: {
+            supported: true,
+            enabledByDefault: false,
+            canDisable: true,
+            minBudget: 512,
+            maxBudget: 24576,
+            defaultBudget: -1,
+            dynamicBudget: {
+                value: -1,
+                description: "Let model decide based on query complexity",
+            },
+            outputType: 'summary',
+        },
     },
     {
         id: "gemini-2.0-flash",
@@ -265,6 +336,12 @@ exports.SUPPORTED_MODELS = [
         supportsPromptCache: true,
         cacheReadsPrice: 0.275,
         unsupportedParameters: ["topP"],
+        reasoning: {
+            supported: true,
+            enabledByDefault: true,
+            canDisable: false,
+            outputType: 'none',
+        },
     },
     {
         id: "gpt-4.1",
@@ -401,6 +478,16 @@ function getDefaultSettingsForModel(modelId, providerId) {
     if (modelInfo && modelInfo.maxTokens !== undefined) {
         mergedSettings.maxTokens = modelInfo.maxTokens;
     }
+    // Handle reasoning settings based on model capabilities
+    if (modelInfo?.reasoning?.supported) {
+        // If the model has reasoning enabled by default, update the settings
+        if (modelInfo.reasoning.enabledByDefault) {
+            mergedSettings.reasoning = {
+                ...mergedSettings.reasoning,
+                enabled: true,
+            };
+        }
+    }
     // Filter out undefined values and ensure required fields
     return Object.fromEntries(Object.entries(mergedSettings).filter(([_, value]) => value !== undefined));
 }
@@ -504,5 +591,28 @@ function validateLLMSettings(settings) {
             }
         }
     }
+    if (settings.reasoning !== undefined) {
+        if (typeof settings.reasoning !== "object" || settings.reasoning === null) {
+            errors.push("reasoning must be an object");
+        }
+        else {
+            if (settings.reasoning.enabled !== undefined && typeof settings.reasoning.enabled !== "boolean") {
+                errors.push("reasoning.enabled must be a boolean");
+            }
+            if (settings.reasoning.effort !== undefined) {
+                if (!["high", "medium", "low"].includes(settings.reasoning.effort)) {
+                    errors.push("reasoning.effort must be 'high', 'medium', or 'low'");
+                }
+            }
+            if (settings.reasoning.maxTokens !== undefined) {
+                if (!Number.isInteger(settings.reasoning.maxTokens) || settings.reasoning.maxTokens < 0) {
+                    errors.push("reasoning.maxTokens must be a non-negative integer");
+                }
+            }
+            if (settings.reasoning.exclude !== undefined && typeof settings.reasoning.exclude !== "boolean") {
+                errors.push("reasoning.exclude must be a boolean");
+            }
+        }
+    }
     return errors;
 }

package/dist/llm/config.test.js

@@ -143,6 +143,23 @@ describe('LLM Config', () => {
             };
             expect((0, config_1.validateLLMSettings)(validGeminiSettings)).toEqual([]);
         });
+        it('should validate reasoning settings', () => {
+            // Invalid reasoning object
+            expect((0, config_1.validateLLMSettings)({ reasoning: 'invalid' })).toContain('reasoning must be an object');
+            // Invalid enabled value
+            expect((0, config_1.validateLLMSettings)({ reasoning: { enabled: 'yes' } })).toContain('reasoning.enabled must be a boolean');
+            // Invalid effort value
+            expect((0, config_1.validateLLMSettings)({ reasoning: { effort: 'maximum' } })).toContain("reasoning.effort must be 'high', 'medium', or 'low'");
+            expect((0, config_1.validateLLMSettings)({ reasoning: { effort: 'high' } })).toEqual([]);
+            // Invalid maxTokens value
+            expect((0, config_1.validateLLMSettings)({ reasoning: { maxTokens: -100 } })).toContain('reasoning.maxTokens must be a non-negative integer');
+            expect((0, config_1.validateLLMSettings)({ reasoning: { maxTokens: 1.5 } })).toContain('reasoning.maxTokens must be a non-negative integer');
+            expect((0, config_1.validateLLMSettings)({ reasoning: { maxTokens: 5000 } })).toEqual([]);
+            // Invalid exclude value
+            expect((0, config_1.validateLLMSettings)({ reasoning: { exclude: 'yes' } })).toContain('reasoning.exclude must be a boolean');
+            // Valid reasoning settings
+            expect((0, config_1.validateLLMSettings)({ reasoning: { enabled: true, effort: 'medium', maxTokens: 10000, exclude: false } })).toEqual([]);
+        });
         it('should return multiple errors for multiple invalid fields', () => {
             const invalidSettings = {
                 temperature: -1,

package/dist/llm/types.d.ts

@@ -29,6 +29,19 @@ 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;
+}
 /**
  * Configurable settings for LLM requests
  */
@@ -51,6 +64,8 @@ export interface LLMSettings {
     supportsSystemMessage?: boolean;
     /** Gemini-specific safety settings for content filtering */
     geminiSafetySettings?: GeminiSafetySetting[];
+    /** Universal reasoning/thinking configuration */
+    reasoning?: LLMReasoningSettings;
 }
 /**
  * Request structure for chat completion
@@ -62,6 +77,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 +95,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 +147,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 +190,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 +214,48 @@ export declare const LLM_IPC_CHANNELS: {
  * Type for LLM IPC channel names
  */
 export type LLMIPCChannelName = (typeof LLM_IPC_CHANNELS)[keyof typeof LLM_IPC_CHANNELS];
+/**
+ * Options for preparing messages with model context
+ */
+export interface PrepareMessageOptions {
+    /** Template string to render with variables and model context */
+    template?: string;
+    /** Variables to inject into the template */
+    variables?: Record<string, any>;
+    /** Pre-built messages (alternative to template) */
+    messages?: LLMMessage[];
+    /** Model selection - use preset ID */
+    presetId?: string;
+    /** Model selection - use provider ID (requires modelId) */
+    providerId?: ApiProviderId;
+    /** Model selection - use model ID (requires providerId) */
+    modelId?: string;
+    /** Optional settings override */
+    settings?: LLMSettings;
+}
+/**
+ * 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;
+}
+/**
+ * Result of preparing messages with model context
+ */
+export interface PrepareMessageResult {
+    /** The prepared messages ready to send */
+    messages: LLMMessage[];
+    /** Model context that was injected into the template */
+    modelContext: ModelContext;
+}