@flutchai/flutch-sdk 0.2.8 → 0.2.10

package/dist/index.cjs

@@ -22,7 +22,7 @@ var axios2 = require('axios');
 var zodToJsonSchema = require('zod-to-json-schema');
 var manager = require('@langchain/core/callbacks/manager');
 var openai = require('@langchain/openai');
-var azureOpenai = require('@langchain/azure-openai');
+var aws = require('@langchain/aws');
 var anthropic = require('@langchain/anthropic');
 var cohere = require('@langchain/cohere');
 var document_compressors = require('@langchain/core/retrievers/document_compressors');
@@ -53,6 +53,7 @@ var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
 var os__namespace = /*#__PURE__*/_interopNamespace(os);
 var net__namespace = /*#__PURE__*/_interopNamespace(net);
 var mongoose__default = /*#__PURE__*/_interopDefault(mongoose);
+var crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
 var LangGraph__namespace = /*#__PURE__*/_interopNamespace(LangGraph);
 var axios2__default = /*#__PURE__*/_interopDefault(axios2);
 
@@ -1365,10 +1366,10 @@ exports.AbstractGraphBuilder = class AbstractGraphBuilder {
       return null;
     }
     try {
-      const fs2 = await import('fs/promises');
-      const path3 = await import('path');
-      const manifestFullPath = path3.resolve(this.manifestPath);
-      const manifestContent = await fs2.readFile(manifestFullPath, "utf-8");
+      const fs3 = await import('fs/promises');
+      const path4 = await import('path');
+      const manifestFullPath = path4.resolve(this.manifestPath);
+      const manifestContent = await fs3.readFile(manifestFullPath, "utf-8");
       const manifest = JSON.parse(manifestContent);
       this.manifest = manifest;
       return manifest;
@@ -1387,10 +1388,10 @@ exports.AbstractGraphBuilder = class AbstractGraphBuilder {
       return null;
     }
     try {
-      const fs2 = __require("fs");
-      const path3 = __require("path");
-      const manifestFullPath = path3.resolve(this.manifestPath);
-      const manifestContent = fs2.readFileSync(manifestFullPath, "utf-8");
+      const fs3 = __require("fs");
+      const path4 = __require("path");
+      const manifestFullPath = path4.resolve(this.manifestPath);
+      const manifestContent = fs3.readFileSync(manifestFullPath, "utf-8");
       const manifest = JSON.parse(manifestContent);
       this.manifest = manifest;
       return manifest;
@@ -1430,12 +1431,12 @@ exports.AbstractGraphBuilder = class AbstractGraphBuilder {
     let configSchema = null;
     if (versionConfig.configSchemaPath) {
       try {
-        const fs2 = await import('fs/promises');
+        const fs3 = await import('fs/promises');
         const schemaPath = path2__namespace.resolve(
           process.cwd(),
           versionConfig.configSchemaPath
         );
-        const schemaContent = await fs2.readFile(schemaPath, "utf-8");
+        const schemaContent = await fs3.readFile(schemaPath, "utf-8");
         const schemaData = JSON.parse(schemaContent);
         configSchema = schemaData.schema;
       } catch (error) {
@@ -6420,10 +6421,6 @@ exports.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";
@@ -6466,6 +6463,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 document_compressors.BaseDocumentCompressor {
   apiKey;
   model;
@@ -6517,235 +6533,10 @@ var VoyageAIRerank = class extends document_compressors.BaseDocumentCompressor {
     }
   }
 };
-function patchChatOpenAIForGPT5() {
-  const logger2 = new common.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 = [
-    openai.ChatOpenAI.prototype,
-    azureOpenai.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 common.Logger(_ModelInitializer.name);
   }
   logger;
@@ -6753,9 +6544,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
@@ -6776,29 +6588,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,
@@ -6806,36 +6596,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 openai.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 openai.ChatOpenAI(config);
-        return chatOpenAI;
-      }
+      const config = buildOpenAIModelConfig(
+        modelName,
+        defaultTemperature,
+        defaultMaxTokens,
+        apiToken || this.resolveApiKey("openai" /* OPENAI */) || ""
+      );
+      return new openai.ChatOpenAI(config);
     },
     ["anthropic" /* ANTHROPIC */]: ({
       modelName,
@@ -6846,7 +6613,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,
@@ -6856,8 +6623,7 @@ var ModelInitializer = class _ModelInitializer {
     }) => new cohere.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,
@@ -6868,91 +6634,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 openai.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 openai.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");
     }
@@ -6961,14 +6644,14 @@ var ModelInitializer = class _ModelInitializer {
   rerankModelCreators = {
     ["cohere" /* COHERE */]: ({ modelName, apiToken, maxDocuments }) => {
       return new cohere.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
       });
@@ -6977,27 +6660,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 openai.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) {
@@ -7013,12 +6688,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(
@@ -7029,7 +6698,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 aws.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
@@ -7637,6 +7326,205 @@ exports.StaticDiscovery = class StaticDiscovery {
 exports.StaticDiscovery = __decorateClass([
   common.Injectable()
 ], exports.StaticDiscovery);
+var ALGORITHM = "aes-256-cbc";
+var IV_LENGTH = 16;
+function encryptTokens(tokens, key) {
+  const iv = crypto__namespace.randomBytes(IV_LENGTH);
+  const cipher = crypto__namespace.createCipheriv(
+    ALGORITHM,
+    Buffer.from(key),
+    iv
+  );
+  const json = JSON.stringify(tokens);
+  let encrypted = cipher.update(json, "utf8", "hex");
+  encrypted += cipher.final("hex");
+  return iv.toString("hex") + ":" + encrypted;
+}
+function decryptTokens(encrypted, key) {
+  const separatorIndex = encrypted.indexOf(":");
+  if (separatorIndex === -1) {
+    throw new Error("Invalid encrypted token format");
+  }
+  const ivHex = encrypted.substring(0, separatorIndex);
+  const encryptedData = encrypted.substring(separatorIndex + 1);
+  const iv = Buffer.from(ivHex, "hex");
+  const decipher = crypto__namespace.createDecipheriv(
+    ALGORITHM,
+    Buffer.from(key),
+    iv
+  );
+  let decrypted = decipher.update(encryptedData, "hex", "utf8");
+  decrypted += decipher.final("utf8");
+  return JSON.parse(decrypted);
+}
+
+// src/oauth/oauth-token.manager.ts
+var EXPIRY_BUFFER_MS = 6e4;
+var OAuthTokenManager = class {
+  store;
+  encryptionKey;
+  cache = /* @__PURE__ */ new Map();
+  constructor(options) {
+    if (!options.encryptionKey || options.encryptionKey.length < 32) {
+      throw new Error(
+        "OAUTH_ENCRYPTION_KEY must be at least 32 characters for AES-256-CBC"
+      );
+    }
+    this.store = options.store;
+    this.encryptionKey = options.encryptionKey;
+  }
+  /**
+   * Get a fresh access token for the given provider.
+   * Returns from cache → store → refresh flow (in that order).
+   */
+  async getAccessToken(config) {
+    const cached = this.cache.get(config.provider);
+    if (cached && cached.expiresAt > Date.now() + EXPIRY_BUFFER_MS) {
+      return cached.token;
+    }
+    const encrypted = await this.store.get(config.provider);
+    if (!encrypted) {
+      throw new Error(
+        `No OAuth tokens found for "${config.provider}". Complete the OAuth consent flow first and call saveTokens().`
+      );
+    }
+    const tokens = decryptTokens(encrypted, this.encryptionKey);
+    if (tokens.expiresAt > Date.now() + EXPIRY_BUFFER_MS) {
+      this.setCache(config.provider, tokens.accessToken, tokens.expiresAt);
+      return tokens.accessToken;
+    }
+    const refreshed = await this.refreshAccessToken(config, tokens.refreshToken);
+    await this.persistTokens(config.provider, refreshed);
+    return refreshed.accessToken;
+  }
+  /**
+   * Store tokens after the initial OAuth consent flow.
+   * Call this once after the user completes the OAuth redirect.
+   */
+  async saveTokens(provider, tokens) {
+    await this.persistTokens(provider, tokens);
+  }
+  /**
+   * Remove all tokens for a provider.
+   */
+  async revokeTokens(provider) {
+    await this.store.delete(provider);
+    this.cache.delete(provider);
+  }
+  /**
+   * Check if tokens exist for a provider (without decrypting).
+   */
+  async hasTokens(provider) {
+    const encrypted = await this.store.get(provider);
+    return encrypted !== null;
+  }
+  async refreshAccessToken(config, refreshToken) {
+    try {
+      const response = await axios2__default.default.post(
+        config.tokenUrl,
+        new URLSearchParams({
+          grant_type: "refresh_token",
+          client_id: config.clientId,
+          client_secret: config.clientSecret,
+          refresh_token: refreshToken
+        }).toString(),
+        {
+          headers: { "Content-Type": "application/x-www-form-urlencoded" },
+          timeout: 1e4
+        }
+      );
+      const data = response.data;
+      return {
+        accessToken: data.access_token,
+        // Some providers rotate refresh tokens; keep the old one if not rotated
+        refreshToken: data.refresh_token || refreshToken,
+        expiresAt: Date.now() + (data.expires_in || 3600) * 1e3
+      };
+    } catch (error) {
+      const status = error?.response?.status;
+      const body = error?.response?.data;
+      throw new Error(
+        `OAuth refresh failed for "${config.provider}": ${status || "network error"} ${JSON.stringify(body) || error.message}`
+      );
+    }
+  }
+  async persistTokens(provider, tokens) {
+    const encrypted = encryptTokens(tokens, this.encryptionKey);
+    await this.store.save(provider, encrypted);
+    this.setCache(provider, tokens.accessToken, tokens.expiresAt);
+  }
+  setCache(provider, token, expiresAt) {
+    this.cache.set(provider, { token, expiresAt });
+  }
+};
+var FileTokenStore = class {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  async get(provider) {
+    const data = this.readFile();
+    return data[provider] ?? null;
+  }
+  async save(provider, encrypted) {
+    const data = this.readFile();
+    data[provider] = encrypted;
+    this.writeFile(data);
+  }
+  async delete(provider) {
+    const data = this.readFile();
+    delete data[provider];
+    this.writeFile(data);
+  }
+  readFile() {
+    try {
+      if (fs__namespace.existsSync(this.filePath)) {
+        const content = fs__namespace.readFileSync(this.filePath, "utf8");
+        return JSON.parse(content);
+      }
+    } catch {
+    }
+    return {};
+  }
+  writeFile(data) {
+    const dir = path2__namespace.dirname(this.filePath);
+    if (!fs__namespace.existsSync(dir)) {
+      fs__namespace.mkdirSync(dir, { recursive: true });
+    }
+    fs__namespace.writeFileSync(this.filePath, JSON.stringify(data, null, 2), "utf8");
+  }
+};
+
+// src/oauth/stores/mongo-token.store.ts
+var DEFAULT_COLLECTION = "oauth_tokens";
+var MongoTokenStore = class {
+  constructor(db, collectionName) {
+    this.db = db;
+    this.collectionName = collectionName ?? DEFAULT_COLLECTION;
+  }
+  collectionName;
+  initialized = false;
+  async get(provider) {
+    await this.ensureIndex();
+    const doc = await this.db.collection(this.collectionName).findOne({ provider });
+    return doc?.encrypted ?? null;
+  }
+  async save(provider, encrypted) {
+    await this.ensureIndex();
+    await this.db.collection(this.collectionName).updateOne(
+      { provider },
+      { $set: { provider, encrypted, updatedAt: /* @__PURE__ */ new Date() } },
+      { upsert: true }
+    );
+  }
+  async delete(provider) {
+    await this.db.collection(this.collectionName).deleteOne({ provider });
+  }
+  async ensureIndex() {
+    if (this.initialized) return;
+    await this.db.collection(this.collectionName).createIndex({ provider: 1 }, { unique: true });
+    this.initialized = true;
+  }
+};
 
 exports.AttachmentType = AttachmentType;
 exports.BaseGraphServiceController = exports.GraphController;
@@ -7649,6 +7537,7 @@ exports.ChatFeature = ChatFeature;
 exports.DEFAULT_ATTACHMENT_THRESHOLD = DEFAULT_ATTACHMENT_THRESHOLD;
 exports.DEFAULT_TRACER_OPTIONS = DEFAULT_TRACER_OPTIONS;
 exports.Endpoint = Endpoint;
+exports.FileTokenStore = FileTokenStore;
 exports.GraphEngineType = GraphEngineType;
 exports.GraphManifestSchema = GraphManifestSchema;
 exports.GraphManifestValidator = GraphManifestValidator;
@@ -7659,6 +7548,8 @@ exports.McpToolFilter = McpToolFilter;
 exports.ModelInitializer = ModelInitializer;
 exports.ModelProvider = ModelProvider;
 exports.ModelType = ModelType;
+exports.MongoTokenStore = MongoTokenStore;
+exports.OAuthTokenManager = OAuthTokenManager;
 exports.RetrieverSearchType = RetrieverSearchType;
 exports.StreamChannel = StreamChannel;
 exports.UIEndpoint = UIEndpoint;
@@ -7674,7 +7565,9 @@ exports.createEndpointDescriptors = createEndpointDescriptors;
 exports.createGraphAttachment = createGraphAttachment;
 exports.createMongoClientAdapter = createMongoClientAdapter;
 exports.createStaticMessage = createStaticMessage;
+exports.decryptTokens = decryptTokens;
 exports.dispatchAttachments = dispatchAttachments;
+exports.encryptTokens = encryptTokens;
 exports.executeToolWithAttachments = executeToolWithAttachments;
 exports.findCallbackMethod = findCallbackMethod;
 exports.findEndpointMethod = findEndpointMethod;