dify/web/service/base.ts

412 lines
13 KiB
TypeScript
Raw Normal View History

/* eslint-disable no-new, prefer-promise-reject-errors */
import { API_PREFIX, IS_CE_EDITION, PUBLIC_API_PREFIX } from '@/config'
2023-05-15 08:51:32 +08:00
import Toast from '@/app/components/base/toast'
2023-09-09 19:17:12 +08:00
import type { MessageEnd, ThoughtItem } from '@/app/components/app/chat/type'
2023-05-15 08:51:32 +08:00
const TIME_OUT = 100000
const ContentType = {
json: 'application/json',
stream: 'text/event-stream',
form: 'application/x-www-form-urlencoded; charset=UTF-8',
download: 'application/octet-stream', // for download
upload: 'multipart/form-data', // for upload
}
const baseOptions = {
method: 'GET',
mode: 'cors',
credentials: 'include', // always send cookies、HTTP Basic authentication.
headers: new Headers({
'Content-Type': ContentType.json,
}),
redirect: 'follow',
}
export type IOnDataMoreInfo = {
2023-06-12 16:37:03 +08:00
conversationId?: string
taskId?: string
2023-05-15 08:51:32 +08:00
messageId: string
errorMessage?: string
errorCode?: string
2023-05-15 08:51:32 +08:00
}
export type IOnData = (message: string, isFirstMessage: boolean, moreInfo: IOnDataMoreInfo) => void
export type IOnThought = (though: ThoughtItem) => void
2023-09-09 19:17:12 +08:00
export type IOnMessageEnd = (messageEnd: MessageEnd) => void
2023-05-15 08:51:32 +08:00
export type IOnCompleted = (hasError?: boolean) => void
export type IOnError = (msg: string, code?: string) => void
2023-05-15 08:51:32 +08:00
type IOtherOptions = {
isPublicAPI?: boolean
2023-07-07 17:50:42 +08:00
bodyStringify?: boolean
2023-05-15 08:51:32 +08:00
needAllResponseContent?: boolean
2023-07-07 17:50:42 +08:00
deleteContentType?: boolean
2023-05-15 08:51:32 +08:00
onData?: IOnData // for stream
onThought?: IOnThought
2023-09-09 19:17:12 +08:00
onMessageEnd?: IOnMessageEnd
2023-05-15 08:51:32 +08:00
onError?: IOnError
onCompleted?: IOnCompleted // for stream
getAbortController?: (abortController: AbortController) => void
}
function unicodeToChar(text: string) {
if (!text)
return ''
2023-05-15 08:51:32 +08:00
return text.replace(/\\u[0-9a-f]{4}/g, (_match, p1) => {
return String.fromCharCode(parseInt(p1, 16))
})
}
export function format(text: string) {
let res = text.trim()
if (res.startsWith('\n'))
2023-05-15 08:51:32 +08:00
res = res.replace('\n', '')
2023-05-15 08:51:32 +08:00
return res.replaceAll('\n', '<br/>').replaceAll('```', '')
}
2023-09-09 19:17:12 +08:00
const handleStream = (response: any, onData: IOnData, onCompleted?: IOnCompleted, onThought?: IOnThought, onMessageEnd?: IOnMessageEnd) => {
2023-05-15 08:51:32 +08:00
if (!response.ok)
throw new Error('Network response was not ok')
const reader = response.body.getReader()
const decoder = new TextDecoder('utf-8')
let buffer = ''
let bufferObj: any
let isFirstMessage = true
function read() {
let hasError = false
reader.read().then((result: any) => {
if (result.done) {
onCompleted && onCompleted()
return
}
buffer += decoder.decode(result.value, { stream: true })
const lines = buffer.split('\n')
try {
lines.forEach((message) => {
if (message.startsWith('data: ')) { // check if it starts with data:
try {
bufferObj = JSON.parse(message.substring(6)) // remove data: and parse as json
}
catch (e) {
// mute handle message cut off
onData('', isFirstMessage, {
conversationId: bufferObj?.conversation_id,
messageId: bufferObj?.id,
})
return
}
if (bufferObj.status === 400 || !bufferObj.event) {
2023-05-15 08:51:32 +08:00
onData('', false, {
conversationId: undefined,
messageId: '',
errorMessage: bufferObj.message,
errorCode: bufferObj.code,
2023-05-15 08:51:32 +08:00
})
hasError = true
onCompleted && onCompleted(true)
return
}
if (bufferObj.event === 'message') {
// can not use format here. Because message is splited.
onData(unicodeToChar(bufferObj.answer), isFirstMessage, {
conversationId: bufferObj.conversation_id,
taskId: bufferObj.task_id,
messageId: bufferObj.id,
})
isFirstMessage = false
}
else if (bufferObj.event === 'agent_thought') {
onThought?.(bufferObj as any)
}
2023-09-09 19:17:12 +08:00
else if (bufferObj.event === 'message_end') {
onMessageEnd?.(bufferObj as any)
}
2023-05-15 08:51:32 +08:00
}
})
buffer = lines[lines.length - 1]
}
catch (e) {
2023-05-15 08:51:32 +08:00
onData('', false, {
conversationId: undefined,
messageId: '',
errorMessage: `${e}`,
2023-05-15 08:51:32 +08:00
})
hasError = true
onCompleted && onCompleted(true)
return
}
if (!hasError)
2023-05-15 08:51:32 +08:00
read()
})
}
read()
}
2023-05-18 10:50:34 +08:00
const baseFetch = (
url: string,
fetchOptions: any,
{
isPublicAPI = false,
2023-07-07 17:50:42 +08:00
bodyStringify = true,
needAllResponseContent,
2023-07-07 17:50:42 +08:00
deleteContentType,
}: IOtherOptions,
2023-05-18 10:50:34 +08:00
) => {
2023-05-15 08:51:32 +08:00
const options = Object.assign({}, baseOptions, fetchOptions)
if (isPublicAPI) {
const sharedToken = globalThis.location.pathname.split('/').slice(-1)[0]
const accessToken = localStorage.getItem('token') || JSON.stringify({ [sharedToken]: '' })
let accessTokenJson = { [sharedToken]: '' }
try {
accessTokenJson = JSON.parse(accessToken)
}
catch (e) {
}
options.headers.set('Authorization', `Bearer ${accessTokenJson[sharedToken]}`)
2023-05-15 08:51:32 +08:00
}
2023-07-07 17:50:42 +08:00
if (deleteContentType) {
options.headers.delete('Content-Type')
}
else {
const contentType = options.headers.get('Content-Type')
if (!contentType)
options.headers.set('Content-Type', ContentType.json)
}
const urlPrefix = isPublicAPI ? PUBLIC_API_PREFIX : API_PREFIX
2023-05-15 08:51:32 +08:00
let urlWithPrefix = `${urlPrefix}${url.startsWith('/') ? url : `/${url}`}`
const { method, params, body } = options
// handle query
if (method === 'GET' && params) {
const paramsArray: string[] = []
Object.keys(params).forEach(key =>
paramsArray.push(`${key}=${encodeURIComponent(params[key])}`),
)
if (urlWithPrefix.search(/\?/) === -1)
urlWithPrefix += `?${paramsArray.join('&')}`
else
urlWithPrefix += `&${paramsArray.join('&')}`
delete options.params
}
2023-07-07 17:50:42 +08:00
if (body && bodyStringify)
2023-05-15 08:51:32 +08:00
options.body = JSON.stringify(body)
// Handle timeout
return Promise.race([
new Promise((resolve, reject) => {
setTimeout(() => {
reject(new Error('request timeout'))
}, TIME_OUT)
}),
new Promise((resolve, reject) => {
globalThis.fetch(urlWithPrefix, options)
.then((res: any) => {
const resClone = res.clone()
// Error handler
if (!/^(2|3)\d{2}$/.test(res.status)) {
const bodyJson = res.json()
switch (res.status) {
case 401: {
if (isPublicAPI) {
Toast.notify({ type: 'error', message: 'Invalid token' })
return bodyJson.then((data: any) => Promise.reject(data))
2023-05-15 08:51:32 +08:00
}
const loginUrl = `${globalThis.location.origin}/signin`
if (IS_CE_EDITION) {
bodyJson.then((data: any) => {
if (data.code === 'not_setup') {
globalThis.location.href = `${globalThis.location.origin}/install`
}
else {
2023-05-15 08:51:32 +08:00
if (location.pathname === '/signin') {
bodyJson.then((data: any) => {
Toast.notify({ type: 'error', message: data.message })
})
}
else {
2023-05-15 08:51:32 +08:00
globalThis.location.href = loginUrl
}
}
})
return Promise.reject()
}
globalThis.location.href = loginUrl
break
}
case 403:
new Promise(() => {
bodyJson.then((data: any) => {
Toast.notify({ type: 'error', message: data.message })
if (data.code === 'already_setup')
2023-05-15 08:51:32 +08:00
globalThis.location.href = `${globalThis.location.origin}/signin`
})
})
break
// fall through
default:
new Promise(() => {
bodyJson.then((data: any) => {
Toast.notify({ type: 'error', message: data.message })
})
})
}
return Promise.reject(resClone)
}
// handle delete api. Delete api not return content.
if (res.status === 204) {
resolve({ result: 'success' })
2023-05-15 08:51:32 +08:00
return
}
// return data
const data = options.headers.get('Content-type') === ContentType.download ? res.blob() : res.json()
resolve(needAllResponseContent ? resClone : data)
})
.catch((err) => {
Toast.notify({ type: 'error', message: err })
reject(err)
})
}),
])
}
export const upload = (options: any): Promise<any> => {
const defaultOptions = {
method: 'POST',
url: `${API_PREFIX}/files/upload`,
headers: {},
data: {},
}
options = {
...defaultOptions,
...options,
headers: { ...defaultOptions.headers, ...options.headers },
}
return new Promise((resolve, reject) => {
2023-05-15 08:51:32 +08:00
const xhr = options.xhr
xhr.open(options.method, options.url)
for (const key in options.headers)
xhr.setRequestHeader(key, options.headers[key])
2023-05-15 08:51:32 +08:00
xhr.withCredentials = true
xhr.responseType = 'json'
xhr.onreadystatechange = function () {
if (xhr.readyState === 4) {
if (xhr.status === 201)
2023-05-15 08:51:32 +08:00
resolve(xhr.response)
else
2023-05-15 08:51:32 +08:00
reject(xhr)
}
}
xhr.upload.onprogress = options.onprogress
xhr.send(options.data)
})
}
2023-09-09 19:17:12 +08:00
export const ssePost = (url: string, fetchOptions: any, { isPublicAPI = false, onData, onCompleted, onThought, onMessageEnd, onError, getAbortController }: IOtherOptions) => {
2023-05-15 08:51:32 +08:00
const abortController = new AbortController()
const options = Object.assign({}, baseOptions, {
method: 'POST',
signal: abortController.signal,
}, fetchOptions)
2023-07-07 17:50:42 +08:00
const contentType = options.headers.get('Content-Type')
if (!contentType)
options.headers.set('Content-Type', ContentType.json)
2023-05-15 08:51:32 +08:00
getAbortController?.(abortController)
const urlPrefix = isPublicAPI ? PUBLIC_API_PREFIX : API_PREFIX
const urlWithPrefix = `${urlPrefix}${url.startsWith('/') ? url : `/${url}`}`
const { body } = options
if (body)
options.body = JSON.stringify(body)
globalThis.fetch(urlWithPrefix, options)
.then((res: any) => {
// debugger
if (!/^(2|3)\d{2}$/.test(res.status)) {
new Promise(() => {
res.json().then((data: any) => {
Toast.notify({ type: 'error', message: data.message || 'Server Error' })
})
})
onError?.('Server Error')
return
}
return handleStream(res, (str: string, isFirstMessage: boolean, moreInfo: IOnDataMoreInfo) => {
if (moreInfo.errorMessage) {
// debugger
onError?.(moreInfo.errorMessage, moreInfo.errorCode)
if (moreInfo.errorMessage !== 'AbortError: The user aborted a request.')
Toast.notify({ type: 'error', message: moreInfo.errorMessage })
2023-05-15 08:51:32 +08:00
return
}
onData?.(str, isFirstMessage, moreInfo)
2023-09-09 19:17:12 +08:00
}, onCompleted, onThought, onMessageEnd)
2023-05-15 08:51:32 +08:00
}).catch((e) => {
if (e.toString() !== 'AbortError: The user aborted a request.')
Toast.notify({ type: 'error', message: e })
2023-05-15 08:51:32 +08:00
onError?.(e)
})
}
export const request = (url: string, options = {}, otherOptions?: IOtherOptions) => {
return baseFetch(url, options, otherOptions || {})
}
export const get = (url: string, options = {}, otherOptions?: IOtherOptions) => {
return request(url, Object.assign({}, options, { method: 'GET' }), otherOptions)
}
// For public API
export const getPublic = (url: string, options = {}, otherOptions?: IOtherOptions) => {
return get(url, options, { ...otherOptions, isPublicAPI: true })
}
export const post = (url: string, options = {}, otherOptions?: IOtherOptions) => {
return request(url, Object.assign({}, options, { method: 'POST' }), otherOptions)
}
export const postPublic = (url: string, options = {}, otherOptions?: IOtherOptions) => {
return post(url, options, { ...otherOptions, isPublicAPI: true })
}
export const put = (url: string, options = {}, otherOptions?: IOtherOptions) => {
return request(url, Object.assign({}, options, { method: 'PUT' }), otherOptions)
}
export const putPublic = (url: string, options = {}, otherOptions?: IOtherOptions) => {
return put(url, options, { ...otherOptions, isPublicAPI: true })
}
export const del = (url: string, options = {}, otherOptions?: IOtherOptions) => {
return request(url, Object.assign({}, options, { method: 'DELETE' }), otherOptions)
}
export const delPublic = (url: string, options = {}, otherOptions?: IOtherOptions) => {
return del(url, options, { ...otherOptions, isPublicAPI: true })
}
export const patch = (url: string, options = {}, otherOptions?: IOtherOptions) => {
return request(url, Object.assign({}, options, { method: 'PATCH' }), otherOptions)
}
export const patchPublic = (url: string, options = {}, otherOptions?: IOtherOptions) => {
return patch(url, options, { ...otherOptions, isPublicAPI: true })
}