genai-lite 0.2.1 → 0.3.1

package/dist/llm/LLMService.test.js

@@ -359,4 +359,191 @@ describe('LLMService', () => {
             expect(gpt4.maxTokens).toBeGreaterThan(0);
         });
     });
+    describe('thinking extraction', () => {
+        it('should extract thinking tag from response when enabled', async () => {
+            // Use mistral provider which doesn't have an adapter, so MockClientAdapter will be used
+            const request = {
+                providerId: 'mistral',
+                modelId: 'codestral-2501',
+                messages: [{ role: 'user', content: 'test_thinking:<thinking>I am thinking about this problem.</thinking>Here is the answer.' }],
+                settings: {
+                    thinkingExtraction: {
+                        enabled: true,
+                        tag: 'thinking'
+                    }
+                }
+            };
+            const response = await service.sendMessage(request);
+            expect(response.object).toBe('chat.completion');
+            const successResponse = response;
+            expect(successResponse.choices[0].reasoning).toBe('I am thinking about this problem.');
+            expect(successResponse.choices[0].message.content).toBe('Here is the answer.');
+        });
+        it('should not extract thinking tag when disabled', async () => {
+            const request = {
+                providerId: 'mistral',
+                modelId: 'codestral-2501',
+                messages: [{ role: 'user', content: 'test_thinking:<thinking>I am thinking about this problem.</thinking>Here is the answer.' }],
+                settings: {
+                    thinkingExtraction: {
+                        enabled: false,
+                        tag: 'thinking'
+                    }
+                }
+            };
+            const response = await service.sendMessage(request);
+            expect(response.object).toBe('chat.completion');
+            const successResponse = response;
+            expect(successResponse.choices[0].reasoning).toBeUndefined();
+            expect(successResponse.choices[0].message.content).toBe('<thinking>I am thinking about this problem.</thinking>Here is the answer.');
+        });
+        it('should use custom tag name', async () => {
+            const request = {
+                providerId: 'mistral',
+                modelId: 'codestral-2501',
+                messages: [{ role: 'user', content: 'test_thinking:<scratchpad>Working through the logic...</scratchpad>Final answer is 42.' }],
+                settings: {
+                    thinkingExtraction: {
+                        enabled: true,
+                        tag: 'scratchpad'
+                    }
+                }
+            };
+            const response = await service.sendMessage(request);
+            expect(response.object).toBe('chat.completion');
+            const successResponse = response;
+            expect(successResponse.choices[0].reasoning).toBe('Working through the logic...');
+            expect(successResponse.choices[0].message.content).toBe('Final answer is 42.');
+        });
+        it('should append to existing reasoning', async () => {
+            // Use test_reasoning to get a response with existing reasoning, then test extraction appends to it
+            const request = {
+                providerId: 'mistral',
+                modelId: 'codestral-2501',
+                messages: [{ role: 'user', content: 'test_reasoning:<thinking>Additional thoughts here.</thinking>The analysis is complete.' }],
+                settings: {
+                    thinkingExtraction: {
+                        enabled: true,
+                        tag: 'thinking'
+                    }
+                }
+            };
+            const response = await service.sendMessage(request);
+            expect(response.object).toBe('chat.completion');
+            const successResponse = response;
+            // Should contain both the initial reasoning and the extracted thinking with separator
+            expect(successResponse.choices[0].reasoning).toBe('Initial model reasoning from native capabilities.\n\n#### Additional Reasoning\n\nAdditional thoughts here.');
+            expect(successResponse.choices[0].message.content).toBe('The analysis is complete.');
+        });
+        it('should handle missing tag with explicit ignore', async () => {
+            const request = {
+                providerId: 'mistral',
+                modelId: 'codestral-2501',
+                messages: [{ role: 'user', content: 'test_thinking:This response has no thinking tag.' }],
+                settings: {
+                    thinkingExtraction: {
+                        enabled: true,
+                        tag: 'thinking',
+                        onMissing: 'ignore' // Explicitly set to ignore
+                    }
+                }
+            };
+            const response = await service.sendMessage(request);
+            expect(response.object).toBe('chat.completion');
+            const successResponse = response;
+            expect(successResponse.choices[0].reasoning).toBeUndefined();
+            expect(successResponse.choices[0].message.content).toBe('This response has no thinking tag.');
+        });
+        it('should use default settings when not specified', async () => {
+            // Default is now disabled, needs explicit opt-in
+            const request = {
+                providerId: 'mistral',
+                modelId: 'codestral-2501',
+                messages: [{ role: 'user', content: 'test_thinking:<thinking>Default extraction test.</thinking>Result here.' }]
+            };
+            const response = await service.sendMessage(request);
+            expect(response.object).toBe('chat.completion');
+            const successResponse = response;
+            // With default settings (enabled: false), no extraction should occur
+            expect(successResponse.choices[0].reasoning).toBeUndefined();
+            expect(successResponse.choices[0].message.content).toBe('<thinking>Default extraction test.</thinking>Result here.');
+        });
+        describe('onMissing behavior', () => {
+            it('should use auto mode by default with error for non-native models', async () => {
+                const request = {
+                    providerId: 'mistral',
+                    modelId: 'codestral-2501', // Non-native reasoning model (using mock)
+                    messages: [{ role: 'user', content: 'test_thinking:Response without thinking tag.' }],
+                    settings: {
+                        thinkingExtraction: {
+                            enabled: true,
+                            // onMissing defaults to 'auto'
+                        }
+                    }
+                };
+                const response = await service.sendMessage(request);
+                expect(response.object).toBe('error');
+                const errorResponse = response;
+                expect(errorResponse.error.code).toBe('MISSING_EXPECTED_TAG');
+                expect(errorResponse.error.type).toBe('validation_error');
+                expect(errorResponse.error.message).toContain('response was expected to start with a <thinking> tag');
+                expect(errorResponse.error.message).toContain('does not have native reasoning active');
+            });
+            it('should handle missing tag for non-reasoning model with warn', async () => {
+                const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+                const request = {
+                    providerId: 'mistral',
+                    modelId: 'codestral-2501',
+                    messages: [{ role: 'user', content: 'test_thinking:Response without thinking tag.' }],
+                    settings: {
+                        thinkingExtraction: {
+                            enabled: true,
+                            onMissing: 'warn'
+                        }
+                    }
+                };
+                const response = await service.sendMessage(request);
+                expect(response.object).toBe('chat.completion');
+                const successResponse = response;
+                expect(successResponse.choices[0].message.content).toBe('Response without thinking tag.');
+                expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Expected <thinking> tag was not found'));
+                consoleSpy.mockRestore();
+            });
+            it('should handle missing tag for non-reasoning model with ignore', async () => {
+                const request = {
+                    providerId: 'mistral',
+                    modelId: 'codestral-2501',
+                    messages: [{ role: 'user', content: 'test_thinking:Response without thinking tag.' }],
+                    settings: {
+                        thinkingExtraction: {
+                            enabled: true,
+                            onMissing: 'ignore'
+                        }
+                    }
+                };
+                const response = await service.sendMessage(request);
+                expect(response.object).toBe('chat.completion');
+                const successResponse = response;
+                expect(successResponse.choices[0].message.content).toBe('Response without thinking tag.');
+            });
+            it('should work with custom tag names in error messages', async () => {
+                const request = {
+                    providerId: 'mistral',
+                    modelId: 'codestral-2501',
+                    messages: [{ role: 'user', content: 'test_thinking:Response without custom tag.' }],
+                    settings: {
+                        thinkingExtraction: {
+                            enabled: true,
+                            tag: 'reasoning',
+                            onMissing: 'error'
+                        }
+                    }
+                };
+                const response = await service.sendMessage(request);
+                expect(response.object).toBe('error');
+                const errorResponse = response;
+                expect(errorResponse.error.message).toContain('expected to start with a <reasoning> tag');
+            });
+        });
+    });
 });

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

@@ -42,6 +42,10 @@ describe('AnthropicClientAdapter', () => {
                     effort: undefined,
                     maxTokens: undefined,
                     exclude: false
+                },
+                thinkingExtraction: {
+                    enabled: true,
+                    tag: 'thinking'
                 }
             }
         };

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

@@ -43,6 +43,10 @@ describe('GeminiClientAdapter', () => {
                     effort: undefined,
                     maxTokens: undefined,
                     exclude: false
+                },
+                thinkingExtraction: {
+                    enabled: true,
+                    tag: 'thinking'
                 }
             }
         };

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,16 @@ 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("test_reasoning:")) {
+            // Extract content after "test_reasoning:" and return it as both content and reasoning
+            const startIndex = originalContent.indexOf("test_reasoning:") + "test_reasoning:".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?";
@@ -147,21 +158,26 @@ class MockClientAdapter {
         else if (request.settings.stopSequences.some((seq) => responseContent.includes(seq))) {
             finishReason = "stop";
         }
+        // Check if we need to add reasoning to the response
+        const isReasoningTest = userContent.includes("test_reasoning:");
+        const choice = {
+            message: {
+                role: "assistant",
+                content: responseContent,
+            },
+            finish_reason: finishReason,
+            index: 0,
+        };
+        // Add reasoning field for test_reasoning pattern
+        if (isReasoningTest) {
+            choice.reasoning = "Initial model reasoning from native capabilities.";
+        }
         return {
             id: `mock-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
             provider: request.providerId,
             model: request.modelId,
             created: Math.floor(Date.now() / 1000),
-            choices: [
-                {
-                    message: {
-                        role: "assistant",
-                        content: responseContent,
-                    },
-                    finish_reason: finishReason,
-                    index: 0,
-                },
-            ],
+            choices: [choice],
             usage: {
                 prompt_tokens: promptTokenCount,
                 completion_tokens: mockTokenCount,

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

@@ -26,6 +26,10 @@ describe('MockClientAdapter', () => {
                     effort: undefined,
                     maxTokens: undefined,
                     exclude: false
+                },
+                thinkingExtraction: {
+                    enabled: true,
+                    tag: 'thinking'
                 }
             }
         };

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

@@ -44,6 +44,10 @@ describe('OpenAIClientAdapter', () => {
                     effort: undefined,
                     maxTokens: undefined,
                     exclude: false
+                },
+                thinkingExtraction: {
+                    enabled: true,
+                    tag: 'thinking'
                 }
             }
         };

package/dist/llm/config.js

@@ -63,6 +63,11 @@ exports.DEFAULT_LLM_SETTINGS = {
         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

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 {};