librechat-data-provider 0.7.430 → 0.7.692

package/src/actions.ts

@@ -33,6 +33,16 @@ export type OAuthCredentials = {
 
 export type Credentials = ApiKeyCredentials | OAuthCredentials;
 
+type MediaTypeObject =
+  | undefined
+  | {
+      [media: string]: OpenAPIV3.MediaTypeObject | undefined;
+    };
+
+type RequestBodyObject = Omit<OpenAPIV3.RequestBodyObject, 'content'> & {
+  content: MediaTypeObject;
+};
+
 export function sha1(input: string) {
   return crypto.createHash('sha1').update(input).digest('hex');
 }
@@ -130,39 +140,31 @@ export class FunctionSignature {
     };
   }
 }
+class RequestConfig {
+  constructor(
+    readonly domain: string,
+    readonly basePath: string,
+    readonly method: string,
+    readonly operation: string,
+    readonly isConsequential: boolean,
+    readonly contentType: string,
+  ) {}
+}
 
-export class ActionRequest {
-  domain: string;
+class RequestExecutor {
   path: string;
-  method: string;
-  operation: string;
-  operationHash?: string;
-  isConsequential: boolean;
-  contentType: string;
   params?: object;
-
-  constructor(
-    domain: string,
-    path: string,
-    method: string,
-    operation: string,
-    isConsequential: boolean,
-    contentType: string,
-  ) {
-    this.domain = domain;
-    this.path = path;
-    this.method = method;
-    this.operation = operation;
-    this.isConsequential = isConsequential;
-    this.contentType = contentType;
-  }
-
+  private operationHash?: string;
   private authHeaders: Record<string, string> = {};
   private authToken?: string;
 
+  constructor(private config: RequestConfig) {
+    this.path = config.basePath;
+  }
+
   setParams(params: object) {
     this.operationHash = sha1(JSON.stringify(params));
-    this.params = params;
+    this.params = Object.assign({}, params);
 
     for (const [key, value] of Object.entries(params)) {
       const paramPattern = `{${key}}`;
@@ -171,11 +173,12 @@ export class ActionRequest {
         delete (this.params as Record<string, unknown>)[key];
       }
     }
+    return this;
   }
 
   async setAuth(metadata: ActionMetadata) {
     if (!metadata.auth) {
-      return;
+      return this;
     }
 
     const {
@@ -198,15 +201,21 @@ export class ActionRequest {
       oauth_client_secret,
     } = metadata;
 
-    const isApiKey = api_key && type === AuthTypeEnum.ServiceHttp;
-    const isOAuth =
+    const isApiKey = api_key != null && api_key.length > 0 && type === AuthTypeEnum.ServiceHttp;
+    const isOAuth = !!(
+      oauth_client_id != null &&
       oauth_client_id &&
+      oauth_client_secret != null &&
       oauth_client_secret &&
       type === AuthTypeEnum.OAuth &&
+      authorization_url != null &&
       authorization_url &&
+      client_url != null &&
       client_url &&
+      scope != null &&
       scope &&
-      token_exchange_method;
+      token_exchange_method
+    );
 
     if (isApiKey && authorization_type === AuthorizationTypeEnum.Basic) {
       const basicToken = Buffer.from(api_key).toString('base64');
@@ -216,12 +225,13 @@ export class ActionRequest {
     } else if (
       isApiKey &&
       authorization_type === AuthorizationTypeEnum.Custom &&
+      custom_auth_header != null &&
       custom_auth_header
     ) {
       this.authHeaders[custom_auth_header] = api_key;
     } else if (isOAuth) {
-      // TODO: WIP - OAuth support
-      if (!this.authToken) {
+      const authToken = this.authToken ?? '';
+      if (!authToken) {
         const tokenResponse = await axios.post(
           client_url,
           {
@@ -238,16 +248,17 @@ export class ActionRequest {
       }
       this.authHeaders['Authorization'] = `Bearer ${this.authToken}`;
     }
+    return this;
   }
 
   async execute() {
-    const url = createURL(this.domain, this.path);
+    const url = createURL(this.config.domain, this.path);
     const headers = {
       ...this.authHeaders,
-      'Content-Type': this.contentType,
+      'Content-Type': this.config.contentType,
     };
 
-    const method = this.method.toLowerCase();
+    const method = this.config.method.toLowerCase();
 
     if (method === 'get') {
       return axios.get(url, { headers, params: this.params });
@@ -260,13 +271,73 @@ export class ActionRequest {
     } else if (method === 'patch') {
       return axios.patch(url, this.params, { headers });
     } else {
-      throw new Error(`Unsupported HTTP method: ${this.method}`);
+      throw new Error(`Unsupported HTTP method: ${method}`);
     }
   }
+
+  getConfig() {
+    return this.config;
+  }
+}
+
+export class ActionRequest {
+  private config: RequestConfig;
+
+  constructor(
+    domain: string,
+    path: string,
+    method: string,
+    operation: string,
+    isConsequential: boolean,
+    contentType: string,
+  ) {
+    this.config = new RequestConfig(domain, path, method, operation, isConsequential, contentType);
+  }
+
+  // Add getters to maintain backward compatibility
+  get domain() {
+    return this.config.domain;
+  }
+  get path() {
+    return this.config.basePath;
+  }
+  get method() {
+    return this.config.method;
+  }
+  get operation() {
+    return this.config.operation;
+  }
+  get isConsequential() {
+    return this.config.isConsequential;
+  }
+  get contentType() {
+    return this.config.contentType;
+  }
+
+  createExecutor() {
+    return new RequestExecutor(this.config);
+  }
+
+  // Maintain backward compatibility by delegating to a new executor
+  setParams(params: object) {
+    const executor = this.createExecutor();
+    executor.setParams(params);
+    return executor;
+  }
+
+  async setAuth(metadata: ActionMetadata) {
+    const executor = this.createExecutor();
+    return executor.setAuth(metadata);
+  }
+
+  async execute() {
+    const executor = this.createExecutor();
+    return executor.execute();
+  }
 }
 
 export function resolveRef(
-  schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject | OpenAPIV3.RequestBodyObject,
+  schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject | RequestBodyObject,
   components?: OpenAPIV3.ComponentsObject,
 ): OpenAPIV3.SchemaObject {
   if ('$ref' in schema && components) {
@@ -324,17 +395,17 @@ export function openapiToFunction(
             openapiSpec.components,
           );
           parametersSchema.properties[paramObj.name] = resolvedSchema;
-          if (paramObj.required) {
+          if (paramObj.required === true) {
             parametersSchema.required.push(paramObj.name);
           }
         }
       }
 
       if (operationObj.requestBody) {
-        const requestBody = operationObj.requestBody as OpenAPIV3.RequestBodyObject;
+        const requestBody = operationObj.requestBody as RequestBodyObject;
         const content = requestBody.content;
-        const contentType = Object.keys(content)[0];
-        const schema = content[contentType]?.schema;
+        const contentType = Object.keys(content ?? {})[0];
+        const schema = content?.[contentType]?.schema;
         const resolvedSchema = resolveRef(
           schema as OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject,
           openapiSpec.components,
@@ -356,7 +427,7 @@ export function openapiToFunction(
         path,
         method,
         operationId,
-        !!operationObj['x-openai-isConsequential'], // Custom extension for consequential actions
+        !!(operationObj['x-openai-isConsequential'] ?? false), // Custom extension for consequential actions
         operationObj.requestBody ? 'application/json' : 'application/x-www-form-urlencoded',
       );
 
@@ -414,10 +485,10 @@ export function validateAndParseOpenAPISpec(specString: string): ValidationResul
     for (const [path, methods] of Object.entries(paths)) {
       for (const [httpMethod, operation] of Object.entries(methods as OpenAPIV3.PathItemObject)) {
         // Ensure operation is a valid operation object
-        const { responses } = operation as OpenAPIV3.OperationObject;
+        const { responses } = operation as OpenAPIV3.OperationObject | { responses: undefined };
         if (typeof operation === 'object' && responses) {
           for (const [statusCode, response] of Object.entries(responses)) {
-            const content = (response as OpenAPIV3.ResponseObject).content;
+            const content = (response as OpenAPIV3.ResponseObject).content as MediaTypeObject;
             if (content && content['application/json'] && content['application/json'].schema) {
               const schema = content['application/json'].schema;
               if ('$ref' in schema && typeof schema.$ref === 'string') {

package/src/api-endpoints.ts

@@ -34,9 +34,9 @@ export const abortRequest = (endpoint: string) => `/api/ask/${endpoint}/abort`;
 export const conversationsRoot = '/api/convos';
 
 export const conversations = (pageNumber: string, isArchived?: boolean, tags?: string[]) =>
-  `${conversationsRoot}?pageNumber=${pageNumber}${isArchived ? '&isArchived=true' : ''}${tags
-    ?.map((tag) => `&tags=${tag}`)
-    .join('')}`;
+  `${conversationsRoot}?pageNumber=${pageNumber}${
+    isArchived === true ? '&isArchived=true' : ''
+  }${tags?.map((tag) => `&tags=${tag}`).join('')}`;
 
 export const conversationById = (id: string) => `${conversationsRoot}/${id}`;
 
@@ -50,6 +50,8 @@ export const importConversation = () => `${conversationsRoot}/import`;
 
 export const forkConversation = () => `${conversationsRoot}/fork`;
 
+export const duplicateConversation = () => `${conversationsRoot}/duplicate`;
+
 export const search = (q: string, pageNumber: string) =>
   `/api/search?q=${q}&pageNumber=${pageNumber}`;
 
@@ -77,7 +79,8 @@ export const loginFacebook = () => '/api/auth/facebook';
 
 export const loginGoogle = () => '/api/auth/google';
 
-export const refreshToken = (retry?: boolean) => `/api/auth/refresh${retry ? '?retry=true' : ''}`;
+export const refreshToken = (retry?: boolean) =>
+  `/api/auth/refresh${retry === true ? '?retry=true' : ''}`;
 
 export const requestPasswordReset = () => '/api/auth/requestPasswordReset';
 
@@ -94,19 +97,21 @@ export const config = () => '/api/config';
 export const prompts = () => '/api/prompts';
 
 export const assistants = ({
-  path,
+  path = '',
   options,
   version,
   endpoint,
+  isAvatar,
 }: {
   path?: string;
   options?: object;
   endpoint?: AssistantsEndpoint;
   version: number | string;
+  isAvatar?: boolean;
 }) => {
-  let url = `/api/assistants/v${version}`;
+  let url = isAvatar === true ? `${images()}/assistants` : `/api/assistants/v${version}`;
 
-  if (path) {
+  if (path && path !== '') {
     url += `/${path}`;
   }
 
@@ -125,10 +130,10 @@ export const assistants = ({
   return url;
 };
 
-export const agents = ({ path, options }: { path?: string; options?: object }) => {
+export const agents = ({ path = '', options }: { path?: string; options?: object }) => {
   let url = '/api/agents';
 
-  if (path) {
+  if (path && path !== '') {
     url += `/${path}`;
   }
 
@@ -204,8 +209,8 @@ export const getAllPromptGroups = () => `${prompts()}/all`;
 /* Roles */
 export const roles = () => '/api/roles';
 export const getRole = (roleName: string) => `${roles()}/${roleName.toLowerCase()}`;
-export const updatePromptPermissions = (roleName: string) =>
-  `${roles()}/${roleName.toLowerCase()}/prompts`;
+export const updatePromptPermissions = (roleName: string) => `${getRole(roleName)}/prompts`;
+export const updateAgentPermissions = (roleName: string) => `${getRole(roleName)}/agents`;
 
 /* Conversation Tags */
 export const conversationTags = (tag?: string) =>

package/src/azure.ts

@@ -63,13 +63,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 +120,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 +135,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 +147,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 +191,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 +235,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 +267,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 +290,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 +316,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 +353,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) {