genai-lite 0.3.2 → 0.4.0

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

@@ -114,14 +114,35 @@ describe('ModelResolver', () => {
             expect(result.error?.error.message).toContain('Unsupported provider');
             expect(result.error?.error.message).toContain('Supported providers:');
         });
-        it('should return error for unsupported model', () => {
+        it('should create fallback model info for unknown models (with warning)', () => {
+            const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
             const result = resolver.resolve({
                 providerId: 'openai',
                 modelId: 'unsupported-model'
             });
-            expect(result.error).toBeDefined();
-            expect(result.error?.error.code).toBe('UNSUPPORTED_MODEL');
-            expect(result.error?.error.message).toContain('Unsupported model: unsupported-model');
+            // Should succeed with fallback, not error
+            expect(result.error).toBeUndefined();
+            expect(result.modelInfo).toBeDefined();
+            expect(result.modelInfo?.id).toBe('unsupported-model');
+            expect(result.modelInfo?.providerId).toBe('openai');
+            // Should warn about unknown model
+            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining('Unknown model "unsupported-model"'));
+            consoleWarnSpy.mockRestore();
+        });
+        it('should silently create fallback for llamacpp unknown models (no warning)', () => {
+            const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
+            const result = resolver.resolve({
+                providerId: 'llamacpp',
+                modelId: 'my-custom-gguf-model'
+            });
+            // Should succeed with fallback, not error
+            expect(result.error).toBeUndefined();
+            expect(result.modelInfo).toBeDefined();
+            expect(result.modelInfo?.id).toBe('my-custom-gguf-model');
+            expect(result.modelInfo?.providerId).toBe('llamacpp');
+            // Should NOT warn (llamacpp allows unknown models silently)
+            expect(consoleWarnSpy).not.toHaveBeenCalled();
+            consoleWarnSpy.mockRestore();
         });
         it('should pass through user settings for direct resolution', () => {
             const settings = {

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
@@ -175,6 +177,12 @@ export interface ProviderInfo {
     id: ApiProviderId;
     name: string;
     unsupportedParameters?: (keyof LLMSettings)[];
+    /**
+     * If true, allows using unknown/unregistered model IDs with this provider.
+     * Useful for providers like llamacpp where users load arbitrary models.
+     * Default: false (strict validation)
+     */
+    allowUnknownModels?: boolean;
 }
 /**
  * Reasoning/thinking capabilities for a model

package/dist/providers/fromEnvironment.d.ts

@@ -4,5 +4,9 @@ import type { ApiKeyProvider } from "../types";
  * It looks for variables in the format: PROVIDERID_API_KEY (e.g., OPENAI_API_KEY).
  * This is a secure and standard practice for server-side applications.
  * Note: Provider IDs are converted to uppercase.
+ *
+ * Special handling:
+ * - llamacpp: Returns 'not-needed' (local server, no authentication)
+ * - mock: Returns 'not-needed' (test provider, no authentication)
  */
 export declare const fromEnvironment: ApiKeyProvider;

package/dist/providers/fromEnvironment.js

@@ -6,8 +6,16 @@ exports.fromEnvironment = void 0;
  * It looks for variables in the format: PROVIDERID_API_KEY (e.g., OPENAI_API_KEY).
  * This is a secure and standard practice for server-side applications.
  * Note: Provider IDs are converted to uppercase.
+ *
+ * Special handling:
+ * - llamacpp: Returns 'not-needed' (local server, no authentication)
+ * - mock: Returns 'not-needed' (test provider, no authentication)
  */
 const fromEnvironment = async (providerId) => {
+    // Providers that don't require API keys (local/test providers)
+    if (providerId === 'llamacpp' || providerId === 'mock') {
+        return 'not-needed';
+    }
     const envVarName = `${providerId.toUpperCase()}_API_KEY`;
     return process.env[envVarName] || null;
 };

package/dist/providers/fromEnvironment.test.js

@@ -43,4 +43,17 @@ describe('fromEnvironment', () => {
         const key = await (0, fromEnvironment_1.fromEnvironment)('empty');
         expect(key).toBeNull(); // Empty string is falsy, so || null returns null
     });
+    it('should return "not-needed" for llamacpp provider', async () => {
+        const key = await (0, fromEnvironment_1.fromEnvironment)('llamacpp');
+        expect(key).toBe('not-needed');
+    });
+    it('should return "not-needed" for mock provider', async () => {
+        const key = await (0, fromEnvironment_1.fromEnvironment)('mock');
+        expect(key).toBe('not-needed');
+    });
+    it('should return "not-needed" for llamacpp even if environment variable exists', async () => {
+        process.env.LLAMACPP_API_KEY = 'should-not-be-used';
+        const key = await (0, fromEnvironment_1.fromEnvironment)('llamacpp');
+        expect(key).toBe('not-needed');
+    });
 });

package/package.json

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