librechat-data-provider 0.7.4 → 0.7.7

package/src/azure.ts

@@ -6,8 +6,9 @@ import type {
   TValidatedAzureConfig,
   TAzureConfigValidationResult,
 } from '../src/config';
-import { errorsToString, extractEnvVariable, envVarRegex } from '../src/parsers';
+import { extractEnvVariable, envVarRegex } from '../src/utils';
 import { azureGroupConfigsSchema } from '../src/config';
+import { errorsToString } from '../src/parsers';
 
 export const deprecatedAzureVariables = [
   /* "related to" precedes description text */
@@ -63,13 +64,13 @@ export function validateAzureGroups(configs: TAzureGroups): TAzureConfigValidati
       const {
         group: groupName,
         apiKey,
-        instanceName,
-        deploymentName,
-        version,
-        baseURL,
+        instanceName = '',
+        deploymentName = '',
+        version = '',
+        baseURL = '',
         additionalHeaders,
         models,
-        serverless,
+        serverless = false,
         ...rest
       } = group;
 
@@ -120,9 +121,11 @@ export function validateAzureGroups(configs: TAzureGroups): TAzureConfigValidati
           continue;
         }
 
+        const groupDeploymentName = group.deploymentName ?? '';
+        const groupVersion = group.version ?? '';
         if (typeof model === 'boolean') {
           // For boolean models, check if group-level deploymentName and version are present.
-          if (!group.deploymentName || !group.version) {
+          if (!groupDeploymentName || !groupVersion) {
             errors.push(
               `Model "${modelName}" in group "${groupName}" is missing a deploymentName or version.`,
             );
@@ -133,11 +136,10 @@ export function validateAzureGroups(configs: TAzureGroups): TAzureConfigValidati
             group: groupName,
           };
         } else {
+          const modelDeploymentName = model.deploymentName ?? '';
+          const modelVersion = model.version ?? '';
           // For object models, check if deploymentName and version are required but missing.
-          if (
-            (!model.deploymentName && !group.deploymentName) ||
-            (!model.version && !group.version)
-          ) {
+          if ((!modelDeploymentName && !groupDeploymentName) || (!modelVersion && !groupVersion)) {
             errors.push(
               `Model "${modelName}" in group "${groupName}" is missing a required deploymentName or version.`,
             );
@@ -146,8 +148,8 @@ export function validateAzureGroups(configs: TAzureGroups): TAzureConfigValidati
 
           modelGroupMap[modelName] = {
             group: groupName,
-            // deploymentName: model.deploymentName || group.deploymentName,
-            // version: model.version || group.version,
+            // deploymentName: modelDeploymentName || groupDeploymentName,
+            // version: modelVersion || groupVersion,
           };
         }
       }
@@ -190,26 +192,28 @@ export function mapModelToAzureConfig({
     );
   }
 
-  const instanceName = groupConfig.instanceName;
+  const instanceName = groupConfig.instanceName ?? '';
 
-  if (!instanceName && !groupConfig.serverless) {
+  if (!instanceName && groupConfig.serverless !== true) {
     throw new Error(
       `Group "${modelConfig.group}" is missing an instanceName for non-serverless configuration.`,
     );
   }
 
-  if (groupConfig.serverless && !groupConfig.baseURL) {
+  const baseURL = groupConfig.baseURL ?? '';
+  if (groupConfig.serverless === true && !baseURL) {
     throw new Error(
       `Group "${modelConfig.group}" is missing the required base URL for serverless configuration.`,
     );
   }
 
-  if (groupConfig.serverless) {
+  if (groupConfig.serverless === true) {
     const result: MappedAzureConfig = {
       azureOptions: {
+        azureOpenAIApiVersion: extractEnvVariable(groupConfig.version ?? ''),
         azureOpenAIApiKey: extractEnvVariable(groupConfig.apiKey),
       },
-      baseURL: extractEnvVariable(groupConfig.baseURL as string),
+      baseURL: extractEnvVariable(baseURL),
       serverless: true,
     };
 
@@ -232,11 +236,11 @@ export function mapModelToAzureConfig({
   }
 
   const modelDetails = groupConfig.models[modelName];
-  const { deploymentName, version } =
+  const { deploymentName = '', version = '' } =
     typeof modelDetails === 'object'
       ? {
-        deploymentName: modelDetails.deploymentName || groupConfig.deploymentName,
-        version: modelDetails.version || groupConfig.version,
+        deploymentName: modelDetails.deploymentName ?? groupConfig.deploymentName,
+        version: modelDetails.version ?? groupConfig.version,
       }
       : {
         deploymentName: groupConfig.deploymentName,
@@ -264,8 +268,8 @@ export function mapModelToAzureConfig({
 
   const result: MappedAzureConfig = { azureOptions };
 
-  if (groupConfig.baseURL) {
-    result.baseURL = extractEnvVariable(groupConfig.baseURL);
+  if (baseURL) {
+    result.baseURL = extractEnvVariable(baseURL);
   }
 
   if (groupConfig.additionalHeaders) {
@@ -287,15 +291,17 @@ export function mapGroupToAzureConfig({
     throw new Error(`Group named "${groupName}" not found in configuration.`);
   }
 
-  const instanceName = groupConfig.instanceName as string;
+  const instanceName = groupConfig.instanceName ?? '';
+  const serverless = groupConfig.serverless ?? false;
+  const baseURL = groupConfig.baseURL ?? '';
 
-  if (!instanceName && !groupConfig.serverless) {
+  if (!instanceName && !serverless) {
     throw new Error(
       `Group "${groupName}" is missing an instanceName for non-serverless configuration.`,
     );
   }
 
-  if (groupConfig.serverless && !groupConfig.baseURL) {
+  if (serverless && !baseURL) {
     throw new Error(
       `Group "${groupName}" is missing the required base URL for serverless configuration.`,
     );
@@ -311,25 +317,26 @@ export function mapGroupToAzureConfig({
   const modelDetails = groupConfig.models[firstModelName];
 
   const azureOptions: AzureOptions = {
+    azureOpenAIApiVersion: extractEnvVariable(groupConfig.version ?? ''),
     azureOpenAIApiKey: extractEnvVariable(groupConfig.apiKey),
     azureOpenAIApiInstanceName: extractEnvVariable(instanceName),
     // DeploymentName and Version set below
   };
 
-  if (groupConfig.serverless) {
+  if (serverless) {
     return {
       azureOptions,
-      baseURL: extractEnvVariable(groupConfig.baseURL ?? ''),
+      baseURL: extractEnvVariable(baseURL),
       serverless: true,
       ...(groupConfig.additionalHeaders && { headers: groupConfig.additionalHeaders }),
     };
   }
 
-  const { deploymentName, version } =
+  const { deploymentName = '', version = '' } =
     typeof modelDetails === 'object'
       ? {
-        deploymentName: modelDetails.deploymentName || groupConfig.deploymentName,
-        version: modelDetails.version || groupConfig.version,
+        deploymentName: modelDetails.deploymentName ?? groupConfig.deploymentName,
+        version: modelDetails.version ?? groupConfig.version,
       }
       : {
         deploymentName: groupConfig.deploymentName,
@@ -347,8 +354,8 @@ export function mapGroupToAzureConfig({
 
   const result: MappedAzureConfig = { azureOptions };
 
-  if (groupConfig.baseURL) {
-    result.baseURL = extractEnvVariable(groupConfig.baseURL);
+  if (baseURL) {
+    result.baseURL = extractEnvVariable(baseURL);
   }
 
   if (groupConfig.additionalHeaders) {

package/src/bedrock.ts

@@ -0,0 +1,227 @@
+import { z } from 'zod';
+import * as s from './schemas';
+
+type ThinkingConfig = {
+  type: 'enabled';
+  budget_tokens: number;
+};
+type AnthropicReasoning = {
+  thinking?: ThinkingConfig | boolean;
+  thinkingBudget?: number;
+};
+
+type AnthropicInput = BedrockConverseInput & {
+  additionalModelRequestFields: BedrockConverseInput['additionalModelRequestFields'] &
+    AnthropicReasoning;
+};
+
+export const bedrockInputSchema = s.tConversationSchema
+  .pick({
+    /* LibreChat params; optionType: 'conversation' */
+    modelLabel: true,
+    promptPrefix: true,
+    resendFiles: true,
+    iconURL: true,
+    greeting: true,
+    spec: true,
+    maxOutputTokens: true,
+    maxContextTokens: true,
+    artifacts: true,
+    /* Bedrock params; optionType: 'model' */
+    region: true,
+    system: true,
+    model: true,
+    maxTokens: true,
+    temperature: true,
+    topP: true,
+    stop: true,
+    thinking: true,
+    thinkingBudget: true,
+    /* Catch-all fields */
+    topK: true,
+    additionalModelRequestFields: true,
+  })
+  .transform((obj) => {
+    if ((obj as AnthropicInput).additionalModelRequestFields?.thinking != null) {
+      const _obj = obj as AnthropicInput;
+      obj.thinking = !!_obj.additionalModelRequestFields.thinking;
+      obj.thinkingBudget =
+        typeof _obj.additionalModelRequestFields.thinking === 'object'
+          ? (_obj.additionalModelRequestFields.thinking as ThinkingConfig)?.budget_tokens
+          : undefined;
+      delete obj.additionalModelRequestFields;
+    }
+    return s.removeNullishValues(obj);
+  })
+  .catch(() => ({}));
+
+export type BedrockConverseInput = z.infer<typeof bedrockInputSchema>;
+
+export const bedrockInputParser = s.tConversationSchema
+  .pick({
+    /* LibreChat params; optionType: 'conversation' */
+    modelLabel: true,
+    promptPrefix: true,
+    resendFiles: true,
+    iconURL: true,
+    greeting: true,
+    spec: true,
+    artifacts: true,
+    maxOutputTokens: true,
+    maxContextTokens: true,
+    /* Bedrock params; optionType: 'model' */
+    region: true,
+    model: true,
+    maxTokens: true,
+    temperature: true,
+    topP: true,
+    stop: true,
+    thinking: true,
+    thinkingBudget: true,
+    /* Catch-all fields */
+    topK: true,
+    additionalModelRequestFields: true,
+  })
+  .catchall(z.any())
+  .transform((data) => {
+    const knownKeys = [
+      'modelLabel',
+      'promptPrefix',
+      'resendFiles',
+      'iconURL',
+      'greeting',
+      'spec',
+      'maxOutputTokens',
+      'artifacts',
+      'additionalModelRequestFields',
+      'region',
+      'model',
+      'maxTokens',
+      'temperature',
+      'topP',
+      'stop',
+    ];
+
+    const additionalFields: Record<string, unknown> = {};
+    const typedData = data as Record<string, unknown>;
+
+    Object.entries(typedData).forEach(([key, value]) => {
+      if (!knownKeys.includes(key)) {
+        if (key === 'topK') {
+          additionalFields['top_k'] = value;
+        } else {
+          additionalFields[key] = value;
+        }
+        delete typedData[key];
+      }
+    });
+
+    /** Default thinking and thinkingBudget for 'anthropic.claude-3-7-sonnet' models, if not defined */
+    if (
+      typeof typedData.model === 'string' &&
+      typedData.model.includes('anthropic.claude-3-7-sonnet')
+    ) {
+      if (additionalFields.thinking === undefined) {
+        additionalFields.thinking = true;
+      } else if (additionalFields.thinking === false) {
+        delete additionalFields.thinking;
+        delete additionalFields.thinkingBudget;
+      }
+
+      if (additionalFields.thinking === true && additionalFields.thinkingBudget === undefined) {
+        additionalFields.thinkingBudget = 2000;
+      }
+      additionalFields.anthropic_beta = ['output-128k-2025-02-19'];
+    } else if (additionalFields.thinking != null || additionalFields.thinkingBudget != null) {
+      delete additionalFields.thinking;
+      delete additionalFields.thinkingBudget;
+    }
+
+    if (Object.keys(additionalFields).length > 0) {
+      typedData.additionalModelRequestFields = {
+        ...((typedData.additionalModelRequestFields as Record<string, unknown> | undefined) || {}),
+        ...additionalFields,
+      };
+    }
+
+    if (typedData.maxOutputTokens !== undefined) {
+      typedData.maxTokens = typedData.maxOutputTokens;
+    } else if (typedData.maxTokens !== undefined) {
+      typedData.maxOutputTokens = typedData.maxTokens;
+    }
+
+    return s.removeNullishValues(typedData) as BedrockConverseInput;
+  })
+  .catch(() => ({}));
+
+/**
+ * Configures the "thinking" parameter based on given input and thinking options.
+ *
+ * @param data - The parsed Bedrock request options object
+ * @returns The object with thinking configured appropriately
+ */
+function configureThinking(data: AnthropicInput): AnthropicInput {
+  const updatedData = { ...data };
+  if (updatedData.additionalModelRequestFields?.thinking === true) {
+    updatedData.maxTokens = updatedData.maxTokens ?? updatedData.maxOutputTokens ?? 8192;
+    delete updatedData.maxOutputTokens;
+    const thinkingConfig: AnthropicReasoning['thinking'] = {
+      type: 'enabled',
+      budget_tokens: updatedData.additionalModelRequestFields.thinkingBudget ?? 2000,
+    };
+
+    if (thinkingConfig.budget_tokens > updatedData.maxTokens) {
+      thinkingConfig.budget_tokens = Math.floor(updatedData.maxTokens * 0.9);
+    }
+    updatedData.additionalModelRequestFields.thinking = thinkingConfig;
+    delete updatedData.additionalModelRequestFields.thinkingBudget;
+  }
+  return updatedData;
+}
+
+export const bedrockOutputParser = (data: Record<string, unknown>) => {
+  const knownKeys = [...Object.keys(s.tConversationSchema.shape), 'topK', 'top_k'];
+  let result: Record<string, unknown> = {};
+
+  // Extract known fields from the root level
+  Object.entries(data).forEach(([key, value]) => {
+    if (knownKeys.includes(key)) {
+      result[key] = value;
+    }
+  });
+
+  // Extract known fields from additionalModelRequestFields
+  if (
+    typeof data.additionalModelRequestFields === 'object' &&
+    data.additionalModelRequestFields !== null
+  ) {
+    Object.entries(data.additionalModelRequestFields as Record<string, unknown>).forEach(
+      ([key, value]) => {
+        if (knownKeys.includes(key)) {
+          if (key === 'top_k') {
+            result['topK'] = value;
+          } else if (key === 'thinking' || key === 'thinkingBudget') {
+            return;
+          } else {
+            result[key] = value;
+          }
+        }
+      },
+    );
+  }
+
+  // Handle maxTokens and maxOutputTokens
+  if (result.maxTokens !== undefined && result.maxOutputTokens === undefined) {
+    result.maxOutputTokens = result.maxTokens;
+  } else if (result.maxOutputTokens !== undefined && result.maxTokens === undefined) {
+    result.maxTokens = result.maxOutputTokens;
+  }
+
+  result = configureThinking(result as AnthropicInput);
+  // Remove additionalModelRequestFields from the result if it doesn't thinking config
+  if ((result as AnthropicInput).additionalModelRequestFields?.thinking == null) {
+    delete result.additionalModelRequestFields;
+  }
+
+  return result;
+};