librechat-data-provider 0.7.4 → 0.7.7

package/src/actions.ts

@@ -1,8 +1,15 @@
-import axios from 'axios';
+import { z } from 'zod';
+import _axios from 'axios';
 import { URL } from 'url';
 import crypto from 'crypto';
 import { load } from 'js-yaml';
-import type { FunctionTool, Schema, Reference, ActionMetadata } from './types/assistants';
+import type {
+  FunctionTool,
+  Schema,
+  Reference,
+  ActionMetadata,
+  ActionMetadataRuntime,
+} from './types/assistants';
 import type { OpenAPIV3 } from 'openapi-types';
 import { Tools, AuthTypeEnum, AuthorizationTypeEnum } from './types/assistants';
 
@@ -10,8 +17,14 @@ export type ParametersSchema = {
   type: string;
   properties: Record<string, Reference | Schema>;
   required: string[];
+  additionalProperties?: boolean;
 };
 
+export type OpenAPISchema = OpenAPIV3.SchemaObject &
+  ParametersSchema & {
+    items?: OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject;
+  };
+
 export type ApiKeyCredentials = {
   api_key: string;
   custom_auth_header?: string;
@@ -27,6 +40,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,65 +61,129 @@ 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);
+}
+
+/**
+ * Class representing a function signature.
+ */
 export class FunctionSignature {
   name: string;
   description: string;
   parameters: ParametersSchema;
+  strict: boolean;
 
-  constructor(name: string, description: string, parameters: ParametersSchema) {
+  constructor(name: string, description: string, parameters: ParametersSchema, strict?: boolean) {
     this.name = name;
     this.description = description;
-    if (parameters.properties?.['requestBody']) {
-      this.parameters = parameters.properties?.['requestBody'] as ParametersSchema;
-    } else {
-      this.parameters = parameters;
-    }
+    this.parameters = parameters;
+    this.strict = strict ?? false;
   }
 
   toObjectTool(): FunctionTool {
+    const parameters = {
+      ...this.parameters,
+      additionalProperties: this.strict ? false : undefined,
+    };
+
     return {
       type: Tools.function,
       function: {
         name: this.name,
         description: this.description,
-        parameters: this.parameters,
+        parameters,
+        ...(this.strict ? { strict: this.strict } : {}),
       },
     };
   }
 }
 
-export class ActionRequest {
-  domain: string;
-  path: string;
-  method: string;
-  operation: string;
-  operationHash?: string;
-  isConsequential: boolean;
-  contentType: string;
-  params?: object;
-
+class RequestConfig {
   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;
-  }
+    readonly domain: string,
+    readonly basePath: string,
+    readonly method: string,
+    readonly operation: string,
+    readonly isConsequential: boolean,
+    readonly contentType: string,
+  ) {}
+}
 
+class RequestExecutor {
+  path: string;
+  params?: object;
+  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 +192,12 @@ export class ActionRequest {
         delete (this.params as Record<string, unknown>)[key];
       }
     }
+    return this;
   }
 
-  async setAuth(metadata: ActionMetadata) {
+  async setAuth(metadata: ActionMetadataRuntime) {
     if (!metadata.auth) {
-      return;
+      return this;
     }
 
     const {
@@ -130,17 +218,25 @@ export class ActionRequest {
       /* OAuth */
       oauth_client_id,
       oauth_client_secret,
+      oauth_token_expires_at,
+      oauth_access_token = '',
     } = 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');
@@ -150,39 +246,42 @@ 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 tokenResponse = await axios.post(
-          client_url,
-          {
-            client_id: oauth_client_id,
-            client_secret: oauth_client_secret,
-            scope: scope,
-            grant_type: 'client_credentials',
-          },
-          {
-            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-          },
-        );
-        this.authToken = tokenResponse.data.access_token;
+      // TODO: maybe doing it in a different way later on. but we want that the user needs to folllow the oauth flow.
+      // If we do not have a valid token, bail or ask user to sign in
+      const now = new Date();
+
+      // 1. Check if token is set
+      if (!oauth_access_token) {
+        throw new Error('No access token found. Please log in first.');
       }
+
+      // 2. Check if token is expired
+      if (oauth_token_expires_at && now >= new Date(oauth_token_expires_at)) {
+        // Optionally check refresh_token logic, or just prompt user to re-login
+        throw new Error('Access token is expired. Please re-login.');
+      }
+
+      // If valid, use it
+      this.authToken = oauth_access_token;
       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();
+    const axios = _axios.create();
     if (method === 'get') {
       return axios.get(url, { headers, params: this.params });
     } else if (method === 'post') {
@@ -194,39 +293,114 @@ 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,
-  components?: OpenAPIV3.ComponentsObject,
-): OpenAPIV3.SchemaObject {
-  if ('$ref' in schema && components) {
-    const refPath = schema.$ref.replace(/^#\/components\/schemas\//, '');
-    const resolvedSchema = components.schemas?.[refPath];
-    if (!resolvedSchema) {
-      throw new Error(`Reference ${schema.$ref} not found`);
+export function resolveRef<
+  T extends
+    | OpenAPIV3.ReferenceObject
+    | OpenAPIV3.SchemaObject
+    | OpenAPIV3.ParameterObject
+    | OpenAPIV3.RequestBodyObject,
+>(obj: T, components?: OpenAPIV3.ComponentsObject): Exclude<T, OpenAPIV3.ReferenceObject> {
+  if ('$ref' in obj && components) {
+    const refPath = obj.$ref.replace(/^#\/components\//, '').split('/');
+
+    let resolved: unknown = components as Record<string, unknown>;
+    for (const segment of refPath) {
+      if (typeof resolved === 'object' && resolved !== null && segment in resolved) {
+        resolved = (resolved as Record<string, unknown>)[segment];
+      } else {
+        throw new Error(`Could not resolve reference: ${obj.$ref}`);
+      }
     }
-    return resolveRef(resolvedSchema, components);
+
+    return resolveRef(resolved as typeof obj, components) as Exclude<T, OpenAPIV3.ReferenceObject>;
   }
-  return schema as OpenAPIV3.SchemaObject;
+
+  return obj as Exclude<T, OpenAPIV3.ReferenceObject>;
 }
 
 function sanitizeOperationId(input: string) {
   return input.replace(/[^a-zA-Z0-9_-]/g, '');
 }
 
-/** Function to convert OpenAPI spec to function signatures and request builders */
-export function openapiToFunction(openapiSpec: OpenAPIV3.Document): {
+/**
+ * Converts an OpenAPI spec to function signatures and request builders.
+ */
+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
@@ -234,45 +408,70 @@ export function openapiToFunction(openapiSpec: OpenAPIV3.Document): {
     for (const [method, operation] of Object.entries(methods as OpenAPIV3.PathsObject)) {
       const operationObj = operation as OpenAPIV3.OperationObject & {
         'x-openai-isConsequential'?: boolean;
+      } & {
+        'x-strict'?: boolean;
       };
 
       // Operation ID is used as the function name
       const defaultOperationId = `${method}_${path}`;
       const operationId = operationObj.operationId || sanitizeOperationId(defaultOperationId);
       const description = operationObj.summary || operationObj.description || '';
+      const isStrict = operationObj['x-strict'] ?? false;
+
+      const parametersSchema: OpenAPISchema = {
+        type: 'object',
+        properties: {},
+        required: [],
+      };
+
+      if (operationObj.parameters) {
+        for (const param of operationObj.parameters ?? []) {
+          const resolvedParam = resolveRef(
+            param,
+            openapiSpec.components,
+          ) as OpenAPIV3.ParameterObject;
 
-      const parametersSchema: ParametersSchema = { type: 'object', properties: {}, required: [] };
+          const paramName = resolvedParam.name;
+          if (!paramName || !resolvedParam.schema) {
+            continue;
+          }
+
+          const paramSchema = resolveRef(
+            resolvedParam.schema,
+            openapiSpec.components,
+          ) as OpenAPIV3.SchemaObject;
+
+          parametersSchema.properties[paramName] = paramSchema;
+          if (resolvedParam.required) {
+            parametersSchema.required.push(paramName);
+          }
+        }
+      }
 
       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,
         );
-        parametersSchema.properties['requestBody'] = resolvedSchema;
-      }
-
-      if (operationObj.parameters) {
-        for (const param of operationObj.parameters) {
-          const paramObj = param as OpenAPIV3.ParameterObject;
-          const resolvedSchema = resolveRef(
-            { ...paramObj.schema } as OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject,
-            openapiSpec.components,
-          );
-          parametersSchema.properties[paramObj.name] = resolvedSchema;
-          if (paramObj.required) {
-            parametersSchema.required.push(paramObj.name);
-          }
-          if (paramObj.description && !('$$ref' in parametersSchema.properties[paramObj.name])) {
-            parametersSchema.properties[paramObj.name].description = paramObj.description;
-          }
+        parametersSchema.properties = {
+          ...parametersSchema.properties,
+          ...resolvedSchema.properties,
+        };
+        if (resolvedSchema.required) {
+          parametersSchema.required.push(...resolvedSchema.required);
         }
       }
 
-      const functionSignature = new FunctionSignature(operationId, description, parametersSchema);
+      const functionSignature = new FunctionSignature(
+        operationId,
+        description,
+        parametersSchema,
+        isStrict,
+      );
       functionSignatures.push(functionSignature);
 
       const actionRequest = new ActionRequest(
@@ -280,15 +479,22 @@ export function openapiToFunction(openapiSpec: OpenAPIV3.Document): {
         path,
         method,
         operationId,
-        !!operationObj['x-openai-isConsequential'], // Custom extension for consequential actions
-        operationObj.requestBody ? 'application/json' : 'application/x-www-form-urlencoded',
+        !!(operationObj['x-openai-isConsequential'] ?? false),
+        operationObj.requestBody ? 'application/json' : '',
       );
 
       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 = {
@@ -297,6 +503,9 @@ export type ValidationResult = {
   spec?: OpenAPIV3.Document;
 };
 
+/**
+ * Validates and parses an OpenAPI spec.
+ */
 export function validateAndParseOpenAPISpec(specString: string): ValidationResult {
   try {
     let parsedSpec;
@@ -331,10 +540,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') {
@@ -357,6 +566,7 @@ export function validateAndParseOpenAPISpec(specString: string): ValidationResul
       spec: parsedSpec,
     };
   } catch (error) {
+    console.error(error);
     return { status: false, message: 'Error parsing OpenAPI spec.' };
   }
 }