librechat-data-provider 0.2.5 → 0.3.0

package/src/data-service.ts

@@ -1,7 +1,8 @@
+import * as f from './types/files';
+import * as m from './types/mutations';
+import * as a from './types/assistants';
 import * as t from './types';
 import * as s from './schemas';
-/* TODO: fix dependency cycle */
-// eslint-disable-next-line import/no-cycle
 import request from './request';
 import * as endpoints from './api-endpoints';
 
@@ -35,6 +36,9 @@ export function revokeAllUserKeys(): Promise<unknown> {
 }
 
 export function getMessagesByConvoId(conversationId: string): Promise<s.TMessage[]> {
+  if (conversationId === 'new') {
+    return Promise.resolve([]);
+  }
   return request.get(endpoints.messages(conversationId));
 }
 
@@ -70,15 +74,15 @@ export function getPresets(): Promise<s.TPreset[]> {
   return request.get(endpoints.presets());
 }
 
-export function createPreset(payload: s.TPreset): Promise<s.TPreset[]> {
+export function createPreset(payload: s.TPreset): Promise<s.TPreset> {
   return request.post(endpoints.presets(), payload);
 }
 
-export function updatePreset(payload: s.TPreset): Promise<s.TPreset[]> {
+export function updatePreset(payload: s.TPreset): Promise<s.TPreset> {
   return request.post(endpoints.presets(), payload);
 }
 
-export function deletePreset(arg: s.TPreset | object): Promise<s.TPreset[]> {
+export function deletePreset(arg: s.TPreset | undefined): Promise<m.PresetDeleteResponse> {
   return request.post(endpoints.deletePreset(), arg);
 }
 
@@ -101,14 +105,6 @@ export const searchConversations = async (
   return request.get(endpoints.search(q, pageNumber));
 };
 
-export const getAIEndpoints = (): Promise<t.TEndpointsConfig> => {
-  return request.get(endpoints.aiEndpoints());
-};
-
-export const getModels = async (): Promise<t.TModelsConfig> => {
-  return request.get(endpoints.models());
-};
-
 export const updateTokenCount = (text: string) => {
   return request.post(endpoints.tokenizer(), { arg: text });
 };
@@ -125,8 +121,6 @@ export const register = (payload: t.TRegisterUser) => {
   return request.post(endpoints.register(), payload);
 };
 
-export const refreshToken = (retry?: boolean) => request.post(endpoints.refreshToken(retry));
-
 export const userKeyQuery = (name: string): Promise<t.TCheckUserKeyResponse> =>
   request.get(endpoints.userKeyQuery(name));
 
@@ -152,6 +146,58 @@ export const updateUserPlugins = (payload: t.TUpdateUserPlugins) => {
   return request.post(endpoints.userPlugins(), payload);
 };
 
+/* Config */
+
 export const getStartupConfig = (): Promise<t.TStartupConfig> => {
   return request.get(endpoints.config());
 };
+
+export const getAIEndpoints = (): Promise<t.TEndpointsConfig> => {
+  return request.get(endpoints.aiEndpoints());
+};
+
+export const getModels = async (): Promise<t.TModelsConfig> => {
+  return request.get(endpoints.models());
+};
+
+export const getEndpointsConfigOverride = (): Promise<unknown | boolean> => {
+  return request.get(endpoints.endpointsConfigOverride());
+};
+
+/* Assistants */
+
+export const createAssistant = (data: a.AssistantCreateParams): Promise<a.Assistant> => {
+  return request.post(endpoints.assistants(), data);
+};
+
+export const getAssistantById = (assistant_id: string): Promise<a.Assistant> => {
+  return request.get(endpoints.assistants(assistant_id));
+};
+
+export const updateAssistant = (
+  assistant_id: string,
+  data: a.AssistantUpdateParams,
+): Promise<a.Assistant> => {
+  return request.patch(endpoints.assistants(assistant_id), data);
+};
+
+export const deleteAssistant = (assistant_id: string): Promise<void> => {
+  return request.delete(endpoints.assistants(assistant_id));
+};
+
+export const listAssistants = (
+  params?: a.AssistantListParams,
+): Promise<a.AssistantListResponse> => {
+  return request.get(endpoints.assistants(), { params });
+};
+
+/* Files */
+
+export const uploadImage = (data: FormData): Promise<f.FileUploadResponse> => {
+  return request.postMultiPart(endpoints.images(), data);
+};
+
+export const deleteFiles = async (files: f.BatchFile[]): Promise<f.DeleteFilesResponse> =>
+  request.deleteWithOptions(endpoints.files(), {
+    data: { files },
+  });

package/src/index.ts

@@ -1,7 +1,14 @@
-export * from './data-service';
-export { default as request } from './request';
+/* types/schemas/schema helpers */
 export * from './types';
-export * from './react-query-service';
+export * from './types/assistants';
+export * from './types/files';
+export * from './types/mutations';
+export * from './keys';
+/* api call helpers */
 export * from './headers-helpers';
+export { default as request } from './request';
+import * as dataService from './data-service';
+export { dataService };
+/* general helpers */
 export * from './sse';
 export { default as createPayload } from './createPayload';

package/src/keys.ts

@@ -0,0 +1,27 @@
+export enum QueryKeys {
+  messages = 'messages',
+  allConversations = 'allConversations',
+  conversation = 'conversation',
+  searchEnabled = 'searchEnabled',
+  user = 'user',
+  name = 'name', // user key name
+  models = 'models',
+  balance = 'balance',
+  endpoints = 'endpoints',
+  presets = 'presets',
+  searchResults = 'searchResults',
+  tokenCount = 'tokenCount',
+  availablePlugins = 'availablePlugins',
+  startupConfig = 'startupConfig',
+  assistants = 'assistants',
+  assistant = 'assistant',
+  endpointsConfigOverride = 'endpointsConfigOverride',
+}
+
+export enum MutationKeys {
+  imageUpload = 'imageUpload',
+  fileDelete = 'fileDelete',
+  updatePreset = 'updatePreset',
+  deletePreset = 'deletePreset',
+  logoutUser = 'logoutUser',
+}

package/src/react-query/assistants.ts

@@ -0,0 +1,138 @@
+import { useQuery, useMutation, useQueryClient, useInfiniteQuery } from '@tanstack/react-query';
+import type {
+  UseQueryOptions,
+  UseMutationResult,
+  QueryObserverResult,
+  UseInfiniteQueryOptions,
+} from '@tanstack/react-query';
+import * as t from '../types/assistants';
+import * as dataService from '../data-service';
+import { QueryKeys } from '../keys';
+
+/**
+ * Hook for listing all assistants, with optional parameters provided for pagination and sorting
+ */
+export const useListAssistantsQuery = <TData = t.AssistantListResponse>(
+  params?: t.AssistantListParams,
+  config?: UseQueryOptions<t.AssistantListResponse, unknown, TData>,
+): QueryObserverResult<TData> => {
+  return useQuery<t.AssistantListResponse, unknown, TData>(
+    [QueryKeys.assistants, params],
+    () => dataService.listAssistants(params),
+    {
+      // Example selector to sort them by created_at
+      // select: (res) => {
+      //   return res.data.sort((a, b) => a.created_at - b.created_at);
+      // },
+      refetchOnWindowFocus: false,
+      refetchOnReconnect: false,
+      refetchOnMount: false,
+      retry: false,
+      ...config,
+    },
+  );
+};
+
+export const useListAssistantsInfiniteQuery = (
+  params?: t.AssistantListParams,
+  config?: UseInfiniteQueryOptions<t.AssistantListResponse, Error>,
+) => {
+  return useInfiniteQuery<t.AssistantListResponse, Error>(
+    ['assistantsList', params],
+    ({ pageParam = '' }) => dataService.listAssistants({ ...params, after: pageParam }),
+    {
+      getNextPageParam: (lastPage) => {
+        // lastPage is of type AssistantListResponse, you can use the has_more and last_id from it directly
+        if (lastPage.has_more) {
+          return lastPage.last_id;
+        }
+        return undefined;
+      },
+      ...config,
+    },
+  );
+};
+
+/**
+ * Hook for creating a new assistant
+ */
+export const useCreateAssistantMutation = (): UseMutationResult<
+  t.Assistant,
+  Error,
+  t.AssistantCreateParams
+> => {
+  const queryClient = useQueryClient();
+  return useMutation(
+    (newAssistantData: t.AssistantCreateParams) => dataService.createAssistant(newAssistantData),
+    {
+      onSuccess: () => {
+        // Invalidate and refetch assistants query to update list
+        queryClient.invalidateQueries([QueryKeys.assistants]);
+      },
+    },
+  );
+};
+
+/**
+ * Hook for retrieving details about a single assistant
+ */
+export const useGetAssistantByIdQuery = (
+  assistant_id: string,
+  config?: UseQueryOptions<t.Assistant>,
+): QueryObserverResult<t.Assistant> => {
+  return useQuery<t.Assistant>(
+    [QueryKeys.assistant, assistant_id],
+    () => dataService.getAssistantById(assistant_id),
+    {
+      enabled: !!assistant_id, // Query will not execute until the assistant_id exists
+      refetchOnWindowFocus: false,
+      refetchOnReconnect: false,
+      refetchOnMount: false,
+      retry: false,
+      ...config,
+    },
+  );
+};
+
+/**
+ * Hook for updating an assistant
+ */
+export const useUpdateAssistantMutation = (): UseMutationResult<
+  t.Assistant,
+  Error,
+  { assistant_id: string; data: t.AssistantUpdateParams }
+> => {
+  const queryClient = useQueryClient();
+  return useMutation(
+    ({ assistant_id, data }: { assistant_id: string; data: t.AssistantUpdateParams }) =>
+      dataService.updateAssistant(assistant_id, data),
+    {
+      onSuccess: (_, { assistant_id }) => {
+        // Invalidate and refetch assistant details query
+        queryClient.invalidateQueries([QueryKeys.assistant, assistant_id]);
+        // Optionally invalidate and refetch list of assistants
+        queryClient.invalidateQueries([QueryKeys.assistants]);
+      },
+    },
+  );
+};
+
+/**
+ * Hook for deleting an assistant
+ */
+export const useDeleteAssistantMutation = (): UseMutationResult<
+  void,
+  Error,
+  { assistant_id: string }
+> => {
+  const queryClient = useQueryClient();
+  return useMutation(
+    ({ assistant_id }: { assistant_id: string }) => dataService.deleteAssistant(assistant_id),
+    {
+      onSuccess: () => {
+        // Invalidate and refetch assistant list query
+        queryClient.invalidateQueries([QueryKeys.assistants]);
+      },
+    },
+  );
+};

package/src/react-query/index.ts

@@ -0,0 +1,2 @@
+export * from './react-query-service';
+export * from './assistants';

package/src/{react-query-service.ts → react-query/react-query-service.ts}

@@ -6,26 +6,12 @@ import {
   UseMutationResult,
   QueryObserverResult,
 } from '@tanstack/react-query';
-import * as t from './types';
-import * as s from './schemas';
-import * as dataService from './data-service';
-
-export enum QueryKeys {
-  messages = 'messages',
-  allConversations = 'allConversations',
-  conversation = 'conversation',
-  searchEnabled = 'searchEnabled',
-  user = 'user',
-  name = 'name', // user key name
-  models = 'models',
-  balance = 'balance',
-  endpoints = 'endpoints',
-  presets = 'presets',
-  searchResults = 'searchResults',
-  tokenCount = 'tokenCount',
-  availablePlugins = 'availablePlugins',
-  startupConfig = 'startupConfig',
-}
+import * as t from '../types';
+import * as s from '../schemas';
+import * as m from '../types/mutations';
+import * as dataService from '../data-service';
+import request from '../request';
+import { QueryKeys } from '../keys';
 
 export const useAbortRequestWithMessage = (): UseMutationResult<
   void,
@@ -56,11 +42,11 @@ export const useGetUserQuery = (
   });
 };
 
-export const useGetMessagesByConvoId = (
+export const useGetMessagesByConvoId = <TData = s.TMessage[]>(
   id: string,
-  config?: UseQueryOptions<s.TMessage[]>,
-): QueryObserverResult<s.TMessage[]> => {
-  return useQuery<s.TMessage[]>(
+  config?: UseQueryOptions<s.TMessage[], unknown, TData>,
+): QueryObserverResult<TData> => {
+  return useQuery<s.TMessage[], unknown, TData>(
     [QueryKeys.messages, id],
     () => dataService.getMessagesByConvoId(id),
     {
@@ -99,6 +85,40 @@ export const useGetConversationByIdQuery = (
   );
 };
 
+/* like above, but first try the convos query data */
+export const useGetConvoIdQuery = (
+  id: string,
+  config?: UseQueryOptions<s.TConversation>,
+): QueryObserverResult<s.TConversation> => {
+  const queryClient = useQueryClient();
+  return useQuery<s.TConversation>(
+    [QueryKeys.conversation, id],
+    () => {
+      const defaultQuery = () => dataService.getConversationById(id);
+
+      const convosQueryKey = [QueryKeys.allConversations, { pageNumber: '1', active: true }];
+      const convosQuery = queryClient.getQueryData<t.TGetConversationsResponse>(convosQueryKey);
+
+      if (!convosQuery) {
+        return defaultQuery();
+      }
+
+      const convo = convosQuery.conversations?.find((c) => c.conversationId === id);
+      if (convo) {
+        return convo;
+      }
+
+      return defaultQuery();
+    },
+    {
+      refetchOnWindowFocus: false,
+      refetchOnReconnect: false,
+      refetchOnMount: false,
+      ...config,
+    },
+  );
+};
+
 //This isn't ideal because its just a query and we're using mutation, but it was the only way
 //to make it work with how the Chat component is structured
 export const useGetConversationByIdMutation = (id: string): UseMutationResult<s.TConversation> => {
@@ -208,7 +228,7 @@ export const useGetConversationsQuery = (
   config?: UseQueryOptions<t.TGetConversationsResponse>,
 ): QueryObserverResult<t.TGetConversationsResponse> => {
   return useQuery<t.TGetConversationsResponse>(
-    [QueryKeys.allConversations, pageNumber],
+    [QueryKeys.allConversations, { pageNumber, active: true }],
     () => dataService.getConversations(pageNumber),
     {
       refetchOnReconnect: false,
@@ -237,6 +257,7 @@ export const useGetEndpointsQuery = <TData = t.TEndpointsConfig>(
     [QueryKeys.endpoints],
     () => dataService.getAIEndpoints(),
     {
+      staleTime: Infinity,
       refetchOnWindowFocus: false,
       refetchOnReconnect: false,
       refetchOnMount: false,
@@ -249,6 +270,7 @@ export const useGetModelsQuery = (
   config?: UseQueryOptions<t.TModelsConfig>,
 ): QueryObserverResult<t.TModelsConfig> => {
   return useQuery<t.TModelsConfig>([QueryKeys.models], () => dataService.getModels(), {
+    staleTime: Infinity,
     refetchOnWindowFocus: false,
     refetchOnReconnect: false,
     refetchOnMount: false,
@@ -257,52 +279,27 @@ export const useGetModelsQuery = (
 };
 
 export const useCreatePresetMutation = (): UseMutationResult<
-  s.TPreset[],
-  unknown,
   s.TPreset,
-  unknown
-> => {
-  const queryClient = useQueryClient();
-  return useMutation((payload: s.TPreset) => dataService.createPreset(payload), {
-    onSuccess: () => {
-      queryClient.invalidateQueries([QueryKeys.presets]);
-    },
-  });
-};
-
-export const useUpdatePresetMutation = (): UseMutationResult<
-  s.TPreset[],
   unknown,
   s.TPreset,
   unknown
 > => {
   const queryClient = useQueryClient();
-  return useMutation((payload: s.TPreset) => dataService.updatePreset(payload), {
+  return useMutation((payload: s.TPreset) => dataService.createPreset(payload), {
     onSuccess: () => {
       queryClient.invalidateQueries([QueryKeys.presets]);
     },
   });
 };
 
-export const useGetPresetsQuery = (
-  config?: UseQueryOptions<s.TPreset[]>,
-): QueryObserverResult<s.TPreset[], unknown> => {
-  return useQuery<s.TPreset[]>([QueryKeys.presets], () => dataService.getPresets(), {
-    refetchOnWindowFocus: false,
-    refetchOnReconnect: false,
-    refetchOnMount: false,
-    ...config,
-  });
-};
-
 export const useDeletePresetMutation = (): UseMutationResult<
-  s.TPreset[],
+  m.PresetDeleteResponse,
   unknown,
-  s.TPreset | object,
+  s.TPreset | undefined,
   unknown
 > => {
   const queryClient = useQueryClient();
-  return useMutation((payload: s.TPreset | object) => dataService.deletePreset(payload), {
+  return useMutation((payload: s.TPreset | undefined) => dataService.deletePreset(payload), {
     onSuccess: () => {
       queryClient.invalidateQueries([QueryKeys.presets]);
     },
@@ -348,11 +345,8 @@ export const useLoginUserMutation = (): UseMutationResult<
 > => {
   const queryClient = useQueryClient();
   return useMutation((payload: t.TLoginUser) => dataService.login(payload), {
-    onSuccess: () => {
-      queryClient.invalidateQueries([QueryKeys.user]);
-    },
     onMutate: () => {
-      queryClient.invalidateQueries([QueryKeys.models]);
+      queryClient.removeQueries();
     },
   });
 };
@@ -371,15 +365,6 @@ export const useRegisterUserMutation = (): UseMutationResult<
   });
 };
 
-export const useLogoutUserMutation = (): UseMutationResult<unknown> => {
-  const queryClient = useQueryClient();
-  return useMutation(() => dataService.logout(), {
-    onSuccess: () => {
-      queryClient.invalidateQueries([QueryKeys.user]);
-    },
-  });
-};
-
 export const useRefreshTokenMutation = (): UseMutationResult<
   t.TRefreshTokenResponse,
   unknown,
@@ -387,9 +372,14 @@ export const useRefreshTokenMutation = (): UseMutationResult<
   unknown
 > => {
   const queryClient = useQueryClient();
-  return useMutation(() => dataService.refreshToken(), {
+  return useMutation(() => request.refreshToken(), {
     onMutate: () => {
-      queryClient.invalidateQueries([QueryKeys.models]);
+      queryClient.removeQueries();
+      localStorage.removeItem('lastConversationSetup');
+      localStorage.removeItem('lastSelectedModel');
+      localStorage.removeItem('lastSelectedTools');
+      localStorage.removeItem('filesToDelete');
+      localStorage.removeItem('lastAssistant');
     },
   });
 };

package/src/request.ts

@@ -1,13 +1,57 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import axios, { AxiosRequestConfig, AxiosError } from 'axios';
-/* TODO: fix dependency cycle */
-// eslint-disable-next-line import/no-cycle
-import { refreshToken } from './data-service';
 import { setTokenHeader } from './headers-helpers';
+import * as endpoints from './api-endpoints';
+
+async function _get<T>(url: string, options?: AxiosRequestConfig): Promise<T> {
+  const response = await axios.get(url, { ...options });
+  return response.data;
+}
+
+async function _post(url: string, data?: any) {
+  const response = await axios.post(url, JSON.stringify(data), {
+    headers: { 'Content-Type': 'application/json' },
+  });
+  return response.data;
+}
+
+async function _postMultiPart(url: string, formData: FormData, options?: AxiosRequestConfig) {
+  const response = await axios.post(url, formData, {
+    ...options,
+    headers: { 'Content-Type': 'multipart/form-data' },
+  });
+  return response.data;
+}
+
+async function _put(url: string, data?: any) {
+  const response = await axios.put(url, JSON.stringify(data), {
+    headers: { 'Content-Type': 'application/json' },
+  });
+  return response.data;
+}
+
+async function _delete<T>(url: string): Promise<T> {
+  const response = await axios.delete(url);
+  return response.data;
+}
+
+async function _deleteWithOptions<T>(url: string, options?: AxiosRequestConfig): Promise<T> {
+  const response = await axios.delete(url, { ...options });
+  return response.data;
+}
+
+async function _patch(url: string, data?: any) {
+  const response = await axios.patch(url, JSON.stringify(data), {
+    headers: { 'Content-Type': 'application/json' },
+  });
+  return response.data;
+}
 
 let isRefreshing = false;
 let failedQueue: { resolve: (value?: any) => void; reject: (reason?: any) => void }[] = [];
 
+const refreshToken = (retry?: boolean) => _post(endpoints.refreshToken(retry));
+
 const processQueue = (error: AxiosError | null, token: string | null = null) => {
   failedQueue.forEach((prom) => {
     if (error) {
@@ -68,50 +112,6 @@ axios.interceptors.response.use(
   },
 );
 
-async function _get<T>(url: string, options?: AxiosRequestConfig): Promise<T> {
-  const response = await axios.get(url, { ...options });
-  return response.data;
-}
-
-async function _post(url: string, data?: any) {
-  const response = await axios.post(url, JSON.stringify(data), {
-    headers: { 'Content-Type': 'application/json' },
-  });
-  return response.data;
-}
-
-async function _postMultiPart(url: string, formData: FormData, options?: AxiosRequestConfig) {
-  const response = await axios.post(url, formData, {
-    ...options,
-    headers: { 'Content-Type': 'multipart/form-data' },
-  });
-  return response.data;
-}
-
-async function _put(url: string, data?: any) {
-  const response = await axios.put(url, JSON.stringify(data), {
-    headers: { 'Content-Type': 'application/json' },
-  });
-  return response.data;
-}
-
-async function _delete<T>(url: string): Promise<T> {
-  const response = await axios.delete(url);
-  return response.data;
-}
-
-async function _deleteWithOptions<T>(url: string, options?: AxiosRequestConfig): Promise<T> {
-  const response = await axios.delete(url, { ...options });
-  return response.data;
-}
-
-async function _patch(url: string, data?: any) {
-  const response = await axios.patch(url, JSON.stringify(data), {
-    headers: { 'Content-Type': 'application/json' },
-  });
-  return response.data;
-}
-
 export default {
   get: _get,
   post: _post,
@@ -120,4 +120,5 @@ export default {
   delete: _delete,
   deleteWithOptions: _deleteWithOptions,
   patch: _patch,
+  refreshToken,
 };