API 客户端

// services/api/claude.ts — 简化版
import Anthropic from '@anthropic-ai/sdk'

const anthropic = new Anthropic({
  apiKey: getApiKey(),
  // TCP+TLS 预连接在 init() 阶段完成
})

export async function* streamClaude(opts: {
  model: string
  system: string
  messages: Message[]
  tools: ToolDefinition[]
  abortSignal?: AbortSignal
  usage: UsageTracker
}): AsyncGenerator<StreamEvent> {
  // 1. 消息规范化
  const normalizedMessages = normalizeMessages(opts.messages)

  // 2. 工具 Schema 转换（Zod → JSON Schema）
  const apiTools = convertToolSchemas(opts.tools)

  // 3. 缓存断点插入
  const messagesWithCache = insertCacheBreakpoints(normalizedMessages)

  // 4. Thinking 配置
  const thinkingConfig = getThinkingConfig(opts.model)

  // 5. 带重试的流式调用
  const stream = await withRetry(async () => {
    return anthropic.beta.messages.stream({
      model: opts.model,
      max_tokens: 16384,
      system: [{ type: 'text', text: opts.system, cache_control: { type: 'ephemeral' } }],
      messages: messagesWithCache,
      tools: apiTools,
      ...thinkingConfig,
      betas: ['prompt-caching-2024-07-31', 'extended-thinking-2025-01-24'],
    }, {
      signal: opts.abortSignal,
    })
  }, { maxRetries: 3 })

  // 6. yield 流式事件
  for await (const event of stream) {
    yield {
      type: event.type,
      data: event,
    } as StreamEvent
  }

  // 7. 获取最终消息并记录用量
  const finalMessage = await stream.finalMessage()
  opts.usage.track({
    model: opts.model,
    inputTokens: finalMessage.usage.input_tokens,
    outputTokens: finalMessage.usage.output_tokens,
    cacheCreationTokens: finalMessage.usage.cache_creation_input_tokens ?? 0,
    cacheReadTokens: finalMessage.usage.cache_read_input_tokens ?? 0,
  })

  return finalMessage
}

// services/api/retry.ts — 简化版
interface RetryConfig {
  maxRetries: number
  baseDelay: number      // 默认 1000ms
  maxDelay: number        // 默认 30000ms
  jitterFactor: number    // 默认 0.1
}

export async function withRetry<T>(
  fn: () => Promise<T>,
  config: Partial<RetryConfig> = {}
): Promise<T> {
  const {
    maxRetries = 3,
    baseDelay = 1000,
    maxDelay = 30000,
    jitterFactor = 0.1,
  } = config

  let lastError: Error | null = null

  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      return await fn()
    } catch (error) {
      lastError = error as Error

      // 不可重试的错误：立即抛出
      if (!isRetryableError(error)) {
        throw error
      }

      // 最后一次尝试失败：抛出
      if (attempt === maxRetries) break

      // 计算退避延迟
      const delay = calculateBackoff(attempt, baseDelay, maxDelay, jitterFactor)
      await sleep(delay)
    }
  }

  throw lastError
}

function calculateBackoff(
  attempt: number,
  baseDelay: number,
  maxDelay: number,
  jitterFactor: number
): number {
  // 指数退避：baseDelay * 2^attempt
  const exponentialDelay = baseDelay * Math.pow(2, attempt)

  // 加上随机抖动，避免雷群效应
  const jitter = exponentialDelay * jitterFactor * Math.random()

  // 不超过最大延迟
  return Math.min(exponentialDelay + jitter, maxDelay)
}

function isRetryableError(error: unknown): boolean {
  if (error instanceof Anthropic.APIError) {
    // 可重试：429(频率限制)、500/502/503(服务器错误)
    return [429, 500, 502, 503].includes(error.status)
  }
  // 网络超时也可重试
  if (error instanceof Error && error.message.includes('ETIMEDOUT')) {
    return true
  }
  return false
}

// services/api/thinking.ts — 简化版
type ThinkingMode = 'adaptive' | 'enabled' | 'disabled'

export function getThinkingConfig(model: string): ThinkingParams {
  const mode = getSettingValue<ThinkingMode>('thinkingMode', 'adaptive')
  const maxThinkingTokens = getSettingValue<number>(
    'maxThinkingTokens', 10000
  )

  switch (mode) {
    case 'adaptive':
      // 自适应模式：让模型自行决定思考深度
      return {
        thinking: {
          type: 'enabled',
          budget_tokens: maxThinkingTokens,
        }
      }

    case 'enabled':
      // 始终启用：设置固定的思考长度
      return {
        thinking: {
          type: 'enabled',
          budget_tokens: maxThinkingTokens,
        }
      }

    case 'disabled':
      // 完全禁用：不发送 thinking 参数
      return {}
  }
}

// services/api/usage.ts — 用量追踪
export interface UsageRecord {
  model: string
  inputTokens: number
  outputTokens: number
  cacheCreationTokens: number
  cacheReadTokens: number
}

export class UsageTracker {
  private records: UsageRecord[] = []

  track(record: UsageRecord): void {
    this.records.push(record)
  }

  getSummary(): UsageSummary {
    const byModel = new Map<string, ModelUsage>()

    for (const record of this.records) {
      const existing = byModel.get(record.model) ?? {
        inputTokens: 0, outputTokens: 0,
        cacheCreationTokens: 0, cacheReadTokens: 0,
      }
      byModel.set(record.model, {
        inputTokens: existing.inputTokens + record.inputTokens,
        outputTokens: existing.outputTokens + record.outputTokens,
        cacheCreationTokens: existing.cacheCreationTokens + record.cacheCreationTokens,
        cacheReadTokens: existing.cacheReadTokens + record.cacheReadTokens,
      })
    }

    return {
      byModel: Object.fromEntries(byModel),
      totalTokens: this.records.reduce(
        (sum, r) => sum + r.inputTokens + r.outputTokens, 0
      ),
    }
  }

  get totalTokens(): number {
    return this.records.reduce(
      (sum, r) => sum + r.inputTokens + r.outputTokens, 0
    )
  }
}