1632 lines
31 KiB
TypeScript
1632 lines
31 KiB
TypeScript
import { WEBUI_API_BASE_URL } from '$lib/constants';
|
|
import { getTimeRange } from '$lib/utils';
|
|
|
|
export const getChatConfig = async (token: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/config`, {
|
|
method: 'GET',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const updateChatConfig = async (token: string, config: object) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/config`, {
|
|
method: 'POST',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
},
|
|
body: JSON.stringify(config)
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const createNewChat = async (
|
|
token: string,
|
|
chat: object,
|
|
folderId: string | null,
|
|
variables: object | null = null
|
|
) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/new`, {
|
|
method: 'POST',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
authorization: `Bearer ${token}`
|
|
},
|
|
body: JSON.stringify({
|
|
chat: chat,
|
|
...(variables !== null ? { variables } : {}),
|
|
folder_id: folderId ?? null
|
|
})
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const unarchiveAllChats = async (token: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/unarchive/all`, {
|
|
method: 'POST',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err.detail;
|
|
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const unshareAllChats = async (token: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/share/all`, {
|
|
method: 'DELETE',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err.detail;
|
|
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const importChats = async (token: string, chats: object[]) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/import`, {
|
|
method: 'POST',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
authorization: `Bearer ${token}`
|
|
},
|
|
body: JSON.stringify({
|
|
chats
|
|
})
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const getChatList = async (
|
|
token: string = '',
|
|
page: number | null = null,
|
|
include_pinned: boolean = false,
|
|
include_folders: boolean = false
|
|
) => {
|
|
let error = null;
|
|
const searchParams = new URLSearchParams();
|
|
|
|
if (page !== null) {
|
|
searchParams.append('page', `${page}`);
|
|
}
|
|
|
|
if (include_folders) {
|
|
searchParams.append('include_folders', 'true');
|
|
}
|
|
|
|
if (include_pinned) {
|
|
searchParams.append('include_pinned', 'true');
|
|
}
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/?${searchParams.toString()}`, {
|
|
method: 'GET',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
if (!res) {
|
|
return [];
|
|
}
|
|
|
|
return res.map((chat) => ({
|
|
...chat,
|
|
time_range: getTimeRange(chat.updated_at)
|
|
}));
|
|
};
|
|
|
|
export const getChatListByUserId = async (
|
|
token: string = '',
|
|
userId: string,
|
|
page: number = 1,
|
|
filter?: object
|
|
) => {
|
|
let error = null;
|
|
|
|
const searchParams = new URLSearchParams();
|
|
|
|
searchParams.append('page', `${page}`);
|
|
|
|
if (filter) {
|
|
Object.entries(filter).forEach(([key, value]) => {
|
|
if (value !== undefined && value !== null) {
|
|
searchParams.append(key, value.toString());
|
|
}
|
|
});
|
|
}
|
|
|
|
const res = await fetch(
|
|
`${WEBUI_API_BASE_URL}/chats/list/user/${userId}?${searchParams.toString()}`,
|
|
{
|
|
method: 'GET',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
}
|
|
)
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res.map((chat) => ({
|
|
...chat,
|
|
time_range: getTimeRange(chat.updated_at)
|
|
}));
|
|
};
|
|
|
|
export const getArchivedChatList = async (
|
|
token: string = '',
|
|
page: number = 1,
|
|
filter?: object
|
|
) => {
|
|
let error = null;
|
|
|
|
const searchParams = new URLSearchParams();
|
|
searchParams.append('page', `${page}`);
|
|
|
|
if (filter) {
|
|
Object.entries(filter).forEach(([key, value]) => {
|
|
if (value !== undefined && value !== null) {
|
|
searchParams.append(key, value.toString());
|
|
}
|
|
});
|
|
}
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/archived?${searchParams.toString()}`, {
|
|
method: 'GET',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res.map((chat) => ({
|
|
...chat,
|
|
time_range: getTimeRange(chat.updated_at)
|
|
}));
|
|
};
|
|
|
|
export const getArchivedChatCount = async (token: string = '') => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/archived/count`, {
|
|
method: 'GET',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const getSharedChatList = async (token: string = '', page: number = 1, filter?: object) => {
|
|
let error = null;
|
|
|
|
const searchParams = new URLSearchParams();
|
|
searchParams.append('page', `${page}`);
|
|
|
|
if (filter) {
|
|
Object.entries(filter).forEach(([key, value]) => {
|
|
if (value !== undefined && value !== null) {
|
|
searchParams.append(key, value.toString());
|
|
}
|
|
});
|
|
}
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/shared?${searchParams.toString()}`, {
|
|
method: 'GET',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res.map((chat) => ({
|
|
...chat,
|
|
time_range: getTimeRange(chat.updated_at)
|
|
}));
|
|
};
|
|
|
|
export const getAllChats = async (token: string) => {
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/all`, {
|
|
method: 'GET',
|
|
headers: {
|
|
Accept: 'application/x-ndjson',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
});
|
|
|
|
if (!res.ok) {
|
|
const err = await res.json();
|
|
console.error(err);
|
|
throw err;
|
|
}
|
|
|
|
const reader = res.body?.getReader();
|
|
if (!reader) {
|
|
throw new Error('Response body is not readable');
|
|
}
|
|
|
|
const decoder = new TextDecoder();
|
|
const chats: object[] = [];
|
|
let buffer = '';
|
|
|
|
while (true) {
|
|
const { done, value } = await reader.read();
|
|
if (done) break;
|
|
|
|
buffer += decoder.decode(value, { stream: true });
|
|
const lines = buffer.split('\n');
|
|
// Keep the last potentially incomplete line in the buffer
|
|
buffer = lines.pop() ?? '';
|
|
|
|
for (const line of lines) {
|
|
const trimmed = line.trim();
|
|
if (trimmed) {
|
|
chats.push(JSON.parse(trimmed));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Process any remaining data in the buffer
|
|
const remaining = buffer.trim();
|
|
if (remaining) {
|
|
chats.push(JSON.parse(remaining));
|
|
}
|
|
|
|
return chats;
|
|
};
|
|
|
|
export const getChatListBySearchText = async (token: string, text: string, page: number = 1) => {
|
|
let error = null;
|
|
|
|
const searchParams = new URLSearchParams();
|
|
searchParams.append('text', text);
|
|
searchParams.append('page', `${page}`);
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/search?${searchParams.toString()}`, {
|
|
method: 'GET',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res.map((chat) => ({
|
|
...chat,
|
|
time_range: getTimeRange(chat.updated_at)
|
|
}));
|
|
};
|
|
|
|
export const getChatsByFolderId = async (token: string, folderId: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/folder/${folderId}`, {
|
|
method: 'GET',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const getChatListByFolderId = async (token: string, folderId: string, page: number = 1) => {
|
|
let error = null;
|
|
|
|
const searchParams = new URLSearchParams();
|
|
if (page !== null) {
|
|
searchParams.append('page', `${page}`);
|
|
}
|
|
|
|
const res = await fetch(
|
|
`${WEBUI_API_BASE_URL}/chats/folder/${folderId}/list?${searchParams.toString()}`,
|
|
{
|
|
method: 'GET',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
}
|
|
)
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const getAllArchivedChats = async (token: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/all/archived`, {
|
|
method: 'GET',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const getAllUserChats = async (token: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/all/db`, {
|
|
method: 'GET',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const getAllTags = async (token: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/all/tags`, {
|
|
method: 'GET',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const getPinnedChatList = async (token: string = '') => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/pinned`, {
|
|
method: 'GET',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res.map((chat) => ({
|
|
...chat,
|
|
time_range: getTimeRange(chat.updated_at)
|
|
}));
|
|
};
|
|
|
|
export const getChatListByTagName = async (token: string = '', tagName: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/tags`, {
|
|
method: 'POST',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
},
|
|
body: JSON.stringify({
|
|
name: tagName
|
|
})
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res.map((chat) => ({
|
|
...chat,
|
|
time_range: getTimeRange(chat.updated_at)
|
|
}));
|
|
};
|
|
|
|
export const getChatById = async (token: string, id: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/${id}`, {
|
|
method: 'GET',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err.detail;
|
|
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const getChatByShareId = async (token: string, share_id: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/share/${share_id}`, {
|
|
method: 'GET',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const getChatPinnedStatusById = async (token: string, id: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/${id}/pinned`, {
|
|
method: 'GET',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
|
|
if ('detail' in err) {
|
|
error = err.detail;
|
|
} else {
|
|
error = err;
|
|
}
|
|
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const toggleChatPinnedStatusById = async (token: string, id: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/${id}/pin`, {
|
|
method: 'POST',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
|
|
if ('detail' in err) {
|
|
error = err.detail;
|
|
} else {
|
|
error = err;
|
|
}
|
|
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const markChatUnreadById = async (token: string, id: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/${id}/unread`, {
|
|
method: 'POST',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.catch((err) => {
|
|
error = 'detail' in err ? err.detail : err;
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const cloneChatById = async (token: string, id: string, title?: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/${id}/clone`, {
|
|
method: 'POST',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
},
|
|
body: JSON.stringify({
|
|
...(title && { title: title })
|
|
})
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
|
|
if ('detail' in err) {
|
|
error = err.detail;
|
|
} else {
|
|
error = err;
|
|
}
|
|
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const forkChatById = async (token: string, id: string, messageId?: string | null) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/${id}/fork`, {
|
|
method: 'POST',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
},
|
|
body: JSON.stringify({
|
|
message_id: messageId ?? null
|
|
})
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
|
|
if ('detail' in err) {
|
|
error = err.detail;
|
|
} else {
|
|
error = err;
|
|
}
|
|
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const cloneSharedChatById = async (token: string, id: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/${id}/clone/shared`, {
|
|
method: 'POST',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
|
|
if ('detail' in err) {
|
|
error = err.detail;
|
|
} else {
|
|
error = err;
|
|
}
|
|
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const shareChatById = async (token: string, id: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/${id}/share`, {
|
|
method: 'POST',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const updateChatFolderIdById = async (token: string, id: string, folderId?: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/${id}/folder`, {
|
|
method: 'POST',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
},
|
|
body: JSON.stringify({
|
|
folder_id: folderId
|
|
})
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const archiveChatById = async (token: string, id: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/${id}/archive`, {
|
|
method: 'POST',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const deleteSharedChatById = async (token: string, id: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/${id}/share`, {
|
|
method: 'DELETE',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const updateChatAccessGrants = async (token: string, id: string, accessGrants: object[]) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/shared/${id}/access/update`, {
|
|
method: 'POST',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
},
|
|
body: JSON.stringify({
|
|
access_grants: accessGrants
|
|
})
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const getChatAccessGrants = async (token: string, id: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/shared/${id}/access`, {
|
|
method: 'GET',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const updateChatById = async (
|
|
token: string,
|
|
id: string,
|
|
chat: object,
|
|
variables: object | null = null
|
|
) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/${id}`, {
|
|
method: 'POST',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
},
|
|
body: JSON.stringify({
|
|
chat: chat,
|
|
...(variables !== null ? { variables } : {})
|
|
})
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const compactChatById = async (token: string, id: string, model?: string | null) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/${id}/compact`, {
|
|
method: 'POST',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
},
|
|
body: JSON.stringify({ model })
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const deleteChatMessageById = async (token: string, id: string, messageId: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/${id}/messages/${messageId}`, {
|
|
method: 'DELETE',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const deleteChatById = async (token: string, id: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/${id}`, {
|
|
method: 'DELETE',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err.detail;
|
|
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const getTagsById = async (token: string, id: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/${id}/tags`, {
|
|
method: 'GET',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const addTagById = async (token: string, id: string, tagName: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/${id}/tags`, {
|
|
method: 'POST',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
},
|
|
body: JSON.stringify({
|
|
name: tagName
|
|
})
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err.detail;
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const deleteTagById = async (token: string, id: string, tagName: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/${id}/tags`, {
|
|
method: 'DELETE',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
},
|
|
body: JSON.stringify({
|
|
name: tagName
|
|
})
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const deleteAllChats = async (token: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/`, {
|
|
method: 'DELETE',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err.detail;
|
|
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const archiveAllChats = async (token: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/archive/all`, {
|
|
method: 'POST',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err.detail;
|
|
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
export const exportChatStats = async (token: string, page: number = 1, params: object = {}) => {
|
|
let error = null;
|
|
|
|
const searchParams = new URLSearchParams();
|
|
searchParams.append('page', `${page}`);
|
|
|
|
if (params) {
|
|
for (const [key, value] of Object.entries(params)) {
|
|
searchParams.append(key, `${value}`);
|
|
}
|
|
}
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/stats/export?${searchParams.toString()}`, {
|
|
method: 'GET',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const exportSingleChatStats = async (token: string, chatId: string) => {
|
|
let error = null;
|
|
|
|
const res = await fetch(`${WEBUI_API_BASE_URL}/chats/stats/export/${chatId}`, {
|
|
method: 'GET',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
...(token && { authorization: `Bearer ${token}` })
|
|
}
|
|
})
|
|
.then(async (res) => {
|
|
if (!res.ok) throw await res.json();
|
|
return res.json();
|
|
})
|
|
.then((json) => {
|
|
return json;
|
|
})
|
|
.catch((err) => {
|
|
error = err;
|
|
console.error(err);
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
export const downloadChatStats = async (
|
|
token: string = '',
|
|
updated_at: number | null = null
|
|
): Promise<[Response | null, AbortController]> => {
|
|
const controller = new AbortController();
|
|
let error = null;
|
|
|
|
let url = `${WEBUI_API_BASE_URL}/chats/stats/export?stream=true`;
|
|
if (updated_at) url += `&updated_at=${updated_at}`;
|
|
|
|
const res = await fetch(url, {
|
|
signal: controller.signal,
|
|
method: 'GET',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
Authorization: `Bearer ${token}`
|
|
}
|
|
}).catch((err) => {
|
|
console.error(err);
|
|
error = err;
|
|
return null;
|
|
});
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return [res, controller];
|
|
};
|