@rayadesu/dsh-billing 0.1.0-rc.8

package/packages/llm-billing/src/index.ts

@@ -0,0 +1,219 @@
+/**
+ * DeepSeek account balance and session-spend provider, as a standalone host
+ * plugin. It resolves the DeepSeek endpoint and API key from its own config and
+ * the credential/environment seams, prices each session's billed usage with the
+ * peak/off-peak table, and exposes the `billing` Remote (`getBalance`, the
+ * per-session `getSessionSpend`, and the all-sessions `getTodaySpend`).
+ * @module @rayadesu/dsh-llm-billing
+ */
+
+import type { Context } from '@deepseek-ai/cordis'
+import z from '@deepseek-ai/schemastery'
+import { assertUsableApiKey, LlmError } from '@deepseek-ai/dsh-llm'
+import { credentialRef } from '@deepseek-ai/dsh-credentials'
+import { launchEnvironmentOf } from '@deepseek-ai/dsh-launch-environment'
+import type { SessionEvent, SessionId } from '@deepseek-ai/dsh-session'
+import type {} from '@deepseek-ai/dsh-session-persistence'
+import { DeepSeekBalanceGateway, fetchDeepSeekBalance } from './balance.ts'
+import {
+  computeSessionSpend,
+  computeTodaySpend,
+  DEFAULT_MODEL_PRICING,
+  DEFAULT_PEAK_HOURS,
+  resolveBilling,
+} from './billing.ts'
+import type { BillingConfig, BillingConfigModel } from './billing.ts'
+import type { DeepSeekBalance, DeepSeekSessionSpend, DeepSeekTodaySpend } from './types.ts'
+
+export { DeepSeekBalanceGateway, fetchDeepSeekBalance, parseDeepSeekBalance } from './balance.ts'
+export {
+  computeSessionSpend,
+  computeTodaySpend,
+  DEFAULT_MODEL_PRICING,
+  DEFAULT_PEAK_HOURS,
+  isPeak,
+  resolveBilling,
+} from './billing.ts'
+export type {
+  BillingConfig,
+  BillingConfigModel,
+  DeepSeekModelPricing,
+  DeepSeekTokenPrice,
+  PeakHourWindow,
+  ResolvedBilling,
+} from './billing.ts'
+export type * from './types.ts'
+
+export const name = 'llm-billing'
+
+const DEFAULT_API_KEY_ENV = 'DEEPSEEK_API_KEY'
+const BASE_URL_ENV = 'DEEPSEEK_BASE_URL'
+/** Public API default; deployments may point elsewhere via $DEEPSEEK_BASE_URL. */
+export const PUBLIC_BASE_URL = 'https://api.deepseek.com'
+
+/** One advisory display row; requests are never restricted to this list. */
+export interface BillingModel {
+  /** Wire model id, e.g. `deepseek-v4-flash`. */
+  id: string
+  /** Selector label; defaults to {@link id}. */
+  name?: string
+}
+
+const DEFAULT_MODELS: BillingModel[] = [
+  { id: 'deepseek-v4-flash', name: 'DeepSeek-V4-Flash' },
+  { id: 'deepseek-v4-pro', name: 'DeepSeek-V4-Pro' },
+  { id: 'deepseek-v4-flash-vision-exp', name: 'DeepSeek-V4-Flash-Vision-Exp' },
+]
+
+/**
+ * Plugin config. Every field is optional: the API key resolves per call from
+ * {@link Config.apiKeyEnv} (credentials seam, then environment), the endpoint
+ * falls back to `$DEEPSEEK_BASE_URL` then the public API, and the pricing
+ * table and peak-hour windows fall back to the published DeepSeek rates.
+ */
+export interface Config {
+  /** Credential reference (environment-variable name); defaults to `DEEPSEEK_API_KEY`. */
+  apiKeyEnv?: string
+  /** Endpoint base; defaults to `$DEEPSEEK_BASE_URL`, then `https://api.deepseek.com`. */
+  baseURL?: string
+  /** Advisory display rows, in presentation order; defaults to V4 Flash, V4 Pro, and V4 Flash Vision Exp. */
+  models?: BillingModel[]
+  /** Pricing table and peak-hour windows; omission uses the published defaults. */
+  billing?: BillingConfig
+}
+
+const billingModel: z<BillingModel> = z.object({
+  id: z.string().required(),
+  name: z.string(),
+})
+
+const tokenPrice: z<BillingConfigModel['peak']> = z.object({
+  cacheHitInput: z.number().min(0),
+  cacheMissInput: z.number().min(0),
+  output: z.number().min(0),
+})
+
+const billingConfig: z<BillingConfig> = z.object({
+  peakHours: z.array(z.object({
+    start: z.number().step(1).min(0).max(23),
+    end: z.number().step(1).min(0).max(24),
+  })).default(DEFAULT_PEAK_HOURS),
+  models: z.array(z.object({
+    model: z.string().required(),
+    peak: tokenPrice,
+    offPeak: tokenPrice,
+  })).default(DEFAULT_MODEL_PRICING),
+})
+
+export const Config: z<Config> = z.object({
+  apiKeyEnv: z.string().role('credential-ref').default(DEFAULT_API_KEY_ENV),
+  baseURL: z.string(),
+  models: z.array(billingModel).default(DEFAULT_MODELS),
+  billing: billingConfig,
+})
+
+/**
+ * Read one session's event log: the live SessionStore first, then the
+ * persistence backend for a flushed session.
+ * @param ctx - plugin context carrying the SessionStore and optional persistence.
+ * @param sessionId - the session to read.
+ * @returns the session's complete event log.
+ * @throws {@link LlmError} with code `NOT_FOUND` when the session is unknown.
+ */
+async function sessionEvents(ctx: Context, sessionId: SessionId): Promise<readonly SessionEvent[]> {
+  const sessions = ctx.get('sessions')
+  const live = sessions?.get(sessionId)
+  if (live !== undefined) return live.events
+  const persistence = ctx.get('sessionPersistence')
+  if (persistence !== undefined) {
+    for (const header of await persistence.list()) {
+      if (header.id !== sessionId) continue
+      const inspection = await persistence.inspect(sessionId)
+      return inspection.events
+    }
+  }
+  throw new LlmError(`llm-billing: session ${sessionId} not found`, 'NOT_FOUND')
+}
+
+/**
+ * Read every session's event log, concatenated: each live SessionStore
+ * session first (its log may hold events not yet flushed), then each persisted
+ * session that is not live, so no event is counted twice. Events are appended
+ * one at a time: spreading a very large log into `push(...)` exceeds the
+ * engine's argument limit and throws a stack RangeError.
+ * @param ctx - plugin context carrying the SessionStore and optional persistence.
+ * @returns every session's complete event log, concatenated.
+ */
+async function allSessionEvents(ctx: Context): Promise<readonly SessionEvent[]> {
+  const events: SessionEvent[] = []
+  const sessions = ctx.get('sessions')
+  const liveIds = new Set<SessionId>()
+  if (sessions !== undefined) {
+    for (const session of sessions.list()) {
+      liveIds.add(session.id)
+      for (const event of session.events) events.push(event)
+    }
+  }
+  const persistence = ctx.get('sessionPersistence')
+  if (persistence !== undefined) {
+    for (const header of await persistence.list()) {
+      if (liveIds.has(header.id)) continue
+      try {
+        const inspection = await persistence.inspect(header.id)
+        for (const event of inspection.events) events.push(event)
+      } catch (error: unknown) {
+        // One unreadable session must not blank the whole-day aggregate.
+        ctx.logger.warn(`llm-billing: skipping unreadable session ${header.id}: ${String(error)}`)
+      }
+    }
+  }
+  return events
+}
+
+/**
+ * Register the `billing` Remote under the `billing` namespace.
+ * @param ctx - owning plugin context.
+ * @param config - validated plugin config.
+ */
+export function apply(ctx: Context, config: Config): void {
+  const baseURL = (): string => config.baseURL
+    ?? launchEnvironmentOf(ctx).get(BASE_URL_ENV)?.value
+    ?? PUBLIC_BASE_URL
+  const apiKeyRef = credentialRef(config.apiKeyEnv ?? DEFAULT_API_KEY_ENV)
+
+  const resolveApiKey = async (): Promise<string> => {
+    const credentials = ctx.get('credentials')
+    if (credentials !== undefined) {
+      const hit = await credentials.resolve(apiKeyRef)
+      if (hit !== undefined) return assertUsableApiKey(hit.value, 'llm-billing', apiKeyRef)
+    } else {
+      const ambient = launchEnvironmentOf(ctx).get(apiKeyRef)
+      if (ambient !== undefined && ambient.value.length > 0) {
+        return assertUsableApiKey(ambient.value, 'llm-billing', apiKeyRef)
+      }
+    }
+    throw new LlmError(
+      `llm-billing: no API key; store ${apiKeyRef} through the credentials service or export it`,
+      'MISSING_CREDENTIAL',
+    )
+  }
+
+  const fetchBalance = async (): Promise<DeepSeekBalance> => {
+    const apiKey = await resolveApiKey()
+    return fetchDeepSeekBalance(baseURL(), apiKey)
+  }
+
+  const fetchSessionSpend = async (sessionId: SessionId): Promise<DeepSeekSessionSpend> => {
+    const billing = resolveBilling(config.billing)
+    const catalog = (config.models ?? DEFAULT_MODELS).map(model => ({ id: model.id, name: model.name ?? model.id }))
+    return computeSessionSpend(await sessionEvents(ctx, sessionId), billing, catalog)
+  }
+
+  const fetchTodaySpend = async (): Promise<DeepSeekTodaySpend> => {
+    const billing = resolveBilling(config.billing)
+    const catalog = (config.models ?? DEFAULT_MODELS).map(model => ({ id: model.id, name: model.name ?? model.id }))
+    return computeTodaySpend(await allSessionEvents(ctx), billing, catalog)
+  }
+
+  new DeepSeekBalanceGateway(ctx, { fetchBalance, fetchSessionSpend, fetchTodaySpend })
+}

package/packages/llm-billing/src/invariant.ts

@@ -0,0 +1,30 @@
+/**
+ * Package-owned invariant companion for `@rayadesu/dsh-llm-billing`.
+ * @module @rayadesu/dsh-llm-billing/invariant
+ */
+
+/* jscpd:ignore-start */
+import type { Context } from '@deepseek-ai/cordis'
+import type { InvariantInstaller } from '@deepseek-ai/dsh-invariants'
+
+const PACKAGE_NAME = '@rayadesu/dsh-llm-billing'
+
+/** Cordis companion plugin name. */
+export const name = 'llm-billing-invariant'
+/** Service required before the companion can reserve package ownership. */
+export const inject = ['invariants']
+
+/**
+ * No runtime invariant: this package is a read-only Remote projection over the
+ * provider balance and session logs, and owns no cross-plugin mutable state.
+ */
+const install: InvariantInstaller = () => {}
+
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export const apply = (ctx: Context): Promise<() => void> =>
+  Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install))
+/* jscpd:ignore-end */

package/packages/llm-billing/src/types.ts

@@ -0,0 +1,67 @@
+/**
+ * Client-safe balance and spend vocabulary shared by the `billing` Remote,
+ * its generated artifacts, and the web UI.
+ * @module @rayadesu/dsh-llm-billing/types
+ */
+
+/** One currency line of the account balance returned by `GET /user/balance`. */
+export interface DeepSeekBalanceLine {
+  /** Currency code, e.g. `CNY` or `USD`. */
+  currency: string
+  /** Total available balance (granted plus topped up). */
+  total: string
+  /** Non-expired granted (free) balance. */
+  granted: string
+  /** Topped-up (paid) balance. */
+  toppedUp: string
+}
+
+/** DeepSeek account balance returned by `GET /user/balance`. */
+export interface DeepSeekBalance {
+  /** Whether the account has any balance available for API calls. */
+  isAvailable: boolean
+  /** Balance lines, one per currency; empty when the provider reports none. */
+  lines: readonly DeepSeekBalanceLine[]
+}
+
+/** One model's billed spend within one session, priced by the peak/off-peak table. */
+export interface DeepSeekSessionSpendModel {
+  /** Wire model id, e.g. `deepseek-v4-flash`. */
+  model: string
+  /** Selector label, e.g. `DeepSeek-V4-Flash`. */
+  displayName: string
+  /** Billed cost in CNY (peak plus off-peak portions). */
+  cost: number
+  /** Cost portion billed at peak rates. */
+  peakCost: number
+  /** Cost portion billed at off-peak rates. */
+  offPeakCost: number
+  /** Cache-hit input tokens billed at the hit rate. */
+  cacheHitInputTokens: number
+  /** Cache-miss input tokens (uncached input plus cache writes), billed at the miss rate. */
+  cacheMissInputTokens: number
+  /** Output tokens (reasoning included), billed at the output rate. */
+  outputTokens: number
+  /** Billed cost of cache-hit input tokens in CNY. */
+  cacheHitInputCost: number
+  /** Billed cost of cache-miss input tokens (uncached input plus cache writes) in CNY. */
+  cacheMissInputCost: number
+  /** Billed cost of output tokens (reasoning included) in CNY. */
+  outputCost: number
+}
+
+/** The billed spend of one session, priced per event by its Beijing-time peak/off-peak hour. */
+export interface DeepSeekSessionSpend {
+  /** Total billed cost in CNY across every priced model. */
+  total: number
+  /** One row per model that reported usage AND has a pricing row; empty when the session has no priced usage. */
+  models: readonly DeepSeekSessionSpendModel[]
+}
+
+/** The billed spend of every session on one Beijing-time calendar day, priced per event by its peak/off-peak hour. */
+export interface DeepSeekTodaySpend {
+  /** Total billed cost in CNY across every priced model and every session. */
+  total: number
+  /** One row per model that reported usage AND has a pricing row; empty when today has no priced usage. */
+  models: readonly DeepSeekSessionSpendModel[]
+}

package/packages/llm-billing/tests/balance.spec.ts

@@ -0,0 +1,254 @@
+/**
+ * Account-balance capability: the wire parser, the transport, and the Remote
+ * gateway binding. Fetch is exercised through a mocked global fetch, so the
+ * suite stays keyless and deterministic.
+ */
+import { Context } from '@deepseek-ai/cordis'
+import { LlmError } from '@deepseek-ai/dsh-llm'
+import type { SessionEvent, SessionId } from '@deepseek-ai/dsh-session'
+import { remoteMethods } from '@deepseek-ai/dsh-typert-protocol'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { DeepSeekBalanceGateway, fetchDeepSeekBalance, parseDeepSeekBalance } from '../src/balance.ts'
+import { apply as applyBilling } from '../src/index.ts'
+import type { DeepSeekBalance } from '../src/types.ts'
+
+const VALID_WIRE = {
+  is_available: true,
+  balance_infos: [
+    { currency: 'CNY', total_balance: '110.00', granted_balance: '10.00', topped_up_balance: '100.00' },
+  ],
+}
+
+const VALID_PUBLIC: DeepSeekBalance = {
+  isAvailable: true,
+  lines: [{ currency: 'CNY', total: '110.00', granted: '10.00', toppedUp: '100.00' }],
+}
+
+const VALID_SPEND = {
+  total: 0.31,
+  models: [{
+    model: 'deepseek-v4-flash',
+    displayName: 'DeepSeek-V4-Flash',
+    cost: 0.31,
+    peakCost: 0.31,
+    offPeakCost: 0,
+    cacheHitInputTokens: 1000,
+    cacheMissInputTokens: 100000,
+    outputTokens: 20000,
+    cacheHitInputCost: 0.01,
+    cacheMissInputCost: 0.20,
+    outputCost: 0.10,
+  }],
+}
+
+const VALID_TODAY_SPEND = {
+  total: 0.62,
+  models: [{
+    model: 'deepseek-v4-flash',
+    displayName: 'DeepSeek-V4-Flash',
+    cost: 0.62,
+    peakCost: 0.31,
+    offPeakCost: 0.31,
+    cacheHitInputTokens: 2000,
+    cacheMissInputTokens: 200000,
+    outputTokens: 40000,
+    cacheHitInputCost: 0.02,
+    cacheMissInputCost: 0.40,
+    outputCost: 0.20,
+  }],
+}
+
+function jsonResponse(status: number, body: unknown): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { 'content-type': 'application/json' },
+  })
+}
+
+afterEach(() => {
+  vi.restoreAllMocks()
+})
+
+describe('parseDeepSeekBalance', () => {
+  it('maps the wire response to the public snapshot', () => {
+    expect(parseDeepSeekBalance(VALID_WIRE)).toEqual(VALID_PUBLIC)
+  })
+
+  it('keeps every currency line', () => {
+    expect(parseDeepSeekBalance({
+      is_available: true,
+      balance_infos: [
+        { currency: 'CNY', total_balance: '1.00', granted_balance: '0.00', topped_up_balance: '1.00' },
+        { currency: 'USD', total_balance: '2.00', granted_balance: '1.00', topped_up_balance: '1.00' },
+      ],
+    })).toMatchObject({ lines: [{ currency: 'CNY' }, { currency: 'USD' }] })
+  })
+
+  it('rejects a non-object body', () => {
+    expect(() => parseDeepSeekBalance(null)).toThrow(LlmError)
+  })
+
+  it('rejects a body missing is_available or balance_infos', () => {
+    expect(() => parseDeepSeekBalance({ is_available: true })).toThrow(LlmError)
+    expect(() => parseDeepSeekBalance({ balance_infos: [] })).toThrow(LlmError)
+  })
+
+  it('rejects a malformed balance line', () => {
+    expect(() => parseDeepSeekBalance({
+      is_available: true,
+      balance_infos: [{ currency: 'CNY', total_balance: '1.00', granted_balance: '0.00' }],
+    })).toThrow(LlmError)
+  })
+})
+
+describe('fetchDeepSeekBalance', () => {
+  it('fetches /user/balance with the resolved bearer token', async () => {
+    const spy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(jsonResponse(200, VALID_WIRE))
+    await expect(fetchDeepSeekBalance('https://api.deepseek.com', 'secret')).resolves.toEqual(VALID_PUBLIC)
+    expect(spy).toHaveBeenCalledWith(
+      'https://api.deepseek.com/user/balance',
+      expect.objectContaining({
+        method: 'GET',
+        // The header matcher is the assertion; objectContaining is any-typed.
+        headers: expect.objectContaining({ authorization: 'Bearer secret' }), // oxlint-disable-line typescript/no-unsafe-assignment
+      }),
+    )
+  })
+
+  it('maps an HTTP status to the provider error code', async () => {
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue(jsonResponse(401, {}))
+    await expect(fetchDeepSeekBalance('https://api.deepseek.com', 'bad')).rejects.toMatchObject({ code: 'AUTH' })
+  })
+
+  it('wraps a network failure as TRANSPORT', async () => {
+    vi.spyOn(globalThis, 'fetch').mockRejectedValue(new Error('fetch failed'))
+    await expect(fetchDeepSeekBalance('https://api.deepseek.com', 'key')).rejects.toMatchObject({ code: 'TRANSPORT' })
+  })
+
+  it('rejects a non-JSON body as TRANSPORT', async () => {
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('not json', { status: 200 }))
+    await expect(fetchDeepSeekBalance('https://api.deepseek.com', 'key')).rejects.toMatchObject({ code: 'TRANSPORT' })
+  })
+
+  it('reports caller cancellation as ABORTED', async () => {
+    const controller = new AbortController()
+    controller.abort()
+    vi.spyOn(globalThis, 'fetch').mockRejectedValue(new Error('aborted'))
+    await expect(fetchDeepSeekBalance('https://api.deepseek.com', 'key', controller.signal))
+      .rejects.toMatchObject({ code: 'ABORTED' })
+  })
+})
+
+describe('DeepSeekBalanceGateway', () => {
+  const options = {
+    fetchBalance: async () => VALID_PUBLIC,
+    fetchSessionSpend: async () => VALID_SPEND,
+    fetchTodaySpend: async () => VALID_TODAY_SPEND,
+  }
+
+  it('registers under the billing namespace and exports getBalance, getSessionSpend, and getTodaySpend', () => {
+    const ctx = new Context()
+    const gateway = new DeepSeekBalanceGateway(ctx, options)
+    expect(gateway.typertRemote.namespace).toBe('billing')
+    const methods = remoteMethods(gateway).map(marker => marker.exportName ?? marker.method)
+    expect(methods).toContain('getBalance')
+    expect(methods).toContain('getSessionSpend')
+    expect(methods).toContain('getTodaySpend')
+    expect(ctx.get('billing')).toBeDefined()
+  })
+
+  it('delegates to the bound fetch thunks', async () => {
+    const ctx = new Context()
+    const gateway = new DeepSeekBalanceGateway(ctx, options)
+    await expect(gateway.getBalance()).resolves.toEqual(VALID_PUBLIC)
+    await expect(gateway.getSessionSpend('session-1' as SessionId)).resolves.toEqual(VALID_SPEND)
+    await expect(gateway.getTodaySpend()).resolves.toEqual(VALID_TODAY_SPEND)
+  })
+
+  it('is root-visible when constructed inside a plugin fiber', async () => {
+    const root = new Context()
+    const fiber = root.plugin({
+      name: 'llm-deepseek-sim',
+      apply: (pluginCtx: Context) => {
+        new DeepSeekBalanceGateway(pluginCtx, options)
+      },
+    })
+    await fiber.await()
+    expect(root.get('billing')).toBeDefined()
+    await root.fiber.dispose()
+  })
+})
+
+describe('apply / allSessionEvents', () => {
+  /** One today-priced flash event: now falls on today's Beijing calendar day. */
+  function pricedEvent(index: number): SessionEvent {
+    return {
+      type: 'assistant/message',
+      seq: index,
+      time: Date.now(),
+      data: {
+        turn: 0,
+        step: index,
+        message: {
+          id: `m${index}` as never,
+          role: 'assistant',
+          content: [],
+          source: { kind: 'model', provider: 'deepseek-official', model: 'deepseek-v4-flash' },
+        },
+        usage: { inputTokens: 100, outputTokens: 100, cacheReadTokens: 100, cacheWriteTokens: 50 },
+      },
+    } as unknown as SessionEvent
+  }
+
+  it('aggregates today\'s spend across a very large session log without exceeding the call stack', async () => {
+    const ctx = new Context()
+    ctx.provide('sessions', { list: () => [] } as never)
+    const bigEvents = Array.from({ length: 200_000 }, (_, index) => pricedEvent(index))
+    ctx.provide('sessionPersistence', {
+      list: async () => [{ id: 'session-big' }],
+      inspect: async () => ({ meta: {}, events: bigEvents }),
+    } as never)
+    applyBilling(ctx, {})
+    const gateway = ctx.get('billing') as unknown as DeepSeekBalanceGateway
+    await expect(gateway.getTodaySpend()).resolves.toMatchObject({
+      total: expect.any(Number), // oxlint-disable-line typescript/no-unsafe-assignment
+      models: [{ model: 'deepseek-v4-flash' }],
+    })
+    await ctx.fiber.dispose()
+  })
+
+  it('skips a session that fails to inspect instead of failing the whole day', async () => {
+    const ctx = new Context()
+    ctx.provide('sessions', { list: () => [] } as never)
+    ctx.provide('sessionPersistence', {
+      list: async () => [{ id: 'session-ok' }, { id: 'session-bad' }],
+      inspect: async (id: SessionId) => {
+        if (id === 'session-bad' as SessionId) throw new Error('corrupt log')
+        return { meta: {}, events: [pricedEvent(0)] }
+      },
+    } as never)
+    applyBilling(ctx, {})
+    const gateway = ctx.get('billing') as unknown as DeepSeekBalanceGateway
+    await expect(gateway.getTodaySpend()).resolves.toMatchObject({
+      total: expect.any(Number), // oxlint-disable-line typescript/no-unsafe-assignment
+    })
+    await ctx.fiber.dispose()
+  })
+
+  it('counts live sessions first and does not double-count them through persistence', async () => {
+    const ctx = new Context()
+    ctx.provide('sessions', {
+      list: () => [{ id: 'session-live', events: [pricedEvent(0)] }],
+    } as never)
+    ctx.provide('sessionPersistence', {
+      list: async () => [{ id: 'session-live' }],
+      inspect: async () => { throw new Error('must not be read') },
+    } as never)
+    applyBilling(ctx, {})
+    const gateway = ctx.get('billing') as unknown as DeepSeekBalanceGateway
+    await expect(gateway.getTodaySpend()).resolves.toMatchObject({
+      total: expect.any(Number), // oxlint-disable-line typescript/no-unsafe-assignment
+    })
+    await ctx.fiber.dispose()
+  })
+})