@flutchai/flutch-sdk 0.2.8 → 0.2.9

package/dist/index.js

@@ -20,7 +20,7 @@ import axios2 from 'axios';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 import { parseCallbackConfigArg, CallbackManager } from '@langchain/core/callbacks/manager';
 import { ChatOpenAI, OpenAIEmbeddings } from '@langchain/openai';
-import { AzureChatOpenAI } from '@langchain/azure-openai';
+import { ChatBedrockConverse } from '@langchain/aws';
 import { ChatAnthropic } from '@langchain/anthropic';
 import { ChatCohere, CohereRerank } from '@langchain/cohere';
 import { BaseDocumentCompressor } from '@langchain/core/retrievers/document_compressors';
@@ -6390,10 +6390,6 @@ McpRuntimeHttpClient = __decorateClass([
 
 // src/models/enums.ts
 var ModelProvider = /* @__PURE__ */ ((ModelProvider2) => {
-  ModelProvider2["FLUTCH"] = "flutch";
-  ModelProvider2["FLUTCH_MISTRAL"] = "flutch-mistral";
-  ModelProvider2["FLUTCH_OPENAI"] = "flutch-openai";
-  ModelProvider2["FLUTCH_ANTHROPIC"] = "flutch-anthropic";
   ModelProvider2["MISTRAL"] = "mistral";
   ModelProvider2["OPENAI"] = "openai";
   ModelProvider2["ANTHROPIC"] = "anthropic";
@@ -6436,6 +6432,25 @@ function generateModelCacheKey(modelId, temperature, maxTokens, toolsConfig) {
   }
   return parts.join(":");
 }
+function buildOpenAIModelConfig(modelName, temperature, maxTokens, apiToken) {
+  if (isReasoningModel(modelName)) {
+    return {
+      modelName,
+      temperature: 1,
+      // Reasoning models only support temperature=1
+      maxCompletionTokens: maxTokens,
+      streaming: true,
+      openAIApiKey: apiToken
+    };
+  }
+  return {
+    modelName,
+    temperature,
+    maxTokens,
+    streaming: true,
+    openAIApiKey: apiToken
+  };
+}
 var VoyageAIRerank = class extends BaseDocumentCompressor {
   apiKey;
   model;
@@ -6487,235 +6502,10 @@ var VoyageAIRerank = class extends BaseDocumentCompressor {
     }
   }
 };
-function patchChatOpenAIForGPT5() {
-  const logger2 = new Logger("ModelInitializer.Patch");
-  logger2.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 = [
-    ChatOpenAI.prototype,
-    AzureChatOpenAI.prototype
-  ];
-  prototypes.forEach((prototype, index) => {
-    const modelName = index === 0 ? "ChatOpenAI" : "AzureChatOpenAI";
-    logger2.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 !== void 0) {
-            params.max_completion_tokens = params.max_tokens;
-            delete params.max_tokens;
-          }
-          if (params.max_output_tokens !== void 0 && !params.max_completion_tokens) {
-            params.max_completion_tokens = params.max_output_tokens;
-            delete params.max_output_tokens;
-          }
-          const originalTemperature = params.temperature;
-          if (params.temperature !== void 0 && params.temperature !== 1) {
-            params.temperature = 1;
-            logger2.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 };
-            logger2.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;
-            logger2.warn(
-              `[GPT-5 PATCH] Updated stream_options.include_usage=true for ${params.model}`
-            );
-          }
-        }
-        return params;
-      };
-      logger2.warn(
-        `Successfully patched ${modelName}.invocationParams for GPT-5 support (TEMPORARY WORKAROUND)`
-      );
-    } else {
-      logger2.warn(
-        `Could not find invocationParams method to patch in ${modelName}`
-      );
-    }
-    const originalCompletionWithRetry = prototype.completionWithRetry;
-    if (originalCompletionWithRetry) {
-      prototype.completionWithRetry = async function(request, options) {
-        if (request?.model && (request.model.includes("gpt-5") || /^gpt-(5|6|7|8|9)/.test(request.model))) {
-          let hasChanges = false;
-          if (request.max_tokens !== void 0) {
-            request.max_completion_tokens = request.max_tokens;
-            delete request.max_tokens;
-            hasChanges = true;
-          }
-          if (request.temperature !== void 0 && request.temperature !== 1) {
-            const originalTemp = request.temperature;
-            request.temperature = 1;
-            logger2.debug(
-              `Fixed temperature in completionWithRetry for ${request.model}: ${originalTemp} -> 1`
-            );
-            hasChanges = true;
-          }
-          if (!request.stream_options) {
-            request.stream_options = { include_usage: true };
-            logger2.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;
-            logger2.debug(
-              `Updated stream_options.include_usage=true in completionWithRetry for ${request.model}`
-            );
-            hasChanges = true;
-          }
-          if (hasChanges) {
-            logger2.debug(
-              `Fixed request params in completionWithRetry for ${request.model}`
-            );
-          }
-        }
-        const result = await originalCompletionWithRetry.call(
-          this,
-          request,
-          options
-        );
-        if (request?.model && (request.model.includes("gpt-5") || /^gpt-(5|6|7|8|9)/.test(request.model))) {
-          logger2.warn(
-            `[GPT-5 PATCH] Azure OpenAI Response for ${request.model}:`
-          );
-          logger2.warn(`Response keys: ${Object.keys(result || {}).join(", ")}`);
-          if (result?.usage) {
-            logger2.warn(
-              `Usage found: ${JSON.stringify(result.usage, null, 2)}`
-            );
-          } else {
-            logger2.warn(`No usage found in response`);
-          }
-          if (result?.choices && result.choices[0]) {
-            logger2.warn(
-              `First choice keys: ${Object.keys(result.choices[0]).join(", ")}`
-            );
-          }
-        }
-        return result;
-      };
-      logger2.warn(
-        `Successfully patched ${modelName}.completionWithRetry for GPT-5 support (TEMPORARY WORKAROUND)`
-      );
-    }
-    const originalIsReasoningModel = prototype.isReasoningModel;
-    if (originalIsReasoningModel) {
-      prototype.isReasoningModel = function() {
-        const model = this.modelName || this.model || this.lc_kwargs?.modelName;
-        const isReasoning = /^o\d/.test(model) || model.includes("gpt-5") || /^gpt-(6|7|8|9)/.test(model);
-        const originalResult = originalIsReasoningModel.call(this);
-        logger2.warn(
-          `[GPT-5 PATCH] isReasoningModel check for "${model}": patched=${isReasoning}, original=${originalResult}, modelName=${this.modelName}, model=${this.model}, lc_kwargs=${JSON.stringify(this.lc_kwargs?.modelName)}`
-        );
-        return isReasoning;
-      };
-      logger2.warn(
-        `Successfully patched ${modelName}.isReasoningModel for GPT-5+ reasoning models (TEMPORARY WORKAROUND)`
-      );
-    } else {
-      logger2.warn(
-        `Could not find isReasoningModel method to patch in ${modelName}`
-      );
-    }
-    const originalInvoke = prototype.invoke;
-    if (originalInvoke) {
-      prototype.invoke = async function(...args) {
-        const model = this.modelName || this.model || this.lc_kwargs?.modelName;
-        if (model && model.includes("gpt-5")) {
-          logger2.warn(`[GPT-5 PATCH] Starting invoke for ${model}`);
-          if (args[1]) {
-            const config = args[1];
-            logger2.warn(
-              `[GPT-5 PATCH] Invoke config keys: ${Object.keys(config || {}).join(", ")}`
-            );
-            if (config.tools) {
-              logger2.warn(
-                `[GPT-5 PATCH] Tools in config: ${config.tools.length} tools`
-              );
-            }
-          }
-          const boundTools = this.bound || this.boundTools || this.tools;
-          if (boundTools) {
-            logger2.warn(
-              `[GPT-5 PATCH] Model has bound tools: ${Array.isArray(boundTools) ? boundTools.length : "yes"}`
-            );
-          } else {
-            logger2.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")) {
-            logger2.error(
-              `[GPT-5 PATCH] Azure OpenAI invoke failed for ${model}:`,
-              {
-                errorMessage: error instanceof Error ? error.message : String(error),
-                errorStack: error instanceof Error ? error.stack : void 0,
-                errorType: error?.constructor?.name,
-                args: args.length,
-                hasConfig: !!args[1],
-                configKeys: args[1] ? Object.keys(args[1] || {}) : [],
-                tools: args[1]?.tools?.length || 0
-              }
-            );
-          }
-          throw error;
-        }
-        if (model && model.includes("gpt-5")) {
-          logger2.warn(`[GPT-5 PATCH] Azure OpenAI invoke result for ${model}:`);
-          logger2.warn(`Result keys: ${Object.keys(result || {}).join(", ")}`);
-          if (result?.usage_metadata || result?.usageMetadata) {
-            const usage = result.usage_metadata || result.usageMetadata;
-            logger2.warn(
-              `Usage metadata found: ${JSON.stringify(usage, null, 2)}`
-            );
-          }
-          if (result?.response_metadata || result?.responseMetadata) {
-            const responseMetadata = result.response_metadata || result.responseMetadata;
-            logger2.warn(
-              `Response metadata found: ${JSON.stringify(responseMetadata, null, 2)}`
-            );
-            if (!result.usage_metadata && responseMetadata?.estimatedTokenUsage) {
-              const estimatedUsage = responseMetadata.estimatedTokenUsage;
-              result.usage_metadata = {
-                input_tokens: estimatedUsage.promptTokens || 0,
-                output_tokens: estimatedUsage.completionTokens || 0,
-                total_tokens: estimatedUsage.totalTokens || 0
-              };
-              logger2.warn(
-                `[GPT-5 PATCH] Created usage_metadata from estimatedTokenUsage: ${JSON.stringify(result.usage_metadata, null, 2)}`
-              );
-            }
-          }
-          if (!result?.usage_metadata && !result?.usageMetadata) {
-            logger2.warn(`No usage_metadata found in invoke result`);
-          }
-        }
-        return result;
-      };
-      logger2.warn(
-        `Successfully patched ${modelName}.invoke for GPT-5 response logging (TEMPORARY WORKAROUND)`
-      );
-    }
-  });
-}
-patchChatOpenAIForGPT5();
 var ModelInitializer = class _ModelInitializer {
-  constructor(configFetcher, logger2) {
+  constructor(configFetcher, logger2, apiKeyResolver) {
     this.configFetcher = configFetcher;
+    this.apiKeyResolver = apiKeyResolver;
     this.logger = logger2 || new Logger(_ModelInitializer.name);
   }
   logger;
@@ -6723,9 +6513,30 @@ var ModelInitializer = class _ModelInitializer {
   modelConfigCache = /* @__PURE__ */ new Map();
   // Cache for model instances to avoid recreating identical models
   modelInstanceCache = /* @__PURE__ */ new Map();
+  static DEFAULT_ENV_MAP = {
+    ["openai" /* OPENAI */]: "OPENAI_API_KEY",
+    ["anthropic" /* ANTHROPIC */]: "ANTHROPIC_API_KEY",
+    ["mistral" /* MISTRAL */]: "MISTRAL_API_KEY",
+    ["cohere" /* COHERE */]: "COHERE_API_KEY",
+    ["voyageai" /* VOYAGEAI */]: "VOYAGEAI_API_KEY"
+  };
   /**
-   * Generate cache key for model instances based on configuration
+   * Resolve API key for a provider.
+   * Uses custom resolver if provided, falls back to process.env.
    */
+  resolveApiKey(provider) {
+    if (this.apiKeyResolver) {
+      return this.apiKeyResolver(provider);
+    }
+    const envVar = _ModelInitializer.DEFAULT_ENV_MAP[provider];
+    return envVar ? process.env[envVar] : void 0;
+  }
+  /**
+   * Resolve AWS region for Bedrock.
+   */
+  resolveBedrockRegion() {
+    return process.env.BEDROCK_AWS_REGION || process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || "us-east-1";
+  }
   /**
    * Generate hash from toolsConfig for cache key
    * Uses MD5 hash to create short, unique identifier
@@ -6746,29 +6557,7 @@ var ModelInitializer = class _ModelInitializer {
       config.toolsConfig
     );
   }
-  /**
-   * TEMPORARY SOLUTION for compatibility with new OpenAI models
-   *
-   * OpenAI changed the API for new models (gpt-5, o-series):
-   * - Old models (gpt-3.5, gpt-4, gpt-4o): use maxTokens, support custom temperature
-   * - New reasoning models (gpt-5, gpt-o1, gpt-o3, gpt-o4): use maxCompletionTokens, only temperature = 1
-   *
-   * Patch fixes:
-   * 1. max_tokens -> max_completion_tokens for reasoning GPT-5+ models
-   * 2. temperature -> 1 (forced) for reasoning GPT-5+ models
-   *
-   * @param modelName - OpenAI model name
-   * @returns true if model requires maxCompletionTokens and temperature = 1
-   */
-  requiresMaxCompletionTokens(modelName) {
-    const requiresNew = isReasoningModel(modelName);
-    this.logger.debug(`Checking token parameter for model "${modelName}"`, {
-      modelName,
-      requiresMaxCompletionTokens: requiresNew
-    });
-    return requiresNew;
-  }
-  // Chat model creators (inherit from original LLMInitializer)
+  // Chat model creators
   chatModelCreators = {
     ["openai" /* OPENAI */]: ({
       modelName,
@@ -6776,36 +6565,13 @@ var ModelInitializer = class _ModelInitializer {
       defaultMaxTokens,
       apiToken
     }) => {
-      if (this.requiresMaxCompletionTokens(modelName)) {
-        const fixedTemperature = 1;
-        const config = {
-          modelName,
-          temperature: fixedTemperature,
-          // Force set to 1
-          maxCompletionTokens: defaultMaxTokens,
-          // Only this parameter for new models
-          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 ChatOpenAI(config);
-        return chatOpenAI;
-      } else {
-        const config = {
-          modelName,
-          temperature: defaultTemperature,
-          maxTokens: defaultMaxTokens,
-          // Only this parameter for legacy models
-          streaming: true,
-          openAIApiKey: apiToken || process.env.OPENAI_API_KEY
-        };
-        const chatOpenAI = new ChatOpenAI(config);
-        return chatOpenAI;
-      }
+      const config = buildOpenAIModelConfig(
+        modelName,
+        defaultTemperature,
+        defaultMaxTokens,
+        apiToken || this.resolveApiKey("openai" /* OPENAI */) || ""
+      );
+      return new ChatOpenAI(config);
     },
     ["anthropic" /* ANTHROPIC */]: ({
       modelName,
@@ -6816,7 +6582,7 @@ var ModelInitializer = class _ModelInitializer {
       modelName,
       temperature: defaultTemperature,
       maxTokens: defaultMaxTokens,
-      anthropicApiKey: apiToken || process.env.ANTHROPIC_API_KEY
+      anthropicApiKey: apiToken || this.resolveApiKey("anthropic" /* ANTHROPIC */)
     }),
     ["cohere" /* COHERE */]: ({
       modelName,
@@ -6826,8 +6592,7 @@ var ModelInitializer = class _ModelInitializer {
     }) => new ChatCohere({
       model: modelName,
       temperature: defaultTemperature,
-      // Cohere uses maxTokens via max_tokens parameter, but it's not supported in ChatCohere API
-      apiKey: apiToken || process.env.COHERE_API_KEY
+      apiKey: apiToken || this.resolveApiKey("cohere" /* COHERE */)
     }),
     ["mistral" /* MISTRAL */]: ({
       modelName,
@@ -6838,91 +6603,8 @@ var ModelInitializer = class _ModelInitializer {
       model: modelName,
       temperature: defaultTemperature,
       maxTokens: defaultMaxTokens,
-      apiKey: apiToken || process.env.MISTRAL_API_KEY
+      apiKey: apiToken || this.resolveApiKey("mistral" /* MISTRAL */)
     }),
-    // AWS Bedrock support removed - use Anthropic or OpenAI directly instead
-    ["flutch-openai" /* FLUTCH_OPENAI */]: ({
-      modelName,
-      defaultTemperature,
-      defaultMaxTokens,
-      apiToken
-    }) => {
-      if (this.requiresMaxCompletionTokens(modelName)) {
-        const fixedTemperature = 1;
-        const config = {
-          modelName,
-          temperature: fixedTemperature,
-          // Force set to 1
-          maxCompletionTokens: defaultMaxTokens,
-          // Only this parameter for new models
-          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 ChatOpenAI(config);
-        this.logger.debug(`FLUTCH ChatOpenAI GPT-5+ instance created`, {
-          modelName,
-          // Use modelName from parameters
-          maxTokens: chatOpenAI.maxTokens,
-          maxCompletionTokens: chatOpenAI.maxCompletionTokens,
-          temperature: chatOpenAI.temperature,
-          streaming: chatOpenAI.streaming,
-          // Try to get internal parameters
-          clientConfig: chatOpenAI.clientConfig,
-          kwargs: chatOpenAI.kwargs
-        });
-        return chatOpenAI;
-      } else {
-        const config = {
-          modelName,
-          temperature: defaultTemperature,
-          maxTokens: defaultMaxTokens,
-          // Only this parameter for legacy models
-          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 ChatOpenAI(config);
-        this.logger.debug(`FLUTCH ChatOpenAI legacy instance created`, {
-          modelName,
-          // Use modelName from parameters
-          maxTokens: chatOpenAI.maxTokens,
-          maxCompletionTokens: chatOpenAI.maxCompletionTokens,
-          temperature: chatOpenAI.temperature,
-          streaming: chatOpenAI.streaming,
-          // Try to get internal parameters
-          clientConfig: chatOpenAI.clientConfig,
-          kwargs: chatOpenAI.kwargs
-        });
-        return chatOpenAI;
-      }
-    },
-    // Other providers not yet implemented for chat
-    ["flutch" /* FLUTCH */]: () => {
-      throw new Error("Flutch chat models not implemented");
-    },
-    ["flutch-mistral" /* FLUTCH_MISTRAL */]: () => {
-      throw new Error("Flutch Mistral chat models not implemented");
-    },
-    ["flutch-anthropic" /* FLUTCH_ANTHROPIC */]: () => {
-      throw new Error("Flutch Anthropic chat models not implemented");
-    },
     ["voyageai" /* VOYAGEAI */]: () => {
       throw new Error("VoyageAI chat models not implemented");
     }
@@ -6931,14 +6613,14 @@ var ModelInitializer = class _ModelInitializer {
   rerankModelCreators = {
     ["cohere" /* COHERE */]: ({ modelName, apiToken, maxDocuments }) => {
       return new CohereRerank({
-        apiKey: apiToken || process.env.COHERE_API_KEY,
+        apiKey: apiToken || this.resolveApiKey("cohere" /* COHERE */),
         model: modelName,
         topN: maxDocuments || 20
       });
     },
     ["voyageai" /* VOYAGEAI */]: ({ modelName, apiToken, maxDocuments }) => {
       return new VoyageAIRerank({
-        apiKey: apiToken || process.env.VOYAGEAI_API_KEY,
+        apiKey: apiToken || this.resolveApiKey("voyageai" /* VOYAGEAI */),
         model: modelName,
         topN: maxDocuments || 20
       });
@@ -6947,27 +6629,19 @@ var ModelInitializer = class _ModelInitializer {
     ["openai" /* OPENAI */]: void 0,
     ["anthropic" /* ANTHROPIC */]: void 0,
     ["mistral" /* MISTRAL */]: void 0,
-    ["aws" /* AWS */]: void 0,
-    ["flutch" /* FLUTCH */]: void 0,
-    ["flutch-mistral" /* FLUTCH_MISTRAL */]: void 0,
-    ["flutch-openai" /* FLUTCH_OPENAI */]: void 0,
-    ["flutch-anthropic" /* FLUTCH_ANTHROPIC */]: void 0
+    ["aws" /* AWS */]: void 0
   };
   // Embedding model creators
   embeddingModelCreators = {
     ["openai" /* OPENAI */]: ({ modelName, apiToken }) => new OpenAIEmbeddings({
       model: modelName,
-      apiKey: apiToken || process.env.OPENAI_API_KEY
+      apiKey: apiToken || this.resolveApiKey("openai" /* OPENAI */)
     }),
     // Other providers not yet implemented for embeddings
     ["anthropic" /* ANTHROPIC */]: void 0,
     ["cohere" /* COHERE */]: void 0,
     ["mistral" /* MISTRAL */]: void 0,
     ["aws" /* AWS */]: void 0,
-    ["flutch" /* FLUTCH */]: void 0,
-    ["flutch-mistral" /* FLUTCH_MISTRAL */]: void 0,
-    ["flutch-openai" /* FLUTCH_OPENAI */]: void 0,
-    ["flutch-anthropic" /* FLUTCH_ANTHROPIC */]: void 0,
     ["voyageai" /* VOYAGEAI */]: void 0
   };
   async initializeChatModel(config) {
@@ -6983,12 +6657,6 @@ var ModelInitializer = class _ModelInitializer {
         `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 = {
       ...modelConfig,
       defaultTemperature: Number(
@@ -6999,7 +6667,27 @@ var ModelInitializer = class _ModelInitializer {
       )
     };
     this.logger.debug(`Creating new chat model instance: ${cacheKey}`);
-    const model = creator(finalConfig);
+    let model;
+    if (finalConfig.useBedrock && finalConfig.bedrockModelId) {
+      this.logger.debug(
+        `Using Bedrock for model ${finalConfig.modelName}, bedrockModelId: ${finalConfig.bedrockModelId}`
+      );
+      model = new ChatBedrockConverse({
+        model: finalConfig.bedrockModelId,
+        region: this.resolveBedrockRegion(),
+        temperature: finalConfig.defaultTemperature,
+        maxTokens: finalConfig.defaultMaxTokens,
+        streaming: true
+      });
+    } else {
+      const creator = this.chatModelCreators[modelConfig.provider];
+      if (!creator) {
+        throw new Error(
+          `Chat models not supported for provider: ${modelConfig.provider}`
+        );
+      }
+      model = creator(finalConfig);
+    }
     model.metadata = {
       ...model.metadata,
       modelId: config.modelId