Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
178 changes: 178 additions & 0 deletions src/main/rate-limits/deepseek-fetcher.test.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,178 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'

const netFetchMock = vi.hoisted(() => vi.fn())

vi.mock('electron', () => ({
net: { fetch: netFetchMock }
}))

import {
fetchDeepSeekRateLimits,
isDeepSeekAuthConfigured,
readDeepSeekApiKey
} from './deepseek-fetcher'

function jsonResponse(
body: unknown,
status = 200
): { ok: boolean; status: number; json: () => Promise<unknown> } {
return {
ok: status >= 200 && status < 300,
status,
json: async () => body
}
}

const USD_BALANCE = {
is_available: true,
balance_infos: [
{
currency: 'CNY',
total_balance: '50.00',
granted_balance: '0.00',
topped_up_balance: '50.00'
},
{
currency: 'USD',
total_balance: '110.00',
granted_balance: '10.00',
topped_up_balance: '100.00'
}
]
}

describe('deepseek-fetcher', () => {
beforeEach(() => {
netFetchMock.mockReset()
})

afterEach(() => {
vi.unstubAllEnvs()
})

it('reads a trimmed DEEPSEEK_API_KEY', () => {
expect(readDeepSeekApiKey({ DEEPSEEK_API_KEY: ' sk-test ' })).toBe('sk-test')
expect(readDeepSeekApiKey({ DEEPSEEK_API_KEY: ' ' })).toBeNull()
expect(readDeepSeekApiKey({})).toBeNull()
expect(isDeepSeekAuthConfigured({ DEEPSEEK_API_KEY: 'sk' })).toBe(true)
expect(isDeepSeekAuthConfigured({})).toBe(false)
})

it('returns unavailable when no API key is set', async () => {
const result = await fetchDeepSeekRateLimits({ env: {} })
expect(result.provider).toBe('deepseek')
expect(result.status).toBe('unavailable')
expect(result.error).toMatch(/DEEPSEEK_API_KEY/)
expect(result.usageMetadata?.failureKind).toBe('missing-credentials')
expect(netFetchMock).not.toHaveBeenCalled()
})

it('prefers the USD balance_info when present', async () => {
netFetchMock.mockResolvedValueOnce(jsonResponse(USD_BALANCE))

const result = await fetchDeepSeekRateLimits({ env: { DEEPSEEK_API_KEY: 'sk-test' } })

expect(result.status).toBe('ok')
expect(result.monthly?.usedPercent).toBe(0)
expect(result.monthly?.windowMinutes).toBe(43_200)
expect(result.monthly?.resetsAt).toBeNull()
expect(result.monthly?.resetDescription).toBe('USD 110.00')
expect(result.planType).toBe('USD')
expect(result.session).toBeNull()
expect(result.weekly).toBeNull()
expect(result.usageMetadata?.source).toBe('cli')
expect(result.usageMetadata?.authProvenance).toContain('USD 110.00')

expect(netFetchMock).toHaveBeenCalledWith(
'https://api.deepseek.com/user/balance',
expect.objectContaining({
headers: expect.objectContaining({
Authorization: 'Bearer sk-test',
Accept: 'application/json'
})
})
)
})

it('falls back to the first balance_info when USD is absent', async () => {
netFetchMock.mockResolvedValueOnce(
jsonResponse({
is_available: true,
balance_infos: [
{
currency: 'CNY',
total_balance: '88.50',
granted_balance: '0',
topped_up_balance: '88.50'
}
]
})
)

const result = await fetchDeepSeekRateLimits({ env: { DEEPSEEK_API_KEY: 'sk-cny' } })
expect(result.status).toBe('ok')
expect(result.monthly?.resetDescription).toBe('CNY 88.50')
expect(result.planType).toBe('CNY')
expect(result.monthly?.usedPercent).toBe(0)
})

it('reports 100% used when balance is unavailable or non-positive', async () => {
netFetchMock.mockResolvedValueOnce(
jsonResponse({
is_available: false,
balance_infos: [{ currency: 'USD', total_balance: '5.00' }]
})
)
const unavailable = await fetchDeepSeekRateLimits({ env: { DEEPSEEK_API_KEY: 'sk' } })
expect(unavailable.status).toBe('ok')
expect(unavailable.monthly?.usedPercent).toBe(100)

netFetchMock.mockResolvedValueOnce(
jsonResponse({
is_available: true,
balance_infos: [{ currency: 'USD', total_balance: '0.00' }]
})
)
const zero = await fetchDeepSeekRateLimits({ env: { DEEPSEEK_API_KEY: 'sk' } })
expect(zero.status).toBe('ok')
expect(zero.monthly?.usedPercent).toBe(100)
})

it('returns error on 401', async () => {
netFetchMock.mockResolvedValueOnce(jsonResponse({}, 401))
const result = await fetchDeepSeekRateLimits({ env: { DEEPSEEK_API_KEY: 'sk-bad' } })
expect(result.status).toBe('error')
expect(result.error).toMatch(/unauthorized/i)
expect(result.usageMetadata?.failureKind).toBe('stale-token')
})

it('returns error when the response body is not JSON', async () => {
netFetchMock.mockResolvedValueOnce({
ok: true,
status: 200,
json: async () => {
throw new SyntaxError('Unexpected token')
}
})

const result = await fetchDeepSeekRateLimits({ env: { DEEPSEEK_API_KEY: 'sk' } })
expect(result.status).toBe('error')
expect(result.error).toMatch(/valid JSON/i)
expect(result.usageMetadata?.failureKind).toBe('parse')
})

it('returns error when balance_infos is missing', async () => {
netFetchMock.mockResolvedValueOnce(jsonResponse({ is_available: true }))
const result = await fetchDeepSeekRateLimits({ env: { DEEPSEEK_API_KEY: 'sk' } })
expect(result.status).toBe('error')
expect(result.error).toMatch(/balance_infos/i)
})

it('returns error on network failure', async () => {
netFetchMock.mockRejectedValueOnce(new Error('network down'))
const result = await fetchDeepSeekRateLimits({ env: { DEEPSEEK_API_KEY: 'sk' } })
expect(result.status).toBe('error')
expect(result.error).toBe('network down')
expect(result.usageMetadata?.failureKind).toBe('network')
})
})
195 changes: 195 additions & 0 deletions src/main/rate-limits/deepseek-fetcher.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,195 @@
import { net } from 'electron'
import type {
ProviderRateLimits,
RateLimitWindow,
UsageRateLimitMetadata
} from '../../shared/rate-limit-types'

const BALANCE_URL = 'https://api.deepseek.com/user/balance'
const API_TIMEOUT_MS = 10_000
// Why: prepaid balance is not a rolling quota; monthly-ish window keeps hasUsageData true for the status bar.
const MONTHLY_WINDOW_MINUTES = 43_200

type DeepSeekBalanceInfo = {
currency?: unknown
total_balance?: unknown
granted_balance?: unknown
topped_up_balance?: unknown
}

export function readDeepSeekApiKey(env: NodeJS.ProcessEnv = process.env): string | null {
const key = env.DEEPSEEK_API_KEY?.trim()
return key ? key : null
}

export function isDeepSeekAuthConfigured(env: NodeJS.ProcessEnv = process.env): boolean {
return readDeepSeekApiKey(env) !== null
}

function result(
status: ProviderRateLimits['status'],
error: string | null,
usageMetadata?: UsageRateLimitMetadata
): ProviderRateLimits {
return {
provider: 'deepseek',
session: null,
weekly: null,
updatedAt: Date.now(),
error,
status,
...(usageMetadata ? { usageMetadata } : {})
}
}

function isBalanceRecord(value: unknown): value is Record<string, unknown> {
return typeof value === 'object' && value !== null && !Array.isArray(value)
}

function asString(value: unknown): string | null {
return typeof value === 'string' && value.trim() ? value.trim() : null
}

function asBalance(value: unknown): number | null {
if (typeof value === 'number' && Number.isFinite(value)) {
return value
}
if (typeof value === 'string' && value.trim()) {
const parsed = Number(value)
return Number.isFinite(parsed) ? parsed : null
}
return null
}

function pickBalanceInfo(infos: unknown): DeepSeekBalanceInfo | null {
if (!Array.isArray(infos) || infos.length === 0) {
return null
}
const entries = infos.filter(
(entry): entry is DeepSeekBalanceInfo => typeof entry === 'object' && entry !== null
)
if (entries.length === 0) {
return null
}
const usd = entries.find((entry) => asString(entry.currency)?.toUpperCase() === 'USD')
return usd ?? entries[0]
}

function mapBalanceWindow(info: DeepSeekBalanceInfo, isAvailable: boolean): RateLimitWindow | null {
const totalBalance = asBalance(info.total_balance)
if (totalBalance === null) {
return null
}
const currency = asString(info.currency)?.toUpperCase() ?? null
const balanceAmountLabel = asString(info.total_balance) ?? String(totalBalance)
const balanceLabel = currency !== null ? `${currency} ${balanceAmountLabel}` : balanceAmountLabel
// Why: remaining prepaid credit is shown as "used %" for the status bar — 0% with credit left, 100% when depleted/unavailable.
const usedPercent = isAvailable && totalBalance > 0 ? 0 : 100
return {
usedPercent,
windowMinutes: MONTHLY_WINDOW_MINUTES,
resetsAt: null,
resetDescription: balanceLabel
}
}

function mapBalanceResponse(data: Record<string, unknown>): ProviderRateLimits {
const isAvailable = data.is_available === true
const info = pickBalanceInfo(data.balance_infos)
if (!info) {
return result('error', 'DeepSeek balance response did not include balance_infos', {
failureKind: 'parse',
source: 'cli'
})
}
const monthly = mapBalanceWindow(info, isAvailable)
if (!monthly) {
return result('error', 'DeepSeek balance response did not include a total_balance', {
failureKind: 'parse',
source: 'cli'
})
}
const currency = asString(info.currency)?.toUpperCase() ?? null
return {
provider: 'deepseek',
session: null,
weekly: null,
monthly,
planType: currency,
updatedAt: Date.now(),
error: null,
status: 'ok',
usageMetadata: {
source: 'cli',
authProvenance: monthly.resetDescription
? `DeepSeek balance ${monthly.resetDescription}`
: 'DeepSeek API key'
}
}
}

/**
* Prepaid balance for DeepSeek via DEEPSEEK_API_KEY.
*
* Why: DeepSeek exposes remaining credit (not rolling rate-limit windows). Map the
* preferred USD (else first) balance into the monthly slot so the status bar has
* hasUsageData without inventing session/weekly quotas.
*/
export async function fetchDeepSeekRateLimits(
options: { env?: NodeJS.ProcessEnv; signal?: AbortSignal } = {}
): Promise<ProviderRateLimits> {
const env = options.env ?? process.env
const apiKey = readDeepSeekApiKey(env)
if (!apiKey) {
return result('unavailable', 'DeepSeek API key not set — export DEEPSEEK_API_KEY', {
failureKind: 'missing-credentials',
source: 'cli'
})
}

try {
const requestSignal = options.signal
? AbortSignal.any([options.signal, AbortSignal.timeout(API_TIMEOUT_MS)])
: AbortSignal.timeout(API_TIMEOUT_MS)
const res = await net.fetch(BALANCE_URL, {
headers: {
Authorization: `Bearer ${apiKey}`,
Accept: 'application/json'
},
signal: requestSignal
})
if (res.status === 401 || res.status === 403) {
return result('error', `DeepSeek balance request unauthorized (HTTP ${res.status})`, {
failureKind: 'stale-token',
source: 'cli'
})
}
if (!res.ok) {
return result('error', `DeepSeek balance request failed (HTTP ${res.status})`, {
failureKind: res.status >= 500 ? 'server' : 'unknown',
source: 'cli'
})
}
let data: unknown
try {
data = await res.json()
} catch {
return result('error', 'DeepSeek balance response was not valid JSON', {
failureKind: 'parse',
source: 'cli'
})
}
if (!isBalanceRecord(data)) {
return result('error', 'DeepSeek balance response was not an object', {
failureKind: 'parse',
source: 'cli'
})
}
return mapBalanceResponse(data)
} catch (err) {
return result('error', err instanceof Error ? err.message : 'DeepSeek balance request failed', {
failureKind: 'network',
source: 'cli'
})
}
}
Loading