genai-lite 0.3.2 → 0.4.0

package/dist/llm/clients/LlamaCppServerClient.js

@@ -0,0 +1,192 @@
+"use strict";
+// AI Summary: Utility client for interacting with llama.cpp server's non-LLM endpoints.
+// Provides methods for tokenization, embeddings, health checks, and server management.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LlamaCppServerClient = void 0;
+/**
+ * Client for interacting with llama.cpp server's management and utility endpoints
+ *
+ * This class provides access to non-LLM endpoints like tokenization, embeddings,
+ * health checks, and server properties. For chat completions, use LlamaCppClientAdapter.
+ *
+ * @example
+ * ```typescript
+ * const client = new LlamaCppServerClient('http://localhost:8080');
+ *
+ * // Check if server is ready
+ * const health = await client.getHealth();
+ * console.log(health.status); // 'ok', 'loading', or 'error'
+ *
+ * // Tokenize text
+ * const { tokens } = await client.tokenize('Hello world');
+ * console.log(tokens); // [123, 456, 789]
+ *
+ * // Generate embeddings
+ * const { embedding } = await client.createEmbedding('Some text');
+ * ```
+ */
+class LlamaCppServerClient {
+    /**
+     * Creates a new llama.cpp server client
+     *
+     * @param baseURL - The base URL of the llama.cpp server (e.g., 'http://localhost:8080')
+     */
+    constructor(baseURL) {
+        // Remove trailing slash if present
+        this.baseURL = baseURL.replace(/\/$/, '');
+    }
+    /**
+     * Checks the health and readiness of the server
+     *
+     * @returns Promise resolving to health status
+     * @throws Error if the request fails
+     */
+    async getHealth() {
+        const response = await fetch(`${this.baseURL}/health`);
+        if (!response.ok) {
+            throw new Error(`Health check failed: ${response.status} ${response.statusText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Converts text to tokens using the loaded model's tokenizer
+     *
+     * @param content - The text to tokenize
+     * @returns Promise resolving to array of token IDs
+     * @throws Error if the request fails
+     */
+    async tokenize(content) {
+        const response = await fetch(`${this.baseURL}/tokenize`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ content }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Tokenize failed: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Converts tokens back to text using the loaded model's tokenizer
+     *
+     * @param tokens - Array of token IDs to convert
+     * @returns Promise resolving to the decoded text
+     * @throws Error if the request fails
+     */
+    async detokenize(tokens) {
+        const response = await fetch(`${this.baseURL}/detokenize`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ tokens }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Detokenize failed: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Generates an embedding vector for the given text
+     *
+     * @param content - The text to embed
+     * @param imageData - Optional base64-encoded image data for multimodal models
+     * @returns Promise resolving to the embedding vector
+     * @throws Error if the request fails
+     */
+    async createEmbedding(content, imageData) {
+        const body = { content };
+        if (imageData) {
+            body.image_data = imageData;
+        }
+        const response = await fetch(`${this.baseURL}/embedding`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Embedding failed: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Performs code infilling (completing code between prefix and suffix)
+     *
+     * @param inputPrefix - The code before the cursor/gap
+     * @param inputSuffix - The code after the cursor/gap
+     * @returns Promise resolving to the infilled completion
+     * @throws Error if the request fails
+     */
+    async infill(inputPrefix, inputSuffix) {
+        const response = await fetch(`${this.baseURL}/infill`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                input_prefix: inputPrefix,
+                input_suffix: inputSuffix,
+            }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Infill failed: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Retrieves server properties and configuration
+     *
+     * @returns Promise resolving to server properties
+     * @throws Error if the request fails
+     */
+    async getProps() {
+        const response = await fetch(`${this.baseURL}/props`);
+        if (!response.ok) {
+            throw new Error(`Get props failed: ${response.status} ${response.statusText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Retrieves performance metrics from the server
+     *
+     * @returns Promise resolving to metrics data
+     * @throws Error if the request fails
+     */
+    async getMetrics() {
+        const response = await fetch(`${this.baseURL}/metrics`);
+        if (!response.ok) {
+            throw new Error(`Get metrics failed: ${response.status} ${response.statusText}`);
+        }
+        // Metrics endpoint might return Prometheus format or JSON
+        const contentType = response.headers.get('content-type');
+        if (contentType?.includes('application/json')) {
+            return await response.json();
+        }
+        else {
+            // Return raw text for Prometheus format
+            const text = await response.text();
+            return { raw: text };
+        }
+    }
+    /**
+     * Retrieves processing slot status (debugging endpoint)
+     *
+     * WARNING: This endpoint may expose sensitive information including prompt content.
+     * The llama.cpp documentation strongly advises against enabling this in production.
+     * Only use this endpoint in development/debugging environments.
+     *
+     * @returns Promise resolving to slot status information
+     * @throws Error if the request fails or endpoint is not enabled
+     */
+    async getSlots() {
+        const response = await fetch(`${this.baseURL}/slots`);
+        if (!response.ok) {
+            if (response.status === 404) {
+                throw new Error('Slots endpoint not enabled. Start server with --slots flag to enable.');
+            }
+            throw new Error(`Get slots failed: ${response.status} ${response.statusText}`);
+        }
+        return await response.json();
+    }
+}
+exports.LlamaCppServerClient = LlamaCppServerClient;

package/dist/llm/clients/LlamaCppServerClient.test.d.ts

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

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

@@ -0,0 +1,294 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const LlamaCppServerClient_1 = require("./LlamaCppServerClient");
+// Mock global fetch
+global.fetch = jest.fn();
+describe('LlamaCppServerClient', () => {
+    let client;
+    const baseURL = 'http://localhost:8080';
+    beforeEach(() => {
+        client = new LlamaCppServerClient_1.LlamaCppServerClient(baseURL);
+        jest.clearAllMocks();
+    });
+    describe('constructor', () => {
+        it('should remove trailing slash from baseURL', () => {
+            const clientWithSlash = new LlamaCppServerClient_1.LlamaCppServerClient('http://localhost:8080/');
+            expect(clientWithSlash.baseURL).toBe('http://localhost:8080');
+        });
+        it('should preserve baseURL without trailing slash', () => {
+            expect(client.baseURL).toBe('http://localhost:8080');
+        });
+    });
+    describe('getHealth', () => {
+        it('should return health status when server is ok', async () => {
+            const mockResponse = { status: 'ok' };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockResponse,
+            });
+            const result = await client.getHealth();
+            expect(global.fetch).toHaveBeenCalledWith(`${baseURL}/health`);
+            expect(result).toEqual(mockResponse);
+        });
+        it('should return loading status', async () => {
+            const mockResponse = { status: 'loading' };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockResponse,
+            });
+            const result = await client.getHealth();
+            expect(result.status).toBe('loading');
+        });
+        it('should return error status with message', async () => {
+            const mockResponse = { status: 'error', error: 'Model load failed' };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockResponse,
+            });
+            const result = await client.getHealth();
+            expect(result.status).toBe('error');
+            expect(result.error).toBe('Model load failed');
+        });
+        it('should throw error when request fails', async () => {
+            global.fetch.mockResolvedValueOnce({
+                ok: false,
+                status: 500,
+                statusText: 'Internal Server Error',
+            });
+            await expect(client.getHealth()).rejects.toThrow('Health check failed: 500 Internal Server Error');
+        });
+    });
+    describe('tokenize', () => {
+        it('should tokenize text and return token IDs', async () => {
+            const mockResponse = { tokens: [12, 345, 6789] };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockResponse,
+            });
+            const result = await client.tokenize('Hello world');
+            expect(global.fetch).toHaveBeenCalledWith(`${baseURL}/tokenize`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ content: 'Hello world' }),
+            });
+            expect(result).toEqual(mockResponse);
+            expect(result.tokens).toHaveLength(3);
+        });
+        it('should handle empty string', async () => {
+            const mockResponse = { tokens: [] };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockResponse,
+            });
+            const result = await client.tokenize('');
+            expect(result.tokens).toEqual([]);
+        });
+        it('should throw error when tokenization fails', async () => {
+            global.fetch.mockResolvedValueOnce({
+                ok: false,
+                status: 400,
+                statusText: 'Bad Request',
+                text: async () => 'Invalid input',
+            });
+            await expect(client.tokenize('test')).rejects.toThrow('Tokenize failed: 400 Bad Request - Invalid input');
+        });
+    });
+    describe('detokenize', () => {
+        it('should convert tokens back to text', async () => {
+            const mockResponse = { content: 'Hello world' };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockResponse,
+            });
+            const result = await client.detokenize([12, 345, 6789]);
+            expect(global.fetch).toHaveBeenCalledWith(`${baseURL}/detokenize`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ tokens: [12, 345, 6789] }),
+            });
+            expect(result).toEqual(mockResponse);
+            expect(result.content).toBe('Hello world');
+        });
+        it('should handle empty token array', async () => {
+            const mockResponse = { content: '' };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockResponse,
+            });
+            const result = await client.detokenize([]);
+            expect(result.content).toBe('');
+        });
+        it('should throw error when detokenization fails', async () => {
+            global.fetch.mockResolvedValueOnce({
+                ok: false,
+                status: 400,
+                statusText: 'Bad Request',
+                text: async () => 'Invalid tokens',
+            });
+            await expect(client.detokenize([1, 2, 3])).rejects.toThrow('Detokenize failed: 400 Bad Request - Invalid tokens');
+        });
+    });
+    describe('createEmbedding', () => {
+        it('should generate embedding for text', async () => {
+            const mockEmbedding = [0.1, 0.2, 0.3, 0.4];
+            const mockResponse = { embedding: mockEmbedding };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockResponse,
+            });
+            const result = await client.createEmbedding('Hello world');
+            expect(global.fetch).toHaveBeenCalledWith(`${baseURL}/embedding`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ content: 'Hello world' }),
+            });
+            expect(result.embedding).toEqual(mockEmbedding);
+        });
+        it('should include image data when provided', async () => {
+            const mockResponse = { embedding: [0.1, 0.2] };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockResponse,
+            });
+            const imageData = 'base64encodedimage';
+            await client.createEmbedding('Text with image', imageData);
+            expect(global.fetch).toHaveBeenCalledWith(`${baseURL}/embedding`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    content: 'Text with image',
+                    image_data: imageData,
+                }),
+            });
+        });
+        it('should throw error when embedding fails', async () => {
+            global.fetch.mockResolvedValueOnce({
+                ok: false,
+                status: 500,
+                statusText: 'Server Error',
+                text: async () => 'Model error',
+            });
+            await expect(client.createEmbedding('test')).rejects.toThrow('Embedding failed: 500 Server Error - Model error');
+        });
+    });
+    describe('infill', () => {
+        it('should complete code between prefix and suffix', async () => {
+            const mockResponse = { content: '    return x + y;\n', tokens: [1, 2, 3], stop: true };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockResponse,
+            });
+            const result = await client.infill('def add(x, y):\n', '\nprint(add(2, 3))');
+            expect(global.fetch).toHaveBeenCalledWith(`${baseURL}/infill`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    input_prefix: 'def add(x, y):\n',
+                    input_suffix: '\nprint(add(2, 3))',
+                }),
+            });
+            expect(result.content).toBe('    return x + y;\n');
+            expect(result.stop).toBe(true);
+        });
+        it('should throw error when infill fails', async () => {
+            global.fetch.mockResolvedValueOnce({
+                ok: false,
+                status: 400,
+                statusText: 'Bad Request',
+                text: async () => 'Invalid code',
+            });
+            await expect(client.infill('prefix', 'suffix')).rejects.toThrow('Infill failed: 400 Bad Request - Invalid code');
+        });
+    });
+    describe('getProps', () => {
+        it('should retrieve server properties', async () => {
+            const mockResponse = {
+                assistant_name: 'Assistant',
+                user_name: 'User',
+                default_generation_settings: { temperature: 0.8 },
+                total_slots: 4,
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockResponse,
+            });
+            const result = await client.getProps();
+            expect(global.fetch).toHaveBeenCalledWith(`${baseURL}/props`);
+            expect(result).toEqual(mockResponse);
+            expect(result.total_slots).toBe(4);
+        });
+        it('should throw error when getting props fails', async () => {
+            global.fetch.mockResolvedValueOnce({
+                ok: false,
+                status: 404,
+                statusText: 'Not Found',
+            });
+            await expect(client.getProps()).rejects.toThrow('Get props failed: 404 Not Found');
+        });
+    });
+    describe('getMetrics', () => {
+        it('should retrieve JSON metrics', async () => {
+            const mockResponse = { requests_total: 100, tokens_generated: 50000 };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                headers: new Map([['content-type', 'application/json']]),
+                json: async () => mockResponse,
+            });
+            const result = await client.getMetrics();
+            expect(global.fetch).toHaveBeenCalledWith(`${baseURL}/metrics`);
+            expect(result).toEqual(mockResponse);
+        });
+        it('should handle Prometheus format metrics', async () => {
+            const prometheusText = '# HELP metric_name Description\nmetric_name 42\n';
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                headers: new Map([['content-type', 'text/plain']]),
+                text: async () => prometheusText,
+            });
+            const result = await client.getMetrics();
+            expect(result).toEqual({ raw: prometheusText });
+        });
+        it('should throw error when getting metrics fails', async () => {
+            global.fetch.mockResolvedValueOnce({
+                ok: false,
+                status: 500,
+                statusText: 'Server Error',
+            });
+            await expect(client.getMetrics()).rejects.toThrow('Get metrics failed: 500 Server Error');
+        });
+    });
+    describe('getSlots', () => {
+        it('should retrieve slot information', async () => {
+            const mockResponse = {
+                slots: [
+                    { id: 0, state: 1, prompt: 'Hello' },
+                    { id: 1, state: 0 },
+                ],
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockResponse,
+            });
+            const result = await client.getSlots();
+            expect(global.fetch).toHaveBeenCalledWith(`${baseURL}/slots`);
+            expect(result.slots).toHaveLength(2);
+            expect(result.slots[0].id).toBe(0);
+        });
+        it('should throw specific error when endpoint is not enabled', async () => {
+            global.fetch.mockResolvedValueOnce({
+                ok: false,
+                status: 404,
+                statusText: 'Not Found',
+            });
+            await expect(client.getSlots()).rejects.toThrow('Slots endpoint not enabled. Start server with --slots flag to enable.');
+        });
+        it('should throw error for other failures', async () => {
+            global.fetch.mockResolvedValueOnce({
+                ok: false,
+                status: 500,
+                statusText: 'Server Error',
+            });
+            await expect(client.getSlots()).rejects.toThrow('Get slots failed: 500 Server Error');
+        });
+    });
+});

package/dist/llm/config.d.ts

@@ -6,6 +6,7 @@ import type { ILLMClientAdapter } from "./clients/types";
  */
 export declare const ADAPTER_CONSTRUCTORS: Partial<Record<ApiProviderId, new (config?: {
     baseURL?: string;
+    checkHealth?: boolean;
 }) => ILLMClientAdapter>>;
 /**
  * Optional configuration objects for each adapter
@@ -73,6 +74,17 @@ export declare function isProviderSupported(providerId: string): boolean;
  * @returns True if the model is supported for the provider
  */
 export declare function isModelSupported(modelId: string, providerId: string): boolean;
+/**
+ * Creates a fallback ModelInfo for unknown/unregistered models
+ *
+ * Used when allowUnknownModels is enabled for a provider, or as a permissive
+ * fallback when strict validation is disabled. Provides sensible defaults.
+ *
+ * @param modelId - The model ID to create info for
+ * @param providerId - The provider ID
+ * @returns ModelInfo with default/placeholder values
+ */
+export declare function createFallbackModelInfo(modelId: string, providerId: string): ModelInfo;
 /**
  * Gets merged default settings for a specific model and provider
  *

package/dist/llm/config.js

@@ -8,11 +8,13 @@ exports.getModelById = getModelById;
 exports.getModelsByProvider = getModelsByProvider;
 exports.isProviderSupported = isProviderSupported;
 exports.isModelSupported = isModelSupported;
+exports.createFallbackModelInfo = createFallbackModelInfo;
 exports.getDefaultSettingsForModel = getDefaultSettingsForModel;
 exports.validateLLMSettings = validateLLMSettings;
 const OpenAIClientAdapter_1 = require("./clients/OpenAIClientAdapter");
 const AnthropicClientAdapter_1 = require("./clients/AnthropicClientAdapter");
 const GeminiClientAdapter_1 = require("./clients/GeminiClientAdapter");
+const LlamaCppClientAdapter_1 = require("./clients/LlamaCppClientAdapter");
 // Placeholder for future imports:
 // import { MistralClientAdapter } from './clients/MistralClientAdapter';
 /**
@@ -23,6 +25,7 @@ exports.ADAPTER_CONSTRUCTORS = {
     openai: OpenAIClientAdapter_1.OpenAIClientAdapter,
     anthropic: AnthropicClientAdapter_1.AnthropicClientAdapter,
     gemini: GeminiClientAdapter_1.GeminiClientAdapter,
+    llamacpp: LlamaCppClientAdapter_1.LlamaCppClientAdapter,
     // 'mistral': MistralClientAdapter, // Uncomment and add when Mistral adapter is ready
 };
 /**
@@ -36,6 +39,9 @@ exports.ADAPTER_CONFIGS = {
     anthropic: {
         baseURL: process.env.ANTHROPIC_API_BASE_URL || undefined,
     },
+    llamacpp: {
+        baseURL: process.env.LLAMACPP_API_BASE_URL || 'http://localhost:8080',
+    },
     // 'gemini': { /* ... Gemini specific config ... */ },
     // 'mistral': { /* ... Mistral specific config ... */ },
 };
@@ -116,6 +122,16 @@ exports.SUPPORTED_PROVIDERS = [
         id: "mistral",
         name: "Mistral AI",
     },
+    {
+        id: "llamacpp",
+        name: "llama.cpp",
+        allowUnknownModels: true, // Users load arbitrary GGUF models with custom names
+    },
+    {
+        id: "mock",
+        name: "Mock Provider",
+        allowUnknownModels: true, // Test provider accepts any model
+    },
 ];
 /**
  * Supported LLM models with their configurations
@@ -412,6 +428,43 @@ exports.SUPPORTED_MODELS = [
         supportsImages: false,
         supportsPromptCache: false,
     },
+    // llama.cpp Models (examples - users can specify any loaded model)
+    {
+        id: "llama-3-8b-instruct",
+        name: "Llama 3 8B Instruct",
+        providerId: "llamacpp",
+        contextWindow: 8192,
+        inputPrice: 0.0,
+        outputPrice: 0.0,
+        description: "Local Llama 3 8B model via llama.cpp server",
+        maxTokens: 4096,
+        supportsImages: false,
+        supportsPromptCache: false,
+    },
+    {
+        id: "llama-3-70b-instruct",
+        name: "Llama 3 70B Instruct",
+        providerId: "llamacpp",
+        contextWindow: 8192,
+        inputPrice: 0.0,
+        outputPrice: 0.0,
+        description: "Local Llama 3 70B model via llama.cpp server",
+        maxTokens: 4096,
+        supportsImages: false,
+        supportsPromptCache: false,
+    },
+    {
+        id: "mistral-7b-instruct",
+        name: "Mistral 7B Instruct",
+        providerId: "llamacpp",
+        contextWindow: 32768,
+        inputPrice: 0.0,
+        outputPrice: 0.0,
+        description: "Local Mistral 7B model via llama.cpp server",
+        maxTokens: 4096,
+        supportsImages: false,
+        supportsPromptCache: false,
+    },
 ];
 /**
  * Gets provider information by ID
@@ -460,6 +513,30 @@ function isProviderSupported(providerId) {
 function isModelSupported(modelId, providerId) {
     return exports.SUPPORTED_MODELS.some((model) => model.id === modelId && model.providerId === providerId);
 }
+/**
+ * Creates a fallback ModelInfo for unknown/unregistered models
+ *
+ * Used when allowUnknownModels is enabled for a provider, or as a permissive
+ * fallback when strict validation is disabled. Provides sensible defaults.
+ *
+ * @param modelId - The model ID to create info for
+ * @param providerId - The provider ID
+ * @returns ModelInfo with default/placeholder values
+ */
+function createFallbackModelInfo(modelId, providerId) {
+    return {
+        id: modelId,
+        name: modelId,
+        providerId: providerId,
+        contextWindow: 4096,
+        maxTokens: 2048,
+        inputPrice: 0,
+        outputPrice: 0,
+        description: `Unknown model (using defaults)`,
+        supportsImages: false,
+        supportsPromptCache: false,
+    };
+}
 /**
  * Gets merged default settings for a specific model and provider
  *

package/dist/llm/services/ModelResolver.js

@@ -90,20 +90,20 @@ class ModelResolver {
                 }
             };
         }
-        const modelInfo = (0, config_1.getModelById)(options.modelId, options.providerId);
+        let modelInfo = (0, config_1.getModelById)(options.modelId, options.providerId);
         if (!modelInfo) {
-            return {
-                error: {
-                    provider: options.providerId,
-                    model: options.modelId,
-                    error: {
-                        message: `Unsupported model: ${options.modelId} for provider: ${options.providerId}`,
-                        code: 'UNSUPPORTED_MODEL',
-                        type: 'validation_error',
-                    },
-                    object: 'error',
-                }
-            };
+            // Check if provider allows unknown models
+            const provider = (0, config_1.getProviderById)(options.providerId);
+            if (provider?.allowUnknownModels) {
+                // Flexible provider (e.g., llamacpp) - silent fallback
+                modelInfo = (0, config_1.createFallbackModelInfo)(options.modelId, options.providerId);
+            }
+            else {
+                // Strict provider - warn but allow
+                console.warn(`⚠️  Unknown model "${options.modelId}" for provider "${options.providerId}". ` +
+                    `Using default settings. This may fail at the provider API if the model doesn't exist.`);
+                modelInfo = (0, config_1.createFallbackModelInfo)(options.modelId, options.providerId);
+            }
         }
         return {
             providerId: options.providerId,