librechat-data-provider 0.7.41 → 0.7.52

package/specs/openapiSpecs.ts

@@ -348,3 +348,130 @@ components:
         message:
           type: string
           description: Confirmation of successful save or error message.`;
+
+export const swapidev = `
+openapi: 3.0.3
+info:
+  title: Star Wars API
+  description: This is a simple API that provides information about the Star Wars universe.
+  version: 1.0.0
+servers:
+  - url: https://swapi.dev
+
+paths:
+  /api/people:
+    get:
+      summary: List all people
+      operationId: getPeople
+      tags:
+        - People
+      responses:
+        '200':
+          description: A list of people
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  count:
+                    type: integer
+                    example: 82
+                  next:
+                    type: string
+                    nullable: true
+                    example: https://swapi.dev/api/people/?page=2
+                  previous:
+                    type: string
+                    nullable: true
+                    example: null
+                  results:
+                    type: array
+                    items:
+                      $ref: '#/components/schemas/Person'
+
+  /api/people/{id}:
+    get:
+      summary: Get a person by ID
+      operationId: getPersonById
+      tags:
+        - People
+      parameters:
+        - name: id
+          in: path
+          required: true
+          description: The ID of the person to retrieve
+          schema:
+            type: string
+      responses:
+        '200':
+          description: A single person
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Person'
+        '404':
+          description: Person not found
+
+components:
+  schemas:
+    Person:
+      type: object
+      properties:
+        name:
+          type: string
+          example: Luke Skywalker
+        height:
+          type: string
+          example: "172"
+        mass:
+          type: string
+          example: "77"
+        hair_color:
+          type: string
+          example: blond
+        skin_color:
+          type: string
+          example: fair
+        eye_color:
+          type: string
+          example: blue
+        birth_year:
+          type: string
+          example: "19BBY"
+        gender:
+          type: string
+          example: male
+        homeworld:
+          type: string
+          example: https://swapi.dev/api/planets/1/
+        films:
+          type: array
+          items:
+            type: string
+            example: https://swapi.dev/api/films/1/
+        species:
+          type: array
+          items:
+            type: string
+            example: https://swapi.dev/api/species/1/
+        vehicles:
+          type: array
+          items:
+            type: string
+            example: https://swapi.dev/api/vehicles/14/
+        starships:
+          type: array
+          items:
+            type: string
+            example: https://swapi.dev/api/starships/12/
+        created:
+          type: string
+          format: date-time
+          example: 2014-12-09T13:50:51.644000Z
+        edited:
+          type: string
+          format: date-time
+          example: 2014-12-20T21:17:56.891000Z
+        url:
+          type: string
+          example: https://swapi.dev/api/people/1/`;

package/src/actions.ts

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 import axios from 'axios';
 import { URL } from 'url';
 import crypto from 'crypto';
@@ -12,6 +13,11 @@ export type ParametersSchema = {
   required: string[];
 };
 
+export type OpenAPISchema = OpenAPIV3.SchemaObject &
+  ParametersSchema & {
+    items?: OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject;
+  };
+
 export type ApiKeyCredentials = {
   api_key: string;
   custom_auth_header?: string;
@@ -27,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');
 }
@@ -38,6 +54,70 @@ export function createURL(domain: string, path: string) {
   return new URL(fullURL).toString();
 }
 
+const schemaTypeHandlers: Record<string, (schema: OpenAPISchema) => z.ZodTypeAny> = {
+  string: (schema) => {
+    if (schema.enum) {
+      return z.enum(schema.enum as [string, ...string[]]);
+    }
+
+    let stringSchema = z.string();
+    if (schema.minLength !== undefined) {
+      stringSchema = stringSchema.min(schema.minLength);
+    }
+    if (schema.maxLength !== undefined) {
+      stringSchema = stringSchema.max(schema.maxLength);
+    }
+    return stringSchema;
+  },
+  number: (schema) => {
+    let numberSchema = z.number();
+    if (schema.minimum !== undefined) {
+      numberSchema = numberSchema.min(schema.minimum);
+    }
+    if (schema.maximum !== undefined) {
+      numberSchema = numberSchema.max(schema.maximum);
+    }
+    return numberSchema;
+  },
+  integer: (schema) => (schemaTypeHandlers.number(schema) as z.ZodNumber).int(),
+  boolean: () => z.boolean(),
+  array: (schema) => {
+    if (schema.items) {
+      const zodSchema = openAPISchemaToZod(schema.items as OpenAPISchema);
+      if (zodSchema) {
+        return z.array(zodSchema);
+      }
+
+      return z.array(z.unknown());
+    }
+    return z.array(z.unknown());
+  },
+  object: (schema) => {
+    const shape: { [key: string]: z.ZodTypeAny } = {};
+    if (schema.properties) {
+      Object.entries(schema.properties).forEach(([key, value]) => {
+        const zodSchema = openAPISchemaToZod(value as OpenAPISchema);
+        shape[key] = zodSchema || z.unknown();
+        if (schema.required && schema.required.includes(key)) {
+          shape[key] = shape[key].describe(value.description || '');
+        } else {
+          shape[key] = shape[key].optional().describe(value.description || '');
+        }
+      });
+    }
+    return z.object(shape);
+  },
+};
+
+function openAPISchemaToZod(schema: OpenAPISchema): z.ZodTypeAny | undefined {
+  if (schema.type === 'object' && Object.keys(schema.properties || {}).length === 0) {
+    return undefined;
+  }
+
+  const handler = schemaTypeHandlers[schema.type as string] || (() => z.unknown());
+  return handler(schema);
+}
+
 export class FunctionSignature {
   name: string;
   description: string;
@@ -46,11 +126,7 @@ export class FunctionSignature {
   constructor(name: string, description: string, parameters: ParametersSchema) {
     this.name = name;
     this.description = description;
-    if (parameters.properties?.['requestBody']) {
-      this.parameters = parameters.properties?.['requestBody'] as ParametersSchema;
-    } else {
-      this.parameters = parameters;
-    }
+    this.parameters = parameters;
   }
 
   toObjectTool(): FunctionTool {
@@ -64,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}}`;
@@ -105,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 {
@@ -154,7 +223,6 @@ export class ActionRequest {
     ) {
       this.authHeaders[custom_auth_header] = api_key;
     } else if (isOAuth) {
-      // TODO: WIP - OAuth support
       if (!this.authToken) {
         const tokenResponse = await axios.post(
           client_url,
@@ -172,16 +240,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 });
@@ -194,13 +263,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) {
@@ -219,14 +348,17 @@ function sanitizeOperationId(input: string) {
 }
 
 /** Function to convert OpenAPI spec to function signatures and request builders */
-export function openapiToFunction(openapiSpec: OpenAPIV3.Document): {
+export function openapiToFunction(
+  openapiSpec: OpenAPIV3.Document,
+  generateZodSchemas = false,
+): {
   functionSignatures: FunctionSignature[];
   requestBuilders: Record<string, ActionRequest>;
+  zodSchemas?: Record<string, z.ZodTypeAny>;
 } {
   const functionSignatures: FunctionSignature[] = [];
   const requestBuilders: Record<string, ActionRequest> = {};
-
-  // Base URL from OpenAPI spec servers
+  const zodSchemas: Record<string, z.ZodTypeAny> = {};
   const baseUrl = openapiSpec.servers?.[0]?.url ?? '';
 
   // Iterate over each path and method in the OpenAPI spec
@@ -241,19 +373,11 @@ export function openapiToFunction(openapiSpec: OpenAPIV3.Document): {
       const operationId = operationObj.operationId || sanitizeOperationId(defaultOperationId);
       const description = operationObj.summary || operationObj.description || '';
 
-      const parametersSchema: ParametersSchema = { type: 'object', properties: {}, required: [] };
-
-      if (operationObj.requestBody) {
-        const requestBody = operationObj.requestBody as OpenAPIV3.RequestBodyObject;
-        const content = requestBody.content;
-        const contentType = Object.keys(content)[0];
-        const schema = content[contentType]?.schema;
-        const resolvedSchema = resolveRef(
-          schema as OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject,
-          openapiSpec.components,
-        );
-        parametersSchema.properties['requestBody'] = resolvedSchema;
-      }
+      const parametersSchema: OpenAPISchema = {
+        type: 'object',
+        properties: {},
+        required: [],
+      };
 
       if (operationObj.parameters) {
         for (const param of operationObj.parameters) {
@@ -263,12 +387,27 @@ export function openapiToFunction(openapiSpec: OpenAPIV3.Document): {
             openapiSpec.components,
           );
           parametersSchema.properties[paramObj.name] = resolvedSchema;
-          if (paramObj.required) {
+          if (paramObj.required === true) {
             parametersSchema.required.push(paramObj.name);
           }
-          if (paramObj.description && !('$$ref' in parametersSchema.properties[paramObj.name])) {
-            parametersSchema.properties[paramObj.name].description = paramObj.description;
-          }
+        }
+      }
+
+      if (operationObj.requestBody) {
+        const requestBody = operationObj.requestBody as RequestBodyObject;
+        const content = requestBody.content;
+        const contentType = Object.keys(content ?? {})[0];
+        const schema = content?.[contentType]?.schema;
+        const resolvedSchema = resolveRef(
+          schema as OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject,
+          openapiSpec.components,
+        );
+        parametersSchema.properties = {
+          ...parametersSchema.properties,
+          ...resolvedSchema.properties,
+        };
+        if (resolvedSchema.required) {
+          parametersSchema.required.push(...resolvedSchema.required);
         }
       }
 
@@ -280,15 +419,22 @@ export function openapiToFunction(openapiSpec: OpenAPIV3.Document): {
         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',
       );
 
       requestBuilders[operationId] = actionRequest;
+
+      if (generateZodSchemas && Object.keys(parametersSchema.properties).length > 0) {
+        const schema = openAPISchemaToZod(parametersSchema);
+        if (schema) {
+          zodSchemas[operationId] = schema;
+        }
+      }
     }
   }
 
-  return { functionSignatures, requestBuilders };
+  return { functionSignatures, requestBuilders, zodSchemas };
 }
 
 export type ValidationResult = {
@@ -331,10 +477,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

@@ -125,6 +125,21 @@ export const assistants = ({
   return url;
 };
 
+export const agents = ({ path = '', options }: { path?: string; options?: object }) => {
+  let url = '/api/agents';
+
+  if (path && path !== '') {
+    url += `/${path}`;
+  }
+
+  if (options && Object.keys(options).length > 0) {
+    const queryParams = new URLSearchParams(options as Record<string, string>).toString();
+    url += `?${queryParams}`;
+  }
+
+  return url;
+};
+
 export const files = () => '/api/files';
 
 export const images = () => `${files()}/images`;
@@ -193,7 +208,8 @@ export const updatePromptPermissions = (roleName: string) =>
   `${roles()}/${roleName.toLowerCase()}/prompts`;
 
 /* Conversation Tags */
-export const conversationTags = (tag?: string) => `/api/tags${tag ? `/${tag}` : ''}`;
+export const conversationTags = (tag?: string) =>
+  `/api/tags${tag != null && tag ? `/${encodeURIComponent(tag)}` : ''}`;
 
 export const conversationTagsList = (pageNumber: string, sort?: string, order?: string) =>
   `${conversationTags()}/list?pageNumber=${pageNumber}${sort ? `&sort=${sort}` : ''}${
@@ -201,4 +217,8 @@ export const conversationTagsList = (pageNumber: string, sort?: string, order?:
   }`;
 
 export const addTagToConversation = (conversationId: string) =>
-  `${conversationsRoot}/tags/${conversationId}`;
+  `${conversationTags()}/convo/${conversationId}`;
+
+export const userTerms = () => '/api/user/terms';
+export const acceptUserTerms = () => '/api/user/terms/accept';
+export const banner = () => '/api/banner';