@flutchai/flutch-sdk 0.1.0

package/dist/llm/model.initializer.js

@@ -0,0 +1,630 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelInitializer = void 0;
+exports.prepareModelWithTools = prepareModelWithTools;
+const openai_1 = require("@langchain/openai");
+const azure_openai_1 = require("@langchain/azure-openai");
+const common_1 = require("@nestjs/common");
+function patchChatOpenAIForGPT5() {
+    const logger = new common_1.Logger("ModelInitializer.Patch");
+    logger.warn(`TEMPORARY WORKAROUND: Applying monkey patch for GPT-5 support in LangChain. Fixes: max_tokens->max_completion_tokens, temperature->1. This patch will be removed once LangChain officially supports GPT-5 models.`);
+    const prototypes = [
+        openai_1.ChatOpenAI.prototype,
+        azure_openai_1.AzureChatOpenAI.prototype,
+    ];
+    prototypes.forEach((prototype, index) => {
+        const modelName = index === 0 ? "ChatOpenAI" : "AzureChatOpenAI";
+        logger.warn(`Patching ${modelName} for GPT-5 support`);
+        const originalInvocationParams = prototype.invocationParams;
+        if (originalInvocationParams) {
+            prototype.invocationParams = function (options) {
+                const params = originalInvocationParams.call(this, options);
+                if (params.model &&
+                    (params.model.includes("gpt-5") ||
+                        /^gpt-(5|6|7|8|9)/.test(params.model))) {
+                    if (params.max_tokens !== undefined) {
+                        params.max_completion_tokens = params.max_tokens;
+                        delete params.max_tokens;
+                    }
+                    if (params.max_output_tokens !== undefined &&
+                        !params.max_completion_tokens) {
+                        params.max_completion_tokens = params.max_output_tokens;
+                        delete params.max_output_tokens;
+                    }
+                    const originalTemperature = params.temperature;
+                    if (params.temperature !== undefined && params.temperature !== 1) {
+                        params.temperature = 1;
+                        logger.debug(`Fixed temperature for ${params.model}: ${originalTemperature} -> 1 (GPT-5 models only support temperature=1)`);
+                    }
+                }
+                if (params.model &&
+                    (params.model.includes("gpt-5") ||
+                        /^gpt-(5|6|7|8|9)/.test(params.model))) {
+                    if (!params.stream_options) {
+                        params.stream_options = { include_usage: true };
+                        logger.warn(`[GPT-5 PATCH] Added stream_options.include_usage=true for ${params.model}`);
+                    }
+                    else if (params.stream_options.include_usage !== true) {
+                        params.stream_options.include_usage = true;
+                        logger.warn(`[GPT-5 PATCH] Updated stream_options.include_usage=true for ${params.model}`);
+                    }
+                }
+                return params;
+            };
+            logger.warn(`Successfully patched ${modelName}.invocationParams for GPT-5 support (TEMPORARY WORKAROUND)`);
+        }
+        else {
+            logger.warn(`Could not find invocationParams method to patch in ${modelName}`);
+        }
+        const originalCompletionWithRetry = prototype.completionWithRetry;
+        if (originalCompletionWithRetry) {
+            prototype.completionWithRetry = async function (request, options) {
+                if ((request === null || request === void 0 ? void 0 : request.model) &&
+                    (request.model.includes("gpt-5") ||
+                        /^gpt-(5|6|7|8|9)/.test(request.model))) {
+                    let hasChanges = false;
+                    if (request.max_tokens !== undefined) {
+                        request.max_completion_tokens = request.max_tokens;
+                        delete request.max_tokens;
+                        hasChanges = true;
+                    }
+                    if (request.temperature !== undefined && request.temperature !== 1) {
+                        const originalTemp = request.temperature;
+                        request.temperature = 1;
+                        logger.debug(`Fixed temperature in completionWithRetry for ${request.model}: ${originalTemp} -> 1`);
+                        hasChanges = true;
+                    }
+                    if (!request.stream_options) {
+                        request.stream_options = { include_usage: true };
+                        logger.debug(`Added stream_options.include_usage=true in completionWithRetry for ${request.model}`);
+                        hasChanges = true;
+                    }
+                    else if (request.stream_options.include_usage !== true) {
+                        request.stream_options.include_usage = true;
+                        logger.debug(`Updated stream_options.include_usage=true in completionWithRetry for ${request.model}`);
+                        hasChanges = true;
+                    }
+                    if (hasChanges) {
+                        logger.debug(`Fixed request params in completionWithRetry for ${request.model}`);
+                    }
+                }
+                const result = await originalCompletionWithRetry.call(this, request, options);
+                if ((request === null || request === void 0 ? void 0 : request.model) &&
+                    (request.model.includes("gpt-5") ||
+                        /^gpt-(5|6|7|8|9)/.test(request.model))) {
+                    logger.warn(`[GPT-5 PATCH] Azure OpenAI Response for ${request.model}:`);
+                    logger.warn(`Response keys: ${Object.keys(result || {}).join(", ")}`);
+                    if (result === null || result === void 0 ? void 0 : result.usage) {
+                        logger.warn(`Usage found: ${JSON.stringify(result.usage, null, 2)}`);
+                    }
+                    else {
+                        logger.warn(`No usage found in response`);
+                    }
+                    if ((result === null || result === void 0 ? void 0 : result.choices) && result.choices[0]) {
+                        logger.warn(`First choice keys: ${Object.keys(result.choices[0]).join(", ")}`);
+                    }
+                }
+                return result;
+            };
+            logger.warn(`Successfully patched ${modelName}.completionWithRetry for GPT-5 support (TEMPORARY WORKAROUND)`);
+        }
+        const originalIsReasoningModel = prototype.isReasoningModel;
+        if (originalIsReasoningModel) {
+            prototype.isReasoningModel = function () {
+                var _a, _b;
+                const model = this.modelName || this.model || ((_a = this.lc_kwargs) === null || _a === void 0 ? void 0 : _a.modelName);
+                const isReasoning = /^o\d/.test(model) ||
+                    model.includes("gpt-5") ||
+                    /^gpt-(6|7|8|9)/.test(model);
+                const originalResult = originalIsReasoningModel.call(this);
+                logger.warn(`[GPT-5 PATCH] isReasoningModel check for "${model}": patched=${isReasoning}, original=${originalResult}, modelName=${this.modelName}, model=${this.model}, lc_kwargs=${JSON.stringify((_b = this.lc_kwargs) === null || _b === void 0 ? void 0 : _b.modelName)}`);
+                return isReasoning;
+            };
+            logger.warn(`Successfully patched ${modelName}.isReasoningModel for GPT-5+ reasoning models (TEMPORARY WORKAROUND)`);
+        }
+        else {
+            logger.warn(`Could not find isReasoningModel method to patch in ${modelName}`);
+        }
+        const originalInvoke = prototype.invoke;
+        if (originalInvoke) {
+            prototype.invoke = async function (...args) {
+                var _a, _b, _c, _d;
+                const model = this.modelName || this.model || ((_a = this.lc_kwargs) === null || _a === void 0 ? void 0 : _a.modelName);
+                if (model && model.includes("gpt-5")) {
+                    logger.warn(`[GPT-5 PATCH] Starting invoke for ${model}`);
+                    if (args[1]) {
+                        const config = args[1];
+                        logger.warn(`[GPT-5 PATCH] Invoke config keys: ${Object.keys(config || {}).join(", ")}`);
+                        if (config.tools) {
+                            logger.warn(`[GPT-5 PATCH] Tools in config: ${config.tools.length} tools`);
+                        }
+                    }
+                    const boundTools = this.bound ||
+                        this.boundTools ||
+                        this.tools;
+                    if (boundTools) {
+                        logger.warn(`[GPT-5 PATCH] Model has bound tools: ${Array.isArray(boundTools) ? boundTools.length : "yes"}`);
+                    }
+                    else {
+                        logger.warn(`[GPT-5 PATCH] Model has NO bound tools`);
+                    }
+                }
+                let result;
+                try {
+                    result = await originalInvoke.apply(this, args);
+                }
+                catch (error) {
+                    if (model && model.includes("gpt-5")) {
+                        logger.error(`[GPT-5 PATCH] Azure OpenAI invoke failed for ${model}:`, {
+                            errorMessage: error instanceof Error ? error.message : String(error),
+                            errorStack: error instanceof Error ? error.stack : undefined,
+                            errorType: (_b = error === null || error === void 0 ? void 0 : error.constructor) === null || _b === void 0 ? void 0 : _b.name,
+                            args: args.length,
+                            hasConfig: !!args[1],
+                            configKeys: args[1] ? Object.keys(args[1] || {}) : [],
+                            tools: ((_d = (_c = args[1]) === null || _c === void 0 ? void 0 : _c.tools) === null || _d === void 0 ? void 0 : _d.length) || 0,
+                        });
+                    }
+                    throw error;
+                }
+                if (model && model.includes("gpt-5")) {
+                    logger.warn(`[GPT-5 PATCH] Azure OpenAI invoke result for ${model}:`);
+                    logger.warn(`Result keys: ${Object.keys(result || {}).join(", ")}`);
+                    if ((result === null || result === void 0 ? void 0 : result.usage_metadata) || (result === null || result === void 0 ? void 0 : result.usageMetadata)) {
+                        const usage = result.usage_metadata || result.usageMetadata;
+                        logger.warn(`Usage metadata found: ${JSON.stringify(usage, null, 2)}`);
+                    }
+                    if ((result === null || result === void 0 ? void 0 : result.response_metadata) || (result === null || result === void 0 ? void 0 : result.responseMetadata)) {
+                        const responseMetadata = result.response_metadata || result.responseMetadata;
+                        logger.warn(`Response metadata found: ${JSON.stringify(responseMetadata, null, 2)}`);
+                        if (!result.usage_metadata &&
+                            (responseMetadata === null || responseMetadata === void 0 ? void 0 : responseMetadata.estimatedTokenUsage)) {
+                            const estimatedUsage = responseMetadata.estimatedTokenUsage;
+                            result.usage_metadata = {
+                                input_tokens: estimatedUsage.promptTokens || 0,
+                                output_tokens: estimatedUsage.completionTokens || 0,
+                                total_tokens: estimatedUsage.totalTokens || 0,
+                            };
+                            logger.warn(`[GPT-5 PATCH] Created usage_metadata from estimatedTokenUsage: ${JSON.stringify(result.usage_metadata, null, 2)}`);
+                        }
+                    }
+                    if (!(result === null || result === void 0 ? void 0 : result.usage_metadata) && !(result === null || result === void 0 ? void 0 : result.usageMetadata)) {
+                        logger.warn(`No usage_metadata found in invoke result`);
+                    }
+                }
+                return result;
+            };
+            logger.warn(`Successfully patched ${modelName}.invoke for GPT-5 response logging (TEMPORARY WORKAROUND)`);
+        }
+    });
+}
+patchChatOpenAIForGPT5();
+const openai_2 = require("@langchain/openai");
+const anthropic_1 = require("@langchain/anthropic");
+const cohere_1 = require("@langchain/cohere");
+const cohere_2 = require("@langchain/cohere");
+const voyageai_rerank_1 = require("./rerankers/voyageai-rerank");
+const mistralai_1 = require("@langchain/mistralai");
+const shared_types_1 = require("../shared-types");
+class ModelInitializer {
+    constructor(configFetcher, logger) {
+        this.configFetcher = configFetcher;
+        this.modelConfigCache = new Map();
+        this.modelInstanceCache = new Map();
+        this.chatModelCreators = {
+            [shared_types_1.ModelProvider.OPENAI]: ({ modelName, defaultTemperature, defaultMaxTokens, apiToken, }) => {
+                if (this.requiresMaxCompletionTokens(modelName)) {
+                    const fixedTemperature = 1;
+                    const config = {
+                        modelName,
+                        temperature: fixedTemperature,
+                        maxCompletionTokens: defaultMaxTokens,
+                        streaming: true,
+                        openAIApiKey: apiToken || process.env.OPENAI_API_KEY,
+                    };
+                    if (defaultTemperature !== 1) {
+                        this.logger.debug(`Fixed temperature for GPT-5+ model ${modelName}: ${defaultTemperature} -> 1 (GPT-5+ models only support temperature=1)`);
+                    }
+                    const chatOpenAI = new openai_1.ChatOpenAI(config);
+                    return chatOpenAI;
+                }
+                else {
+                    const config = {
+                        modelName,
+                        temperature: defaultTemperature,
+                        maxTokens: defaultMaxTokens,
+                        streaming: true,
+                        openAIApiKey: apiToken || process.env.OPENAI_API_KEY,
+                    };
+                    const chatOpenAI = new openai_1.ChatOpenAI(config);
+                    return chatOpenAI;
+                }
+            },
+            [shared_types_1.ModelProvider.ANTHROPIC]: ({ modelName, defaultTemperature, defaultMaxTokens, apiToken, }) => new anthropic_1.ChatAnthropic({
+                modelName,
+                temperature: defaultTemperature,
+                maxTokens: defaultMaxTokens,
+                anthropicApiKey: apiToken || process.env.ANTHROPIC_API_KEY,
+            }),
+            [shared_types_1.ModelProvider.COHERE]: ({ modelName, defaultTemperature, defaultMaxTokens, apiToken, }) => new cohere_1.ChatCohere({
+                model: modelName,
+                temperature: defaultTemperature,
+                apiKey: apiToken || process.env.COHERE_API_KEY,
+            }),
+            [shared_types_1.ModelProvider.MISTRAL]: ({ modelName, defaultTemperature, defaultMaxTokens, apiToken, }) => new mistralai_1.ChatMistralAI({
+                model: modelName,
+                temperature: defaultTemperature,
+                maxTokens: defaultMaxTokens,
+                apiKey: apiToken || process.env.MISTRAL_API_KEY,
+            }),
+            [shared_types_1.ModelProvider.FLUTCH_OPENAI]: ({ modelName, defaultTemperature, defaultMaxTokens, apiToken, }) => {
+                if (this.requiresMaxCompletionTokens(modelName)) {
+                    const fixedTemperature = 1;
+                    const config = {
+                        modelName,
+                        temperature: fixedTemperature,
+                        maxCompletionTokens: defaultMaxTokens,
+                        streaming: true,
+                        openAIApiKey: apiToken || process.env.OPENAI_API_KEY,
+                    };
+                    if (defaultTemperature !== 1) {
+                        this.logger.debug(`Fixed temperature for FLUTCH GPT-5+ model ${modelName}: ${defaultTemperature} -> 1 (GPT-5+ models only support temperature=1)`);
+                    }
+                    this.logger.debug(`Creating FLUTCH GPT-5+ model with config`, {
+                        modelName,
+                        maxCompletionTokens: defaultMaxTokens,
+                        temperature: fixedTemperature,
+                        originalTemperature: defaultTemperature,
+                        hasApiKey: !!config.openAIApiKey,
+                    });
+                    const chatOpenAI = new openai_1.ChatOpenAI(config);
+                    this.logger.debug(`FLUTCH ChatOpenAI GPT-5+ instance created`, {
+                        modelName: modelName,
+                        maxTokens: chatOpenAI.maxTokens,
+                        maxCompletionTokens: chatOpenAI.maxCompletionTokens,
+                        temperature: chatOpenAI.temperature,
+                        streaming: chatOpenAI.streaming,
+                        clientConfig: chatOpenAI.clientConfig,
+                        kwargs: chatOpenAI.kwargs,
+                    });
+                    return chatOpenAI;
+                }
+                else {
+                    const config = {
+                        modelName,
+                        temperature: defaultTemperature,
+                        maxTokens: defaultMaxTokens,
+                        streaming: true,
+                        openAIApiKey: apiToken || process.env.OPENAI_API_KEY,
+                    };
+                    this.logger.debug(`Creating FLUTCH legacy model with config`, {
+                        modelName,
+                        maxTokens: defaultMaxTokens,
+                        temperature: defaultTemperature,
+                        hasApiKey: !!config.openAIApiKey,
+                    });
+                    const chatOpenAI = new openai_1.ChatOpenAI(config);
+                    this.logger.debug(`FLUTCH ChatOpenAI legacy instance created`, {
+                        modelName: modelName,
+                        maxTokens: chatOpenAI.maxTokens,
+                        maxCompletionTokens: chatOpenAI.maxCompletionTokens,
+                        temperature: chatOpenAI.temperature,
+                        streaming: chatOpenAI.streaming,
+                        clientConfig: chatOpenAI.clientConfig,
+                        kwargs: chatOpenAI.kwargs,
+                    });
+                    return chatOpenAI;
+                }
+            },
+            [shared_types_1.ModelProvider.FLUTCH]: () => {
+                throw new Error("Flutch chat models not implemented");
+            },
+            [shared_types_1.ModelProvider.FLUTCH_MISTRAL]: () => {
+                throw new Error("Flutch Mistral chat models not implemented");
+            },
+            [shared_types_1.ModelProvider.FLUTCH_ANTHROPIC]: () => {
+                throw new Error("Flutch Anthropic chat models not implemented");
+            },
+            [shared_types_1.ModelProvider.VOYAGEAI]: () => {
+                throw new Error("VoyageAI chat models not implemented");
+            },
+        };
+        this.rerankModelCreators = {
+            [shared_types_1.ModelProvider.COHERE]: ({ modelName, apiToken, maxDocuments }) => {
+                return new cohere_2.CohereRerank({
+                    apiKey: apiToken || process.env.COHERE_API_KEY,
+                    model: modelName,
+                    topN: maxDocuments || 20,
+                });
+            },
+            [shared_types_1.ModelProvider.VOYAGEAI]: ({ modelName, apiToken, maxDocuments }) => {
+                return new voyageai_rerank_1.VoyageAIRerank({
+                    apiKey: apiToken || process.env.VOYAGEAI_API_KEY,
+                    model: modelName,
+                    topN: maxDocuments || 20,
+                });
+            },
+            [shared_types_1.ModelProvider.OPENAI]: undefined,
+            [shared_types_1.ModelProvider.ANTHROPIC]: undefined,
+            [shared_types_1.ModelProvider.MISTRAL]: undefined,
+            [shared_types_1.ModelProvider.AWS]: undefined,
+            [shared_types_1.ModelProvider.FLUTCH]: undefined,
+            [shared_types_1.ModelProvider.FLUTCH_MISTRAL]: undefined,
+            [shared_types_1.ModelProvider.FLUTCH_OPENAI]: undefined,
+            [shared_types_1.ModelProvider.FLUTCH_ANTHROPIC]: undefined,
+        };
+        this.embeddingModelCreators = {
+            [shared_types_1.ModelProvider.OPENAI]: ({ modelName, apiToken }) => new openai_2.OpenAIEmbeddings({
+                model: modelName,
+                apiKey: apiToken || process.env.OPENAI_API_KEY,
+            }),
+            [shared_types_1.ModelProvider.ANTHROPIC]: undefined,
+            [shared_types_1.ModelProvider.COHERE]: undefined,
+            [shared_types_1.ModelProvider.MISTRAL]: undefined,
+            [shared_types_1.ModelProvider.AWS]: undefined,
+            [shared_types_1.ModelProvider.FLUTCH]: undefined,
+            [shared_types_1.ModelProvider.FLUTCH_MISTRAL]: undefined,
+            [shared_types_1.ModelProvider.FLUTCH_OPENAI]: undefined,
+            [shared_types_1.ModelProvider.FLUTCH_ANTHROPIC]: undefined,
+            [shared_types_1.ModelProvider.VOYAGEAI]: undefined,
+        };
+        this.logger = logger || new common_1.Logger(ModelInitializer.name);
+    }
+    generateModelCacheKey(modelId, temperature, maxTokens, modelType) {
+        return `${modelId}:${temperature || "default"}:${maxTokens || "default"}:${modelType || shared_types_1.ModelType.CHAT}`;
+    }
+    requiresMaxCompletionTokens(modelName) {
+        const requiresNew = modelName.includes("gpt-5") ||
+            modelName.includes("gpt-o1") ||
+            modelName.includes("gpt-o2") ||
+            modelName.includes("gpt-o3") ||
+            modelName.includes("gpt-o4") ||
+            /^gpt-(5|6|7|8|9)/.test(modelName) ||
+            /^gpt-o[1-4]/.test(modelName);
+        this.logger.debug(`Checking token parameter for model "${modelName}"`, {
+            modelName,
+            requiresMaxCompletionTokens: requiresNew,
+            checks: {
+                includesGpt5: modelName.includes("gpt-5"),
+                includesO1: modelName.includes("gpt-o1"),
+                includesO2: modelName.includes("gpt-o2"),
+                includesO3: modelName.includes("gpt-o3"),
+                includesO4: modelName.includes("gpt-o4"),
+                regexGpt5Plus: /^gpt-(5|6|7|8|9)/.test(modelName),
+                regexO1to4: /^gpt-o[1-4]/.test(modelName),
+            },
+        });
+        return requiresNew;
+    }
+    async initializeChatModel(config) {
+        var _a, _b, _c;
+        const cacheKey = this.generateModelCacheKey(config.modelId, config.temperature, config.maxTokens, shared_types_1.ModelType.CHAT);
+        const cachedModel = this.modelInstanceCache.get(cacheKey);
+        if (cachedModel) {
+            this.logger.debug(`Using cached chat model instance: ${cacheKey}`);
+            return cachedModel;
+        }
+        const modelConfig = await this.getModelConfigWithType(config.modelId);
+        if (modelConfig.modelType !== shared_types_1.ModelType.CHAT) {
+            throw new Error(`Model ${config.modelId} is not a chat model (type: ${modelConfig.modelType})`);
+        }
+        const creator = this.chatModelCreators[modelConfig.provider];
+        if (!creator) {
+            throw new Error(`Chat models not supported for provider: ${modelConfig.provider}`);
+        }
+        const finalConfig = Object.assign(Object.assign({}, modelConfig), { defaultTemperature: Number((_a = config.temperature) !== null && _a !== void 0 ? _a : modelConfig.defaultTemperature), defaultMaxTokens: Number((_b = config.maxTokens) !== null && _b !== void 0 ? _b : modelConfig.defaultMaxTokens) });
+        this.logger.debug(`Creating new chat model instance: ${cacheKey}`);
+        const model = creator(finalConfig);
+        model.metadata = Object.assign(Object.assign({}, model.metadata), { modelId: config.modelId });
+        this.logger.debug("🔧 Model initialized with metadata", {
+            modelId: config.modelId,
+            metadataKeys: Object.keys(model.metadata || {}),
+            hasModelId: !!((_c = model.metadata) === null || _c === void 0 ? void 0 : _c.modelId),
+        });
+        this.modelInstanceCache.set(cacheKey, model);
+        return model;
+    }
+    async initializeRerankModel(config) {
+        const cacheKey = this.generateModelCacheKey(config.modelId, undefined, config.maxTokens, shared_types_1.ModelType.RERANK);
+        const cachedModel = this.modelInstanceCache.get(cacheKey);
+        if (cachedModel) {
+            this.logger.debug(`Using cached rerank model instance: ${cacheKey}`);
+            return cachedModel;
+        }
+        const modelConfig = await this.getModelConfigWithType(config.modelId);
+        if (modelConfig.modelType !== shared_types_1.ModelType.RERANK) {
+            throw new Error(`Model ${config.modelId} is not a rerank model (type: ${modelConfig.modelType})`);
+        }
+        const creator = this.rerankModelCreators[modelConfig.provider];
+        if (!creator) {
+            throw new Error(`Rerank models not supported for provider: ${modelConfig.provider}`);
+        }
+        this.logger.debug(`Creating new rerank model instance: ${cacheKey}`);
+        const model = creator(modelConfig);
+        model.metadata = Object.assign(Object.assign({}, model.metadata), { modelId: config.modelId });
+        this.modelInstanceCache.set(cacheKey, model);
+        return model;
+    }
+    async initializeEmbeddingModel(config) {
+        const cacheKey = this.generateModelCacheKey(config.modelId, undefined, undefined, shared_types_1.ModelType.EMBEDDING);
+        const cachedModel = this.modelInstanceCache.get(cacheKey);
+        if (cachedModel) {
+            this.logger.debug(`Using cached embedding model instance: ${cacheKey}`);
+            return cachedModel;
+        }
+        const modelConfig = await this.getModelConfigWithType(config.modelId);
+        if (modelConfig.modelType !== shared_types_1.ModelType.EMBEDDING) {
+            throw new Error(`Model ${config.modelId} is not an embedding model (type: ${modelConfig.modelType})`);
+        }
+        const creator = this.embeddingModelCreators[modelConfig.provider];
+        if (!creator) {
+            throw new Error(`Embedding models not supported for provider: ${modelConfig.provider}`);
+        }
+        this.logger.debug(`Creating new embedding model instance: ${cacheKey}`);
+        const model = creator(modelConfig);
+        model.metadata = Object.assign(Object.assign({}, model.metadata), { modelId: config.modelId });
+        this.modelInstanceCache.set(cacheKey, model);
+        return model;
+    }
+    async createChatModelById(modelId) {
+        const config = await this.getModelConfigWithType(modelId);
+        if (config.modelType !== shared_types_1.ModelType.CHAT) {
+            throw new Error(`Model ${modelId} is not a chat model, got: ${config.modelType}`);
+        }
+        return this.initializeChatModel(config);
+    }
+    async createRerankModelById(modelId) {
+        const config = await this.getModelConfigWithType(modelId);
+        if (config.modelType !== shared_types_1.ModelType.RERANK) {
+            throw new Error(`Model ${modelId} is not a rerank model, got: ${config.modelType}`);
+        }
+        return this.initializeRerankModel(config);
+    }
+    async createEmbeddingModelById(modelId) {
+        const config = await this.getModelConfigWithType(modelId);
+        if (config.modelType !== shared_types_1.ModelType.EMBEDDING) {
+            throw new Error(`Model ${modelId} is not an embedding model, got: ${config.modelType}`);
+        }
+        return this.initializeEmbeddingModel(config);
+    }
+    async createModelById(modelId, expectedType) {
+        const config = await this.getModelConfigWithType(modelId);
+        if (expectedType && config.modelType !== expectedType) {
+            throw new Error(`Model ${modelId} expected to be ${expectedType}, but got: ${config.modelType}`);
+        }
+        return this.initializeModelByType(config);
+    }
+    async initializeModelByType(config) {
+        switch (config.modelType) {
+            case shared_types_1.ModelType.CHAT:
+                return this.initializeChatModel(config);
+            case shared_types_1.ModelType.RERANK:
+                return this.initializeRerankModel(config);
+            case shared_types_1.ModelType.EMBEDDING:
+                return this.initializeEmbeddingModel(config);
+            case shared_types_1.ModelType.IMAGE:
+            case shared_types_1.ModelType.SPEECH:
+                throw new Error(`Model type ${config.modelType} not yet supported`);
+            default:
+                throw new Error(`Unknown model type: ${config.modelType}`);
+        }
+    }
+    async getModelConfigWithType(modelId) {
+        const cachedConfig = this.modelConfigCache.get(modelId);
+        if (cachedConfig) {
+            this.logger.debug(`Using cached model config: ${modelId}`);
+            return cachedConfig;
+        }
+        this.logger.debug(`Fetching model config: ${modelId}`);
+        const baseConfig = this.configFetcher
+            ? await this.configFetcher(modelId)
+            : await this.fetchFromApi(modelId);
+        const result = Object.assign(Object.assign({}, baseConfig), { modelType: baseConfig.modelType || shared_types_1.ModelType.CHAT, maxDocuments: baseConfig.maxDocuments, dimensions: baseConfig.dimensions, supportedFormats: baseConfig.supportedFormats });
+        this.modelConfigCache.set(modelId, result);
+        return result;
+    }
+    isModelTypeSupported(modelType) {
+        return [shared_types_1.ModelType.CHAT, shared_types_1.ModelType.RERANK, shared_types_1.ModelType.EMBEDDING].includes(modelType);
+    }
+    getSupportedModelTypes() {
+        return [shared_types_1.ModelType.CHAT, shared_types_1.ModelType.RERANK, shared_types_1.ModelType.EMBEDDING];
+    }
+    clearCache() {
+        this.logger.debug(`Clearing ModelInitializer cache: ${this.modelConfigCache.size} configs, ${this.modelInstanceCache.size} instances`);
+        this.modelConfigCache.clear();
+        this.modelInstanceCache.clear();
+    }
+    clearModelCache(modelId) {
+        this.modelConfigCache.delete(modelId);
+        const keysToDelete = [];
+        for (const [key] of this.modelInstanceCache.entries()) {
+            if (key.startsWith(`${modelId}:`)) {
+                keysToDelete.push(key);
+            }
+        }
+        keysToDelete.forEach(key => {
+            this.modelInstanceCache.delete(key);
+        });
+        this.logger.debug(`Cleared cache for model ${modelId}: ${keysToDelete.length} instances`);
+    }
+    getCacheStats() {
+        return {
+            configCacheSize: this.modelConfigCache.size,
+            instanceCacheSize: this.modelInstanceCache.size,
+            configCacheKeys: Array.from(this.modelConfigCache.keys()),
+            instanceCacheKeys: Array.from(this.modelInstanceCache.keys()),
+        };
+    }
+    async fetchFromApi(modelId) {
+        const apiUrl = process.env.API_URL || "http://amelie-service";
+        const token = process.env.INTERNAL_API_TOKEN;
+        if (!token) {
+            throw new Error("INTERNAL_API_TOKEN required for API mode");
+        }
+        const url = `${apiUrl}/internal/model-catalog/models/${modelId}/config`;
+        const response = await fetch(url, {
+            method: "GET",
+            headers: {
+                "x-internal-token": token,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch model config: ${response.status} ${response.statusText}`);
+        }
+        const config = await response.json();
+        console.debug(`ModelInitializer.fetchFromApi - API response for ${modelId}:`, {
+            url,
+            statusCode: response.status,
+            configKeys: Object.keys(config),
+            modelType: config.modelType,
+            hasModelType: !!config.modelType,
+            fullConfig: config,
+        });
+        const result = Object.assign(Object.assign({}, config), { modelType: config.modelType || shared_types_1.ModelType.CHAT });
+        console.debug(`ModelInitializer.fetchFromApi - final result:`, {
+            modelId,
+            resultModelType: result.modelType,
+            usedFallback: !config.modelType,
+            resultKeys: Object.keys(result),
+        });
+        return result;
+    }
+}
+exports.ModelInitializer = ModelInitializer;
+function prepareModelWithTools(model, tools, baseConfig = {}) {
+    if (tools.length === 0) {
+        return {
+            modelWithTools: model,
+            finalConfig: baseConfig,
+            toolsMethod: "none",
+        };
+    }
+    if (model.bindTools && typeof model.bindTools === "function") {
+        try {
+            const modelWithTools = model.bindTools(tools);
+            return {
+                modelWithTools,
+                finalConfig: baseConfig,
+                toolsMethod: "bindTools",
+            };
+        }
+        catch (error) {
+            const invokeConfig = { tools };
+            const finalConfig = Object.assign(Object.assign({}, baseConfig), invokeConfig);
+            return {
+                modelWithTools: model,
+                finalConfig,
+                toolsMethod: "manual",
+            };
+        }
+    }
+    const invokeConfig = { tools };
+    const finalConfig = Object.assign(Object.assign({}, baseConfig), invokeConfig);
+    return {
+        modelWithTools: model,
+        finalConfig,
+        toolsMethod: "manual",
+    };
+}
+//# sourceMappingURL=model.initializer.js.map