[feat] added abort

src/lib/ChatScreens/DefaultChatScreen.svelte

@@ -143,10 +143,13 @@
         }
     }
 
+    let abortController:null|AbortController = null
+
     async function sendChatMain(saveReroll = false) {
         messageInput = ''
+        abortController = new AbortController()
         try {
-            await sendChat()            
+            await sendChat(-1, {signal:abortController.signal})            
         } catch (error) {
             console.error(error)
             alertError(`${error}`)
@@ -161,6 +164,13 @@
         }
     }
 
+    function abortChat(){
+        if(abortController){
+            console.log('abort')
+            abortController.abort()
+        }
+    }
+
     async function runAutoMode() {
         if(autoMode){
             autoMode = false
@@ -323,7 +333,7 @@
                 
                 {#if $doingChat || doingChatInputTranslate}
                     <div
-                        class="mr-2 bg-selected flex justify-center items-center text-white w-12 h-12 rounded-md hover:bg-green-500 transition-colors">
+                        class="mr-2 bg-selected flex justify-center items-center text-white w-12 h-12 rounded-md hover:bg-green-500 transition-colors" on:click={abortChat}>
                         <div class="loadmove" class:autoload={autoMode}>
                         </div>
                     </div>

src/ts/process/index.ts

@@ -32,9 +32,14 @@ export interface OpenAIChatFull extends OpenAIChat{
 }
 
 export const doingChat = writable(false)
+export const abortChat = writable(false)
 
-export async function sendChat(chatProcessIndex = -1,arg:{chatAdditonalTokens?:number} = {}):Promise<boolean> {
+export async function sendChat(chatProcessIndex = -1,arg:{chatAdditonalTokens?:number,signal?:AbortSignal} = {}):Promise<boolean> {
 
+
+    const abortSignal = arg.signal ?? (new AbortController()).signal
+
+    let isAborted = false
     let findCharCache:{[key:string]:character} = {}
     function findCharacterbyIdwithCache(id:string){
         const d = findCharCache[id]
@@ -98,7 +103,8 @@ export async function sendChat(chatProcessIndex = -1,arg:{chatAdditonalTokens?:n
             }
             for(let i=0;i<order.length;i++){
                 const r = await sendChat(order[i].index, {
-                    chatAdditonalTokens: caculatedChatTokens
+                    chatAdditonalTokens: caculatedChatTokens,
+                    signal: abortSignal
                 })
                 if(!r){
                     return false
@@ -416,12 +422,15 @@ export async function sendChat(chatProcessIndex = -1,arg:{chatAdditonalTokens?:n
         bias: bias,
         currentChar: currentChar,
         useStreaming: true,
-        isGroupChat: nowChatroom.type === 'group'
+        isGroupChat: nowChatroom.type === 'group',
-    }, 'model')
+    }, 'model', abortSignal)
 
     let result = ''
     let emoChanged = false
-
+    
+    if(abortSignal.aborted === true){
+        return false
+    }
     if(req.type === 'fail'){
         alertError(req.result)
         return false
@@ -435,7 +444,7 @@ export async function sendChat(chatProcessIndex = -1,arg:{chatAdditonalTokens?:n
             data: "",
             saying: currentChar.chaId
         })
-        while(true){
+        while(abortSignal.aborted === false){
             const readed = (await reader.read())
             if(readed.value){
                 result = readed.value
@@ -495,7 +504,7 @@ export async function sendChat(chatProcessIndex = -1,arg:{chatAdditonalTokens?:n
         }
     }
 
-    if(currentChar.viewScreen === 'emotion' && (!emoChanged)){
+    if(currentChar.viewScreen === 'emotion' && (!emoChanged) && (abortSignal.aborted === false)){
 
         let currentEmotion = currentChar.emotionImages
 
@@ -569,9 +578,12 @@ export async function sendChat(chatProcessIndex = -1,arg:{chatAdditonalTokens?:n
             currentChar: currentChar,
             temperature: 0.4,
             maxTokens: 30,
-        }, 'submodel')
+        }, 'submodel', abortSignal)
 
         if(rq.type === 'fail' || rq.type === 'streaming' || rq.type === 'multiline'){
+            if(abortSignal.aborted){
+                return true
+            }
             alertError(`${rq.result}`)
             return true
         }

src/ts/storage/globalApi.ts

@@ -455,6 +455,14 @@ export async function globalFetch(url:string, arg:{
         const method = arg.method ?? "POST"
         db.requestmet = "normal"
     
+        if(arg.abortSignal && arg.abortSignal.aborted){
+            return {
+                ok: false,
+                data: 'aborted',
+                headers: {}
+            }
+        }
+        
         function addFetchLog(response:any, success:boolean){
             try{
                 fetchLog.unshift({
@@ -522,69 +530,10 @@ export async function globalFetch(url:string, arg:{
             }
         }
         if(isTauri){
-            if(db.requester === 'pure_reqwest'){
-                try {
-                    let preHeader = arg.headers ?? {}
-                    let body:any
-                    if(arg.body instanceof URLSearchParams){
-                        const argBody = arg.body as URLSearchParams
-                        body = argBody.toString()
-                        preHeader["Content-Type"] =  `application/x-www-form-urlencoded`
-                    }
-                    else{
-                        body = JSON.stringify(arg.body)
-                        preHeader["Content-Type"] = `application/json`
-                    }
-                    console.log(body)
-                    const header = JSON.stringify(preHeader)
-                    const res:string = await invoke('native_request', {url:url, body:body, header:header, method: method})
-                    const d:{
-                        success: boolean
-                        body:string,
-                        headers: {[key:string]:string}
-                    } = JSON.parse(res)
-
-                    const resHeader = d.headers ?? {}
-                     
-                    if(!d.success){
-                        addFetchLog(Buffer.from(d.body, 'base64').toString('utf-8'), false)
-                        return {
-                            ok:false,
-                            data: Buffer.from(d.body, 'base64').toString('utf-8'),
-                            headers: resHeader
-                        }
-                    }
-                    else{
-                        if(arg.rawResponse){
-                            addFetchLog("Uint8Array Response", true)
-                            return {
-                                ok:true,
-                                data: new Uint8Array(Buffer.from(d.body, 'base64')),
-                                headers: resHeader
-                            }
-                        }
-                        else{
-                            addFetchLog(JSON.parse(Buffer.from(d.body, 'base64').toString('utf-8')), true)
-                            return {
-                                ok:true,
-                                data: JSON.parse(Buffer.from(d.body, 'base64').toString('utf-8')),
-                                headers: resHeader
-                            }
-                        }
-                    }   
-                } catch (error) {
-                    return {
-                        ok: false,
-                        data: `${error}`,
-                        headers: {}
-                    }
-                }
-            }
-    
             const body = (!arg.body) ? null :
                 (arg.body instanceof URLSearchParams) ? (Body.text(arg.body.toString())) : (Body.json(arg.body))
             const headers = arg.headers ?? {}
-            const d = await TauriFetch(url, {
+            const fetchPromise = TauriFetch(url, {
                 body: body,
                 method: method,
                 headers: headers,
@@ -595,20 +544,43 @@ export async function globalFetch(url:string, arg:{
                 responseType: arg.rawResponse ? ResponseType.Binary : ResponseType.JSON,
                 
             })
-            if(arg.rawResponse){
+
-                addFetchLog("Uint8Array Response", d.ok)
+            //abort the promise when abort signal is triggered
+            let abortFn:() => void = () => {}
+
+            const abortPromise = (new Promise<"aborted">((res,rej) => {
+                abortFn = () => {
+                    res("aborted")
+                }
+                arg.abortSignal?.addEventListener('abort', abortFn)
+            }))
+
+            const result = await Promise.any([fetchPromise,abortPromise])
+
+            arg.abortSignal.removeEventListener('abort', abortFn)
+
+            if(result === 'aborted'){
                 return {
-                    ok: d.ok,
+                    ok: false,
-                    data: new Uint8Array(d.data as number[]),
+                    data: 'aborted',
-                    headers: d.headers
+                    headers: {}
+                }
+            }
+
+            if(arg.rawResponse){
+                addFetchLog("Uint8Array Response", result.ok)
+                return {
+                    ok: result.ok,
+                    data: new Uint8Array(result.data as number[]),
+                    headers: result.headers
                 }
             }
             else{
-                addFetchLog(d.data, d.ok)
+                addFetchLog(result.data, result.ok)
                 return {
-                    ok: d.ok,
+                    ok: result.ok,
-                    data: d.data,
+                    data: result.data,
-                    headers: d.headers
+                    headers: result.headers
                 }
             }
         }