🪨 feat: AWS Bedrock support (#3935)

* feat: Add BedrockIcon component to SVG library

* feat: EModelEndpoint.bedrock

* feat: first pass, bedrock chat. note: AgentClient is returning `agents` as conversation.endpoint

* fix: declare endpoint in initialization step

* chore: Update @librechat/agents dependency to version 1.4.5

* feat: backend content aggregation for agents/bedrock

* feat: abort agent requests

* feat: AWS Bedrock icons

* WIP: agent provider schema parsing

* chore: Update EditIcon props type

* refactor(useGenerationsByLatest): make agents and bedrock editable

* refactor: non-assistant message content, parts

* fix: Bedrock response `sender`

* fix: use endpointOption.model_parameters not endpointOption.modelOptions

* fix: types for step handler

* refactor: Update Agents.ToolCallDelta type

* refactor: Remove unnecessary assignment of parentMessageId in AskController

* refactor: remove unnecessary assignment of parentMessageId (agent request handler)

* fix(bedrock/agents): message regeneration

* refactor: dynamic form elements using react-hook-form Controllers

* fix: agent icons/labels for messages

* fix: agent actions

* fix: use of new dynamic tags causing application crash

* refactor: dynamic settings touch-ups

* refactor: update Slider component to allow custom track class name

* refactor: update DynamicSlider component styles

* refactor: use Constants value for GLOBAL_PROJECT_NAME (enum)

* feat: agent share global methods/controllers

* fix: agents query

* fix: `getResponseModel`

* fix: share prompt a11y issue

* refactor: update SharePrompt dialog theme styles

* refactor: explicit typing for SharePrompt

* feat: add agent roles/permissions

* chore: update @librechat/agents dependency to version 1.4.7 for tool_call_ids edge case

* fix(Anthropic): messages.X.content.Y.tool_use.input: Input should be a valid dictionary

* fix: handle text parts with tool_call_ids and empty text

* fix: role initialization

* refactor: don't make instructions required

* refactor: improve typing of Text part

* fix: setShowStopButton for agents route

* chore: remove params for now

* fix: add streamBuffer and streamRate to help prevent 'Overloaded' errors from Anthropic API

* refactor: remove console.log statement in ContentRender component

* chore: typing, rename Context to Delete Button

* chore(DeleteButton): logging

* refactor(Action): make accessible

* style(Action): improve a11y again

* refactor: remove use/mention of mongoose sessions

* feat: first pass, sharing agents

* feat: visual indicator for global agent, remove author when serving to non-author

* wip: params

* chore: fix typing issues

* fix(schemas): typing

* refactor: improve accessibility of ListCard component and fix console React warning

* wip: reset templates for non-legacy new convos

* Revert "wip: params"

This reverts commit f8067e91d4.

* Revert "refactor: dynamic form elements using react-hook-form Controllers"

This reverts commit 2150c4815d.

* fix(Parameters): types and parameter effect update to only update local state to parameters

* refactor: optimize useDebouncedInput hook for better performance

* feat: first pass, anthropic bedrock params

* chore: paramEndpoints check for endpointType too

* fix: maxTokens to use coerceNumber.optional(),

* feat: extra chat model params

* chore: reduce code repetition

* refactor: improve preset title handling in SaveAsPresetDialog component

* refactor: improve preset handling in HeaderOptions component

* chore: improve typing, replace legacy dialog for SaveAsPresetDialog

* feat: save as preset from parameters panel

* fix: multi-search in select dropdown when using Option type

* refactor: update default showDefault value to false in Dynamic components

* feat: Bedrock presets settings

* chore: config, fix agents schema, update config version

* refactor: update AWS region variable name in bedrock options endpoint to BEDROCK_AWS_DEFAULT_REGION

* refactor: update baseEndpointSchema in config.ts to include baseURL property

* refactor: update createRun function to include req parameter and set streamRate based on provider

* feat: availableRegions via config

* refactor: remove unused demo agent controller file

* WIP: title

* Update @librechat/agents to version 1.5.0

* chore: addTitle.js to handle empty responseText

* feat: support images and titles

* feat: context token updates

* Refactor BaseClient test to use expect.objectContaining

* refactor: add model select, remove header options params, move side panel params below prompts

* chore: update models list, catch title error

* feat: model service for bedrock models (env)

* chore: Remove verbose debug log in AgentClient class following stream

* feat(bedrock): track token spend; fix: token rates, value key mapping for AWS models

* refactor: handle streamRate in `handleLLMNewToken` callback

* chore: AWS Bedrock example config in `.env.example`

* refactor: Rename bedrockMeta to bedrockGeneral in settings.ts and use for AI21 and Amazon Bedrock providers

* refactor: Update `.env.example` with AWS Bedrock model IDs URL and additional notes

* feat: titleModel support for bedrock

* refactor: Update `.env.example` with additional notes for AWS Bedrock model IDs

api/server/services/ActionService.js

@@ -165,7 +165,7 @@ async function createActionTool({ action, requestBuilder, zodSchema, name, descr
  * Encrypts sensitive metadata values for an action.
  *
  * @param {ActionMetadata} metadata - The action metadata to encrypt.
- * @returns {ActionMetadata} The updated action metadata with encrypted values.
+ * @returns {Promise<ActionMetadata>} The updated action metadata with encrypted values.
  */
 async function encryptMetadata(metadata) {
   const encryptedMetadata = { ...metadata };

api/server/services/AppService.js

@@ -94,18 +94,19 @@ const AppService = async (app) => {
     );
   }
 
-  if (endpoints?.[EModelEndpoint.openAI]) {
-    endpointLocals[EModelEndpoint.openAI] = endpoints[EModelEndpoint.openAI];
-  }
-  if (endpoints?.[EModelEndpoint.google]) {
-    endpointLocals[EModelEndpoint.google] = endpoints[EModelEndpoint.google];
-  }
-  if (endpoints?.[EModelEndpoint.anthropic]) {
-    endpointLocals[EModelEndpoint.anthropic] = endpoints[EModelEndpoint.anthropic];
-  }
-  if (endpoints?.[EModelEndpoint.gptPlugins]) {
-    endpointLocals[EModelEndpoint.gptPlugins] = endpoints[EModelEndpoint.gptPlugins];
-  }
+  const endpointKeys = [
+    EModelEndpoint.openAI,
+    EModelEndpoint.google,
+    EModelEndpoint.bedrock,
+    EModelEndpoint.anthropic,
+    EModelEndpoint.gptPlugins,
+  ];
+
+  endpointKeys.forEach((key) => {
+    if (endpoints?.[key]) {
+      endpointLocals[key] = endpoints[key];
+    }
+  });
 
   app.locals = {
     ...defaultLocals,

api/server/services/Config/EndpointService.js

@@ -45,6 +45,7 @@ module.exports = {
       AZURE_ASSISTANTS_BASE_URL,
       EModelEndpoint.azureAssistants,
     ),
+    [EModelEndpoint.bedrock]: generateConfig(process.env.BEDROCK_AWS_SECRET_ACCESS_KEY),
     /* key will be part of separate config */
     [EModelEndpoint.agents]: generateConfig(process.env.I_AM_A_TEAPOT),
   },

api/server/services/Config/loadDefaultEConfig.js

@@ -9,22 +9,13 @@ const { config } = require('./EndpointService');
  */
 async function loadDefaultEndpointsConfig(req) {
   const { google, gptPlugins } = await loadAsyncEndpoints(req);
-  const {
-    openAI,
-    agents,
-    assistants,
-    azureAssistants,
-    bingAI,
-    anthropic,
-    azureOpenAI,
-    chatGPTBrowser,
-  } = config;
+  const { assistants, azureAssistants, bingAI, azureOpenAI, chatGPTBrowser } = config;
 
   const enabledEndpoints = getEnabledEndpoints();
 
   const endpointConfig = {
-    [EModelEndpoint.openAI]: openAI,
-    [EModelEndpoint.agents]: agents,
+    [EModelEndpoint.openAI]: config[EModelEndpoint.openAI],
+    [EModelEndpoint.agents]: config[EModelEndpoint.agents],
     [EModelEndpoint.assistants]: assistants,
     [EModelEndpoint.azureAssistants]: azureAssistants,
     [EModelEndpoint.azureOpenAI]: azureOpenAI,
@@ -32,7 +23,8 @@ async function loadDefaultEndpointsConfig(req) {
     [EModelEndpoint.bingAI]: bingAI,
     [EModelEndpoint.chatGPTBrowser]: chatGPTBrowser,
     [EModelEndpoint.gptPlugins]: gptPlugins,
-    [EModelEndpoint.anthropic]: anthropic,
+    [EModelEndpoint.anthropic]: config[EModelEndpoint.anthropic],
+    [EModelEndpoint.bedrock]: config[EModelEndpoint.bedrock],
   };
 
   const orderedAndFilteredEndpoints = enabledEndpoints.reduce((config, key, index) => {

api/server/services/Config/loadDefaultModels.js

@@ -3,6 +3,7 @@ const { useAzurePlugins } = require('~/server/services/Config/EndpointService').
 const {
   getOpenAIModels,
   getGoogleModels,
+  getBedrockModels,
   getAnthropicModels,
   getChatGPTBrowserModels,
 } = require('~/server/services/ModelService');
@@ -38,6 +39,7 @@ async function loadDefaultModels(req) {
     [EModelEndpoint.chatGPTBrowser]: chatGPTBrowser,
     [EModelEndpoint.assistants]: assistants,
     [EModelEndpoint.azureAssistants]: azureAssistants,
+    [EModelEndpoint.bedrock]: getBedrockModels(),
   };
 }
 

api/server/services/Endpoints/agents/build.js

@@ -2,7 +2,7 @@ const { getAgent } = require('~/models/Agent');
 const { logger } = require('~/config');
 
 const buildOptions = (req, endpoint, parsedBody) => {
-  const { agent_id, instructions, spec, ...rest } = parsedBody;
+  const { agent_id, instructions, spec, ...model_parameters } = parsedBody;
 
   const agentPromise = getAgent({
     id: agent_id,
@@ -19,9 +19,7 @@ const buildOptions = (req, endpoint, parsedBody) => {
     agent_id,
     instructions,
     spec,
-    modelOptions: {
-      ...rest,
-    },
+    model_parameters,
   };
 
   return endpointOption;

api/server/services/Endpoints/agents/initialize.js

@@ -11,7 +11,12 @@
 
 const { z } = require('zod');
 const { tool } = require('@langchain/core/tools');
-const { EModelEndpoint, providerEndpointMap } = require('librechat-data-provider');
+const { createContentAggregator } = require('@librechat/agents');
+const {
+  EModelEndpoint,
+  providerEndpointMap,
+  getResponseSender,
+} = require('librechat-data-provider');
 const { getDefaultHandlers } = require('~/server/controllers/agents/callbacks');
 // for testing purposes
 // const createTavilySearchTool = require('~/app/clients/tools/structured/TavilySearch');
@@ -53,7 +58,8 @@ const initializeClient = async ({ req, res, endpointOption }) => {
   }
 
   // TODO: use endpointOption to determine options/modelOptions
-  const eventHandlers = getDefaultHandlers({ res });
+  const { contentParts, aggregateContent } = createContentAggregator();
+  const eventHandlers = getDefaultHandlers({ res, aggregateContent });
 
   // const tools = [createTavilySearchTool()];
   // const tools = [_getWeather];
@@ -90,7 +96,7 @@ const initializeClient = async ({ req, res, endpointOption }) => {
   }
 
   // TODO: pass-in override settings that are specific to current run
-  endpointOption.modelOptions.model = agent.model;
+  endpointOption.model_parameters.model = agent.model;
   const options = await getOptions({
     req,
     res,
@@ -101,13 +107,21 @@ const initializeClient = async ({ req, res, endpointOption }) => {
   });
   modelOptions = Object.assign(modelOptions, options.llmConfig);
 
+  const sender = getResponseSender({
+    ...endpointOption,
+    model: endpointOption.model_parameters.model,
+  });
+
   const client = new AgentClient({
     req,
     agent,
     tools,
+    sender,
     toolMap,
+    contentParts,
     modelOptions,
     eventHandlers,
+    endpoint: EModelEndpoint.agents,
     configOptions: options.configOptions,
     maxContextTokens:
       agent.max_context_tokens ??

api/server/services/Endpoints/anthropic/addTitle.js

@@ -23,7 +23,7 @@ const addTitle = async (req, { text, response, client }) => {
 
   const title = await client.titleConvo({
     text,
-    responseText: response?.text,
+    responseText: response?.text ?? '',
     conversationId: response.conversationId,
   });
   await titleCache.set(key, title, 120000);

api/server/services/Endpoints/bedrock/build.js

@@ -0,0 +1,44 @@
+const { removeNullishValues, bedrockInputParser } = require('librechat-data-provider');
+const generateArtifactsPrompt = require('~/app/clients/prompts/artifacts');
+const { logger } = require('~/config');
+
+const buildOptions = (endpoint, parsedBody) => {
+  const {
+    modelLabel: name,
+    promptPrefix,
+    maxContextTokens,
+    resendFiles = true,
+    imageDetail,
+    iconURL,
+    greeting,
+    spec,
+    artifacts,
+    ...model_parameters
+  } = parsedBody;
+  let parsedParams = model_parameters;
+  try {
+    parsedParams = bedrockInputParser.parse(model_parameters);
+  } catch (error) {
+    logger.warn('Failed to parse bedrock input', error);
+  }
+  const endpointOption = removeNullishValues({
+    endpoint,
+    name,
+    resendFiles,
+    imageDetail,
+    iconURL,
+    greeting,
+    spec,
+    promptPrefix,
+    maxContextTokens,
+    model_parameters: parsedParams,
+  });
+
+  if (typeof artifacts === 'string') {
+    endpointOption.artifactsPrompt = generateArtifactsPrompt({ endpoint, artifacts });
+  }
+
+  return endpointOption;
+};
+
+module.exports = { buildOptions };

api/server/services/Endpoints/bedrock/index.js

@@ -0,0 +1,7 @@
+const build = require('./build');
+const initialize = require('./initialize');
+
+module.exports = {
+  ...build,
+  ...initialize,
+};

api/server/services/Endpoints/bedrock/initialize.js

@@ -0,0 +1,72 @@
+const { createContentAggregator } = require('@librechat/agents');
+const {
+  EModelEndpoint,
+  providerEndpointMap,
+  getResponseSender,
+} = require('librechat-data-provider');
+const { getDefaultHandlers } = require('~/server/controllers/agents/callbacks');
+// const { loadAgentTools } = require('~/server/services/ToolService');
+const getOptions = require('~/server/services/Endpoints/bedrock/options');
+const AgentClient = require('~/server/controllers/agents/client');
+const { getModelMaxTokens } = require('~/utils');
+
+const initializeClient = async ({ req, res, endpointOption }) => {
+  if (!endpointOption) {
+    throw new Error('Endpoint option not provided');
+  }
+
+  /** @type {Array<UsageMetadata>} */
+  const collectedUsage = [];
+  const { contentParts, aggregateContent } = createContentAggregator();
+  const eventHandlers = getDefaultHandlers({ res, aggregateContent, collectedUsage });
+
+  // const tools = [createTavilySearchTool()];
+
+  /** @type {Agent} */
+  const agent = {
+    id: EModelEndpoint.bedrock,
+    name: endpointOption.name,
+    instructions: endpointOption.promptPrefix,
+    provider: EModelEndpoint.bedrock,
+    model: endpointOption.model_parameters.model,
+    model_parameters: endpointOption.model_parameters,
+  };
+
+  let modelOptions = { model: agent.model };
+
+  // TODO: pass-in override settings that are specific to current run
+  const options = await getOptions({
+    req,
+    res,
+    endpointOption,
+  });
+
+  modelOptions = Object.assign(modelOptions, options.llmConfig);
+  const maxContextTokens =
+    agent.max_context_tokens ??
+    getModelMaxTokens(modelOptions.model, providerEndpointMap[agent.provider]);
+
+  const sender = getResponseSender({
+    ...endpointOption,
+    model: endpointOption.model_parameters.model,
+  });
+
+  const client = new AgentClient({
+    req,
+    agent,
+    sender,
+    // tools,
+    // toolMap,
+    modelOptions,
+    contentParts,
+    eventHandlers,
+    collectedUsage,
+    maxContextTokens,
+    endpoint: EModelEndpoint.bedrock,
+    configOptions: options.configOptions,
+    attachments: endpointOption.attachments,
+  });
+  return { client };
+};
+
+module.exports = { initializeClient };

api/server/services/Endpoints/bedrock/options.js

@@ -0,0 +1,90 @@
+const { HttpsProxyAgent } = require('https-proxy-agent');
+const {
+  EModelEndpoint,
+  Constants,
+  AuthType,
+  removeNullishValues,
+} = require('librechat-data-provider');
+const { getUserKey, checkUserKeyExpiry } = require('~/server/services/UserService');
+const { sleep } = require('~/server/utils');
+
+const getOptions = async ({ req, endpointOption }) => {
+  const {
+    BEDROCK_AWS_SECRET_ACCESS_KEY,
+    BEDROCK_AWS_ACCESS_KEY_ID,
+    BEDROCK_REVERSE_PROXY,
+    BEDROCK_AWS_DEFAULT_REGION,
+    PROXY,
+  } = process.env;
+  const expiresAt = req.body.key;
+  const isUserProvided = BEDROCK_AWS_SECRET_ACCESS_KEY === AuthType.USER_PROVIDED;
+
+  const credentials = isUserProvided
+    ? await getUserKey({ userId: req.user.id, name: EModelEndpoint.bedrock })
+    : {
+      accessKeyId: BEDROCK_AWS_ACCESS_KEY_ID,
+      secretAccessKey: BEDROCK_AWS_SECRET_ACCESS_KEY,
+    };
+
+  if (!credentials) {
+    throw new Error('Bedrock credentials not provided. Please provide them again.');
+  }
+
+  if (expiresAt && isUserProvided) {
+    checkUserKeyExpiry(expiresAt, EModelEndpoint.bedrock);
+  }
+
+  /** @type {number} */
+  let streamRate = Constants.DEFAULT_STREAM_RATE;
+
+  /** @type {undefined | TBaseEndpoint} */
+  const bedrockConfig = req.app.locals[EModelEndpoint.bedrock];
+
+  if (bedrockConfig && bedrockConfig.streamRate) {
+    streamRate = bedrockConfig.streamRate;
+  }
+
+  /** @type {undefined | TBaseEndpoint} */
+  const allConfig = req.app.locals.all;
+  if (allConfig && allConfig.streamRate) {
+    streamRate = allConfig.streamRate;
+  }
+
+  /** @type {import('@librechat/agents').BedrockConverseClientOptions} */
+  const requestOptions = Object.assign(
+    {
+      credentials,
+      model: endpointOption.model,
+      region: BEDROCK_AWS_DEFAULT_REGION,
+      streaming: true,
+      streamUsage: true,
+      callbacks: [
+        {
+          handleLLMNewToken: async () => {
+            if (!streamRate) {
+              return;
+            }
+            await sleep(streamRate);
+          },
+        },
+      ],
+    },
+    endpointOption.model_parameters,
+  );
+
+  const configOptions = {};
+  if (PROXY) {
+    configOptions.httpAgent = new HttpsProxyAgent(PROXY);
+  }
+
+  if (BEDROCK_REVERSE_PROXY) {
+    configOptions.endpointHost = BEDROCK_REVERSE_PROXY;
+  }
+
+  return {
+    llmConfig: removeNullishValues(requestOptions),
+    configOptions,
+  };
+};
+
+module.exports = getOptions;

api/server/services/Endpoints/bedrock/title.js

@@ -0,0 +1,40 @@
+const { CacheKeys } = require('librechat-data-provider');
+const getLogStores = require('~/cache/getLogStores');
+const { isEnabled } = require('~/server/utils');
+const { saveConvo } = require('~/models');
+
+const addTitle = async (req, { text, response, client }) => {
+  const { TITLE_CONVO = true } = process.env ?? {};
+  if (!isEnabled(TITLE_CONVO)) {
+    return;
+  }
+
+  if (client.options.titleConvo === false) {
+    return;
+  }
+
+  // If the request was aborted, don't generate the title.
+  if (client.abortController.signal.aborted) {
+    return;
+  }
+
+  const titleCache = getLogStores(CacheKeys.GEN_TITLE);
+  const key = `${req.user.id}-${response.conversationId}`;
+
+  const title = await client.titleConvo({
+    text,
+    responseText: response?.text ?? '',
+    conversationId: response.conversationId,
+  });
+  await titleCache.set(key, title, 120000);
+  await saveConvo(
+    req,
+    {
+      conversationId: response.conversationId,
+      title,
+    },
+    { context: 'api/server/services/Endpoints/bedrock/title.js' },
+  );
+};
+
+module.exports = addTitle;

api/server/services/Endpoints/google/addTitle.js

@@ -49,7 +49,7 @@ const addTitle = async (req, { text, response, client }) => {
 
   const title = await titleClient.titleConvo({
     text,
-    responseText: response?.text,
+    responseText: response?.text ?? '',
     conversationId: response.conversationId,
   });
   await titleCache.set(key, title, 120000);

api/server/services/Endpoints/openAI/addTitle.js

@@ -23,7 +23,7 @@ const addTitle = async (req, { text, response, client }) => {
 
   const title = await client.titleConvo({
     text,
-    responseText: response?.text,
+    responseText: response?.text ?? '',
     conversationId: response.conversationId,
   });
   await titleCache.set(key, title, 120000);

api/server/services/Files/images/encode.js

@@ -23,7 +23,13 @@ async function fetchImageToBase64(url) {
   }
 }
 
-const base64Only = new Set([EModelEndpoint.google, EModelEndpoint.anthropic, 'Ollama', 'ollama']);
+const base64Only = new Set([
+  EModelEndpoint.google,
+  EModelEndpoint.anthropic,
+  'Ollama',
+  'ollama',
+  EModelEndpoint.bedrock,
+]);
 
 /**
  * Encodes and formats the given files.

api/server/services/ModelService.js

@@ -5,6 +5,21 @@ const { extractBaseURL, inputSchema, processModelData, logAxiosError } = require
 const { OllamaClient } = require('~/app/clients/OllamaClient');
 const getLogStores = require('~/cache/getLogStores');
 
+/**
+ * Splits a string by commas and trims each resulting value.
+ * @param {string} input - The input string to split.
+ * @returns {string[]} An array of trimmed values.
+ */
+const splitAndTrim = (input) => {
+  if (!input || typeof input !== 'string') {
+    return [];
+  }
+  return input
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+};
+
 const { openAIApiKey, userProvidedOpenAI } = require('./Config/EndpointService').config;
 
 /**
@@ -194,7 +209,7 @@ const getOpenAIModels = async (opts) => {
   }
 
   if (process.env[key]) {
-    models = String(process.env[key]).split(',');
+    models = splitAndTrim(process.env[key]);
     return models;
   }
 
@@ -208,7 +223,7 @@ const getOpenAIModels = async (opts) => {
 const getChatGPTBrowserModels = () => {
   let models = ['text-davinci-002-render-sha', 'gpt-4'];
   if (process.env.CHATGPT_MODELS) {
-    models = String(process.env.CHATGPT_MODELS).split(',');
+    models = splitAndTrim(process.env.CHATGPT_MODELS);
   }
 
   return models;
@@ -217,7 +232,7 @@ const getChatGPTBrowserModels = () => {
 const getAnthropicModels = () => {
   let models = defaultModels[EModelEndpoint.anthropic];
   if (process.env.ANTHROPIC_MODELS) {
-    models = String(process.env.ANTHROPIC_MODELS).split(',');
+    models = splitAndTrim(process.env.ANTHROPIC_MODELS);
   }
 
   return models;
@@ -226,7 +241,16 @@ const getAnthropicModels = () => {
 const getGoogleModels = () => {
   let models = defaultModels[EModelEndpoint.google];
   if (process.env.GOOGLE_MODELS) {
-    models = String(process.env.GOOGLE_MODELS).split(',');
+    models = splitAndTrim(process.env.GOOGLE_MODELS);
+  }
+
+  return models;
+};
+
+const getBedrockModels = () => {
+  let models = defaultModels[EModelEndpoint.bedrock];
+  if (process.env.BEDROCK_AWS_MODELS) {
+    models = splitAndTrim(process.env.BEDROCK_AWS_MODELS);
   }
 
   return models;
@@ -234,7 +258,9 @@ const getGoogleModels = () => {
 
 module.exports = {
   fetchModels,
+  splitAndTrim,
   getOpenAIModels,
+  getBedrockModels,
   getChatGPTBrowserModels,
   getAnthropicModels,
   getGoogleModels,

api/server/services/ModelService.spec.js

@@ -1,7 +1,16 @@
 const axios = require('axios');
+const { EModelEndpoint, defaultModels } = require('librechat-data-provider');
 const { logger } = require('~/config');
 
-const { fetchModels, getOpenAIModels } = require('./ModelService');
+const {
+  fetchModels,
+  splitAndTrim,
+  getOpenAIModels,
+  getGoogleModels,
+  getBedrockModels,
+  getAnthropicModels,
+} = require('./ModelService');
+
 jest.mock('~/utils', () => {
   const originalUtils = jest.requireActual('~/utils');
   return {
@@ -329,3 +338,71 @@ describe('fetchModels with Ollama specific logic', () => {
     );
   });
 });
+
+describe('splitAndTrim', () => {
+  it('should split a string by commas and trim each value', () => {
+    const input = ' model1, model2 , model3,model4 ';
+    const expected = ['model1', 'model2', 'model3', 'model4'];
+    expect(splitAndTrim(input)).toEqual(expected);
+  });
+
+  it('should return an empty array for empty input', () => {
+    expect(splitAndTrim('')).toEqual([]);
+  });
+
+  it('should return an empty array for null input', () => {
+    expect(splitAndTrim(null)).toEqual([]);
+  });
+
+  it('should return an empty array for undefined input', () => {
+    expect(splitAndTrim(undefined)).toEqual([]);
+  });
+
+  it('should filter out empty values after trimming', () => {
+    const input = 'model1,,  ,model2,';
+    const expected = ['model1', 'model2'];
+    expect(splitAndTrim(input)).toEqual(expected);
+  });
+});
+
+describe('getAnthropicModels', () => {
+  it('returns default models when ANTHROPIC_MODELS is not set', () => {
+    delete process.env.ANTHROPIC_MODELS;
+    const models = getAnthropicModels();
+    expect(models).toEqual(defaultModels[EModelEndpoint.anthropic]);
+  });
+
+  it('returns models from ANTHROPIC_MODELS when set', () => {
+    process.env.ANTHROPIC_MODELS = 'claude-1, claude-2 ';
+    const models = getAnthropicModels();
+    expect(models).toEqual(['claude-1', 'claude-2']);
+  });
+});
+
+describe('getGoogleModels', () => {
+  it('returns default models when GOOGLE_MODELS is not set', () => {
+    delete process.env.GOOGLE_MODELS;
+    const models = getGoogleModels();
+    expect(models).toEqual(defaultModels[EModelEndpoint.google]);
+  });
+
+  it('returns models from GOOGLE_MODELS when set', () => {
+    process.env.GOOGLE_MODELS = 'gemini-pro, bard ';
+    const models = getGoogleModels();
+    expect(models).toEqual(['gemini-pro', 'bard']);
+  });
+});
+
+describe('getBedrockModels', () => {
+  it('returns default models when BEDROCK_AWS_MODELS is not set', () => {
+    delete process.env.BEDROCK_AWS_MODELS;
+    const models = getBedrockModels();
+    expect(models).toEqual(defaultModels[EModelEndpoint.bedrock]);
+  });
+
+  it('returns models from BEDROCK_AWS_MODELS when set', () => {
+    process.env.BEDROCK_AWS_MODELS = 'anthropic.claude-v2, ai21.j2-ultra ';
+    const models = getBedrockModels();
+    expect(models).toEqual(['anthropic.claude-v2', 'ai21.j2-ultra']);
+  });
+});