mirror of
https://github.com/danny-avila/LibreChat.git
synced 2026-11-16 13:00:55 +00:00
* ✨ feat: Enhance agent update functionality to save current state in versions array - Updated the `updateAgent` function to push the current agent's state into a new `versions` array when an agent is updated. - Modified the agent schema to include a `versions` field for storing historical states of agents. * ✨ feat: Add comprehensive CRUD operations for agents in tests - Introduced a new test suite for CRUD operations on agents, including create, read, update, and delete functionalities. - Implemented tests for listing agents by author and updating agent projects. - Enhanced the agent model to support version history tracking during updates. - Ensured proper environment variable management during tests. * ✨ feat: Introduce version tracking for agents and enhance UI components - Added a `version` property to the agent model to track the number of versions. - Updated the `getAgentHandler` to include the agent's version in the response. - Introduced a new `VersionButton` component for navigating to the version panel. - Created a `VersionPanel` component for displaying version-related information. - Updated the UI to conditionally render the version button and panel based on the active state. - Added localization for the new version-related UI elements. * ✨ i18n: Add "version" translation key across multiple languages - Introduced the "com_ui_agent_version" translation key in various language files to support version tracking for agents. - Updated Arabic, Czech, German, English, Spanish, Estonian, Persian, Finnish, French, Hebrew, Hungarian, Indonesian, Italian, Japanese, Korean, Dutch, Polish, Portuguese (Brazil and Portugal), Russian, Swedish, Thai, Turkish, Vietnamese, and Chinese (Simplified and Traditional) translations. * ✨ feat: Update AgentFooter to conditionally render AdminSettings - Modified the logic for displaying buttons in the AgentFooter component to only show them when the active panel is the builder. - Ensured that AdminSettings is displayed only when the user has an admin role and the buttons are visible. * ✨ feat: Enhance AgentPanelSwitch and VersionPanel for improved agent capabilities - Updated AgentPanelSwitch to include a new VersionPanel for displaying version-related information. - Enhanced agentsConfig logic to properly handle agent capabilities. - Modified VersionPanel to improve structure and localization support. - Integrated createAgent mutation for future agent creation functionality. * ✨ feat: Enhance VersionPanel to display agent version history and loading states - Integrated version fetching logic in VersionPanel to retrieve and display agent version history. - Added loading and error handling states to improve user experience. - Updated agent schema to use mixed types for versions, allowing for more flexible version data structures. - Introduced localization support for version-related UI elements. * ✨ feat: Update VersionPanel and AgentPanelSwitch to enhance agent selection and version display - Modified AgentPanelSwitch to pass selectedAgentId to VersionPanel for improved agent context. - Enhanced VersionPanel to handle multiple timestamp formats and display appropriate messages when no agent is selected. - Improved structure and readability of the VersionPanel component by adding a helper function for timestamp retrieval. * ✨ feat: Refactor VersionPanel to utilize localization and improve timestamp handling - Replaced hardcoded text constants with localization support for various UI elements in VersionPanel. - Enhanced the timestamp retrieval function to handle errors gracefully and utilize localized messages for unknown dates. - Improved user feedback by displaying localized messages for agent selection, version errors, and empty states. * ✨ refactor: Clean up VersionPanel by removing unused code and improving timestamp handling * ✨ feat: Implement agent version reverting functionality - Added `revertAgentVersion` method in the Agent model to allow reverting to a previous version of an agent. - Introduced `revertAgentVersionHandler` in the agents controller to handle requests for reverting agent versions. - Updated API routes to include a new endpoint for reverting agent versions. - Enhanced the VersionPanel component to support version restoration with user confirmation and feedback. - Added localization support for success and error messages related to version restoration. * ✨ i18n: Add localization for agent version restoration messages * Simplify VersionPanel by removing unused parameters and enhancing agent ID handling * Refactor Agent model and VersionPanel component to streamline version data handling * Update version handling in Agent model and VersionPanel - Enhanced the Agent model to include an `updatedAt` timestamp when pushing new versions. - Improved the VersionPanel component to sort versions by the `updatedAt` timestamp for better display order. - Added a new localization entry for indicating the active version of an agent. * ✨ i18n: Add localization for active agent version across multiple languages * ✨ feat: Introduce version management components for agent history - Added `isActiveVersion` utility to determine the active version of an agent based on various criteria. - Implemented `VersionContent` and `VersionItem` components to display agent version history, including loading and error states. - Enhanced `VersionPanel` to integrate new components and manage version context effectively. - Added comprehensive tests for version management functionalities to ensure reliability and correctness. * Add unit tests for AgentFooter component * cleanup * Enhance agent version update handling and add unit tests for update operators - Updated the `updateAgent` function to properly handle various update operators ($push, $pull, $addToSet) while maintaining version history. - Modified unit tests to validate the correct behavior of agent updates, including versioning and tool management. * Enhance version comparison logic and update tests for artifacts handling - Modified the `isActiveVersion` utility to include artifacts in the version comparison criteria. - Updated the `VersionPanel` component to support artifacts in the agent state. - Added new unit tests to validate artifacts matching scenarios and edge cases in the `isActiveVersion` function. * Implement duplicate version detection in agent updates and enhance error handling - Added `isDuplicateVersion` function to check for identical versions during agent updates, excluding certain fields. - Updated `updateAgent` function to throw an error if a duplicate version is detected, with detailed error information. - Enhanced the `updateAgentHandler` to return appropriate responses for duplicate version errors. - Modified client-side error handling to display user-friendly messages for duplicate version scenarios. - Added comprehensive unit tests to validate duplicate version detection and error handling across various update scenarios. * Update version title localization to include version number across multiple languages - Modified the `com_ui_agent_version_title` translation key to include a placeholder for the version number in various language files. - Enhanced the `VersionItem` component to utilize the updated localization for displaying version titles dynamically. * Enhance agent version handling and add revert functionality - Updated the `isDuplicateVersion` function to improve version comparison logic, including special handling for `projectIds` and arrays of objects. - Modified the `updateAgent` function to streamline version updates and removed unnecessary checks for test environments. - Introduced a new `revertAgentVersion` function to allow reverting agents to specific versions, with detailed documentation. - Enhanced unit tests to validate duplicate version detection and revert functionality, ensuring robust error handling and version management. * fix CI issues * cleanup * Revert all non-English translations * clean up tests
792 lines
22 KiB
TypeScript
792 lines
22 KiB
TypeScript
import type { AxiosResponse } from 'axios';
|
|
import type * as t from './types';
|
|
import * as endpoints from './api-endpoints';
|
|
import * as a from './types/assistants';
|
|
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 s from './schemas';
|
|
import * as r from './roles';
|
|
|
|
export function abortRequestWithMessage(
|
|
endpoint: string,
|
|
abortKey: string,
|
|
message: string,
|
|
): Promise<void> {
|
|
return request.post(endpoints.abortRequest(endpoint), { arg: { abortKey, message } });
|
|
}
|
|
|
|
export function revokeUserKey(name: string): Promise<unknown> {
|
|
return request.delete(endpoints.revokeUserKey(name));
|
|
}
|
|
|
|
export function revokeAllUserKeys(): Promise<unknown> {
|
|
return request.delete(endpoints.revokeAllUserKeys());
|
|
}
|
|
|
|
export function deleteUser(): Promise<s.TPreset> {
|
|
return request.delete(endpoints.deleteUser());
|
|
}
|
|
|
|
export function getSharedMessages(shareId: string): Promise<t.TSharedMessagesResponse> {
|
|
return request.get(endpoints.shareMessages(shareId));
|
|
}
|
|
|
|
export const listSharedLinks = async (
|
|
params: q.SharedLinksListParams,
|
|
): Promise<q.SharedLinksResponse> => {
|
|
const { pageSize, isPublic, sortBy, sortDirection, search, cursor } = params;
|
|
|
|
return request.get(
|
|
endpoints.getSharedLinks(pageSize, isPublic, sortBy, sortDirection, search, cursor),
|
|
);
|
|
};
|
|
|
|
export function getSharedLink(conversationId: string): Promise<t.TSharedLinkGetResponse> {
|
|
return request.get(endpoints.getSharedLink(conversationId));
|
|
}
|
|
|
|
export function createSharedLink(conversationId: string): Promise<t.TSharedLinkResponse> {
|
|
return request.post(endpoints.createSharedLink(conversationId));
|
|
}
|
|
|
|
export function updateSharedLink(shareId: string): Promise<t.TSharedLinkResponse> {
|
|
return request.patch(endpoints.updateSharedLink(shareId));
|
|
}
|
|
|
|
export function deleteSharedLink(shareId: string): Promise<m.TDeleteSharedLinkResponse> {
|
|
return request.delete(endpoints.shareMessages(shareId));
|
|
}
|
|
|
|
export function updateUserKey(payload: t.TUpdateUserKeyRequest) {
|
|
const { value } = payload;
|
|
if (!value) {
|
|
throw new Error('value is required');
|
|
}
|
|
|
|
return request.put(endpoints.keys(), payload);
|
|
}
|
|
|
|
export function getPresets(): Promise<s.TPreset[]> {
|
|
return request.get(endpoints.presets());
|
|
}
|
|
|
|
export function createPreset(payload: s.TPreset): Promise<s.TPreset> {
|
|
return request.post(endpoints.presets(), payload);
|
|
}
|
|
|
|
export function updatePreset(payload: s.TPreset): Promise<s.TPreset> {
|
|
return request.post(endpoints.presets(), payload);
|
|
}
|
|
|
|
export function deletePreset(arg: s.TPreset | undefined): Promise<m.PresetDeleteResponse> {
|
|
return request.post(endpoints.deletePreset(), arg);
|
|
}
|
|
|
|
export function getSearchEnabled(): Promise<boolean> {
|
|
return request.get(endpoints.searchEnabled());
|
|
}
|
|
|
|
export function getUser(): Promise<t.TUser> {
|
|
return request.get(endpoints.user());
|
|
}
|
|
|
|
export function getUserBalance(): Promise<string> {
|
|
return request.get(endpoints.balance());
|
|
}
|
|
|
|
export const updateTokenCount = (text: string) => {
|
|
return request.post(endpoints.tokenizer(), { arg: text });
|
|
};
|
|
|
|
export const login = (payload: t.TLoginUser): Promise<t.TLoginResponse> => {
|
|
return request.post(endpoints.login(), payload);
|
|
};
|
|
|
|
export const logout = (): Promise<m.TLogoutResponse> => {
|
|
return request.post(endpoints.logout());
|
|
};
|
|
|
|
export const register = (payload: t.TRegisterUser) => {
|
|
return request.post(endpoints.register(), payload);
|
|
};
|
|
|
|
export const userKeyQuery = (name: string): Promise<t.TCheckUserKeyResponse> =>
|
|
request.get(endpoints.userKeyQuery(name));
|
|
|
|
export const getLoginGoogle = () => {
|
|
return request.get(endpoints.loginGoogle());
|
|
};
|
|
|
|
export const requestPasswordReset = (
|
|
payload: t.TRequestPasswordReset,
|
|
): Promise<t.TRequestPasswordResetResponse> => {
|
|
return request.post(endpoints.requestPasswordReset(), payload);
|
|
};
|
|
|
|
export const resetPassword = (payload: t.TResetPassword) => {
|
|
return request.post(endpoints.resetPassword(), payload);
|
|
};
|
|
|
|
export const verifyEmail = (payload: t.TVerifyEmail): Promise<t.VerifyEmailResponse> => {
|
|
return request.post(endpoints.verifyEmail(), payload);
|
|
};
|
|
|
|
export const resendVerificationEmail = (
|
|
payload: t.TResendVerificationEmail,
|
|
): Promise<t.VerifyEmailResponse> => {
|
|
return request.post(endpoints.resendVerificationEmail(), payload);
|
|
};
|
|
|
|
export const getAvailablePlugins = (): Promise<s.TPlugin[]> => {
|
|
return request.get(endpoints.plugins());
|
|
};
|
|
|
|
export const updateUserPlugins = (payload: t.TUpdateUserPlugins) => {
|
|
return request.post(endpoints.userPlugins(), payload);
|
|
};
|
|
|
|
/* Config */
|
|
|
|
export const getStartupConfig = (): Promise<config.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 = ({
|
|
version,
|
|
...data
|
|
}: a.AssistantCreateParams): Promise<a.Assistant> => {
|
|
return request.post(endpoints.assistants({ version }), data);
|
|
};
|
|
|
|
export const getAssistantById = ({
|
|
endpoint,
|
|
assistant_id,
|
|
version,
|
|
}: {
|
|
endpoint: s.AssistantsEndpoint;
|
|
assistant_id: string;
|
|
version: number | string | number;
|
|
}): Promise<a.Assistant> => {
|
|
return request.get(
|
|
endpoints.assistants({
|
|
path: assistant_id,
|
|
endpoint,
|
|
version,
|
|
}),
|
|
);
|
|
};
|
|
|
|
export const updateAssistant = ({
|
|
assistant_id,
|
|
data,
|
|
version,
|
|
}: {
|
|
assistant_id: string;
|
|
data: a.AssistantUpdateParams;
|
|
version: number | string;
|
|
}): Promise<a.Assistant> => {
|
|
return request.patch(
|
|
endpoints.assistants({
|
|
path: assistant_id,
|
|
version,
|
|
}),
|
|
data,
|
|
);
|
|
};
|
|
|
|
export const deleteAssistant = ({
|
|
assistant_id,
|
|
model,
|
|
endpoint,
|
|
version,
|
|
}: m.DeleteAssistantBody & { version: number | string }): Promise<void> => {
|
|
return request.delete(
|
|
endpoints.assistants({
|
|
path: assistant_id,
|
|
options: { model, endpoint },
|
|
version,
|
|
}),
|
|
);
|
|
};
|
|
|
|
export const listAssistants = (
|
|
params: a.AssistantListParams,
|
|
version: number | string,
|
|
): Promise<a.AssistantListResponse> => {
|
|
return request.get(
|
|
endpoints.assistants({
|
|
version,
|
|
options: params,
|
|
}),
|
|
);
|
|
};
|
|
|
|
export function getAssistantDocs({
|
|
endpoint,
|
|
version,
|
|
}: {
|
|
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,
|
|
options: { endpoint },
|
|
endpoint: endpoint as s.AssistantsEndpoint,
|
|
}),
|
|
);
|
|
}
|
|
|
|
/* Tools */
|
|
|
|
export const getAvailableTools = (
|
|
_endpoint: s.AssistantsEndpoint | s.EModelEndpoint.agents,
|
|
version?: number | string,
|
|
): Promise<s.TPlugin[]> => {
|
|
let path = '';
|
|
if (s.isAssistantsEndpoint(_endpoint)) {
|
|
const endpoint = _endpoint as s.AssistantsEndpoint;
|
|
path = endpoints.assistants({
|
|
path: 'tools',
|
|
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,
|
|
}),
|
|
);
|
|
};
|
|
|
|
/* Files */
|
|
|
|
export const getFiles = (): Promise<f.TFile[]> => {
|
|
return request.get(endpoints.files());
|
|
};
|
|
|
|
export const getFileConfig = (): Promise<f.FileConfig> => {
|
|
return request.get(`${endpoints.files()}/config`);
|
|
};
|
|
|
|
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 listAgents = (params: a.AgentListParams): Promise<a.AgentListResponse> => {
|
|
return request.get(
|
|
endpoints.agents({
|
|
options: params,
|
|
}),
|
|
);
|
|
};
|
|
|
|
export const revertAgentVersion = ({
|
|
agent_id,
|
|
version_index,
|
|
}: {
|
|
agent_id: string;
|
|
version_index: number;
|
|
}): Promise<a.Agent> => request.post(endpoints.revertAgentVersion(agent_id), { version_index });
|
|
|
|
/* 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.
|
|
*
|
|
* @param data - The FormData containing the file to import.
|
|
* @returns A Promise that resolves to the import start response.
|
|
*/
|
|
export const importConversationsFile = (data: FormData): Promise<t.TImportResponse> => {
|
|
return request.postMultiPart(endpoints.importConversation(), data);
|
|
};
|
|
|
|
export const uploadAvatar = (data: FormData): Promise<f.AvatarUploadResponse> => {
|
|
return request.postMultiPart(endpoints.avatar(), data);
|
|
};
|
|
|
|
export const uploadAssistantAvatar = (data: m.AssistantAvatarVariables): Promise<a.Assistant> => {
|
|
return request.postMultiPart(
|
|
endpoints.assistants({
|
|
isAvatar: true,
|
|
path: `${data.assistant_id}/avatar`,
|
|
options: { model: data.model, endpoint: data.endpoint },
|
|
version: data.version,
|
|
}),
|
|
data.formData,
|
|
);
|
|
};
|
|
|
|
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',
|
|
headers: {
|
|
Accept: 'application/octet-stream',
|
|
},
|
|
});
|
|
};
|
|
|
|
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: payload,
|
|
});
|
|
|
|
/* Speech */
|
|
|
|
export const speechToText = (data: FormData): Promise<f.SpeechToTextResponse> => {
|
|
return request.postMultiPart(endpoints.speechToText(), data);
|
|
};
|
|
|
|
export const textToSpeech = (data: FormData): Promise<ArrayBuffer> => {
|
|
return request.postTTS(endpoints.textToSpeechManual(), data);
|
|
};
|
|
|
|
export const getVoices = (): Promise<f.VoiceResponse> => {
|
|
return request.get(endpoints.textToSpeechVoices());
|
|
};
|
|
|
|
export const getCustomConfigSpeech = (): Promise<t.TCustomConfigSpeechResponse> => {
|
|
return request.get(endpoints.getCustomConfigSpeech());
|
|
};
|
|
|
|
/* conversations */
|
|
|
|
export function duplicateConversation(
|
|
payload: t.TDuplicateConvoRequest,
|
|
): Promise<t.TDuplicateConvoResponse> {
|
|
return request.post(endpoints.duplicateConversation(), payload);
|
|
}
|
|
|
|
export function forkConversation(payload: t.TForkConvoRequest): Promise<t.TForkConvoResponse> {
|
|
return request.post(endpoints.forkConversation(), payload);
|
|
}
|
|
|
|
export function deleteConversation(payload: t.TDeleteConversationRequest) {
|
|
return request.deleteWithOptions(endpoints.deleteConversation(), { data: { arg: payload } });
|
|
}
|
|
|
|
export function clearAllConversations(): Promise<unknown> {
|
|
return request.delete(endpoints.deleteAllConversation());
|
|
}
|
|
|
|
export const listConversations = (
|
|
params?: q.ConversationListParams,
|
|
): Promise<q.ConversationListResponse> => {
|
|
return request.get(endpoints.conversations(params ?? {}));
|
|
};
|
|
|
|
export function getConversations(cursor: string): Promise<t.TGetConversationsResponse> {
|
|
return request.get(endpoints.conversations({ cursor }));
|
|
}
|
|
|
|
export function getConversationById(id: string): Promise<s.TConversation> {
|
|
return request.get(endpoints.conversationById(id));
|
|
}
|
|
|
|
export function updateConversation(
|
|
payload: t.TUpdateConversationRequest,
|
|
): Promise<t.TUpdateConversationResponse> {
|
|
return request.post(endpoints.updateConversation(), { arg: payload });
|
|
}
|
|
|
|
export function archiveConversation(
|
|
payload: t.TArchiveConversationRequest,
|
|
): Promise<t.TArchiveConversationResponse> {
|
|
return request.post(endpoints.updateConversation(), { arg: payload });
|
|
}
|
|
|
|
export function genTitle(payload: m.TGenTitleRequest): Promise<m.TGenTitleResponse> {
|
|
return request.post(endpoints.genTitle(), payload);
|
|
}
|
|
|
|
export const listMessages = (params?: q.MessagesListParams): Promise<q.MessagesListResponse> => {
|
|
return request.get(endpoints.messages(params ?? {}));
|
|
};
|
|
|
|
export function updateMessage(payload: t.TUpdateMessageRequest): Promise<unknown> {
|
|
const { conversationId, messageId, text } = payload;
|
|
if (!conversationId) {
|
|
throw new Error('conversationId is required');
|
|
}
|
|
|
|
return request.put(endpoints.messages({ conversationId, messageId }), { text });
|
|
}
|
|
|
|
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 const editArtifact = async ({
|
|
messageId,
|
|
...params
|
|
}: m.TEditArtifactRequest): Promise<m.TEditArtifactResponse> => {
|
|
return request.post(`/api/messages/artifact/${messageId}`, params);
|
|
};
|
|
|
|
export function getMessagesByConvoId(conversationId: string): Promise<s.TMessage[]> {
|
|
if (
|
|
conversationId === config.Constants.NEW_CONVO ||
|
|
conversationId === config.Constants.PENDING_CONVO
|
|
) {
|
|
return Promise.resolve([]);
|
|
}
|
|
return request.get(endpoints.messages({ conversationId }));
|
|
}
|
|
|
|
export function getPrompt(id: string): Promise<{ prompt: t.TPrompt }> {
|
|
return request.get(endpoints.getPrompt(id));
|
|
}
|
|
|
|
export function getPrompts(filter: t.TPromptsWithFilterRequest): Promise<t.TPrompt[]> {
|
|
return request.get(endpoints.getPromptsWithFilters(filter));
|
|
}
|
|
|
|
export function getAllPromptGroups(): Promise<q.AllPromptGroupsResponse> {
|
|
return request.get(endpoints.getAllPromptGroups());
|
|
}
|
|
|
|
export function getPromptGroups(
|
|
filter: t.TPromptGroupsWithFilterRequest,
|
|
): Promise<t.PromptGroupListResponse> {
|
|
return request.get(endpoints.getPromptGroupsWithFilters(filter));
|
|
}
|
|
|
|
export function getPromptGroup(id: string): Promise<t.TPromptGroup> {
|
|
return request.get(endpoints.getPromptGroup(id));
|
|
}
|
|
|
|
export function createPrompt(payload: t.TCreatePrompt): Promise<t.TCreatePromptResponse> {
|
|
return request.post(endpoints.postPrompt(), payload);
|
|
}
|
|
|
|
export function updatePromptGroup(
|
|
variables: t.TUpdatePromptGroupVariables,
|
|
): Promise<t.TUpdatePromptGroupResponse> {
|
|
return request.patch(endpoints.updatePromptGroup(variables.id), variables.payload);
|
|
}
|
|
|
|
export function deletePrompt(payload: t.TDeletePromptVariables): Promise<t.TDeletePromptResponse> {
|
|
return request.delete(endpoints.deletePrompt(payload));
|
|
}
|
|
|
|
export function makePromptProduction(id: string): Promise<t.TMakePromptProductionResponse> {
|
|
return request.patch(endpoints.updatePromptTag(id));
|
|
}
|
|
|
|
export function updatePromptLabels(
|
|
variables: t.TUpdatePromptLabelsRequest,
|
|
): Promise<t.TUpdatePromptLabelsResponse> {
|
|
return request.patch(endpoints.updatePromptLabels(variables.id), variables.payload);
|
|
}
|
|
|
|
export function deletePromptGroup(id: string): Promise<t.TDeletePromptGroupResponse> {
|
|
return request.delete(endpoints.deletePromptGroup(id));
|
|
}
|
|
|
|
export function getCategories(): Promise<t.TGetCategoriesResponse> {
|
|
return request.get(endpoints.getCategories());
|
|
}
|
|
|
|
export function getRandomPrompts(
|
|
variables: t.TGetRandomPromptsRequest,
|
|
): Promise<t.TGetRandomPromptsResponse> {
|
|
return request.get(endpoints.getRandomPrompts(variables.limit, variables.skip));
|
|
}
|
|
|
|
/* Roles */
|
|
export function getRole(roleName: string): Promise<r.TRole> {
|
|
return request.get(endpoints.getRole(roleName));
|
|
}
|
|
|
|
export function updatePromptPermissions(
|
|
variables: m.UpdatePromptPermVars,
|
|
): 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);
|
|
}
|