refine request queue

Jicheng Lu · Jicheng Lu · commit e4a3b7da222d · 2025-11-12T15:54:38.000-06:00
diff --git a/src/lib/helpers/http.js b/src/lib/helpers/http.js
@@ -4,23 +4,92 @@ import { renewToken } from '$lib/services/auth-service';
 import { delay } from './utils/common';
 
 
-/** @type {{config: import('axios').InternalAxiosRequestConfig, resolve: (value: any) => void, reject: (reason?: any) => void}[]} */
-const retryQueue = [];
-
-// Refresh handling state
-let isRefreshingToken = false;
+const retryQueue = {
+    /** @type {{config: import('axios').InternalAxiosRequestConfig, resolve: (value: any) => void, reject: (reason?: any) => void}[]} */
+    queue: [],
+
+    /** @type {boolean} */
+    isRefreshingToken: false,
+
+    /** @type {number} */
+    timeout: 20,
+
+    /**
+     * refresh access token
+     * @param {string} token
+     * @returns {Promise<string>}
+     */
+    refreshAccessToken(token) {
+        return new Promise((resolve, reject) => {
+            renewToken(token, (newToken) => resolve(newToken), () => reject(new Error('Failed to refresh token')));
+        });
+    },
 
-/**
- * Wrap renewToken into a Promise that resolves with the new access token string
- * @param {string} token
- * @returns {Promise<string>}
- */
-function refreshAccessToken(token) {
-    return new Promise((resolve, reject) => {
-        renewToken(token, (newToken) => resolve(newToken), () => reject(new Error('Failed to refresh token')));
-    });
-}
+    /** @param {{config: import('axios').InternalAxiosRequestConfig, resolve: (value: any) => void, reject: (reason?: any) => void}} item */
+    enqueue(item) {
+        this.queue.push(item);
+
+        if (!this.isRefreshingToken) {
+            const user = getUserStore();
+            if (!isTokenExired(user.expires)) {
+                this.dequeue(user.token);
+            } else {
+                this.isRefreshingToken = true;
+                this.refreshAccessToken(user?.token || '')
+                    .then((newToken) => {
+                        this.isRefreshingToken = false;
+                        const promise = this.dequeue(newToken);
+                        return promise;
+                    })
+                    .catch((err) => {
+                        this.isRefreshingToken = false;
+                        // Reject all queued requests
+                        while (this.queue.length > 0) {
+                            const item = this.queue.shift();
+                            if (item) {
+                                item.reject(err);
+                            }
+                        }
+                        redirectToLogin();
+                    });
+            }
+        }
+    },
 
+    /**
+     * @param {string} newToken
+     * @returns {Promise<void>}
+     */
+    dequeue(newToken) {
+        let chain = Promise.resolve();
+        while (this.queue.length > 0) {
+            const item = this.queue.shift();
+            if (!item?.config) {
+                continue;
+            }
+            
+            const { config } = item;
+            // @ts-ignore
+            config.headers = config.headers || {};
+            // @ts-ignore
+            config.headers.Authorization = `Bearer ${newToken}`;
+
+            chain = chain.then(() => delay(this.timeout))
+                         .then(() => {
+                            return new Promise((resolve) => {
+                                axios(config).then((response) => {
+                                    resolve();
+                                    item.resolve(response);
+                                }).catch((err) => {
+                                    resolve();
+                                    item.reject(err);
+                                });
+                            });
+                         });
+        }
+        return chain;
+    }
+};
 
 // Add a request interceptor to attach authentication tokens or headers
 axios.interceptors.request.use(
@@ -54,10 +123,13 @@ axios.interceptors.response.use(
         const user = getUserStore();
 
         // If token expired or 401 returned, attempt a single token refresh and retry requests in queue.
-        if ((error?.response?.status === 401 || isTokenExired(user.expires)) && originalRequest && !originalRequest._retried) {
+        if ((error?.response?.status === 401 || isTokenExired(user.expires))
+            && originalRequest
+            && !originalRequest._retried
+            && !originalRequest.url.includes('renew-token')) {
             originalRequest._retried = true;
             return new Promise((resolve, reject) => {
-                enqueue({ config: originalRequest, resolve, reject });
+                retryQueue.enqueue({ config: originalRequest, resolve, reject });
             });
         } else if (!skipGlobalError(originalRequest)) {
             globalErrorStore.set(true);
@@ -71,62 +143,6 @@ axios.interceptors.response.use(
     }
 );
 
-/** 
- * @param {{config: import('axios').InternalAxiosRequestConfig, resolve: (value: any) => void, reject: (reason?: any) => void}} retryItem 
- */
-function enqueue(retryItem) {
-    // Push the current request into the queue
-    retryQueue.push({ ...retryItem });
-
-    // Start refresh token
-    if (!isRefreshingToken) {
-        const user = getUserStore();
-        if (!isTokenExired(user.expires)) {
-            dequeue(user.token);
-        } else {
-            isRefreshingToken = true;
-            refreshAccessToken(user?.token || '')
-                .then((newToken) => {
-                    isRefreshingToken = false;
-                    const promise = dequeue(newToken);
-                    return promise;
-                })
-                .catch((err) => {
-                    isRefreshingToken = false;
-                    // Reject all queued requests
-                    while (retryQueue.length > 0) {
-                        const item = retryQueue.shift();
-                        if (item) {
-                            item.reject(err);
-                        }
-                    }
-                    redirectToLogin();
-                });
-        }
-    }
-}
-
-/**
- * Retry queued requests sequentially
- * @param {string} newToken
- * @returns {Promise<void>}
- */
-function dequeue(newToken) {
-    let chain = Promise.resolve();
-    while (retryQueue.length > 0) {
-        const item = retryQueue.shift();
-        if (!item) continue;
-        const { config, resolve, reject } = item;
-        // @ts-ignore
-        config.headers = config.headers || {};
-        // @ts-ignore
-        config.headers.Authorization = `Bearer ${newToken}`;
-        chain = chain.then(() => delay(20))
-                     .then(() => { axios(config).then(resolve).catch(reject); });
-    }
-    return chain;
-}
-
 /**
  * @param {number} expires
  */
diff --git a/src/lib/helpers/types/instructTypes.js b/src/lib/helpers/types/instructTypes.js
@@ -28,6 +28,7 @@
  * @property {string[]?} [providers]
  * @property {string[]?} [models]
  * @property {string[]?} [templateNames]
+ * @property {string?} [similarTemplateName]
  * @property {string?} [startTime]
  * @property {string?} [endTime]
  * @property {{key: string, value: string}[]?} [states]
diff --git a/src/lib/services/auth-service.js b/src/lib/services/auth-service.js
@@ -46,13 +46,10 @@ export async function getToken(email, password, onSucceed, onError) {
  * @param {(() => void) | null} [onError]
  */
 export async function renewToken(token, onSucceed = null, onError = null) {
-    const headers = {
-        Authorization: `Bearer ${token}`,
-    };
-
     await fetch(endpoints.renewTokenUrl, {
         method: 'POST',
-        headers: headers,
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ refresh_token: token, access_token: token }),
     }).then(response => {
         if (response.ok) {
             return response.json();
diff --git a/src/lib/services/instruct-service.js b/src/lib/services/instruct-service.js
@@ -1,7 +1,6 @@
 import { endpoints } from '$lib/services/api-endpoints.js';
 import { replaceUrl } from '$lib/helpers/http';
 import axios from 'axios';
-import qs from 'qs';
 
 /**
  * Execute agent instruction by template or user provided prompt.
@@ -27,22 +26,6 @@ export async function sendChatCompletion(request) {
 }
 
 
-/**
- * Get instruction logs
- * @param {import('$instructTypes').InstructLogFilter} filter
- * @returns {Promise<import('$commonTypes').PagedItems<import('$instructTypes').InstructionLogModel>>}
- */
-export async function getInstructionLogs(filter) {
-    const url = endpoints.instructLogUrl;
-    const response = await axios.get(url, {
-        params: {
-            ...filter
-        },
-        paramsSerializer: (params) => qs.stringify(params, { encode: false, allowDots: true, arrayFormat: "indices" })
-    });
-    return response.data;
-}
-
 /**
  * get instruction log search keys
  * @param {import('$instructTypes').StateSearchQuery} request
diff --git a/src/lib/services/logging-service.js b/src/lib/services/logging-service.js
@@ -1,6 +1,7 @@
 import { replaceUrl } from '$lib/helpers/http.js';
 import { endpoints } from './api-endpoints.js';
 import axios from 'axios';
+import qs from 'qs';
 
 /**
  * Show backend full log
@@ -51,4 +52,21 @@ export async function getStateLogs(conversationId, filter) {
         }
     });
     return response.data;
+}
+
+
+/**
+ * Get instruction logs
+ * @param {import('$instructTypes').InstructLogFilter} filter
+ * @returns {Promise<import('$commonTypes').PagedItems<import('$instructTypes').InstructionLogModel>>}
+ */
+export async function getInstructionLogs(filter) {
+    const url = endpoints.instructLogUrl;
+    const response = await axios.get(url, {
+        params: {
+            ...filter
+        },
+        paramsSerializer: (params) => qs.stringify(params, { encode: false, allowDots: true, arrayFormat: "indices" })
+    });
+    return response.data;
 }
diff --git a/src/routes/page/instruction/log/+page.svelte b/src/routes/page/instruction/log/+page.svelte
@@ -9,9 +9,9 @@
 	import TablePagination from '$lib/common/TablePagination.svelte';
 	import { getAgentOptions } from '$lib/services/agent-service';
 	import { getLlmConfigs } from '$lib/services/llm-provider-service';
-	import { getInstructionLogs, getInstructionLogSearchKeys } from '$lib/services/instruct-service';
+	import { getInstructionLogSearchKeys } from '$lib/services/instruct-service';
+	import { getInstructionLogs } from '$lib/services/logging-service';
 	import LoadingToComplete from '$lib/common/LoadingToComplete.svelte';
-	import LogItem from './log-item.svelte';
 	import { convertTimeRange, removeDuplicates } from '$lib/helpers/utils/common';
 	import StateSearch from '$lib/common/StateSearch.svelte';
 	import Select from '$lib/common/Select.svelte';
@@ -22,6 +22,8 @@
 	} from '$lib/helpers/utils/common';
 	import { TimeRange } from '$lib/helpers/enums';
 	import { TIME_RANGE_OPTIONS } from '$lib/helpers/constants';
+	import LogItem from './log-item.svelte';
+	
 
     const firstPage = 1;
 	const pageSize = 15;
@@ -60,7 +62,7 @@
 		agentIds: [],
 		providers: [],
 		models: [],
-        template: '',
+        similarTemplate: '',
 		timeRange: TimeRange.Today,
 		states: []
 	};
@@ -244,7 +246,7 @@
             agentIds: agentIds,
             providers: providers,
             models: models,
-            templateNames: template ? [template] : [],
+            similarTemplateName: template,
 			startTime: innerTimeRange.startTime,
 			endTime: innerTimeRange.endTime,
 			states: states
