librechat-data-provider 0.7.4 → 0.7.7

package/src/generate.ts

@@ -13,10 +13,18 @@ export type ComponentType =
   | 'checkbox'
   | 'switch'
   | 'dropdown'
+  | 'combobox'
   | 'tags';
 
 export type OptionType = 'conversation' | 'model' | 'custom';
 
+export type Option = Record<string, unknown> & {
+  label?: string;
+  value: string | number | null;
+};
+
+export type OptionWithIcon = Option & { icon?: React.ReactNode };
+
 export enum ComponentTypes {
   Input = 'input',
   Textarea = 'textarea',
@@ -24,6 +32,7 @@ export enum ComponentTypes {
   Checkbox = 'checkbox',
   Switch = 'switch',
   Dropdown = 'dropdown',
+  Combobox = 'combobox',
   Tags = 'tags',
 }
 
@@ -45,6 +54,7 @@ export interface SettingDefinition {
   description?: string;
   type: 'number' | 'boolean' | 'string' | 'enum' | 'array';
   default?: number | boolean | string | string[];
+  showLabel?: boolean;
   showDefault?: boolean;
   options?: string[];
   range?: SettingRange;
@@ -64,13 +74,18 @@ export interface SettingDefinition {
   maxTags?: number; // Specific to tags component
   includeInput?: boolean; // Specific to slider component
   descriptionSide?: 'top' | 'right' | 'bottom' | 'left';
+  items?: OptionWithIcon[]; // Specific to combobox component
+  searchPlaceholder?: string; // Specific to combobox component
+  selectPlaceholder?: string; // Specific to combobox component
+  searchPlaceholderCode?: boolean; // Specific to combobox component
+  selectPlaceholderCode?: boolean; // Specific to combobox component
 }
 
 export type DynamicSettingProps = Partial<SettingDefinition> & {
   readonly?: boolean;
   settingKey: string;
   setOption: TSetOption;
-  conversation: TConversation | TPreset | null;
+  conversation: Partial<TConversation> | Partial<TPreset> | null;
   defaultValue?: number | boolean | string | string[];
   className?: string;
   inputClassName?: string;
@@ -190,6 +205,7 @@ const minColumns = 1;
 const maxColumns = 4;
 const minSliderOptions = 2;
 const minDropdownOptions = 2;
+const minComboboxOptions = 2;
 
 /**
  * Validates the provided setting using the constraints unique to each component type.
@@ -383,9 +399,22 @@ export function validateSettingDefinitions(settings: SettingsConfiguration): voi
       }
     }
 
+    if (setting.component === ComponentTypes.Combobox) {
+      if (!setting.options || setting.options.length < minComboboxOptions) {
+        errors.push({
+          code: ZodIssueCode.custom,
+          message: `Combobox component for setting ${setting.key} requires at least ${minComboboxOptions} options.`,
+          path: ['options'],
+        });
+      }
+      if (!setting.default && setting.options && setting.options.length > 0) {
+        setting.default = setting.options[0];
+      }
+    }
+
     // Default columnSpan
     if (!setting.columnSpan) {
-      setting.columnSpan = Math.floor(columns / 2);
+      setting.columnSpan = Math.floor((columns ?? 0) / 2);
     }
 
     // Default label to key

package/src/index.ts

@@ -1,28 +1,36 @@
 /* config */
 export * from './azure';
+export * from './bedrock';
 export * from './config';
 export * from './file-config';
+/* artifacts  */
+export * from './artifacts';
 /* schema helpers  */
 export * from './parsers';
+export * from './zod';
 /* custom/dynamic configurations  */
-export * from './models';
 export * from './generate';
+export * from './models';
+/* mcp */
+export * from './mcp';
 /* RBAC */
 export * from './roles';
 /* types (exports schemas from `./types` as they contain needed in other defs) */
 export * from './types';
+export * from './types/agents';
 export * from './types/assistants';
-export * from './types/queries';
 export * from './types/files';
 export * from './types/mutations';
+export * from './types/queries';
+export * from './types/runs';
 /* query/mutation keys */
 export * from './keys';
 /* api call helpers */
 export * from './headers-helpers';
 export { default as request } from './request';
-import * as dataService from './data-service';
 export { dataService };
+import * as dataService from './data-service';
 /* general helpers */
-export * from './sse';
+export * from './utils';
 export * from './actions';
 export { default as createPayload } from './createPayload';

package/src/keys.ts

@@ -19,12 +19,18 @@ export enum QueryKeys {
   startupConfig = 'startupConfig',
   assistants = 'assistants',
   assistant = 'assistant',
+  agents = 'agents',
+  agent = 'agent',
   endpointsConfigOverride = 'endpointsConfigOverride',
   files = 'files',
   fileConfig = 'fileConfig',
   tools = 'tools',
+  toolAuth = 'toolAuth',
+  toolCalls = 'toolCalls',
+  agentTools = 'agentTools',
   actions = 'actions',
   assistantDocs = 'assistantDocs',
+  agentDocs = 'agentDocs',
   fileDownload = 'fileDownload',
   voices = 'voices',
   customConfigSpeech = 'customConfigSpeech',
@@ -36,6 +42,10 @@ export enum QueryKeys {
   categories = 'categories',
   randomPrompts = 'randomPrompts',
   roles = 'roles',
+  conversationTags = 'conversationTags',
+  health = 'health',
+  userTerms = 'userTerms',
+  banner = 'banner',
 }
 
 export enum MutationKeys {
@@ -43,13 +53,20 @@ export enum MutationKeys {
   fileDelete = 'fileDelete',
   updatePreset = 'updatePreset',
   deletePreset = 'deletePreset',
+  loginUser = 'loginUser',
   logoutUser = 'logoutUser',
+  refreshToken = 'refreshToken',
   avatarUpload = 'avatarUpload',
   speechToText = 'speechToText',
   textToSpeech = 'textToSpeech',
   assistantAvatarUpload = 'assistantAvatarUpload',
+  agentAvatarUpload = 'agentAvatarUpload',
   updateAction = 'updateAction',
+  updateAgentAction = 'updateAgentAction',
   deleteAction = 'deleteAction',
+  deleteAgentAction = 'deleteAgentAction',
   deleteUser = 'deleteUser',
   updateRole = 'updateRole',
+  enableTwoFactor = 'enableTwoFactor',
+  verifyTwoFactor = 'verifyTwoFactor',
 }

package/src/mcp.ts

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+import { extractEnvVariable } from './utils';
+
+const BaseOptionsSchema = z.object({
+  iconPath: z.string().optional(),
+  timeout: z.number().optional(),
+});
+
+export const StdioOptionsSchema = BaseOptionsSchema.extend({
+  type: z.literal('stdio').optional(),
+  /**
+   * The executable to run to start the server.
+   */
+  command: z.string(),
+  /**
+   * Command line arguments to pass to the executable.
+   */
+  args: z.array(z.string()),
+  /**
+   * The environment to use when spawning the process.
+   *
+   * If not specified, the result of getDefaultEnvironment() will be used.
+   * Environment variables can be referenced using ${VAR_NAME} syntax.
+   */
+  env: z
+    .record(z.string(), z.string())
+    .optional()
+    .transform((env) => {
+      if (!env) {
+        return env;
+      }
+
+      const processedEnv: Record<string, string> = {};
+      for (const [key, value] of Object.entries(env)) {
+        processedEnv[key] = extractEnvVariable(value);
+      }
+      return processedEnv;
+    }),
+  /**
+   * How to handle stderr of the child process. This matches the semantics of Node's `child_process.spawn`.
+   *
+   * @type {import('node:child_process').IOType | import('node:stream').Stream | number}
+   *
+   * The default is "inherit", meaning messages to stderr will be printed to the parent process's stderr.
+   */
+  stderr: z.any().optional(),
+});
+
+export const WebSocketOptionsSchema = BaseOptionsSchema.extend({
+  type: z.literal('websocket').optional(),
+  url: z
+    .string()
+    .url()
+    .refine(
+      (val) => {
+        const protocol = new URL(val).protocol;
+        return protocol === 'ws:' || protocol === 'wss:';
+      },
+      {
+        message: 'WebSocket URL must start with ws:// or wss://',
+      },
+    ),
+});
+
+export const SSEOptionsSchema = BaseOptionsSchema.extend({
+  type: z.literal('sse').optional(),
+  url: z
+    .string()
+    .url()
+    .refine(
+      (val) => {
+        const protocol = new URL(val).protocol;
+        return protocol !== 'ws:' && protocol !== 'wss:';
+      },
+      {
+        message: 'SSE URL must not start with ws:// or wss://',
+      },
+    ),
+});
+
+export const MCPOptionsSchema = z.union([
+  StdioOptionsSchema,
+  WebSocketOptionsSchema,
+  SSEOptionsSchema,
+]);
+
+export const MCPServersSchema = z.record(z.string(), MCPOptionsSchema);

package/src/models.ts

@@ -37,7 +37,7 @@ export const tModelSpecSchema = z.object({
 export const specsConfigSchema = z.object({
   enforce: z.boolean().default(false),
   prioritize: z.boolean().default(true),
-  list: z.array(tModelSpecSchema).optional(),
+  list: z.array(tModelSpecSchema).min(1),
 });
 
 export type TSpecsConfig = z.infer<typeof specsConfigSchema>;

package/src/parsers.ts

@@ -2,45 +2,48 @@ import type { ZodIssue } from 'zod';
 import type * as a from './types/assistants';
 import type * as s from './schemas';
 import type * as t from './types';
-import { ContentTypes } from './types/assistants';
+import { ContentTypes } from './types/runs';
 import {
-  EModelEndpoint,
   openAISchema,
   googleSchema,
-  bingAISchema,
+  EModelEndpoint,
   anthropicSchema,
-  chatGPTBrowserSchema,
-  gptPluginsSchema,
   assistantSchema,
-  compactOpenAISchema,
+  gptPluginsSchema,
+  // agentsSchema,
+  compactAgentsSchema,
   compactGoogleSchema,
-  compactAnthropicSchema,
   compactChatGPTSchema,
+  chatGPTBrowserSchema,
   compactPluginsSchema,
   compactAssistantSchema,
 } from './schemas';
+import { bedrockInputSchema } from './bedrock';
+import { extractEnvVariable } from './utils';
 import { alternateName } from './config';
 
 type EndpointSchema =
   | typeof openAISchema
   | typeof googleSchema
-  | typeof bingAISchema
   | typeof anthropicSchema
   | typeof chatGPTBrowserSchema
   | typeof gptPluginsSchema
-  | typeof assistantSchema;
+  | typeof assistantSchema
+  | typeof compactAgentsSchema
+  | typeof bedrockInputSchema;
 
 const endpointSchemas: Record<EModelEndpoint, EndpointSchema> = {
   [EModelEndpoint.openAI]: openAISchema,
   [EModelEndpoint.azureOpenAI]: openAISchema,
   [EModelEndpoint.custom]: openAISchema,
   [EModelEndpoint.google]: googleSchema,
-  [EModelEndpoint.bingAI]: bingAISchema,
   [EModelEndpoint.anthropic]: anthropicSchema,
   [EModelEndpoint.chatGPTBrowser]: chatGPTBrowserSchema,
   [EModelEndpoint.gptPlugins]: gptPluginsSchema,
   [EModelEndpoint.assistants]: assistantSchema,
   [EModelEndpoint.azureAssistants]: assistantSchema,
+  [EModelEndpoint.agents]: compactAgentsSchema,
+  [EModelEndpoint.bedrock]: bedrockInputSchema,
 };
 
 // const schemaCreators: Record<EModelEndpoint, (customSchema: DefaultSchemaValues) => EndpointSchema> = {
@@ -51,22 +54,23 @@ const endpointSchemas: Record<EModelEndpoint, EndpointSchema> = {
 export function getEnabledEndpoints() {
   const defaultEndpoints: string[] = [
     EModelEndpoint.openAI,
+    EModelEndpoint.agents,
     EModelEndpoint.assistants,
     EModelEndpoint.azureAssistants,
     EModelEndpoint.azureOpenAI,
     EModelEndpoint.google,
-    EModelEndpoint.bingAI,
     EModelEndpoint.chatGPTBrowser,
     EModelEndpoint.gptPlugins,
     EModelEndpoint.anthropic,
+    EModelEndpoint.bedrock,
   ];
 
-  const endpointsEnv = process.env.ENDPOINTS || '';
+  const endpointsEnv = process.env.ENDPOINTS ?? '';
   let enabledEndpoints = defaultEndpoints;
   if (endpointsEnv) {
     enabledEndpoints = endpointsEnv
       .split(',')
-      .filter((endpoint) => endpoint?.trim())
+      .filter((endpoint) => endpoint.trim())
       .map((endpoint) => endpoint.trim());
   }
   return enabledEndpoints;
@@ -119,17 +123,6 @@ export function errorsToString(errors: ZodIssue[]) {
     .join(' ');
 }
 
-export const envVarRegex = /^\${(.+)}$/;
-
-/** Extracts the value of an environment variable from a string. */
-export function extractEnvVariable(value: string) {
-  const envVarMatch = value.match(envVarRegex);
-  if (envVarMatch) {
-    return process.env[envVarMatch[1]] || value;
-  }
-  return value;
-}
-
 /** Resolves header values to env variables if detected */
 export function resolveHeaders(headers: Record<string, string> | undefined) {
   const resolvedHeaders = { ...(headers ?? {}) };
@@ -154,6 +147,15 @@ export function getFirstDefinedValue(possibleValues: string[]) {
   return returnValue;
 }
 
+export function getNonEmptyValue(possibleValues: string[]) {
+  for (const value of possibleValues) {
+    if (value && value.trim() !== '') {
+      return value;
+    }
+  }
+  return undefined;
+}
+
 export type TPossibleValues = {
   models: string[];
   secondaryModels?: string[];
@@ -166,13 +168,13 @@ export const parseConvo = ({
   possibleValues,
 }: {
   endpoint: EModelEndpoint;
-  endpointType?: EModelEndpoint;
-  conversation: Partial<s.TConversation | s.TPreset>;
+  endpointType?: EModelEndpoint | null;
+  conversation: Partial<s.TConversation | s.TPreset> | null;
   possibleValues?: TPossibleValues;
   // TODO: POC for default schema
   // defaultSchema?: Partial<EndpointSchema>,
 }) => {
-  let schema = endpointSchemas[endpoint];
+  let schema = endpointSchemas[endpoint] as EndpointSchema | undefined;
 
   if (!schema && !endpointType) {
     throw new Error(`Unknown endpoint: ${endpoint}`);
@@ -184,56 +186,93 @@ export const parseConvo = ({
   //   schema = schemaCreators[endpoint](defaultSchema);
   // }
 
-  const convo = schema.parse(conversation) as s.TConversation;
+  const convo = schema?.parse(conversation) as s.TConversation | undefined;
   const { models, secondaryModels } = possibleValues ?? {};
 
   if (models && convo) {
     convo.model = getFirstDefinedValue(models) ?? convo.model;
   }
 
-  if (secondaryModels && convo.agentOptions) {
+  if (secondaryModels && convo?.agentOptions) {
     convo.agentOptions.model = getFirstDefinedValue(secondaryModels) ?? convo.agentOptions.model;
   }
 
   return convo;
 };
 
-export const getResponseSender = (endpointOption: t.TEndpointOption): string => {
-  const { model, endpoint, endpointType, modelDisplayLabel, chatGptLabel, modelLabel, jailbreak } =
-    endpointOption;
+/** Match GPT followed by digit, optional decimal, and optional suffix
+ *
+ * Examples: gpt-4, gpt-4o, gpt-4.5, gpt-5a, etc. */
+const extractGPTVersion = (modelStr: string): string => {
+  const gptMatch = modelStr.match(/gpt-(\d+(?:\.\d+)?)([a-z])?/i);
+  if (gptMatch) {
+    const version = gptMatch[1];
+    const suffix = gptMatch[2] || '';
+    return `GPT-${version}${suffix}`;
+  }
+  return '';
+};
 
+/** Match omni models (o1, o3, etc.), "o" followed by a digit, possibly with decimal */
+const extractOmniVersion = (modelStr: string): string => {
+  const omniMatch = modelStr.match(/\bo(\d+(?:\.\d+)?)\b/i);
+  if (omniMatch) {
+    const version = omniMatch[1];
+    return `o${version}`;
+  }
+  return '';
+};
+
+export const getResponseSender = (endpointOption: t.TEndpointOption): string => {
+  const {
+    model: _m,
+    endpoint,
+    endpointType,
+    modelDisplayLabel: _mdl,
+    chatGptLabel: _cgl,
+    modelLabel: _ml,
+  } = endpointOption;
+
+  const model = _m ?? '';
+  const modelDisplayLabel = _mdl ?? '';
+  const chatGptLabel = _cgl ?? '';
+  const modelLabel = _ml ?? '';
   if (
     [
       EModelEndpoint.openAI,
-      EModelEndpoint.azureOpenAI,
+      EModelEndpoint.bedrock,
       EModelEndpoint.gptPlugins,
+      EModelEndpoint.azureOpenAI,
       EModelEndpoint.chatGPTBrowser,
     ].includes(endpoint)
   ) {
     if (chatGptLabel) {
       return chatGptLabel;
-    } else if (model && model.includes('gpt-3')) {
-      return 'GPT-3.5';
-    } else if (model && model.includes('gpt-4')) {
-      return 'GPT-4';
+    } else if (modelLabel) {
+      return modelLabel;
+    } else if (model && extractOmniVersion(model)) {
+      return extractOmniVersion(model);
     } else if (model && model.includes('mistral')) {
       return 'Mistral';
+    } else if (model && model.includes('gpt-')) {
+      const gptVersion = extractGPTVersion(model);
+      return gptVersion || 'GPT';
     }
-    return alternateName[endpoint] ?? 'ChatGPT';
+    return (alternateName[endpoint] as string | undefined) ?? 'ChatGPT';
   }
 
-  if (endpoint === EModelEndpoint.bingAI) {
-    return jailbreak ? 'Sydney' : 'BingAI';
+  if (endpoint === EModelEndpoint.anthropic) {
+    return modelLabel || 'Claude';
   }
 
-  if (endpoint === EModelEndpoint.anthropic) {
-    return modelLabel ?? 'Claude';
+  if (endpoint === EModelEndpoint.bedrock) {
+    return modelLabel || alternateName[endpoint];
   }
 
   if (endpoint === EModelEndpoint.google) {
     if (modelLabel) {
       return modelLabel;
-    } else if (model && model.includes('gemini')) {
+    } else if (model && (model.includes('gemini') || model.includes('learnlm'))) {
       return 'Gemini';
     } else if (model && model.includes('code')) {
       return 'Codey';
@@ -247,12 +286,13 @@ export const getResponseSender = (endpointOption: t.TEndpointOption): string =>
       return modelLabel;
     } else if (chatGptLabel) {
       return chatGptLabel;
+    } else if (model && extractOmniVersion(model)) {
+      return extractOmniVersion(model);
     } else if (model && model.includes('mistral')) {
       return 'Mistral';
-    } else if (model && model.includes('gpt-3')) {
-      return 'GPT-3.5';
-    } else if (model && model.includes('gpt-4')) {
-      return 'GPT-4';
+    } else if (model && model.includes('gpt-')) {
+      const gptVersion = extractGPTVersion(model);
+      return gptVersion || 'GPT';
     } else if (modelDisplayLabel) {
       return modelDisplayLabel;
     }
@@ -264,24 +304,25 @@ export const getResponseSender = (endpointOption: t.TEndpointOption): string =>
 };
 
 type CompactEndpointSchema =
-  | typeof compactOpenAISchema
+  | typeof openAISchema
   | typeof compactAssistantSchema
+  | typeof compactAgentsSchema
   | typeof compactGoogleSchema
-  | typeof bingAISchema
-  | typeof compactAnthropicSchema
+  | typeof anthropicSchema
   | typeof compactChatGPTSchema
+  | typeof bedrockInputSchema
   | typeof compactPluginsSchema;
 
 const compactEndpointSchemas: Record<string, CompactEndpointSchema> = {
-  [EModelEndpoint.openAI]: compactOpenAISchema,
-  [EModelEndpoint.azureOpenAI]: compactOpenAISchema,
-  [EModelEndpoint.custom]: compactOpenAISchema,
+  [EModelEndpoint.openAI]: openAISchema,
+  [EModelEndpoint.azureOpenAI]: openAISchema,
+  [EModelEndpoint.custom]: openAISchema,
   [EModelEndpoint.assistants]: compactAssistantSchema,
   [EModelEndpoint.azureAssistants]: compactAssistantSchema,
+  [EModelEndpoint.agents]: compactAgentsSchema,
   [EModelEndpoint.google]: compactGoogleSchema,
-  /* BingAI needs all fields */
-  [EModelEndpoint.bingAI]: bingAISchema,
-  [EModelEndpoint.anthropic]: compactAnthropicSchema,
+  [EModelEndpoint.bedrock]: bedrockInputSchema,
+  [EModelEndpoint.anthropic]: anthropicSchema,
   [EModelEndpoint.chatGPTBrowser]: compactChatGPTSchema,
   [EModelEndpoint.gptPlugins]: compactPluginsSchema,
 };
@@ -293,7 +334,7 @@ export const parseCompactConvo = ({
   possibleValues,
 }: {
   endpoint?: EModelEndpoint;
-  endpointType?: EModelEndpoint;
+  endpointType?: EModelEndpoint | null;
   conversation: Partial<s.TConversation | s.TPreset>;
   possibleValues?: TPossibleValues;
   // TODO: POC for default schema
@@ -303,7 +344,7 @@ export const parseCompactConvo = ({
     throw new Error(`undefined endpoint: ${endpoint}`);
   }
 
-  let schema = compactEndpointSchemas[endpoint];
+  let schema = compactEndpointSchemas[endpoint] as CompactEndpointSchema | undefined;
 
   if (!schema && !endpointType) {
     throw new Error(`Unknown endpoint: ${endpoint}`);
@@ -311,7 +352,11 @@ export const parseCompactConvo = ({
     schema = compactEndpointSchemas[endpointType];
   }
 
-  const convo = schema.parse(conversation) as s.TConversation;
+  if (!schema) {
+    throw new Error(`Unknown endpointType: ${endpointType}`);
+  }
+
+  const convo = schema.parse(conversation) as s.TConversation | null;
   // const { models, secondaryModels } = possibleValues ?? {};
   const { models } = possibleValues ?? {};
 
@@ -331,7 +376,7 @@ export function parseTextParts(contentParts: a.TMessageContentParts[]): string {
 
   for (const part of contentParts) {
     if (part.type === ContentTypes.TEXT) {
-      const textValue = part.text.value;
+      const textValue = typeof part.text === 'string' ? part.text : part.text.value;
 
       if (
         result.length > 0 &&
@@ -347,3 +392,16 @@ export function parseTextParts(contentParts: a.TMessageContentParts[]): string {
 
   return result;
 }
+
+export const SEPARATORS = ['.', '?', '!', '۔', '。', '‥', ';', '¡', '¿', '\n', '```'];
+
+export function findLastSeparatorIndex(text: string, separators = SEPARATORS): number {
+  let lastIndex = -1;
+  for (const separator of separators) {
+    const index = text.lastIndexOf(separator);
+    if (index > lastIndex) {
+      lastIndex = index;
+    }
+  }
+  return lastIndex;
+}