genai-lite 0.2.0 → 0.3.0

package/dist/llm/clients/MockClientAdapter.js

@@ -31,7 +31,8 @@ class MockClientAdapter {
         try {
             // Check for special test patterns in the last user message
             const lastMessage = request.messages[request.messages.length - 1];
-            const content = lastMessage?.content?.toLowerCase() || "";
+            const originalContent = lastMessage?.content || "";
+            const content = originalContent.toLowerCase();
             // Simulate various error conditions based on message content
             if (content.includes("error_invalid_key")) {
                 return this.createErrorResponse("Invalid API key provided", types_1.ADAPTER_ERROR_CODES.INVALID_API_KEY, 401, request);
@@ -58,7 +59,7 @@ class MockClientAdapter {
                 return this.createErrorResponse("Generic provider error", types_1.ADAPTER_ERROR_CODES.PROVIDER_ERROR, 500, request);
             }
             // Generate successful mock response
-            return this.createSuccessResponse(request, content);
+            return this.createSuccessResponse(request, content, originalContent);
         }
         catch (error) {
             return this.createErrorResponse(`Mock adapter error: ${error instanceof Error ? error.message : "Unknown error"}`, types_1.ADAPTER_ERROR_CODES.UNKNOWN_ERROR, 500, request);
@@ -84,7 +85,7 @@ class MockClientAdapter {
     /**
      * Creates a successful mock response
      */
-    createSuccessResponse(request, userContent) {
+    createSuccessResponse(request, userContent, originalContent) {
         // Generate response content based on user input and settings
         let responseContent;
         // Check for settings-based test patterns
@@ -94,6 +95,11 @@ class MockClientAdapter {
         else if (userContent.includes("test_settings")) {
             responseContent = this.generateSettingsTestResponse(request.settings);
         }
+        else if (userContent.includes("test_thinking:")) {
+            // Extract content after "test_thinking:" for testing thinking extraction
+            const startIndex = originalContent.indexOf("test_thinking:") + "test_thinking:".length;
+            responseContent = originalContent.substring(startIndex).trim();
+        }
         else if (userContent.includes("hello") || userContent.includes("hi")) {
             responseContent =
                 "Hello! I'm a mock LLM assistant. How can I help you today?";

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

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

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,17 @@ describe('OpenAIClientAdapter', () => {
                 stopSequences: [],
                 user: 'test-user',
                 geminiSafetySettings: [],
-                supportsSystemMessage: true
+                supportsSystemMessage: true,
+                reasoning: {
+                    enabled: false,
+                    effort: undefined,
+                    maxTokens: undefined,
+                    exclude: false
+                },
+                thinkingExtraction: {
+                    enabled: true,
+                    tag: 'thinking'
+                }
             }
         };
     });

package/dist/llm/config.js

@@ -57,6 +57,17 @@ 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,
+    },
+    thinkingExtraction: {
+        enabled: false, // Now requires explicit opt-in, works with onMissing: 'auto'
+        tag: 'thinking',
+        onMissing: 'auto' // Smart enforcement based on native reasoning status
+    },
 };
 /**
  * Per-provider default setting overrides
@@ -126,6 +137,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 +161,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 +185,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 +237,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 +262,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 +287,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 +341,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 +483,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 +596,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/services/AdapterRegistry.d.ts

@@ -0,0 +1,59 @@
+import type { ApiProviderId } from "../types";
+import type { ILLMClientAdapter } from "../clients/types";
+/**
+ * Information about a registered adapter
+ */
+export interface AdapterInfo {
+    providerId: ApiProviderId;
+    hasAdapter: boolean;
+    adapterInfo: {
+        name: string;
+    };
+}
+/**
+ * Summary of provider availability
+ */
+export interface ProviderSummary {
+    totalProviders: number;
+    providersWithAdapters: number;
+    availableProviders: string[];
+    unavailableProviders: string[];
+}
+/**
+ * Registry for managing LLM client adapters
+ */
+export declare class AdapterRegistry {
+    private clientAdapters;
+    private mockClientAdapter;
+    constructor();
+    /**
+     * Initializes adapters for all supported providers
+     */
+    private initializeAdapters;
+    /**
+     * Registers a client adapter for a specific provider
+     *
+     * @param providerId - The provider ID
+     * @param adapter - The client adapter implementation
+     */
+    registerAdapter(providerId: ApiProviderId, adapter: ILLMClientAdapter): void;
+    /**
+     * Gets the appropriate client adapter for a provider
+     *
+     * @param providerId - The provider ID
+     * @returns The client adapter to use
+     */
+    getAdapter(providerId: ApiProviderId): ILLMClientAdapter;
+    /**
+     * Gets information about registered adapters
+     *
+     * @returns Map of provider IDs to adapter info
+     */
+    getRegisteredAdapters(): Map<ApiProviderId, AdapterInfo>;
+    /**
+     * Gets a summary of available providers and their adapter status
+     *
+     * @returns Summary of provider availability
+     */
+    getProviderSummary(): ProviderSummary;
+}

package/dist/llm/services/AdapterRegistry.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdapterRegistry = void 0;
+const MockClientAdapter_1 = require("../clients/MockClientAdapter");
+const config_1 = require("../config");
+/**
+ * Registry for managing LLM client adapters
+ */
+class AdapterRegistry {
+    constructor() {
+        this.clientAdapters = new Map();
+        this.mockClientAdapter = new MockClientAdapter_1.MockClientAdapter();
+        this.initializeAdapters();
+    }
+    /**
+     * Initializes adapters for all supported providers
+     */
+    initializeAdapters() {
+        let registeredCount = 0;
+        const successfullyRegisteredProviders = [];
+        for (const provider of config_1.SUPPORTED_PROVIDERS) {
+            const AdapterClass = config_1.ADAPTER_CONSTRUCTORS[provider.id];
+            if (AdapterClass) {
+                try {
+                    const adapterConfig = config_1.ADAPTER_CONFIGS[provider.id];
+                    const adapterInstance = new AdapterClass(adapterConfig);
+                    this.registerAdapter(provider.id, adapterInstance);
+                    registeredCount++;
+                    successfullyRegisteredProviders.push(provider.id);
+                }
+                catch (error) {
+                    console.error(`LLMService: Failed to instantiate adapter for provider '${provider.id}'. This provider will use the mock adapter. Error:`, error);
+                }
+            }
+            else {
+                console.warn(`LLMService: No adapter constructor found for supported provider '${provider.id}'. This provider will use the mock adapter as a fallback.`);
+            }
+        }
+        if (registeredCount > 0) {
+            console.log(`LLMService: Initialized with ${registeredCount} dynamically registered adapter(s) for: ${successfullyRegisteredProviders.join(", ")}.`);
+        }
+        else {
+            console.log(`LLMService: No real adapters were dynamically registered. All providers will use the mock adapter.`);
+        }
+    }
+    /**
+     * Registers a client adapter for a specific provider
+     *
+     * @param providerId - The provider ID
+     * @param adapter - The client adapter implementation
+     */
+    registerAdapter(providerId, adapter) {
+        this.clientAdapters.set(providerId, adapter);
+        console.log(`Registered client adapter for provider: ${providerId}`);
+    }
+    /**
+     * Gets the appropriate client adapter for a provider
+     *
+     * @param providerId - The provider ID
+     * @returns The client adapter to use
+     */
+    getAdapter(providerId) {
+        // Check for registered real adapters first
+        const registeredAdapter = this.clientAdapters.get(providerId);
+        if (registeredAdapter) {
+            console.log(`Using registered adapter for provider: ${providerId}`);
+            return registeredAdapter;
+        }
+        // Fall back to mock adapter for unsupported providers
+        console.log(`No real adapter found for ${providerId}, using mock adapter`);
+        return this.mockClientAdapter;
+    }
+    /**
+     * Gets information about registered adapters
+     *
+     * @returns Map of provider IDs to adapter info
+     */
+    getRegisteredAdapters() {
+        const adapterInfo = new Map();
+        for (const [providerId, adapter] of this.clientAdapters.entries()) {
+            adapterInfo.set(providerId, {
+                providerId,
+                hasAdapter: true,
+                adapterInfo: adapter.getAdapterInfo?.() || { name: "Unknown Adapter" },
+            });
+        }
+        return adapterInfo;
+    }
+    /**
+     * Gets a summary of available providers and their adapter status
+     *
+     * @returns Summary of provider availability
+     */
+    getProviderSummary() {
+        const availableProviders = [];
+        const unavailableProviders = [];
+        for (const provider of config_1.SUPPORTED_PROVIDERS) {
+            if (this.clientAdapters.has(provider.id)) {
+                availableProviders.push(provider.id);
+            }
+            else {
+                unavailableProviders.push(provider.id);
+            }
+        }
+        return {
+            totalProviders: config_1.SUPPORTED_PROVIDERS.length,
+            providersWithAdapters: availableProviders.length,
+            availableProviders,
+            unavailableProviders,
+        };
+    }
+}
+exports.AdapterRegistry = AdapterRegistry;

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

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