librechat-data-provider 0.7.4 → 0.7.7

package/src/createPayload.ts

@@ -3,7 +3,8 @@ import { EndpointURLs } from './config';
 import * as s from './schemas';
 
 export default function createPayload(submission: t.TSubmission) {
-  const { conversation, userMessage, endpointOption, isEdited, isContinued } = submission;
+  const { conversation, userMessage, endpointOption, isEdited, isContinued, isTemporary } =
+    submission;
   const { conversationId } = s.tConvoUpdateSchema.parse(conversation);
   const { endpoint, endpointType } = endpointOption as {
     endpoint: s.EModelEndpoint;
@@ -23,6 +24,7 @@ export default function createPayload(submission: t.TSubmission) {
     ...endpointOption,
     isContinued: !!(isEdited && isContinued),
     conversationId,
+    isTemporary,
   };
 
   return { server, payload };

package/src/data-service.ts

@@ -1,13 +1,14 @@
 import type { AxiosResponse } from 'axios';
-import * as f from './types/files';
-import * as q from './types/queries';
-import * as m from './types/mutations';
+import type * as t from './types';
+import * as endpoints from './api-endpoints';
 import * as a from './types/assistants';
-import * as r from './roles';
-import * as t from './types';
-import * as s from './schemas';
+import * as m from './types/mutations';
+import * as q from './types/queries';
+import * as f from './types/files';
+import * as config from './config';
 import request from './request';
-import * as endpoints from './api-endpoints';
+import * as s from './schemas';
+import * as r from './roles';
 
 export function abortRequestWithMessage(
   endpoint: string,
@@ -40,27 +41,29 @@ export function getSharedMessages(shareId: string): Promise<t.TSharedMessagesRes
   return request.get(endpoints.shareMessages(shareId));
 }
 
-export const listSharedLinks = (
-  params?: q.SharedLinkListParams,
+export const listSharedLinks = async (
+  params: q.SharedLinksListParams,
 ): Promise<q.SharedLinksResponse> => {
-  const pageNumber = params?.pageNumber || '1'; // Default to page 1 if not provided
-  const isPublic = params?.isPublic || true; // Default to true if not provided
-  return request.get(endpoints.getSharedLinks(pageNumber, isPublic));
+  const { pageSize, isPublic, sortBy, sortDirection, search, cursor } = params;
+
+  return request.get(
+    endpoints.getSharedLinks(pageSize, isPublic, sortBy, sortDirection, search, cursor),
+  );
 };
 
-export function getSharedLink(shareId: string): Promise<t.TSharedLinkResponse> {
-  return request.get(endpoints.shareMessages(shareId));
+export function getSharedLink(conversationId: string): Promise<t.TSharedLinkGetResponse> {
+  return request.get(endpoints.getSharedLink(conversationId));
 }
 
-export function createSharedLink(payload: t.TSharedLinkRequest): Promise<t.TSharedLinkResponse> {
-  return request.post(endpoints.createSharedLink, payload);
+export function createSharedLink(conversationId: string): Promise<t.TSharedLinkResponse> {
+  return request.post(endpoints.createSharedLink(conversationId));
 }
 
-export function updateSharedLink(payload: t.TSharedLinkRequest): Promise<t.TSharedLinkResponse> {
-  return request.patch(endpoints.updateSharedLink, payload);
+export function updateSharedLink(shareId: string): Promise<t.TSharedLinkResponse> {
+  return request.patch(endpoints.updateSharedLink(shareId));
 }
 
-export function deleteSharedLink(shareId: string): Promise<t.TDeleteSharedLinkResponse> {
+export function deleteSharedLink(shareId: string): Promise<m.TDeleteSharedLinkResponse> {
   return request.delete(endpoints.shareMessages(shareId));
 }
 
@@ -73,6 +76,22 @@ export function updateMessage(payload: t.TUpdateMessageRequest): Promise<unknown
   return request.put(endpoints.messages(conversationId, messageId), { text });
 }
 
+export const editArtifact = async ({
+  messageId,
+  ...params
+}: m.TEditArtifactRequest): Promise<m.TEditArtifactResponse> => {
+  return request.post(`/api/messages/artifact/${messageId}`, params);
+};
+
+export function updateMessageContent(payload: t.TUpdateMessageContent): Promise<unknown> {
+  const { conversationId, messageId, index, text } = payload;
+  if (!conversationId) {
+    throw new Error('conversationId is required');
+  }
+
+  return request.put(endpoints.messages(conversationId, messageId), { text, index });
+}
+
 export function updateUserKey(payload: t.TUpdateUserKeyRequest) {
   const { value } = payload;
   if (!value) {
@@ -114,11 +133,11 @@ export const updateTokenCount = (text: string) => {
   return request.post(endpoints.tokenizer(), { arg: text });
 };
 
-export const login = (payload: t.TLoginUser) => {
+export const login = (payload: t.TLoginUser): Promise<t.TLoginResponse> => {
   return request.post(endpoints.login(), payload);
 };
 
-export const logout = () => {
+export const logout = (): Promise<m.TLogoutResponse> => {
   return request.post(endpoints.logout());
 };
 
@@ -163,7 +182,7 @@ export const updateUserPlugins = (payload: t.TUpdateUserPlugins) => {
 
 /* Config */
 
-export const getStartupConfig = (): Promise<t.TStartupConfig> => {
+export const getStartupConfig = (): Promise<config.TStartupConfig> => {
   return request.get(endpoints.config());
 };
 
@@ -255,14 +274,18 @@ export function getAssistantDocs({
   endpoint,
   version,
 }: {
-  endpoint: s.AssistantsEndpoint;
+  endpoint: s.AssistantsEndpoint | string;
   version: number | string;
 }): Promise<a.AssistantDocument[]> {
+  if (!s.isAssistantsEndpoint(endpoint)) {
+    return Promise.resolve([]);
+  }
   return request.get(
     endpoints.assistants({
       path: 'documents',
       version,
-      endpoint,
+      options: { endpoint },
+      endpoint: endpoint as s.AssistantsEndpoint,
     }),
   );
 }
@@ -270,14 +293,56 @@ export function getAssistantDocs({
 /* Tools */
 
 export const getAvailableTools = (
-  version: number | string,
-  endpoint: s.AssistantsEndpoint,
+  _endpoint: s.AssistantsEndpoint | s.EModelEndpoint.agents,
+  version?: number | string,
 ): Promise<s.TPlugin[]> => {
-  return request.get(
-    endpoints.assistants({
+  let path = '';
+  if (s.isAssistantsEndpoint(_endpoint)) {
+    const endpoint = _endpoint as s.AssistantsEndpoint;
+    path = endpoints.assistants({
       path: 'tools',
-      endpoint,
-      version,
+      endpoint: endpoint,
+      version: version ?? config.defaultAssistantsVersion[endpoint],
+    });
+  } else {
+    path = endpoints.agents({
+      path: 'tools',
+    });
+  }
+
+  return request.get(path);
+};
+
+export const getVerifyAgentToolAuth = (
+  params: q.VerifyToolAuthParams,
+): Promise<q.VerifyToolAuthResponse> => {
+  return request.get(
+    endpoints.agents({
+      path: `tools/${params.toolId}/auth`,
+    }),
+  );
+};
+
+export const callTool = <T extends m.ToolId>({
+  toolId,
+  toolParams,
+}: {
+  toolId: T;
+  toolParams: m.ToolParams<T>;
+}): Promise<m.ToolCallResponse> => {
+  return request.post(
+    endpoints.agents({
+      path: `tools/${toolId}/call`,
+    }),
+    toolParams,
+  );
+};
+
+export const getToolCalls = (params: q.GetToolCallParams): Promise<q.ToolCallResults> => {
+  return request.get(
+    endpoints.agents({
+      path: 'tools/calls',
+      options: params,
     }),
   );
 };
@@ -292,14 +357,146 @@ export const getFileConfig = (): Promise<f.FileConfig> => {
   return request.get(`${endpoints.files()}/config`);
 };
 
-export const uploadImage = (data: FormData): Promise<f.TFileUpload> => {
-  return request.postMultiPart(endpoints.images(), data);
+export const uploadImage = (
+  data: FormData,
+  signal?: AbortSignal | null,
+): Promise<f.TFileUpload> => {
+  const requestConfig = signal ? { signal } : undefined;
+  return request.postMultiPart(endpoints.images(), data, requestConfig);
+};
+
+export const uploadFile = (data: FormData, signal?: AbortSignal | null): Promise<f.TFileUpload> => {
+  const requestConfig = signal ? { signal } : undefined;
+  return request.postMultiPart(endpoints.files(), data, requestConfig);
+};
+
+/* actions */
+
+export const updateAction = (data: m.UpdateActionVariables): Promise<m.UpdateActionResponse> => {
+  const { assistant_id, version, ...body } = data;
+  return request.post(
+    endpoints.assistants({
+      path: `actions/${assistant_id}`,
+      version,
+    }),
+    body,
+  );
+};
+
+export function getActions(): Promise<a.Action[]> {
+  return request.get(
+    endpoints.agents({
+      path: 'actions',
+    }),
+  );
+}
+
+export const deleteAction = async ({
+  assistant_id,
+  action_id,
+  model,
+  version,
+  endpoint,
+}: m.DeleteActionVariables & { version: number | string }): Promise<void> =>
+  request.delete(
+    endpoints.assistants({
+      path: `actions/${assistant_id}/${action_id}/${model}`,
+      version,
+      endpoint,
+    }),
+  );
+
+/**
+ * Agents
+ */
+
+export const createAgent = ({ ...data }: a.AgentCreateParams): Promise<a.Agent> => {
+  return request.post(endpoints.agents({}), data);
+};
+
+export const getAgentById = ({ agent_id }: { agent_id: string }): Promise<a.Agent> => {
+  return request.get(
+    endpoints.agents({
+      path: agent_id,
+    }),
+  );
+};
+
+export const updateAgent = ({
+  agent_id,
+  data,
+}: {
+  agent_id: string;
+  data: a.AgentUpdateParams;
+}): Promise<a.Agent> => {
+  return request.patch(
+    endpoints.agents({
+      path: agent_id,
+    }),
+    data,
+  );
+};
+
+export const duplicateAgent = ({
+  agent_id,
+}: m.DuplicateAgentBody): Promise<{ agent: a.Agent; actions: a.Action[] }> => {
+  return request.post(
+    endpoints.agents({
+      path: `${agent_id}/duplicate`,
+    }),
+  );
+};
+
+export const deleteAgent = ({ agent_id }: m.DeleteAgentBody): Promise<void> => {
+  return request.delete(
+    endpoints.agents({
+      path: agent_id,
+    }),
+  );
 };
 
-export const uploadFile = (data: FormData): Promise<f.TFileUpload> => {
-  return request.postMultiPart(endpoints.files(), data);
+export const listAgents = (params: a.AgentListParams): Promise<a.AgentListResponse> => {
+  return request.get(
+    endpoints.agents({
+      options: params,
+    }),
+  );
+};
+
+/* Tools */
+
+export const getAvailableAgentTools = (): Promise<s.TPlugin[]> => {
+  return request.get(
+    endpoints.agents({
+      path: 'tools',
+    }),
+  );
 };
 
+/* Actions */
+
+export const updateAgentAction = (
+  data: m.UpdateAgentActionVariables,
+): Promise<m.UpdateAgentActionResponse> => {
+  const { agent_id, ...body } = data;
+  return request.post(
+    endpoints.agents({
+      path: `actions/${agent_id}`,
+    }),
+    body,
+  );
+};
+
+export const deleteAgentAction = async ({
+  agent_id,
+  action_id,
+}: m.DeleteAgentActionVariables): Promise<void> =>
+  request.delete(
+    endpoints.agents({
+      path: `actions/${agent_id}/${action_id}`,
+    }),
+  );
+
 /**
  * Imports a conversations file.
  *
@@ -317,7 +514,8 @@ export const uploadAvatar = (data: FormData): Promise<f.AvatarUploadResponse> =>
 export const uploadAssistantAvatar = (data: m.AssistantAvatarVariables): Promise<a.Assistant> => {
   return request.postMultiPart(
     endpoints.assistants({
-      path: `avatar/${data.assistant_id}`,
+      isAvatar: true,
+      path: `${data.assistant_id}/avatar`,
       options: { model: data.model, endpoint: data.endpoint },
       version: data.version,
     }),
@@ -325,6 +523,13 @@ export const uploadAssistantAvatar = (data: m.AssistantAvatarVariables): Promise
   );
 };
 
+export const uploadAgentAvatar = (data: m.AgentAvatarVariables): Promise<a.Agent> => {
+  return request.postMultiPart(
+    `${endpoints.images()}/agents/${data.agent_id}/avatar`,
+    data.formData,
+  );
+};
+
 export const getFileDownload = async (userId: string, file_id: string): Promise<AxiosResponse> => {
   return request.getResponse(`${endpoints.files()}/download/${userId}/${file_id}`, {
     responseType: 'blob',
@@ -334,15 +539,27 @@ export const getFileDownload = async (userId: string, file_id: string): Promise<
   });
 };
 
-export const deleteFiles = async (
-  files: f.BatchFile[],
-  assistant_id?: string,
-  tool_resource?: a.EToolResources,
-): Promise<f.DeleteFilesResponse> =>
+export const getCodeOutputDownload = async (url: string): Promise<AxiosResponse> => {
+  return request.getResponse(url, {
+    responseType: 'blob',
+    headers: {
+      Accept: 'application/octet-stream',
+    },
+  });
+};
+
+export const deleteFiles = async (payload: {
+  files: f.BatchFile[];
+  agent_id?: string;
+  assistant_id?: string;
+  tool_resource?: a.EToolResources;
+}): Promise<f.DeleteFilesResponse> =>
   request.deleteWithOptions(endpoints.files(), {
-    data: { files, assistant_id, tool_resource },
+    data: payload,
   });
 
+/* Speech */
+
 export const speechToText = (data: FormData): Promise<f.SpeechToTextResponse> => {
   return request.postMultiPart(endpoints.speechToText(), data);
 };
@@ -359,52 +576,14 @@ export const getCustomConfigSpeech = (): Promise<t.TCustomConfigSpeechResponse>
   return request.get(endpoints.getCustomConfigSpeech());
 };
 
-/* actions */
-
-export const updateAction = (data: m.UpdateActionVariables): Promise<m.UpdateActionResponse> => {
-  const { assistant_id, version, ...body } = data;
-  return request.post(
-    endpoints.assistants({
-      path: `actions/${assistant_id}`,
-      version,
-    }),
-    body,
-  );
-};
+/* conversations */
 
-export function getActions({
-  endpoint,
-  version,
-}: {
-  endpoint: s.AssistantsEndpoint;
-  version: number | string;
-}): Promise<a.Action[]> {
-  return request.get(
-    endpoints.assistants({
-      path: 'actions',
-      version,
-      endpoint,
-    }),
-  );
+export function duplicateConversation(
+  payload: t.TDuplicateConvoRequest,
+): Promise<t.TDuplicateConvoResponse> {
+  return request.post(endpoints.duplicateConversation(), payload);
 }
 
-export const deleteAction = async ({
-  assistant_id,
-  action_id,
-  model,
-  version,
-  endpoint,
-}: m.DeleteActionVariables & { version: number | string }): Promise<void> =>
-  request.delete(
-    endpoints.assistants({
-      path: `actions/${assistant_id}/${action_id}/${model}`,
-      version,
-      endpoint,
-    }),
-  );
-
-/* conversations */
-
 export function forkConversation(payload: t.TForkConvoRequest): Promise<t.TForkConvoResponse> {
   return request.post(endpoints.forkConversation(), payload);
 }
@@ -422,16 +601,17 @@ export const listConversations = (
   params?: q.ConversationListParams,
 ): Promise<q.ConversationListResponse> => {
   // Assuming params has a pageNumber property
-  const pageNumber = params?.pageNumber || '1'; // Default to page 1 if not provided
-  const isArchived = params?.isArchived || false; // Default to false if not provided
-  return request.get(endpoints.conversations(pageNumber, isArchived));
+  const pageNumber = (params?.pageNumber ?? '1') || '1'; // Default to page 1 if not provided
+  const isArchived = params?.isArchived ?? false; // Default to false if not provided
+  const tags = params?.tags || []; // Default to an empty array if not provided
+  return request.get(endpoints.conversations(pageNumber, isArchived, tags));
 };
 
 export const listConversationsByQuery = (
   params?: q.ConversationListParams & { searchQuery?: string },
 ): Promise<q.ConversationListResponse> => {
-  const pageNumber = params?.pageNumber || '1'; // Default to page 1 if not provided
-  const searchQuery = params?.searchQuery || ''; // If no search query is provided, default to an empty string
+  const pageNumber = (params?.pageNumber ?? '1') || '1'; // Default to page 1 if not provided
+  const searchQuery = params?.searchQuery ?? ''; // If no search query is provided, default to an empty string
   // Update the endpoint to handle a search query
   if (searchQuery !== '') {
     return request.get(endpoints.search(searchQuery, pageNumber));
@@ -538,6 +718,89 @@ export function getRole(roleName: string): Promise<r.TRole> {
 
 export function updatePromptPermissions(
   variables: m.UpdatePromptPermVars,
-): Promise<m.UpdatePromptPermResponse> {
+): Promise<m.UpdatePermResponse> {
   return request.put(endpoints.updatePromptPermissions(variables.roleName), variables.updates);
 }
+
+export function updateAgentPermissions(
+  variables: m.UpdateAgentPermVars,
+): Promise<m.UpdatePermResponse> {
+  return request.put(endpoints.updateAgentPermissions(variables.roleName), variables.updates);
+}
+
+/* Tags */
+export function getConversationTags(): Promise<t.TConversationTagsResponse> {
+  return request.get(endpoints.conversationTags());
+}
+
+export function createConversationTag(
+  payload: t.TConversationTagRequest,
+): Promise<t.TConversationTagResponse> {
+  return request.post(endpoints.conversationTags(), payload);
+}
+
+export function updateConversationTag(
+  tag: string,
+  payload: t.TConversationTagRequest,
+): Promise<t.TConversationTagResponse> {
+  return request.put(endpoints.conversationTags(tag), payload);
+}
+export function deleteConversationTag(tag: string): Promise<t.TConversationTagResponse> {
+  return request.delete(endpoints.conversationTags(tag));
+}
+
+export function addTagToConversation(
+  conversationId: string,
+  payload: t.TTagConversationRequest,
+): Promise<t.TTagConversationResponse> {
+  return request.put(endpoints.addTagToConversation(conversationId), payload);
+}
+export function rebuildConversationTags(): Promise<t.TConversationTagsResponse> {
+  return request.post(endpoints.conversationTags('rebuild'));
+}
+
+export function healthCheck(): Promise<string> {
+  return request.get(endpoints.health());
+}
+
+export function getUserTerms(): Promise<t.TUserTermsResponse> {
+  return request.get(endpoints.userTerms());
+}
+
+export function acceptTerms(): Promise<t.TAcceptTermsResponse> {
+  return request.post(endpoints.acceptUserTerms());
+}
+
+export function getBanner(): Promise<t.TBannerResponse> {
+  return request.get(endpoints.banner());
+}
+
+export function enableTwoFactor(): Promise<t.TEnable2FAResponse> {
+  return request.get(endpoints.enableTwoFactor());
+}
+
+export function verifyTwoFactor(
+  payload: t.TVerify2FARequest,
+): Promise<t.TVerify2FAResponse> {
+  return request.post(endpoints.verifyTwoFactor(), payload);
+}
+
+export function confirmTwoFactor(
+  payload: t.TVerify2FARequest,
+): Promise<t.TVerify2FAResponse> {
+  return request.post(endpoints.confirmTwoFactor(), payload);
+}
+
+export function disableTwoFactor(): Promise<t.TDisable2FAResponse> {
+  return request.post(endpoints.disableTwoFactor());
+}
+
+export function regenerateBackupCodes(): Promise<t.TRegenerateBackupCodesResponse> {
+  return request.post(endpoints.regenerateBackupCodes());
+}
+
+export function verifyTwoFactorTemp(
+  payload: t.TVerify2FATempRequest,
+): Promise<t.TVerify2FATempResponse> {
+  return request.post(endpoints.verifyTwoFactorTemp(), payload);
+}

package/src/file-config.ts

@@ -8,9 +8,11 @@ export const supportsFiles = {
   [EModelEndpoint.google]: true,
   [EModelEndpoint.assistants]: true,
   [EModelEndpoint.azureAssistants]: true,
+  [EModelEndpoint.agents]: true,
   [EModelEndpoint.azureOpenAI]: true,
   [EModelEndpoint.anthropic]: true,
   [EModelEndpoint.custom]: true,
+  [EModelEndpoint.bedrock]: true,
 };
 
 export const excelFileTypes = [
@@ -43,6 +45,7 @@ export const fullMimeTypesList = [
   'text/x-tex',
   'text/plain',
   'text/css',
+  'text/vtt',
   'image/jpeg',
   'text/javascript',
   'image/gif',
@@ -51,6 +54,8 @@ export const fullMimeTypesList = [
   'application/typescript',
   'application/xml',
   'application/zip',
+  'image/svg',
+  'image/svg+xml',
   ...excelFileTypes,
 ];
 
@@ -107,7 +112,7 @@ export const excelMimeTypes =
   /^application\/(vnd\.ms-excel|msexcel|x-msexcel|x-ms-excel|x-excel|x-dos_ms_excel|xls|x-xls|vnd\.openxmlformats-officedocument\.spreadsheetml\.sheet)$/;
 
 export const textMimeTypes =
-  /^(text\/(x-c|x-c\+\+|x-java|html|markdown|x-php|x-python|x-script\.python|x-ruby|x-tex|plain|css|javascript|csv))$/;
+  /^(text\/(x-c|x-csharp|x-c\+\+|x-java|html|markdown|x-php|x-python|x-script\.python|x-ruby|x-tex|plain|css|vtt|javascript|csv))$/;
 
 export const applicationMimeTypes =
   /^(application\/(epub\+zip|csv|json|pdf|x-tar|typescript|vnd\.openxmlformats-officedocument\.(wordprocessingml\.document|presentationml\.presentation|spreadsheetml\.sheet)|xml|zip))$/;
@@ -119,6 +124,8 @@ export const supportedMimeTypes = [
   excelMimeTypes,
   applicationMimeTypes,
   imageMimeTypes,
+  /** Supported by LC Code Interpreter PAI */
+  /^image\/(svg|svg\+xml)$/,
 ];
 
 export const codeInterpreterMimeTypes = [
@@ -142,10 +149,13 @@ export const codeTypeMapping: { [key: string]: string } = {
   ts: 'application/typescript',
   tar: 'application/x-tar',
   zip: 'application/zip',
+  yml: 'application/x-yaml',
+  yaml: 'application/x-yaml',
+  log: 'text/plain',
 };
 
 export const retrievalMimeTypes = [
-  /^(text\/(x-c|x-c\+\+|html|x-java|markdown|x-php|x-python|x-script\.python|x-ruby|x-tex|plain|xml))$/,
+  /^(text\/(x-c|x-c\+\+|html|x-java|markdown|x-php|x-python|x-script\.python|x-ruby|x-tex|plain|vtt|xml))$/,
   /^(application\/(json|pdf|vnd\.openxmlformats-officedocument\.(wordprocessingml\.document|presentationml\.presentation)))$/,
 ];
 
@@ -166,6 +176,7 @@ export const fileConfig = {
   endpoints: {
     [EModelEndpoint.assistants]: assistantsFileConfig,
     [EModelEndpoint.azureAssistants]: assistantsFileConfig,
+    [EModelEndpoint.agents]: assistantsFileConfig,
     default: {
       fileLimit: 10,
       fileSizeLimit: defaultSizeLimit,