Migrate backend jobs to Redis Streams

src/utils/api.js

@@ -1,4 +1,15 @@
-import { API_URL, API_KEY, PRO_STREAM_URL, PRO_FRONTEND_TIMEOUT_MS, TTS_URL, TTS_STATUS_URL, TTS_CONFIG_URL } from './config.js'
+import {
+  API_URL,
+  API_KEY,
+  PRO_URL,
+  PRO_FRONTEND_TIMEOUT_MS,
+  TTS_URL,
+  TTS_STATUS_URL,
+  TTS_CONFIG_URL,
+  COMPRESS_SUBMIT_URL,
+  COMPRESS_STATUS_URL,
+  JOB_LOAD_URL,
+} from './config.js'
 import { useSettingsStore } from '../stores/settings'
 
 function generateRequestId() {
@@ -8,27 +19,6 @@ function generateRequestId() {
   return `${Date.now()}-${Math.random().toString(16).slice(2)}`
 }
 
-function getCancelUrl(apiUrl) {
-  const normalized = String(apiUrl || '').replace(/\/+$/, '')
-  if (!normalized) return '/v1/completions/cancel'
-  if (/\/v1\/pro\/completions\/stream$/i.test(normalized)) {
-    return normalized.replace(/\/v1\/pro\/completions\/stream$/i, '/v1/completions/cancel')
-  }
-  if (normalized.endsWith('/v1/completions')) {
-    return `${normalized}/cancel`
-  }
-  return `${normalized}/cancel`
-}
-
-function getProCancelUrl(apiUrl) {
-  const normalized = String(apiUrl || '').replace(/\/+$/, '')
-  if (!normalized) return '/v1/completions/cancel'
-  if (/\/v1\/pro\/completions$/i.test(normalized)) {
-    return normalized.replace(/\/v1\/pro\/completions$/i, '/v1/completions/cancel')
-  }
-  return normalized.replace(/\/v1\/pro\/completions\/stream$/i, '/v1/completions/cancel')
-}
-
 function normalizeAbortReason(reason) {
   if (typeof reason === 'string' && reason.trim()) {
     return reason.trim().slice(0, 64)
@@ -36,46 +26,6 @@ function normalizeAbortReason(reason) {
   return 'abort'
 }
 
-async function sendCancelRequest(cancelUrl, requestId, reason) {
-  try {
-    await fetch(cancelUrl, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'X-API-Key': API_KEY,
-      },
-      body: JSON.stringify({
-        request_id: requestId,
-        reason,
-      }),
-    })
-  } catch {
-    // Cancel request failed silently
-  }
-}
-
-function createAbortError(message = 'Request aborted') {
-  const error = new Error(message)
-  error.name = 'AbortError'
-  return error
-}
-
-function buildCompletionBody(settings, prefix, suffix, languageId, extra = {}) {
-  return {
-    prefix,
-    suffix,
-    languageId,
-    model_thinking: settings.modelThinking,
-    privacy_mode: settings.privacyMode,
-    user_preferences: {
-      language: settings.language,
-      currency: settings.currency,
-      timezone: settings.detectedTimezone,
-    },
-    ...extra,
-  }
-}
-
 function parseSseEvent(rawEvent) {
   const lines = String(rawEvent || '').replace(/\r/g, '').split('\n')
   let event = 'message'
@@ -98,6 +48,156 @@ function parseSseEvent(rawEvent) {
   }
 }
 
+function createAbortError(message = 'Request aborted') {
+  const error = new Error(message)
+  error.name = 'AbortError'
+  return error
+}
+
+async function sendCancelRequest(cancelUrl, requestId, reason) {
+  try {
+    await fetch(cancelUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-API-Key': API_KEY,
+      },
+      body: JSON.stringify({
+        request_id: requestId,
+        reason,
+      }),
+    })
+  } catch {
+    // Best-effort cancel only
+  }
+}
+
+function getCancelUrl(apiUrl) {
+  const normalized = String(apiUrl || '').replace(/\/+$/, '')
+  if (/\/v1\/pro\/completions$/i.test(normalized)) {
+    return normalized.replace(/\/v1\/pro\/completions$/i, '/v1/pro/completions/cancel')
+  }
+  if (/\/v1\/completions$/i.test(normalized)) {
+    return normalized.replace(/\/v1\/completions$/i, '/v1/completions/cancel')
+  }
+  return `${normalized}/cancel`
+}
+
+function buildCompletionBody(settings, prefix, suffix, languageId, extra = {}) {
+  return {
+    prefix,
+    suffix,
+    languageId,
+    model_thinking: settings.modelThinking,
+    privacy_mode: settings.privacyMode,
+    user_preferences: {
+      language: settings.language,
+      currency: settings.currency,
+      timezone: settings.detectedTimezone,
+    },
+    ...extra,
+  }
+}
+
+async function consumeSseJson({
+  url,
+  body,
+  requestId,
+  signal,
+  timeoutMs,
+  onChunk,
+  onEvent,
+  onDone,
+}) {
+  const requestController = new AbortController()
+  const timeoutId = timeoutMs ? setTimeout(() => requestController.abort('timeout'), timeoutMs) : null
+  const cancelUrl = getCancelUrl(url)
+
+  const relayAbort = () => {
+    requestController.abort(signal?.reason || 'abort')
+  }
+
+  const onAbort = () => {
+    const reason = normalizeAbortReason(requestController.signal.reason)
+    void sendCancelRequest(cancelUrl, requestId, reason)
+  }
+
+  requestController.signal.addEventListener('abort', onAbort, { once: true })
+  if (signal) {
+    if (signal.aborted) {
+      relayAbort()
+    } else {
+      signal.addEventListener('abort', relayAbort, { once: true })
+    }
+  }
+
+  try {
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Request-Id': requestId,
+        'X-API-Key': API_KEY,
+      },
+      body: JSON.stringify(body),
+      signal: requestController.signal,
+    })
+
+    if (!res.ok) {
+      const errorText = await res.text()
+      throw new Error(`HTTP ${res.status}: ${errorText}`)
+    }
+    if (!res.body) {
+      throw new Error('流式响应不可用')
+    }
+
+    const reader = res.body.getReader()
+    const decoder = new TextDecoder()
+    let buffer = ''
+    let finalPayload = null
+
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      buffer += decoder.decode(value, { stream: true })
+
+      let boundary = buffer.indexOf('\n\n')
+      while (boundary >= 0) {
+        const chunk = buffer.slice(0, boundary)
+        buffer = buffer.slice(boundary + 2)
+        const parsed = parseSseEvent(chunk)
+        const data = parsed.data ? JSON.parse(parsed.data) : {}
+
+        onEvent?.(parsed.event, data)
+
+        if (parsed.event === 'result') {
+          onChunk?.(data)
+        } else if (parsed.event === 'done') {
+          finalPayload = data.result || data
+          return onDone ? onDone(finalPayload) : finalPayload
+        } else if (parsed.event === 'error') {
+          throw new Error(String(data.error || '请求失败'))
+        } else if (parsed.event === 'cancelled') {
+          throw createAbortError('请求已取消')
+        }
+
+        boundary = buffer.indexOf('\n\n')
+      }
+    }
+
+    if (requestController.signal.aborted) {
+      throw createAbortError('请求已中止')
+    }
+    return onDone ? onDone(finalPayload || {}) : finalPayload
+  } finally {
+    if (timeoutId) clearTimeout(timeoutId)
+    requestController.signal.removeEventListener('abort', onAbort)
+    if (signal) {
+      signal.removeEventListener('abort', relayAbort)
+    }
+  }
+}
+
 export async function fetchSuggestion(prefix, suffix, languageId, signal, apiUrl = API_URL) {
   let normalizedLanguageId = 'markdown'
   if (typeof languageId === 'string' && languageId.trim()) {
@@ -109,60 +209,32 @@ export async function fetchSuggestion(prefix, suffix, languageId, signal, apiUrl
     apiUrl = signal
     signal = undefined
   }
+
+  const settings = useSettingsStore()
   const requestId = generateRequestId()
-  const cancelUrl = getCancelUrl(apiUrl)
+  let finalContent = ''
 
-  const onAbort = () => {
-    const reason = normalizeAbortReason(signal?.reason)
-    void sendCancelRequest(cancelUrl, requestId, reason)
-  }
+  const result = await consumeSseJson({
+    url: apiUrl,
+    body: buildCompletionBody(settings, prefix, suffix, normalizedLanguageId),
+    requestId,
+    signal,
+    onChunk(data) {
+      if (typeof data.content === 'string') {
+        finalContent = data.content
+      } else if (typeof data.delta === 'string') {
+        finalContent += data.delta
+      }
+    },
+    onDone(data) {
+      return typeof data.content === 'string' ? data.content : finalContent
+    },
+  })
 
-  if (signal) {
-    if (signal.aborted) {
-      onAbort()
-    } else {
-      signal.addEventListener('abort', onAbort, { once: true })
-    }
-  }
-
-  try {
-    const settings = useSettingsStore()
-    const headers = {
-      'Content-Type': 'application/json',
-      'X-Request-Id': requestId,
-      'X-API-Key': API_KEY,
-    }
-
-    const body = buildCompletionBody(settings, prefix, suffix, normalizedLanguageId)
-
-    const res = await fetch(apiUrl, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(body),
-      signal,
-    })
-
-    if (!res.ok) {
-      const errorText = await res.text()
-      throw new Error(`HTTP ${res.status}: ${errorText}`)
-    }
-
-    const data = await res.json()
-    return data.content || ''
-  } catch (e) {
-    if (e.name === 'AbortError') {
-      // ignore abort
-    } else {
-      throw e
-    }
-  } finally {
-    if (signal) {
-      signal.removeEventListener('abort', onAbort)
-    }
-  }
+  return result || ''
 }
 
-export async function fetchProSuggestionStream(payload, apiUrl = PRO_STREAM_URL) {
+export async function fetchProSuggestionStream(payload, apiUrl = PRO_URL) {
   const {
     prefix = '',
     suffix = '',
@@ -176,168 +248,65 @@ export async function fetchProSuggestionStream(payload, apiUrl = PRO_STREAM_URL)
 
   const settings = useSettingsStore()
   const requestId = generateRequestId()
-  const cancelUrl = getProCancelUrl(apiUrl)
-  const requestController = new AbortController()
-  const timeoutId = setTimeout(() => {
-    requestController.abort('timeout')
-  }, timeoutMs)
+  let finalContent = ''
 
-  const relayAbort = () => {
-    requestController.abort(signal?.reason || 'abort')
-  }
-
-  const onAbort = () => {
-    const reason = normalizeAbortReason(requestController.signal.reason)
-    void sendCancelRequest(cancelUrl, requestId, reason)
-  }
-
-  requestController.signal.addEventListener('abort', onAbort, { once: true })
-
-  if (signal) {
-    if (signal.aborted) {
-      relayAbort()
-    } else {
-      signal.addEventListener('abort', relayAbort, { once: true })
-    }
-  }
-
-  try {
-    const res = await fetch(apiUrl, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'X-Request-Id': requestId,
-        'X-API-Key': API_KEY,
+  return consumeSseJson({
+    url: apiUrl,
+    requestId,
+    signal,
+    timeoutMs,
+    body: {
+      prefix,
+      suffix,
+      languageId: String(languageId || 'markdown').trim() || 'markdown',
+      instruction,
+      pro_thinking: settings.proThinking || 'medium',
+      privacy_mode: settings.privacyMode,
+      user_preferences: {
+        language: settings.language,
+        currency: settings.currency,
+        timezone: settings.detectedTimezone,
       },
-      body: JSON.stringify(
-        {
-          prefix,
-          suffix,
-          languageId: String(languageId || 'markdown').trim() || 'markdown',
-          instruction,
-          pro_thinking: settings.proThinking || 'medium',
-          privacy_mode: settings.privacyMode,
-          user_preferences: {
-            language: settings.language,
-            currency: settings.currency,
-            timezone: settings.detectedTimezone,
-          },
-        }
-      ),
-      signal: requestController.signal,
-    })
-
-    if (!res.ok) {
-      const errorText = await res.text()
-      throw new Error(`HTTP ${res.status}: ${errorText}`)
-    }
-
-    if (!res.body) {
-      throw new Error('PRO 模式流式响应不可用')
-    }
-
-    const reader = res.body.getReader()
-    const decoder = new TextDecoder()
-    let buffer = ''
-    let finalContent = ''
-
-    while (true) {
-      const { done, value } = await reader.read()
-      if (done) break
-
-      buffer += decoder.decode(value, { stream: true })
-
-      let boundary = buffer.indexOf('\n\n')
-      while (boundary >= 0) {
-        const chunk = buffer.slice(0, boundary)
-        buffer = buffer.slice(boundary + 2)
-
-        const parsed = parseSseEvent(chunk)
-        if (parsed.event && parsed.event !== 'message') {
-          let eventData = {}
-          if (parsed.data) {
-            try {
-              eventData = JSON.parse(parsed.data)
-            } catch {
-              eventData = {}
-            }
-          }
-          onEvent?.(parsed.event, eventData)
-        }
-
-        if (parsed.event === 'chunk' && parsed.data) {
-          const data = JSON.parse(parsed.data)
-          const delta = String(data.delta || '')
-          if (delta) {
-            finalContent += delta
-            onChunk?.(delta)
-          }
-        }
-
-        if (parsed.event === 'done' && parsed.data) {
-          const data = JSON.parse(parsed.data)
-          return String(data.content || finalContent || '')
-        }
-
-        if (parsed.event === 'error' && parsed.data) {
-          const data = JSON.parse(parsed.data)
-          throw new Error(String(data.error || 'PRO 模式请求失败'))
-        }
-
-        if (parsed.event === 'cancelled') {
-          throw createAbortError('PRO 模式请求已取消')
-        }
-
-        boundary = buffer.indexOf('\n\n')
+    },
+    onChunk(data) {
+      const delta = String(data.delta || data.content || '')
+      if (delta) {
+        finalContent += delta
+        onChunk?.(delta)
       }
-    }
-
-    if (requestController.signal.aborted) {
-      throw createAbortError('PRO 模式请求已中止')
-    }
-
-    return finalContent
-  } catch (e) {
-    if (e?.name === 'AbortError') {
-      throw e
-    }
-    throw e
-  } finally {
-    clearTimeout(timeoutId)
-    requestController.signal.removeEventListener('abort', onAbort)
-    if (signal) {
-      signal.removeEventListener('abort', relayAbort)
-    }
-  }
+    },
+    onEvent(event, data) {
+      if (event === 'progress' && data.phase === 'thinking') {
+        onEvent?.('thinking', data)
+        return
+      }
+      if (event === 'queued' || event === 'started' || event === 'resource') {
+        onEvent?.(event, data)
+      }
+    },
+    onDone(data) {
+      return String(data.content || finalContent || '')
+    },
+  })
 }
 
 export async function fetchTTS(text, instruct = '', apiUrl = TTS_URL) {
-  const res = await fetch(apiUrl, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'X-API-Key': API_KEY,
+  const requestId = generateRequestId()
+  return consumeSseJson({
+    url: apiUrl,
+    requestId,
+    body: { text, instruct, speaker: 'Vivian', format: 'wav' },
+    onDone(data) {
+      return data
     },
-    body: JSON.stringify({ text, instruct, speaker: 'Vivian', format: 'wav' }),
   })
-
-  if (!res.ok) {
-    const errorText = await res.text()
-    throw new Error(`TTS HTTP ${res.status}: ${errorText}`)
-  }
-
-  return res.json()
 }
 
 export async function fetchTTSStatus(apiUrl = TTS_STATUS_URL) {
   const res = await fetch(apiUrl, {
     headers: { 'X-API-Key': API_KEY },
   })
-
-  if (!res.ok) {
-    throw new Error(`TTS Status HTTP ${res.status}`)
-  }
-
+  if (!res.ok) throw new Error(`TTS Status HTTP ${res.status}`)
   return res.json()
 }
 
@@ -345,10 +314,71 @@ export async function fetchTTSConfig(apiUrl = TTS_CONFIG_URL) {
   const res = await fetch(apiUrl, {
     headers: { 'X-API-Key': API_KEY },
   })
+  if (!res.ok) throw new Error(`TTS Config HTTP ${res.status}`)
+  return res.json()
+}
+
+export async function submitCompress(content, docType = 'txt', apiUrl = COMPRESS_SUBMIT_URL) {
+  const res = await fetch(apiUrl, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'X-API-Key': API_KEY,
+    },
+    body: JSON.stringify({ content, docType }),
+  })
 
   if (!res.ok) {
-    throw new Error(`TTS Config HTTP ${res.status}`)
+    const errorText = await res.text()
+    throw new Error(`压缩提交失败 HTTP ${res.status}: ${errorText}`)
   }
 
   return res.json()
 }
+
+export function pollCompressStatus(taskId, onStateChange, apiUrl = COMPRESS_STATUS_URL) {
+  let consecutiveErrors = 0
+
+  const interval = setInterval(async () => {
+    try {
+      const res = await fetch(`${apiUrl}?task_id=${encodeURIComponent(taskId)}`, {
+        headers: { 'X-API-Key': API_KEY },
+      })
+
+      if (!res.ok) {
+        consecutiveErrors++
+        if (consecutiveErrors >= 5) {
+          clearInterval(interval)
+          onStateChange('error', '', `请求失败 HTTP ${res.status}`)
+        }
+        return
+      }
+
+      consecutiveErrors = 0
+      const data = await res.json()
+      onStateChange(data.status, data.content || '', data.message, data)
+
+      if (['completed', 'error', 'cancelled'].includes(data.status)) {
+        clearInterval(interval)
+      }
+    } catch (err) {
+      consecutiveErrors++
+      if (consecutiveErrors >= 5) {
+        clearInterval(interval)
+        onStateChange('error', '', `网络异常: ${err.message || err}`)
+      }
+    }
+  }, 1000)
+
+  return { stop: () => clearInterval(interval) }
+}
+
+export async function fetchJobLoad(apiUrl = JOB_LOAD_URL) {
+  const res = await fetch(apiUrl, {
+    headers: { 'X-API-Key': API_KEY },
+  })
+  if (!res.ok) {
+    throw new Error(`Job Load HTTP ${res.status}`)
+  }
+  return res.json()
+}