genai-lite 0.3.1 → 0.3.3

package/README.md

@@ -268,7 +268,7 @@ The `onMissing` property controls what happens when the expected thinking tag is
 
 - `'ignore'`: Silently continue without the tag
 - `'warn'`: Log a warning but continue processing
-- `'error'`: Return an error response
+- `'error'`: Return an error response with the original response preserved in `partialResponse`
 - `'auto'` (default): Intelligently decide based on the model's native reasoning capabilities
 
 **How `'auto'` Mode Works:**
@@ -290,6 +290,7 @@ const response = await llmService.sendMessage({
   }
 });
 // Result: ERROR if <thinking> tag is missing (strict enforcement)
+// The response is still accessible via errorResponse.partialResponse
 
 // With native reasoning models (e.g., Claude with reasoning enabled)
 const response = await llmService.sendMessage({
@@ -654,6 +655,10 @@ if (response.object === 'error') {
       break;
     case 'validation_error':
       console.error('Invalid request:', response.error.message);
+      // For validation errors, the response may still be available
+      if (response.partialResponse) {
+        console.log('Partial response:', response.partialResponse.choices[0].message.content);
+      }
       break;
     default:
       console.error('Error:', response.error.message);

package/dist/llm/LLMService.js

@@ -155,7 +155,8 @@ class LLMService {
                         // Check if native reasoning is active
                         const isNativeReasoningActive = modelInfo.reasoning?.supported === true &&
                             (internalRequest.settings.reasoning?.enabled === true ||
-                                modelInfo.reasoning?.enabledByDefault === true ||
+                                (modelInfo.reasoning?.enabledByDefault === true &&
+                                    internalRequest.settings.reasoning?.enabled !== false) || // Only if not explicitly disabled
                                 modelInfo.reasoning?.canDisable === false); // Always-on models
                         effectiveOnMissing = isNativeReasoningActive ? 'ignore' : 'error';
                     }
@@ -192,6 +193,14 @@ class LLMService {
                                         type: "validation_error",
                                     },
                                     object: "error",
+                                    partialResponse: {
+                                        id: result.id,
+                                        provider: result.provider,
+                                        model: result.model,
+                                        created: result.created,
+                                        choices: result.choices,
+                                        usage: result.usage
+                                    }
                                 };
                             }
                             else if (effectiveOnMissing === 'warn') {

package/dist/llm/LLMService.test.js

@@ -488,6 +488,9 @@ describe('LLMService', () => {
                 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');
+                // Check that partial response is included
+                expect(errorResponse.partialResponse).toBeDefined();
+                expect(errorResponse.partialResponse.choices[0].message.content).toBe('Response without thinking tag.');
             });
             it('should handle missing tag for non-reasoning model with warn', async () => {
                 const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
@@ -509,6 +512,27 @@ describe('LLMService', () => {
                 expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Expected <thinking> tag was not found'));
                 consoleSpy.mockRestore();
             });
+            it('should handle missing tag with explicit error mode', async () => {
+                const request = {
+                    providerId: 'mistral',
+                    modelId: 'codestral-2501',
+                    messages: [{ role: 'user', content: 'test_thinking:Response without thinking tag.' }],
+                    settings: {
+                        thinkingExtraction: {
+                            enabled: true,
+                            onMissing: 'error' // Explicitly set to error
+                        }
+                    }
+                };
+                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.message).toContain('response was expected to start with a <thinking> tag');
+                // Check that partial response is included
+                expect(errorResponse.partialResponse).toBeDefined();
+                expect(errorResponse.partialResponse.choices[0].message.content).toBe('Response without thinking tag.');
+            });
             it('should handle missing tag for non-reasoning model with ignore', async () => {
                 const request = {
                     providerId: 'mistral',
@@ -543,6 +567,53 @@ describe('LLMService', () => {
                 expect(response.object).toBe('error');
                 const errorResponse = response;
                 expect(errorResponse.error.message).toContain('expected to start with a <reasoning> tag');
+                expect(errorResponse.partialResponse).toBeDefined();
+                expect(errorResponse.partialResponse.choices[0].message.content).toBe('Response without custom tag.');
+            });
+            describe('auto mode with native reasoning detection', () => {
+                it('should enforce thinking tags for non-reasoning models by default', async () => {
+                    // Mistral model doesn't have reasoning support
+                    const request = {
+                        providerId: 'mistral',
+                        modelId: 'codestral-2501',
+                        messages: [{ role: 'user', content: 'test_thinking:Response without thinking tag.' }],
+                        settings: {
+                            thinkingExtraction: {
+                                enabled: true,
+                                onMissing: 'auto'
+                            }
+                        }
+                    };
+                    const response = await service.sendMessage(request);
+                    // Should error because model doesn't have native reasoning
+                    expect(response.object).toBe('error');
+                    const errorResponse = response;
+                    expect(errorResponse.error.code).toBe('MISSING_EXPECTED_TAG');
+                    expect(errorResponse.error.message).toContain('does not have native reasoning active');
+                    expect(errorResponse.partialResponse).toBeDefined();
+                    expect(errorResponse.partialResponse.choices[0].message.content).toBe('Response without thinking tag.');
+                });
+                it('should respect explicit reasoning.enabled: false even for models with enabledByDefault', async () => {
+                    // This is the key test for the fix
+                    const request = {
+                        providerId: 'mistral',
+                        modelId: 'codestral-2501',
+                        messages: [{ role: 'user', content: 'test_thinking:Response without thinking tag.' }],
+                        settings: {
+                            reasoning: { enabled: false }, // Explicitly disabled
+                            thinkingExtraction: {
+                                enabled: true,
+                                onMissing: 'auto'
+                            }
+                        }
+                    };
+                    const response = await service.sendMessage(request);
+                    // Should error because reasoning is explicitly disabled
+                    expect(response.object).toBe('error');
+                    const errorResponse = response;
+                    expect(errorResponse.error.code).toBe('MISSING_EXPECTED_TAG');
+                    expect(errorResponse.partialResponse).toBeDefined();
+                });
             });
         });
     });

package/dist/llm/types.d.ts

@@ -167,6 +167,8 @@ export interface LLMFailureResponse {
     model?: string;
     error: LLMError;
     object: 'error';
+    /** The partial response that was generated before the error occurred (if available) */
+    partialResponse?: Omit<LLMResponse, 'object'>;
 }
 /**
  * Information about a supported LLM provider

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genai-lite",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "A lightweight, portable toolkit for interacting with various Generative AI APIs.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",