librechat-data-provider 0.3.9 → 0.4.1

package/specs/openapiSpecs.ts

@@ -0,0 +1,350 @@
+import { OpenAPIV3 } from 'openapi-types';
+
+export type FlowchartSchema = {
+  mermaid: {
+    type: 'string';
+    description: 'Flowchart to be rendered, in Mermaid syntax';
+  };
+  title: {
+    type: 'string';
+    description: 'Title of the flowchart';
+  };
+};
+
+export const getWeatherOpenapiSpec: OpenAPIV3.Document = {
+  openapi: '3.1.0',
+  info: {
+    title: 'Get weather data',
+    description: 'Retrieves current weather data for a location.',
+    version: 'v1.0.0',
+  },
+  servers: [
+    {
+      url: 'https://weather.example.com',
+    },
+  ],
+  paths: {
+    '/location': {
+      get: {
+        description: 'Get temperature for a specific location',
+        operationId: 'GetCurrentWeather',
+        parameters: [
+          {
+            name: 'location',
+            in: 'query',
+            description: 'The city and state to retrieve the weather for',
+            required: true,
+            schema: {
+              type: 'string',
+            },
+          },
+        ],
+        requestBody: {
+          required: true,
+          content: {
+            'application/json': {
+              schema: {
+                type: 'object',
+                properties: {
+                  locations: {
+                    type: 'array',
+                    items: {
+                      type: 'object',
+                      properties: {
+                        city: {
+                          type: 'string',
+                          example: 'San Francisco',
+                        },
+                        state: {
+                          type: 'string',
+                          example: 'CA',
+                        },
+                        countryCode: {
+                          type: 'string',
+                          description: 'ISO 3166-1 alpha-2 country code',
+                          example: 'US',
+                        },
+                        time: {
+                          type: 'string',
+                          description:
+                            'Optional time for which the weather is requested, in ISO 8601 format.',
+                          example: '2023-12-04T14:00:00Z',
+                        },
+                      },
+                      required: ['city', 'state', 'countryCode'],
+                      description:
+                        'Details of the location for which the weather data is requested.',
+                    },
+                    description: 'A list of locations to retrieve the weather for.',
+                  },
+                },
+              },
+            },
+          },
+        },
+        deprecated: false,
+        responses: {},
+      },
+    },
+  },
+  components: {
+    schemas: {},
+  },
+};
+
+export const whimsicalOpenapiSpec: OpenAPIV3.Document = {
+  openapi: '3.0.0',
+  info: {
+    version: '1.0.0',
+    title: 'Diagram to Image API',
+    description: 'A simple API to generate flowchart, mindmap, or sequence diagram images.',
+  },
+  servers: [{ url: 'https://whimsical.com/api' }],
+  paths: {
+    '/ai.chatgpt.render-flowchart': {
+      post: {
+        operationId: 'postRenderFlowchart',
+        // 'x-openai-isConsequential': false,
+        summary: 'Renders a flowchart',
+        description:
+          'Accepts a string describing a flowchart and returns a URL to a rendered image',
+        requestBody: {
+          content: {
+            'application/json': {
+              schema: {
+                $ref: '#/components/schemas/FlowchartRequest',
+              },
+            },
+          },
+          required: true,
+        },
+        responses: {
+          '200': {
+            description: 'URL to the rendered image',
+            content: {
+              'application/json': {
+                schema: {
+                  $ref: '#/components/schemas/FlowchartResponse',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  components: {
+    schemas: {
+      FlowchartRequest: {
+        type: 'object',
+        properties: {
+          mermaid: {
+            type: 'string',
+            description: 'Flowchart to be rendered, in Mermaid syntax',
+          },
+          title: {
+            type: 'string',
+            description: 'Title of the flowchart',
+          },
+        },
+        required: ['mermaid'],
+      },
+      FlowchartResponse: {
+        type: 'object',
+        properties: {
+          imageURL: {
+            type: 'string',
+            description: 'URL of the rendered image',
+          },
+        },
+      },
+    },
+  },
+};
+
+export const scholarAIOpenapiSpec = `
+openapi: 3.0.1
+info:
+  title: ScholarAI
+  description: Allows the user to search facts and findings from scientific articles
+  version: 'v1'
+servers:
+  - url: https://scholar-ai.net
+paths:
+  /api/abstracts:
+    get:
+      operationId: searchAbstracts
+      summary: Get relevant paper abstracts by keywords search
+      parameters:
+        - name: keywords
+          in: query
+          description: Keywords of inquiry which should appear in article. Must be in English.
+          required: true
+          schema:
+            type: string
+        - name: sort
+          in: query
+          description: The sort order for results. Valid values are cited_by_count or publication_date. Excluding this value does a relevance based search.
+          required: false
+          schema:
+            type: string
+            enum:
+              - cited_by_count
+              - publication_date
+        - name: query
+          in: query
+          description: The user query
+          required: true
+          schema:
+            type: string
+        - name: peer_reviewed_only
+          in: query
+          description: Whether to only return peer reviewed articles. Defaults to true, ChatGPT should cautiously suggest this value can be set to false
+          required: false
+          schema:
+            type: string
+        - name: start_year
+          in: query
+          description: The first year, inclusive, to include in the search range. Excluding this value will include all years.
+          required: false
+          schema:
+            type: string
+        - name: end_year
+          in: query
+          description: The last year, inclusive, to include in the search range. Excluding this value will include all years.
+          required: false
+          schema:
+            type: string
+        - name: offset
+          in: query
+          description: The offset of the first result to return. Defaults to 0.
+          required: false
+          schema:
+            type: string
+      responses:
+        "200":
+          description: OK
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/searchAbstractsResponse'
+  /api/fulltext:
+    get:
+      operationId: getFullText
+      summary: Get full text of a paper by URL for PDF
+      parameters:
+        - name: pdf_url
+          in: query
+          description: URL for PDF
+          required: true
+          schema:
+            type: string
+        - name: chunk
+          in: query
+          description: chunk number to retrieve, defaults to 1
+          required: false
+          schema:
+            type: number
+      responses:
+        "200":
+          description: OK
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/getFullTextResponse'
+  /api/save-citation:
+    get:
+      operationId: saveCitation
+      summary: Save citation to reference manager
+      parameters:
+        - name: doi
+          in: query
+          description: Digital Object Identifier (DOI) of article
+          required: true
+          schema:
+            type: string
+        - name: zotero_user_id
+          in: query
+          description: Zotero User ID
+          required: true
+          schema:
+            type: string
+        - name: zotero_api_key
+          in: query
+          description: Zotero API Key
+          required: true
+          schema:
+            type: string
+      responses:
+        "200":
+          description: OK
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/saveCitationResponse'
+components:
+  schemas:
+    searchAbstractsResponse:
+      type: object
+      properties:
+        next_offset:
+          type: number
+          description: The offset of the next page of results.
+        total_num_results:
+          type: number
+          description: The total number of results. 
+        abstracts:
+          type: array
+          items:
+            type: object
+            properties:
+              title:
+                type: string
+              abstract:
+                type: string
+                description: Summary of the context, methods, results, and conclusions of the paper.
+              doi:
+                type: string
+                description: The DOI of the paper.
+              landing_page_url:
+                type: string
+                description: Link to the paper on its open-access host.
+              pdf_url:
+                type: string
+                description: Link to the paper PDF.
+              publicationDate:
+                type: string
+                description: The date the paper was published in YYYY-MM-DD format.
+              relevance:
+                type: number
+                description: The relevance of the paper to the search query. 1 is the most relevant.
+              creators:
+                type: array
+                items:
+                  type: string
+                  description: The name of the creator.
+              cited_by_count:
+                type: number
+                description: The number of citations of the article.
+          description: The list of relevant abstracts.
+    getFullTextResponse:
+      type: object
+      properties:
+        full_text:
+          type: string
+          description: The full text of the paper.
+        pdf_url:
+          type: string
+          description: The PDF URL of the paper.
+        chunk:
+          type: number
+          description: The chunk of the paper.
+        total_chunk_num:
+          type: number
+          description: The total chunks of the paper.
+    saveCitationResponse:
+      type: object
+      properties:
+        message:
+          type: string
+          description: Confirmation of successful save or error message.`;

package/src/actions.ts

@@ -0,0 +1,347 @@
+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 { OpenAPIV3 } from 'openapi-types';
+import { Tools, AuthTypeEnum, AuthorizationTypeEnum } from './types/assistants';
+
+export type ParametersSchema = {
+  type: string;
+  properties: Record<string, Reference | Schema>;
+  required: string[];
+};
+
+export type ApiKeyCredentials = {
+  api_key: string;
+  custom_auth_header?: string;
+  authorization_type?: AuthorizationTypeEnum;
+};
+
+export type OAuthCredentials = {
+  tokenUrl: string;
+  clientId: string;
+  clientSecret: string;
+  scope: string;
+};
+
+export type Credentials = ApiKeyCredentials | OAuthCredentials;
+
+export function sha1(input: string) {
+  return crypto.createHash('sha1').update(input).digest('hex');
+}
+
+export function createURL(domain: string, path: string) {
+  const myURL = new URL(path, domain);
+  return myURL.toString();
+}
+
+export class FunctionSignature {
+  name: string;
+  description: string;
+  parameters: ParametersSchema;
+
+  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;
+    }
+  }
+
+  toObjectTool(): FunctionTool {
+    return {
+      type: Tools.function,
+      function: {
+        name: this.name,
+        description: this.description,
+        parameters: this.parameters,
+      },
+    };
+  }
+}
+
+export class ActionRequest {
+  domain: string;
+  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 authHeaders: Record<string, string> = {};
+  private authToken?: string;
+
+  async setParams(params: object) {
+    this.operationHash = sha1(JSON.stringify(params));
+    this.params = params;
+  }
+
+  async setAuth(metadata: ActionMetadata) {
+    if (!metadata.auth) {
+      return;
+    }
+
+    const {
+      type,
+      /* API Key */
+      authorization_type,
+      custom_auth_header,
+      /* OAuth */
+      authorization_url,
+      client_url,
+      scope,
+      token_exchange_method,
+    } = metadata.auth;
+
+    const {
+      /* API Key */
+      api_key,
+      /* OAuth */
+      oauth_client_id,
+      oauth_client_secret,
+    } = metadata;
+
+    const isApiKey = api_key && type === AuthTypeEnum.ServiceHttp;
+    const isOAuth =
+      oauth_client_id &&
+      oauth_client_secret &&
+      type === AuthTypeEnum.OAuth &&
+      authorization_url &&
+      client_url &&
+      scope &&
+      token_exchange_method;
+
+    if (isApiKey && authorization_type === AuthorizationTypeEnum.Basic) {
+      const basicToken = Buffer.from(api_key).toString('base64');
+      this.authHeaders['Authorization'] = `Basic ${basicToken}`;
+    } else if (isApiKey && authorization_type === AuthorizationTypeEnum.Bearer) {
+      this.authHeaders['Authorization'] = `Bearer ${api_key}`;
+    } else if (
+      isApiKey &&
+      authorization_type === AuthorizationTypeEnum.Custom &&
+      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;
+      }
+      this.authHeaders['Authorization'] = `Bearer ${this.authToken}`;
+    }
+  }
+
+  async execute() {
+    const url = createURL(this.domain, this.path);
+    const headers = {
+      ...this.authHeaders,
+      'Content-Type': this.contentType,
+    };
+
+    const method = this.method.toLowerCase();
+
+    if (method === 'get') {
+      return axios.get(url, { headers, params: this.params });
+    } else if (method === 'post') {
+      return axios.post(url, this.params, { headers });
+    } else if (method === 'put') {
+      return axios.put(url, this.params, { headers });
+    } else if (method === 'delete') {
+      return axios.delete(url, { headers, data: this.params });
+    } else if (method === 'patch') {
+      return axios.patch(url, this.params, { headers });
+    } else {
+      throw new Error(`Unsupported HTTP method: ${this.method}`);
+    }
+  }
+}
+
+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`);
+    }
+    return resolveRef(resolvedSchema, components);
+  }
+  return schema as OpenAPIV3.SchemaObject;
+}
+
+/** Function to convert OpenAPI spec to function signatures and request builders */
+export function openapiToFunction(openapiSpec: OpenAPIV3.Document): {
+  functionSignatures: FunctionSignature[];
+  requestBuilders: Record<string, ActionRequest>;
+} {
+  const functionSignatures: FunctionSignature[] = [];
+  const requestBuilders: Record<string, ActionRequest> = {};
+
+  // Base URL from OpenAPI spec servers
+  const baseUrl = openapiSpec.servers?.[0]?.url ?? '';
+
+  // Iterate over each path and method in the OpenAPI spec
+  for (const [path, methods] of Object.entries(openapiSpec.paths)) {
+    for (const [method, operation] of Object.entries(methods as OpenAPIV3.PathsObject)) {
+      const operationObj = operation as OpenAPIV3.OperationObject & {
+        'x-openai-isConsequential'?: boolean;
+      };
+
+      // Operation ID is used as the function name
+      const operationId = operationObj.operationId || `${method}_${path}`;
+      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;
+      }
+
+      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;
+          }
+        }
+      }
+
+      const functionSignature = new FunctionSignature(operationId, description, parametersSchema);
+      functionSignatures.push(functionSignature);
+
+      const actionRequest = new ActionRequest(
+        baseUrl,
+        path,
+        method,
+        operationId,
+        !!operationObj['x-openai-isConsequential'], // Custom extension for consequential actions
+        operationObj.requestBody ? 'application/json' : 'application/x-www-form-urlencoded',
+      );
+
+      requestBuilders[operationId] = actionRequest;
+    }
+  }
+
+  return { functionSignatures, requestBuilders };
+}
+
+export type ValidationResult = {
+  status: boolean;
+  message: string;
+  spec?: OpenAPIV3.Document;
+};
+
+export function validateAndParseOpenAPISpec(specString: string): ValidationResult {
+  try {
+    let parsedSpec;
+    try {
+      parsedSpec = JSON.parse(specString);
+    } catch {
+      parsedSpec = load(specString);
+    }
+
+    // Check for servers
+    if (
+      !parsedSpec.servers ||
+      !Array.isArray(parsedSpec.servers) ||
+      parsedSpec.servers.length === 0
+    ) {
+      return { status: false, message: 'Could not find a valid URL in `servers`' };
+    }
+
+    if (!parsedSpec.servers[0].url) {
+      return { status: false, message: 'Could not find a valid URL in `servers`' };
+    }
+
+    // Check for paths
+    const paths = parsedSpec.paths;
+    if (!paths || typeof paths !== 'object' || Object.keys(paths).length === 0) {
+      return { status: false, message: 'No paths found in the OpenAPI spec.' };
+    }
+
+    const components = parsedSpec.components?.schemas || {};
+    const messages = [];
+
+    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;
+        if (typeof operation === 'object' && responses) {
+          for (const [statusCode, response] of Object.entries(responses)) {
+            const content = (response as OpenAPIV3.ResponseObject).content;
+            if (content && content['application/json'] && content['application/json'].schema) {
+              const schema = content['application/json'].schema;
+              if ('$ref' in schema && typeof schema.$ref === 'string') {
+                const refName = schema.$ref.split('/').pop();
+                if (refName && !components[refName]) {
+                  messages.push(
+                    `In context=('paths', '${path}', '${httpMethod}', '${statusCode}', 'response', 'content', 'application/json', 'schema'), reference to unknown component ${refName}; using empty schema`,
+                  );
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return {
+      status: true,
+      message: messages.join('\n') || 'OpenAPI spec is valid.',
+      spec: parsedSpec,
+    };
+  } catch (error) {
+    return { status: false, message: 'Error parsing OpenAPI spec.' };
+  }
+}