756 lines
21 KiB
Plaintext
756 lines
21 KiB
Plaintext
// Content Processing Pipeline - Automated news content workflow
|
|
|
|
import {
|
|
ContentInfo,
|
|
ProcessingStep,
|
|
AIProvider,
|
|
AIResponse,
|
|
AIServiceConfig,
|
|
AIServiceError,
|
|
TranslationResult,
|
|
ContentAnalysisResult,
|
|
BatchProcessingOptions
|
|
} from '../types/ai-types.uts'
|
|
|
|
import { AITranslationService } from './AITranslationService.uts'
|
|
import { AIContentAnalysisService } from './AIContentAnalysisService.uts'
|
|
|
|
// 处理阶段枚举
|
|
type ProcessingStage =
|
|
| 'fetching'
|
|
| 'validation'
|
|
| 'analysis'
|
|
| 'translation'
|
|
| 'categorization'
|
|
| 'quality_check'
|
|
| 'storage'
|
|
| 'indexing'
|
|
| 'completed'
|
|
| 'failed'
|
|
|
|
// 处理状态
|
|
type ProcessingStatus = {
|
|
contentId: string
|
|
stage: ProcessingStage
|
|
progress: number // 0-100
|
|
startTime: number
|
|
lastUpdateTime: number
|
|
completedSteps: string[]
|
|
errors: Array<{ step: string, error: string, timestamp: number }>
|
|
metadata: UTSJSONObject
|
|
}
|
|
|
|
// 管道配置
|
|
type PipelineConfig = {
|
|
enabledSteps: string[]
|
|
parallelProcessing: boolean
|
|
maxConcurrency: number
|
|
retryCount: number
|
|
timeoutMs: number
|
|
qualityThreshold: number
|
|
targetLanguages: string[]
|
|
categorization: {
|
|
enabled: boolean
|
|
threshold: number
|
|
maxCategories: number
|
|
}
|
|
translation: {
|
|
enabled: boolean
|
|
targetLanguages: string[]
|
|
qualityThreshold: number
|
|
}
|
|
analysis: {
|
|
enabled: boolean
|
|
types: string[]
|
|
includeScores: boolean
|
|
}
|
|
}
|
|
|
|
// 处理结果
|
|
type ProcessingResult = {
|
|
contentId: string
|
|
originalContent: ContentInfo
|
|
processedContent: ContentInfo
|
|
translations: Record<string, TranslationResult>
|
|
analysis: ContentAnalysisResult
|
|
categories: string[]
|
|
qualityScore: number
|
|
processingTime: number
|
|
totalCost: number
|
|
status: ProcessingStage
|
|
errors: string[]
|
|
}
|
|
|
|
// 管道统计
|
|
type PipelineStats = {
|
|
totalProcessed: number
|
|
successCount: number
|
|
errorCount: number
|
|
avgProcessingTime: number
|
|
totalCost: number
|
|
stageStats: Record<ProcessingStage, {
|
|
count: number
|
|
avgTime: number
|
|
errorRate: number
|
|
}>
|
|
dailyThroughput: number
|
|
lastProcessedAt: number
|
|
}
|
|
|
|
/**
|
|
* 内容处理管道服务
|
|
* 自动化新闻内容的获取、分析、翻译、分类等全流程处理
|
|
*/
|
|
export class ContentProcessingPipeline {
|
|
private config: AIServiceConfig
|
|
private pipelineConfig: PipelineConfig
|
|
private translationService: AITranslationService
|
|
private analysisService: AIContentAnalysisService
|
|
private processingQueue: Map<string, ProcessingStatus> = new Map()
|
|
private processingSteps: Map<string, ProcessingStep> = new Map()
|
|
private stats: PipelineStats
|
|
|
|
constructor(
|
|
aiConfig: AIServiceConfig,
|
|
pipelineConfig: Partial<PipelineConfig> = {}
|
|
) {
|
|
this.config = aiConfig
|
|
this.pipelineConfig = this.createDefaultPipelineConfig(pipelineConfig)
|
|
this.translationService = new AITranslationService(aiConfig)
|
|
this.analysisService = new AIContentAnalysisService(aiConfig)
|
|
this.stats = this.initializeStats()
|
|
this.initializeProcessingSteps()
|
|
}
|
|
|
|
/**
|
|
* 处理单个内容
|
|
* @param content 原始内容
|
|
*/
|
|
async processContent(content: ContentInfo): Promise<AIResponse<ProcessingResult>> {
|
|
try {
|
|
const contentId = content.id
|
|
const startTime = Date.now()
|
|
|
|
// 初始化处理状态
|
|
const status: ProcessingStatus = {
|
|
contentId,
|
|
stage: 'validation',
|
|
progress: 0,
|
|
startTime,
|
|
lastUpdateTime: startTime,
|
|
completedSteps: [],
|
|
errors: [],
|
|
metadata: {}
|
|
}
|
|
|
|
this.processingQueue.set(contentId, status)
|
|
|
|
// 执行处理步骤
|
|
const result = await this.executeProcessingPipeline(content, status)
|
|
|
|
// 清理处理队列
|
|
this.processingQueue.delete(contentId)
|
|
|
|
// 更新统计
|
|
this.updateStats(result)
|
|
|
|
return { success: true, data: result }
|
|
|
|
} catch (error) {
|
|
const aiError: AIServiceError = {
|
|
code: 'PIPELINE_ERROR',
|
|
message: error.message || 'Content processing failed',
|
|
retryable: this.isRetryableError(error)
|
|
}
|
|
|
|
return {
|
|
success: false,
|
|
error: aiError.message,
|
|
errorCode: aiError.code
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 批量处理内容
|
|
* @param contents 内容列表
|
|
* @param batchOptions 批处理选项
|
|
*/
|
|
async processBatch(
|
|
contents: ContentInfo[],
|
|
batchOptions: BatchProcessingOptions = {
|
|
batchSize: 5,
|
|
concurrency: 3,
|
|
retryCount: 2,
|
|
delayMs: 1000
|
|
}
|
|
): Promise<AIResponse<ProcessingResult[]>> {
|
|
try {
|
|
const results: ProcessingResult[] = []
|
|
const batches = this.createBatches(contents, batchOptions.batchSize)
|
|
|
|
for (let i = 0; i < batches.length; i++) {
|
|
const batch = batches[i]
|
|
|
|
if (this.pipelineConfig.parallelProcessing) {
|
|
// 并行处理
|
|
const batchPromises = batch.map(async (content) => {
|
|
try {
|
|
const response = await this.processContent(content)
|
|
if (response.success && response.data) {
|
|
return response.data
|
|
}
|
|
throw new Error(response.error || 'Processing failed')
|
|
} catch (error) {
|
|
if (batchOptions.onError) {
|
|
batchOptions.onError(error, content)
|
|
}
|
|
throw error
|
|
}
|
|
})
|
|
|
|
const batchResults = await Promise.allSettled(batchPromises)
|
|
|
|
for (const result of batchResults) {
|
|
if (result.status === 'fulfilled') {
|
|
results.push(result.value)
|
|
}
|
|
}
|
|
} else {
|
|
// 串行处理
|
|
for (const content of batch) {
|
|
try {
|
|
const response = await this.processContent(content)
|
|
if (response.success && response.data) {
|
|
results.push(response.data)
|
|
}
|
|
} catch (error) {
|
|
if (batchOptions.onError) {
|
|
batchOptions.onError(error, content)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 进度回调
|
|
if (batchOptions.onProgress) {
|
|
batchOptions.onProgress(results.length, contents.length)
|
|
}
|
|
|
|
// 批次间延迟
|
|
if (i < batches.length - 1 && batchOptions.delayMs > 0) {
|
|
await this.delay(batchOptions.delayMs)
|
|
}
|
|
}
|
|
|
|
return { success: true, data: results }
|
|
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
error: error.message || 'Batch processing failed'
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获取处理状态
|
|
* @param contentId 内容ID
|
|
*/
|
|
getProcessingStatus(contentId: string): ProcessingStatus | null {
|
|
return this.processingQueue.get(contentId) || null
|
|
}
|
|
|
|
/**
|
|
* 获取所有处理中的内容状态
|
|
*/
|
|
getAllProcessingStatus(): ProcessingStatus[] {
|
|
return Array.from(this.processingQueue.values())
|
|
}
|
|
|
|
/**
|
|
* 添加自定义处理步骤
|
|
* @param step 处理步骤
|
|
*/
|
|
addProcessingStep(step: ProcessingStep): void {
|
|
this.processingSteps.set(step.name, step)
|
|
}
|
|
|
|
/**
|
|
* 移除处理步骤
|
|
* @param stepName 步骤名称
|
|
*/
|
|
removeProcessingStep(stepName: string): void {
|
|
this.processingSteps.delete(stepName)
|
|
}
|
|
|
|
/**
|
|
* 更新管道配置
|
|
* @param config 新配置
|
|
*/
|
|
updatePipelineConfig(config: Partial<PipelineConfig>): void {
|
|
this.pipelineConfig = { ...this.pipelineConfig, ...config }
|
|
}
|
|
|
|
/**
|
|
* 获取管道统计
|
|
*/
|
|
getPipelineStatistics(): PipelineStats {
|
|
return { ...this.stats }
|
|
}
|
|
|
|
/**
|
|
* 重置统计数据
|
|
*/
|
|
resetStatistics(): void {
|
|
this.stats = this.initializeStats()
|
|
}
|
|
|
|
// Private methods
|
|
|
|
private async executeProcessingPipeline(
|
|
content: ContentInfo,
|
|
status: ProcessingStatus
|
|
): Promise<ProcessingResult> {
|
|
|
|
const result: ProcessingResult = {
|
|
contentId: content.id,
|
|
originalContent: content,
|
|
processedContent: { ...content },
|
|
translations: {},
|
|
analysis: {} as ContentAnalysisResult,
|
|
categories: [],
|
|
qualityScore: 0,
|
|
processingTime: 0,
|
|
totalCost: 0,
|
|
status: 'fetching',
|
|
errors: []
|
|
}
|
|
|
|
try {
|
|
// 1. 内容验证
|
|
await this.executeStep('validation', content, result, status)
|
|
|
|
// 2. 内容分析
|
|
if (this.pipelineConfig.analysis.enabled) {
|
|
await this.executeStep('analysis', content, result, status)
|
|
}
|
|
|
|
// 3. 内容翻译
|
|
if (this.pipelineConfig.translation.enabled && this.pipelineConfig.translation.targetLanguages.length > 0) {
|
|
await this.executeStep('translation', content, result, status)
|
|
}
|
|
|
|
// 4. 内容分类
|
|
if (this.pipelineConfig.categorization.enabled) {
|
|
await this.executeStep('categorization', content, result, status)
|
|
}
|
|
|
|
// 5. 质量检查
|
|
await this.executeStep('quality_check', content, result, status)
|
|
|
|
// 6. 存储处理
|
|
await this.executeStep('storage', content, result, status)
|
|
|
|
// 7. 索引构建
|
|
await this.executeStep('indexing', content, result, status)
|
|
|
|
// 完成处理
|
|
result.status = 'completed'
|
|
result.processingTime = Date.now() - status.startTime
|
|
this.updateProcessingStatus(status, 'completed', 100)
|
|
|
|
} catch (error) {
|
|
result.status = 'failed'
|
|
result.errors.push(error.message || 'Unknown error')
|
|
this.updateProcessingStatus(status, 'failed', status.progress, error.message)
|
|
throw error
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
private async executeStep(
|
|
stepName: string,
|
|
content: ContentInfo,
|
|
result: ProcessingResult,
|
|
status: ProcessingStatus
|
|
): Promise<void> {
|
|
|
|
const step = this.processingSteps.get(stepName)
|
|
if (!step) {
|
|
throw new Error(`Processing step '${stepName}' not found`)
|
|
}
|
|
|
|
try {
|
|
// 验证前置条件
|
|
if (step.validate && !step.validate(result)) {
|
|
throw new Error(`Validation failed for step '${stepName}'`)
|
|
}
|
|
|
|
// 执行步骤
|
|
const stepResult = await step.execute(result)
|
|
|
|
// 更新结果
|
|
if (stepResult) {
|
|
Object.assign(result, stepResult)
|
|
}
|
|
|
|
// 更新状态
|
|
status.completedSteps.push(stepName)
|
|
const progress = (status.completedSteps.length / 7) * 100 // 7个主要步骤
|
|
this.updateProcessingStatus(status, this.getStageFromStep(stepName), progress)
|
|
|
|
} catch (error) {
|
|
// 记录错误
|
|
status.errors.push({
|
|
step: stepName,
|
|
error: error.message || 'Unknown error',
|
|
timestamp: Date.now()
|
|
})
|
|
|
|
// 尝试回滚
|
|
if (step.rollback) {
|
|
try {
|
|
await step.rollback(result)
|
|
} catch (rollbackError) {
|
|
console.error(`Rollback failed for step '${stepName}':`, rollbackError)
|
|
}
|
|
}
|
|
|
|
throw error
|
|
}
|
|
}
|
|
|
|
private updateProcessingStatus(
|
|
status: ProcessingStatus,
|
|
stage: ProcessingStage,
|
|
progress: number,
|
|
error?: string
|
|
): void {
|
|
status.stage = stage
|
|
status.progress = progress
|
|
status.lastUpdateTime = Date.now()
|
|
|
|
if (error) {
|
|
status.errors.push({
|
|
step: stage,
|
|
error,
|
|
timestamp: Date.now()
|
|
})
|
|
}
|
|
}
|
|
|
|
private getStageFromStep(stepName: string): ProcessingStage {
|
|
const stageMap: Record<string, ProcessingStage> = {
|
|
'validation': 'validation',
|
|
'analysis': 'analysis',
|
|
'translation': 'translation',
|
|
'categorization': 'categorization',
|
|
'quality_check': 'quality_check',
|
|
'storage': 'storage',
|
|
'indexing': 'indexing'
|
|
}
|
|
|
|
return stageMap[stepName] || 'validation'
|
|
}
|
|
|
|
private initializeProcessingSteps(): void {
|
|
// 内容验证步骤
|
|
this.processingSteps.set('validation', {
|
|
name: 'validation',
|
|
order: 1,
|
|
execute: async (data: ProcessingResult) => {
|
|
const content = data.originalContent
|
|
|
|
// 验证必需字段
|
|
if (!content.title || content.title.trim().length === 0) {
|
|
throw new Error('Content title is required')
|
|
}
|
|
|
|
if (!content.content || content.content.trim().length < 50) {
|
|
throw new Error('Content is too short (minimum 50 characters)')
|
|
}
|
|
|
|
// 验证内容质量
|
|
if (content.quality !== undefined && content.quality < this.pipelineConfig.qualityThreshold) {
|
|
throw new Error(`Content quality (${content.quality}) below threshold (${this.pipelineConfig.qualityThreshold})`)
|
|
}
|
|
|
|
return data
|
|
},
|
|
validate: (data: ProcessingResult) => {
|
|
return data.originalContent && data.originalContent.title && data.originalContent.content
|
|
}
|
|
})
|
|
|
|
// 内容分析步骤
|
|
this.processingSteps.set('analysis', {
|
|
name: 'analysis',
|
|
order: 2,
|
|
execute: async (data: ProcessingResult) => {
|
|
const response = await this.analysisService.analyzeContent(data.originalContent.content, {
|
|
types: this.pipelineConfig.analysis.types as any,
|
|
includeScores: this.pipelineConfig.analysis.includeScores,
|
|
language: data.originalContent.originalLanguage
|
|
})
|
|
|
|
if (response.success && response.data) {
|
|
data.analysis = response.data
|
|
data.processedContent.sentiment = response.data.sentimentScore
|
|
data.processedContent.readability = response.data.readabilityScore
|
|
data.processedContent.credibility = response.data.credibilityScore
|
|
data.processedContent.keywords = response.data.keywords
|
|
data.totalCost += (response.costUSD || 0)
|
|
} else {
|
|
throw new Error(response.error || 'Content analysis failed')
|
|
}
|
|
|
|
return data
|
|
}
|
|
})
|
|
|
|
// 内容翻译步骤
|
|
this.processingSteps.set('translation', {
|
|
name: 'translation',
|
|
order: 3,
|
|
execute: async (data: ProcessingResult) => {
|
|
const sourceContent = data.originalContent
|
|
const targetLanguages = this.pipelineConfig.translation.targetLanguages
|
|
|
|
for (const targetLang of targetLanguages) {
|
|
if (targetLang === sourceContent.originalLanguage) continue
|
|
|
|
// 翻译标题
|
|
const titleResponse = await this.translationService.translateText(
|
|
sourceContent.title,
|
|
targetLang,
|
|
sourceContent.originalLanguage,
|
|
{ qualityThreshold: this.pipelineConfig.translation.qualityThreshold }
|
|
)
|
|
|
|
// 翻译内容
|
|
const contentResponse = await this.translationService.translateText(
|
|
sourceContent.content,
|
|
targetLang,
|
|
sourceContent.originalLanguage,
|
|
{ qualityThreshold: this.pipelineConfig.translation.qualityThreshold }
|
|
)
|
|
|
|
if (titleResponse.success && contentResponse.success && titleResponse.data && contentResponse.data) {
|
|
data.translations[targetLang] = {
|
|
...contentResponse.data,
|
|
translatedText: `${titleResponse.data.translatedText}\n\n${contentResponse.data.translatedText}`
|
|
}
|
|
data.totalCost += (titleResponse.costUSD || 0) + (contentResponse.costUSD || 0)
|
|
}
|
|
}
|
|
|
|
return data
|
|
}
|
|
})
|
|
|
|
// 内容分类步骤
|
|
this.processingSteps.set('categorization', {
|
|
name: 'categorization',
|
|
order: 4,
|
|
execute: async (data: ProcessingResult) => {
|
|
if (data.analysis && data.analysis.categories) {
|
|
const validCategories = data.analysis.categories
|
|
.filter(cat => cat.confidence >= this.pipelineConfig.categorization.threshold)
|
|
.slice(0, this.pipelineConfig.categorization.maxCategories)
|
|
.map(cat => cat.categoryId)
|
|
|
|
data.categories = validCategories
|
|
|
|
// 设置主分类
|
|
if (validCategories.length > 0) {
|
|
data.processedContent.categoryId = validCategories[0]
|
|
}
|
|
}
|
|
|
|
return data
|
|
}
|
|
})
|
|
|
|
// 质量检查步骤
|
|
this.processingSteps.set('quality_check', {
|
|
name: 'quality_check',
|
|
order: 5,
|
|
execute: async (data: ProcessingResult) => {
|
|
let qualityScore = 0
|
|
let factors = 0
|
|
|
|
// 基于分析结果的质量评估
|
|
if (data.analysis) {
|
|
if (data.analysis.readabilityScore !== undefined) {
|
|
qualityScore += data.analysis.readabilityScore
|
|
factors++
|
|
}
|
|
|
|
if (data.analysis.credibilityScore !== undefined) {
|
|
qualityScore += data.analysis.credibilityScore
|
|
factors++
|
|
}
|
|
|
|
// 毒性检查
|
|
if (data.analysis.toxicityScore !== undefined) {
|
|
qualityScore += (1 - data.analysis.toxicityScore) // 毒性越低质量越高
|
|
factors++
|
|
}
|
|
}
|
|
|
|
// 内容长度评估
|
|
const contentLength = data.originalContent.content.length
|
|
const lengthScore = contentLength > 500 ? 1 : contentLength / 500
|
|
qualityScore += lengthScore
|
|
factors++
|
|
|
|
// 翻译质量评估
|
|
if (Object.keys(data.translations).length > 0) {
|
|
const translationQualities = Object.values(data.translations).map(t => t.qualityScore)
|
|
const avgTranslationQuality = translationQualities.reduce((sum, q) => sum + q, 0) / translationQualities.length
|
|
qualityScore += avgTranslationQuality
|
|
factors++
|
|
}
|
|
|
|
data.qualityScore = factors > 0 ? qualityScore / factors : 0.5
|
|
data.processedContent.quality = data.qualityScore
|
|
|
|
// 质量阈值检查
|
|
if (data.qualityScore < this.pipelineConfig.qualityThreshold) {
|
|
console.warn(`Content quality (${data.qualityScore}) below threshold (${this.pipelineConfig.qualityThreshold})`)
|
|
}
|
|
|
|
return data
|
|
}
|
|
})
|
|
|
|
// 存储步骤
|
|
this.processingSteps.set('storage', {
|
|
name: 'storage',
|
|
order: 6,
|
|
execute: async (data: ProcessingResult) => {
|
|
// 模拟存储操作
|
|
await this.delay(100)
|
|
|
|
// 在实际实现中，这里会将处理后的内容保存到数据库
|
|
data.processedContent.status = 'published'
|
|
data.processedContent.tags = [...(data.processedContent.tags || []), ...data.categories]
|
|
|
|
return data
|
|
}
|
|
})
|
|
|
|
// 索引构建步骤
|
|
this.processingSteps.set('indexing', {
|
|
name: 'indexing',
|
|
order: 7,
|
|
execute: async (data: ProcessingResult) => {
|
|
// 模拟索引构建
|
|
await this.delay(50)
|
|
|
|
// 在实际实现中，这里会更新搜索索引
|
|
console.log(`Content indexed: ${data.contentId}`)
|
|
|
|
return data
|
|
}
|
|
})
|
|
}
|
|
|
|
private createDefaultPipelineConfig(overrides: Partial<PipelineConfig>): PipelineConfig {
|
|
return {
|
|
enabledSteps: ['validation', 'analysis', 'translation', 'categorization', 'quality_check', 'storage', 'indexing'],
|
|
parallelProcessing: true,
|
|
maxConcurrency: 3,
|
|
retryCount: 2,
|
|
timeoutMs: 300000, // 5分钟
|
|
qualityThreshold: 0.7,
|
|
targetLanguages: ['zh-CN', 'en'],
|
|
categorization: {
|
|
enabled: true,
|
|
threshold: 0.6,
|
|
maxCategories: 3
|
|
},
|
|
translation: {
|
|
enabled: true,
|
|
targetLanguages: ['zh-CN', 'en'],
|
|
qualityThreshold: 0.7
|
|
},
|
|
analysis: {
|
|
enabled: true,
|
|
types: ['sentiment', 'entities', 'topics', 'categories', 'readability', 'credibility', 'summary', 'keywords'],
|
|
includeScores: true
|
|
},
|
|
...overrides
|
|
}
|
|
}
|
|
|
|
private initializeStats(): PipelineStats {
|
|
const stages: ProcessingStage[] = [
|
|
'fetching', 'validation', 'analysis', 'translation',
|
|
'categorization', 'quality_check', 'storage', 'indexing',
|
|
'completed', 'failed'
|
|
]
|
|
|
|
const stageStats: Record<ProcessingStage, any> = {} as Record<ProcessingStage, any>
|
|
stages.forEach(stage => {
|
|
stageStats[stage] = {
|
|
count: 0,
|
|
avgTime: 0,
|
|
errorRate: 0
|
|
}
|
|
})
|
|
|
|
return {
|
|
totalProcessed: 0,
|
|
successCount: 0,
|
|
errorCount: 0,
|
|
avgProcessingTime: 0,
|
|
totalCost: 0,
|
|
stageStats,
|
|
dailyThroughput: 0,
|
|
lastProcessedAt: 0
|
|
}
|
|
}
|
|
|
|
private updateStats(result: ProcessingResult): void {
|
|
this.stats.totalProcessed++
|
|
this.stats.lastProcessedAt = Date.now()
|
|
|
|
if (result.status === 'completed') {
|
|
this.stats.successCount++
|
|
} else {
|
|
this.stats.errorCount++
|
|
}
|
|
|
|
// 更新平均处理时间
|
|
this.stats.avgProcessingTime = (
|
|
this.stats.avgProcessingTime * (this.stats.totalProcessed - 1) + result.processingTime
|
|
) / this.stats.totalProcessed
|
|
|
|
// 更新总成本
|
|
this.stats.totalCost += result.totalCost
|
|
|
|
// 更新阶段统计
|
|
this.stats.stageStats[result.status].count++
|
|
}
|
|
|
|
private createBatches<T>(items: T[], batchSize: number): T[][] {
|
|
const batches: T[][] = []
|
|
for (let i = 0; i < items.length; i += batchSize) {
|
|
batches.push(items.slice(i, i + batchSize))
|
|
}
|
|
return batches
|
|
}
|
|
|
|
private async delay(ms: number): Promise<void> {
|
|
return new Promise(resolve => setTimeout(resolve, ms))
|
|
}
|
|
|
|
private isRetryableError(error: any): boolean {
|
|
const retryableCodes = ['TIMEOUT', 'RATE_LIMIT', 'SERVER_ERROR', 'NETWORK_ERROR']
|
|
return retryableCodes.includes(error.code) || error.status >= 500
|
|
}
|
|
}
|