librechat-data-provider 0.7.3 → 0.7.5

package/dist/react-query/package.json

@@ -5,7 +5,7 @@
   "module": "./index.es.js",
   "types": "../types/react-query/index.d.ts",
   "dependencies": {
-    "axios": "^1.3.4",
+    "axios": "^1.7.7",
     "zod": "^3.22.4"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "librechat-data-provider",
-  "version": "0.7.3",
+  "version": "0.7.5",
   "description": "data services for librechat apps",
   "main": "dist/index.js",
   "module": "dist/index.es.js",
@@ -40,7 +40,7 @@
   "homepage": "https://librechat.ai",
   "dependencies": {
     "@types/js-yaml": "^4.0.9",
-    "axios": "^1.3.4",
+    "axios": "^1.7.7",
     "js-yaml": "^4.1.0",
     "openai": "4.11.1",
     "openapi-types": "^12.1.3",
@@ -62,7 +62,7 @@
     "jest": "^29.5.0",
     "jest-junit": "^16.0.0",
     "rimraf": "^5.0.1",
-    "rollup": "^3.26.0",
+    "rollup": "^4.22.4",
     "rollup-plugin-generate-package-json": "^3.2.0",
     "rollup-plugin-peer-deps-external": "^2.2.4",
     "rollup-plugin-typescript2": "^0.35.0",

package/react-query/package.json

@@ -5,6 +5,6 @@
   "module": "./index.es.js",
   "types": "../dist/types/react-query/index.d.ts",
   "dependencies": {
-    "axios": "^1.3.4"
+    "axios": "^1.7.7"
   }
 }

package/specs/actions.spec.ts

@@ -1,4 +1,5 @@
 import axios from 'axios';
+import { z } from 'zod';
 import { OpenAPIV3 } from 'openapi-types';
 import {
   createURL,
@@ -8,7 +9,12 @@ import {
   FunctionSignature,
   validateAndParseOpenAPISpec,
 } from '../src/actions';
-import { getWeatherOpenapiSpec, whimsicalOpenapiSpec, scholarAIOpenapiSpec } from './openapiSpecs';
+import {
+  getWeatherOpenapiSpec,
+  whimsicalOpenapiSpec,
+  scholarAIOpenapiSpec,
+  swapidev,
+} from './openapiSpecs';
 import { AuthorizationTypeEnum, AuthTypeEnum } from '../src/types/assistants';
 import type { FlowchartSchema } from './openapiSpecs';
 import type { ParametersSchema } from '../src/actions';
@@ -548,4 +554,273 @@ describe('createURL', () => {
       'https://example.com/subdirectory/api/v1/users',
     );
   });
+
+  describe('openapiToFunction zodSchemas', () => {
+    describe('getWeatherOpenapiSpec', () => {
+      const { zodSchemas } = openapiToFunction(getWeatherOpenapiSpec, true);
+
+      it('generates correct Zod schema for GetCurrentWeather', () => {
+        expect(zodSchemas).toBeDefined();
+        expect(zodSchemas?.GetCurrentWeather).toBeDefined();
+
+        const GetCurrentWeatherSchema = zodSchemas?.GetCurrentWeather;
+
+        expect(GetCurrentWeatherSchema instanceof z.ZodObject).toBe(true);
+
+        if (!(GetCurrentWeatherSchema instanceof z.ZodObject)) {
+          throw new Error('GetCurrentWeatherSchema is not a ZodObject');
+        }
+
+        const shape = GetCurrentWeatherSchema.shape;
+        expect(shape.location instanceof z.ZodString).toBe(true);
+
+        // Check locations property
+        expect(shape.locations).toBeDefined();
+        expect(shape.locations instanceof z.ZodOptional).toBe(true);
+
+        if (!(shape.locations instanceof z.ZodOptional)) {
+          throw new Error('locations is not a ZodOptional');
+        }
+
+        const locationsInnerType = shape.locations._def.innerType;
+        expect(locationsInnerType instanceof z.ZodArray).toBe(true);
+
+        if (!(locationsInnerType instanceof z.ZodArray)) {
+          throw new Error('locationsInnerType is not a ZodArray');
+        }
+
+        const locationsItemSchema = locationsInnerType.element;
+        expect(locationsItemSchema instanceof z.ZodObject).toBe(true);
+
+        if (!(locationsItemSchema instanceof z.ZodObject)) {
+          throw new Error('locationsItemSchema is not a ZodObject');
+        }
+
+        // Validate the structure of locationsItemSchema
+        expect(locationsItemSchema.shape.city instanceof z.ZodString).toBe(true);
+        expect(locationsItemSchema.shape.state instanceof z.ZodString).toBe(true);
+        expect(locationsItemSchema.shape.countryCode instanceof z.ZodString).toBe(true);
+
+        // Check if time is optional
+        const timeSchema = locationsItemSchema.shape.time;
+        expect(timeSchema instanceof z.ZodOptional).toBe(true);
+
+        if (!(timeSchema instanceof z.ZodOptional)) {
+          throw new Error('timeSchema is not a ZodOptional');
+        }
+
+        expect(timeSchema._def.innerType instanceof z.ZodString).toBe(true);
+
+        // Check the description
+        expect(shape.locations._def.description).toBe(
+          'A list of locations to retrieve the weather for.',
+        );
+      });
+
+      it('validates correct data for GetCurrentWeather', () => {
+        const GetCurrentWeatherSchema = zodSchemas?.GetCurrentWeather as z.ZodTypeAny;
+        const validData = {
+          location: 'New York',
+          locations: [
+            { city: 'New York', state: 'NY', countryCode: 'US', time: '2023-12-04T14:00:00Z' },
+          ],
+        };
+        expect(() => GetCurrentWeatherSchema.parse(validData)).not.toThrow();
+      });
+
+      it('throws error for invalid data for GetCurrentWeather', () => {
+        const GetCurrentWeatherSchema = zodSchemas?.GetCurrentWeather as z.ZodTypeAny;
+        const invalidData = {
+          location: 123,
+          locations: [{ city: 'New York', state: 'NY', countryCode: 'US', time: 'invalid-time' }],
+        };
+        expect(() => GetCurrentWeatherSchema.parse(invalidData)).toThrow();
+      });
+    });
+
+    describe('whimsicalOpenapiSpec', () => {
+      const { zodSchemas } = openapiToFunction(whimsicalOpenapiSpec, true);
+
+      it('generates correct Zod schema for postRenderFlowchart', () => {
+        expect(zodSchemas).toBeDefined();
+        expect(zodSchemas?.postRenderFlowchart).toBeDefined();
+
+        const PostRenderFlowchartSchema = zodSchemas?.postRenderFlowchart;
+        expect(PostRenderFlowchartSchema).toBeInstanceOf(z.ZodObject);
+
+        if (!(PostRenderFlowchartSchema instanceof z.ZodObject)) {
+          return;
+        }
+
+        const shape = PostRenderFlowchartSchema.shape;
+        expect(shape.mermaid).toBeInstanceOf(z.ZodString);
+        expect(shape.title).toBeInstanceOf(z.ZodOptional);
+        expect((shape.title as z.ZodOptional<z.ZodString>)._def.innerType).toBeInstanceOf(
+          z.ZodString,
+        );
+      });
+
+      it('validates correct data for postRenderFlowchart', () => {
+        const PostRenderFlowchartSchema = zodSchemas?.postRenderFlowchart;
+        const validData = {
+          mermaid: 'graph TD; A-->B; B-->C; C-->D;',
+          title: 'Test Flowchart',
+        };
+        expect(() => PostRenderFlowchartSchema?.parse(validData)).not.toThrow();
+      });
+
+      it('throws error for invalid data for postRenderFlowchart', () => {
+        const PostRenderFlowchartSchema = zodSchemas?.postRenderFlowchart;
+        const invalidData = {
+          mermaid: 123,
+          title: 42,
+        };
+        expect(() => PostRenderFlowchartSchema?.parse(invalidData)).toThrow();
+      });
+    });
+
+    describe('scholarAIOpenapiSpec', () => {
+      const result = validateAndParseOpenAPISpec(scholarAIOpenapiSpec);
+      const spec = result.spec as OpenAPIV3.Document;
+      const { zodSchemas } = openapiToFunction(spec, true);
+
+      it('generates correct Zod schema for searchAbstracts', () => {
+        expect(zodSchemas).toBeDefined();
+        expect(zodSchemas?.searchAbstracts).toBeDefined();
+
+        const SearchAbstractsSchema = zodSchemas?.searchAbstracts;
+        expect(SearchAbstractsSchema).toBeInstanceOf(z.ZodObject);
+
+        if (!(SearchAbstractsSchema instanceof z.ZodObject)) {
+          return;
+        }
+
+        const shape = SearchAbstractsSchema.shape;
+        expect(shape.keywords).toBeInstanceOf(z.ZodString);
+        expect(shape.sort).toBeInstanceOf(z.ZodOptional);
+        expect(
+          (shape.sort as z.ZodOptional<z.ZodEnum<[string, ...string[]]>>)._def.innerType,
+        ).toBeInstanceOf(z.ZodEnum);
+        expect(shape.query).toBeInstanceOf(z.ZodString);
+        expect(shape.peer_reviewed_only).toBeInstanceOf(z.ZodOptional);
+        expect(shape.start_year).toBeInstanceOf(z.ZodOptional);
+        expect(shape.end_year).toBeInstanceOf(z.ZodOptional);
+        expect(shape.offset).toBeInstanceOf(z.ZodOptional);
+      });
+
+      it('validates correct data for searchAbstracts', () => {
+        const SearchAbstractsSchema = zodSchemas?.searchAbstracts;
+        const validData = {
+          keywords: 'machine learning',
+          sort: 'cited_by_count',
+          query: 'AI applications',
+          peer_reviewed_only: 'true',
+          start_year: '2020',
+          end_year: '2023',
+          offset: '0',
+        };
+        expect(() => SearchAbstractsSchema?.parse(validData)).not.toThrow();
+      });
+
+      it('throws error for invalid data for searchAbstracts', () => {
+        const SearchAbstractsSchema = zodSchemas?.searchAbstracts;
+        const invalidData = {
+          keywords: 123,
+          sort: 'invalid_sort',
+          query: 42,
+          peer_reviewed_only: 'maybe',
+          start_year: 2020,
+          end_year: 2023,
+          offset: 0,
+        };
+        expect(() => SearchAbstractsSchema?.parse(invalidData)).toThrow();
+      });
+
+      it('generates correct Zod schema for getFullText', () => {
+        expect(zodSchemas?.getFullText).toBeDefined();
+
+        const GetFullTextSchema = zodSchemas?.getFullText;
+        expect(GetFullTextSchema).toBeInstanceOf(z.ZodObject);
+
+        if (!(GetFullTextSchema instanceof z.ZodObject)) {
+          return;
+        }
+
+        const shape = GetFullTextSchema.shape;
+        expect(shape.pdf_url).toBeInstanceOf(z.ZodString);
+        expect(shape.chunk).toBeInstanceOf(z.ZodOptional);
+        expect((shape.chunk as z.ZodOptional<z.ZodNumber>)._def.innerType).toBeInstanceOf(
+          z.ZodNumber,
+        );
+      });
+
+      it('generates correct Zod schema for saveCitation', () => {
+        expect(zodSchemas?.saveCitation).toBeDefined();
+
+        const SaveCitationSchema = zodSchemas?.saveCitation;
+        expect(SaveCitationSchema).toBeInstanceOf(z.ZodObject);
+
+        if (!(SaveCitationSchema instanceof z.ZodObject)) {
+          return;
+        }
+
+        const shape = SaveCitationSchema.shape;
+        expect(shape.doi).toBeInstanceOf(z.ZodString);
+        expect(shape.zotero_user_id).toBeInstanceOf(z.ZodString);
+        expect(shape.zotero_api_key).toBeInstanceOf(z.ZodString);
+      });
+    });
+  });
+
+  describe('openapiToFunction zodSchemas for SWAPI', () => {
+    const result = validateAndParseOpenAPISpec(swapidev);
+    const spec = result.spec as OpenAPIV3.Document;
+    const { zodSchemas } = openapiToFunction(spec, true);
+
+    describe('getPeople schema', () => {
+      it('does not generate Zod schema for getPeople (no parameters)', () => {
+        expect(zodSchemas).toBeDefined();
+        expect(zodSchemas?.getPeople).toBeUndefined();
+      });
+
+      it('validates correct data for getPeople', () => {
+        const GetPeopleSchema = zodSchemas?.getPeople;
+        expect(GetPeopleSchema).toBeUndefined();
+      });
+
+      it('does not throw for invalid data for getPeople', () => {
+        const GetPeopleSchema = zodSchemas?.getPeople;
+        expect(GetPeopleSchema).toBeUndefined();
+      });
+    });
+
+    describe('getPersonById schema', () => {
+      it('generates correct Zod schema for getPersonById', () => {
+        expect(zodSchemas).toBeDefined();
+        expect(zodSchemas?.getPersonById).toBeDefined();
+
+        const GetPersonByIdSchema = zodSchemas?.getPersonById;
+        expect(GetPersonByIdSchema).toBeInstanceOf(z.ZodObject);
+
+        if (!(GetPersonByIdSchema instanceof z.ZodObject)) {
+          return;
+        }
+
+        const shape = GetPersonByIdSchema.shape;
+        expect(shape.id).toBeInstanceOf(z.ZodString);
+      });
+
+      it('validates correct data for getPersonById', () => {
+        const GetPersonByIdSchema = zodSchemas?.getPersonById;
+        const validData = { id: '1' };
+        expect(() => GetPersonByIdSchema?.parse(validData)).not.toThrow();
+      });
+
+      it('throws error for invalid data for getPersonById', () => {
+        const GetPersonByIdSchema = zodSchemas?.getPersonById;
+        const invalidData = { id: 1 }; // should be string
+        expect(() => GetPersonByIdSchema?.parse(invalidData)).toThrow();
+      });
+    });
+  });
 });

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;
@@ -38,6 +44,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 +116,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 {
@@ -219,14 +285,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 +310,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) {
@@ -266,9 +327,24 @@ export function openapiToFunction(openapiSpec: OpenAPIV3.Document): {
           if (paramObj.required) {
             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 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 = {
+          ...parametersSchema.properties,
+          ...resolvedSchema.properties,
+        };
+        if (resolvedSchema.required) {
+          parametersSchema.required.push(...resolvedSchema.required);
         }
       }
 
@@ -285,10 +361,17 @@ export function openapiToFunction(openapiSpec: OpenAPIV3.Document): {
       );
 
       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 = {