dsh-token-total 1.0.0 → 1.0.1

package/src/client/use-session-usage.ts

@@ -1,115 +1,62 @@
-/**
- * The composer row's window onto the WHOLE session tree.
- *
- * dsh's native `tokenUsage` projection is the main agent of the current
- * session only: a session that delegates to subagents (each subagent is its
- * own persisted session, linked by `header.parentSession`) shows a fraction of
- * what it actually spent, and nothing in the shipped UI shows the rest. The
- * host half answers that question over `/token-total/api/session`, replaying
- * the root log plus every descendant's log; this hook is the browser end.
- *
- * Refresh policy: the request is cheap on the host (its tree cache is
- * invalidated by live events), and the native usage figure moves exactly when
- * a call settles — so a change in the native signature is the trigger to
- * re-ask. There is no timer: an idle session costs nothing.
- *
- * Failure policy: the pill must never break the composer, so a failed request
- * keeps the last good answer and simply does not retry until the next trigger.
- */
+/** The composer row's window onto the whole session tree. The native usage
+ * projection only moves for main-agent calls, so poll the displayed session
+ * even before its first child appears. Requests are serialized and late answers
+ * from a previous session are discarded. Failures keep the last good reading. */
 import { useEffect, useRef, useState } from 'react'
 import { fetchSessionUsage } from './api.ts'
+import { combinedTotals } from './session-usage-core.ts'
 import type { SessionUsageTotals, SessionUsageTree } from '../wire.ts'
 
-const ZERO: SessionUsageTotals = {
-  uncachedInputTokens: 0,
-  outputTokens: 0,
-  cacheReadTokens: 0,
-  cacheWriteTokens: 0,
-}
-
-function add(into: SessionUsageTotals, from: SessionUsageTotals): SessionUsageTotals {
-  return {
-    uncachedInputTokens: into.uncachedInputTokens + from.uncachedInputTokens,
-    outputTokens: into.outputTokens + from.outputTokens,
-    cacheReadTokens: into.cacheReadTokens + from.cacheReadTokens,
-    cacheWriteTokens: into.cacheWriteTokens + from.cacheWriteTokens,
-  }
-}
-
-/** Fold a tree into the flat shape the pill's dialog renders. */
-export function combinedTotals(tree: SessionUsageTree): SessionUsageTotals {
-  return add(tree.self, tree.subagents)
-}
-
-/** Whether a totals record carries any billable token at all. */
-export function hasAnyTokens(totals: SessionUsageTotals | undefined): boolean {
-  if (totals === undefined) return false
-  return totals.uncachedInputTokens + totals.outputTokens
-    + totals.cacheReadTokens + totals.cacheWriteTokens > 0
-}
-
-/** Total billed tokens of a flat totals record (prompt side + completion). */
-export function billedTotal(totals: SessionUsageTotals): number {
-  return totals.uncachedInputTokens + totals.cacheReadTokens
-    + totals.cacheWriteTokens + totals.outputTokens
-}
-
-/** Cache hit rate over the prompt side, or null when nothing was prompted. */
-export function cacheHitPercentOf(totals: SessionUsageTotals): number | null {
-  const hit = totals.cacheReadTokens
-  const miss = totals.uncachedInputTokens + totals.cacheWriteTokens
-  if (hit + miss === 0) return null
-  return (hit / (hit + miss)) * 100
-}
+export { billedTotal, cacheHitPercentOf, combinedTotals, hasAnyTokens } from './session-usage-core.ts'
 
 export interface SessionTreeReading {
   tree: SessionUsageTree | null
-  /** main + subagents, or null before the first successful answer. */
+  /** Log-based main + subagents. The pill substitutes the live main projection. */
   totals: SessionUsageTotals | null
 }
 
-/** How often a session that HAS subagents re-asks. The native figure only moves
- *  when the main agent's own call settles, so without this a subagent still
- *  working (or one that just finished) would not update the pill. A session
- *  with no subagents never polls: nothing exists to miss. */
-const SUBAGENT_POLL_MS = 4_000
+const SESSION_POLL_MS = 4_000
 
-/**
- * Subscribe to one session's whole-tree usage.
- *
- * `signature` is any string that changes when the native usage figure moves;
- * passing it in keeps this hook out of the projection seat and lets the caller
- * decide what "a new call settled" means for its own pill. A session that turns
- * out to have subagents additionally re-asks on a slow beat, because subagent
- * spend lands in a different session log and no native figure moves for it.
- */
 export function useSessionUsage(sessionId: string | undefined, signature: string): SessionTreeReading {
-  const [tree, setTree] = useState<SessionUsageTree | null>(null)
-  const latest = useRef<string>('')
-  const [beat, setBeat] = useState(0)
-  const hasSubagents = (tree?.subagentSessions ?? 0) > 0
-  useEffect(() => {
-    if (!hasSubagents) return
-    const handle = setInterval(() => { setBeat(Date.now()) }, SUBAGENT_POLL_MS)
-    return () => { clearInterval(handle) }
-  }, [hasSubagents])
+  const [reading, setReading] = useState<{ sessionId: string; tree: SessionUsageTree } | null>(null)
+  const refresh = useRef<(() => void) | null>(null)
   useEffect(() => {
     if (typeof sessionId !== 'string' || sessionId === '') return
-    const key = `${sessionId}|${signature}|${beat}`
-    if (latest.current === key) return
-    latest.current = key
-    let cancelled = false
-    void fetchSessionUsage(sessionId).then((value) => {
-      if (cancelled) return
-      setTree(value)
-    }).catch(() => {
-      // Keep the previous reading; the next trigger retries.
-      latest.current = ''
-    })
+    let active = true
+    let pending = false
+    let again = false
+    const request = (): void => {
+      if (!active) return
+      if (pending) {
+        again = true
+        return
+      }
+      pending = true
+      void fetchSessionUsage(sessionId).then((tree) => {
+        if (active) setReading({ sessionId, tree })
+      }).catch(() => {
+        // Retry on the next beat/signature; do not replace good data with zero.
+      }).finally(() => {
+        pending = false
+        if (active && again) {
+          again = false
+          request()
+        }
+      })
+    }
+    refresh.current = request
+    const handle = setInterval(request, SESSION_POLL_MS)
     return () => {
-      cancelled = true
+      active = false
+      refresh.current = null
+      clearInterval(handle)
     }
-  }, [sessionId, signature, beat])
-  const totals = tree === null ? null : combinedTotals(tree)
-  return { tree, totals }
+  }, [sessionId])
+  useEffect(() => {
+    refresh.current?.()
+  }, [sessionId, signature])
+  // Key the answer on its session, not just effect cleanup: the very first
+  // render after switching must not show the previous session's descendants.
+  const tree = reading !== null && reading.sessionId === sessionId ? reading.tree : null
+  return { tree, totals: tree === null ? null : combinedTotals(tree) }
 }

package/src/collector.ts

@@ -3,10 +3,10 @@
  * Two sources feed the same fold:
  *
  * - live: `session/event` subscription — every committed session event
- *   reaches this plugin after the fact. `assistant/message` carries the
- *   step's final `usage` (TokenUsage); `assistant/chunk` carries an early
- *   `usage` sample from the streaming adapter; `request/context` carries the
- *   provider/model route. A completed call's usage is attributed to the model
+ *   reaches this plugin after the fact. Assistant messages expose final usage,
+ *   and modern message/attempt streams retain raw usage even on failed calls.
+ *   Legacy `assistant/chunk` reports an early sample; `request/context` carries
+ *   the provider/model route. A completed call's usage is attributed to the model
  *   the request used — in priority order: the message's own `source`
  *   (authoritative per call), then the session's last-known route, which
  *   comes from observed `request/context` events OR is lazily seeded from
@@ -27,11 +27,10 @@
  *   >= 0.1.2-rc.1, 0 for a non-forked session), and the replay skips it —
  *   the parent's own backfill already counted those events.
  *
- * Idempotence: within ONE session, the same (turn, step) may report usage
- * more than once (a streaming sample then the final assistant/message;
- * compaction replays). The fold emits each (turn, step) key exactly once and
- * keeps the newest values in its own state — see the replaceSample note for
- * why the store observably keeps the FIRST emission. Cross-session
+ * Idempotence: within ONE session, repeated reports for the same (turn, step)
+ * emit only signed bucket corrections: the accumulated usage is last-wins.
+ * A started retry closes that replacement slot because its predecessor was a
+ * separately billed attempt. Cross-session
  * (turn, step) collisions are NOT deduped: two sessions both own a turn 1 /
  * step 1, and each must count. The store's per-day rows accumulate, so
  * re-folding the same log must not add twice: live events are only folded
@@ -51,6 +50,8 @@ interface UsageEventData {
   turn?: number
   step?: number
   usage?: { inputTokens: number; outputTokens: number; cacheReadTokens?: number; cacheWriteTokens?: number; reasoningTokens?: number }
+  /** v2+ durable Assistant stream: usage is a raw (never packed) chunk. */
+  stream?: readonly { type?: string; chunk?: { type?: string; usage?: UsageEventData['usage'] } }[]
 }
 
 /** The assistant/message payload. */
@@ -170,6 +171,11 @@ export class UsageFold {
       // reasonix emits TurnDone regardless of the run's error.
       return { day: dayKey(ev.time), hour: hourKey(ev.time), inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, turn: true }
     }
+    if (ev.type === 'llm/retry-started') {
+      // A retry is a separate billed attempt even though it shares turn/step.
+      const key = this.keyOf(ev)
+      if (key !== null) this.seen.delete(key)
+    }
     if (ev.type === 'step/start' || ev.type === 'llm/retry-started') {
       // Attribution note: agent-loop appends step/start BEFORE request/context
       // (core/agent-loop agent.ts), so the FIRST request marker of a fresh —
@@ -194,17 +200,26 @@ export class UsageFold {
         request: true,
       }
     }
-    // `assistant/chunk` only exists on DSH <= 0.1.2 (streaming usage sample);
-    // 0.1.3+ logs attempts as `assistant/attempt` (no usage) and the final
-    // `assistant/message` stays authoritative. Kept as a dead branch for rc.1.
+    // Legacy streaming event. Modern hosts commit the complete stream on an
+    // assistant/message OR assistant/attempt, including failed/aborted calls.
     if (ev.type === 'assistant/chunk') {
       const data = ev.data as AssistantChunkData
       const usage = data.chunk?.type === 'usage' ? data.chunk.usage : undefined
       return usage ? this.replaceSample(ev, usage) : null
     }
-    if (ev.type === 'assistant/message') {
+    if (ev.type === 'assistant/message' || ev.type === 'assistant/attempt') {
       const data = ev.data as AssistantMessageData
-      return data.usage ? this.replaceSample(ev, data.usage) : null
+      let usage = ev.type === 'assistant/message' ? data.usage : undefined
+      if (usage === undefined && Array.isArray(data.stream)) {
+        for (let i = data.stream.length - 1; i >= 0; i--) {
+          const record = data.stream[i]
+          if (record?.type === 'chunk' && record.chunk?.type === 'usage') {
+            usage = record.chunk.usage
+            break
+          }
+        }
+      }
+      return usage ? this.replaceSample(ev, usage) : null
     }
     if (ev.type === 'compaction/summary') return this.compactionSample(ev)
     return null
@@ -213,53 +228,44 @@ export class UsageFold {
   private replaceSample(ev: UsageSessionEvent, usage: UsageEventData['usage']): UsageSample | null {
     const usage2 = usage
     if (!usage2) return null
-    // A sample with nothing at all is noise; a pure-cache call (zero
-    // uncached input AND zero output but real cache traffic) still counts —
-    // its cacheRead/cacheWrite buckets are real provider-reported tokens.
-    if (
-      (usage2.inputTokens ?? 0)
-      + (usage2.outputTokens ?? 0)
-      + (usage2.cacheReadTokens ?? 0)
-      + (usage2.cacheWriteTokens ?? 0)
-      <= 0
-    ) {
-      return null
-    }
     const key = this.keyOf(ev)
     const sample: UsageSample = {
       day: dayKey(ev.time),
       hour: hourKey(ev.time),
-      inputTokens: usage2.inputTokens,
-      outputTokens: usage2.outputTokens,
+      inputTokens: usage2.inputTokens ?? 0,
+      outputTokens: usage2.outputTokens ?? 0,
       cacheReadTokens: usage2.cacheReadTokens ?? 0,
       cacheWriteTokens: usage2.cacheWriteTokens ?? 0,
     }
-    if (key === null) {
-      // No (turn, step) marker: every emission counts (no dedupe slot). The
-      // shipped adapters always stamp both on usage events, so this path is
-      // a defensive tail, not a live double-count source. ponytail: a
-      // synthetic key (e.g. by time+usage hash) could dedupe it if an
-      // adapter ever reports usage without turn/step.
-      return sample
-    }
-    const prev = this.seen.get(key)
-    // Track the newest report internally either way; the fold must NEVER
-    // mutate an object the store already received.
+    const prev = key === null ? undefined : this.seen.get(key)
+    // A first all-zero report carries no traffic. A later zero report may
+    // replace a nonzero sample, so it must emit a negative correction.
+    if (!prev && sample.inputTokens + sample.outputTokens + sample.cacheReadTokens + sample.cacheWriteTokens <= 0) return null
+    if (key === null) return sample
     this.seen.set(key, sample)
     if (prev) {
-      // Duplicate report for a known (turn, step): swallow it. The shipped
-      // adapters emit the identical TokenUsage on the streaming chunk and
-      // the final message (llm-deepseek yields one `pendingUsage` at DONE;
-      // llm-pi-ai only on done/error), so first == last observationally.
-      // ponytail: true last-wins would need store-side delta corrections
-      // keyed by (session, turn, step); add them only if an adapter ever
-      // reports differing values for one call.
-      return null
+      const correction: UsageSample = {
+        day: prev.day,
+        hour: prev.hour,
+        model: prev.model,
+        inputTokens: sample.inputTokens - prev.inputTokens,
+        outputTokens: sample.outputTokens - prev.outputTokens,
+        cacheReadTokens: sample.cacheReadTokens - prev.cacheReadTokens,
+        cacheWriteTokens: sample.cacheWriteTokens - prev.cacheWriteTokens,
+      }
+      // Keep the original bucket identity across cumulative samples.
+      sample.day = prev.day
+      sample.hour = prev.hour
+      sample.model = prev.model
+      if (correction.inputTokens === 0 && correction.outputTokens === 0 && correction.cacheReadTokens === 0 && correction.cacheWriteTokens === 0) return null
+      return correction
     }
-    // First emission: hand the store its own copy. The internal object stays
-    // fold-owned — mutating it on a later duplicate would rewrite the sample
-    // already sitting in the store's write path through the shared reference.
-    return { ...sample }
+    // The collector fills in model attribution on this returned copy. Retain
+    // the same identity privately for any correction, without ever mutating
+    // a sample already handed to the store.
+    const emitted = { ...sample }
+    this.seen.set(key, emitted)
+    return emitted
   }
 
   /**

package/src/context-types.ts

@@ -150,6 +150,16 @@ export interface UsageSessionPersistence {
 export interface UsageLlmService {
   resolveModelInfo?(provider: string, model: string, signal?: AbortSignal): Promise<{ name: string }>
   listModels?(provider: string): Promise<readonly { id: string; name: string }[]>
+  /** The provider catalog: route id -> the display name the model selector
+   *  shows. Synchronous on every host line this plugin supports (the llm
+   *  runtime's own `listProviders`, mirrored by the dsh-llm service). Optional:
+   *  a host without it leaves every ranked provider row labelled by its raw
+   *  historical route id. */
+  listProviders?(): readonly { id: string; name: string }[]
+  /** The configured-provider view (the models page's own list), whose
+   *  `displayName` is the same label. Read as a fallback for a route that
+   *  `listProviders` omits. */
+  listConfigurableProviders?(): readonly { provider: string; displayName: string }[]
 }
 
 /** The route a session's log records for its model calls (mirror of
@@ -168,8 +178,13 @@ export interface UsageSessionHandle {
   id: string
   cwd?: string
   createdAt?: number
-  /** The parent session a subagent session was delegated from (mirror of the
-   *  SessionHeader field; absent on a root session). */
+  /** Modern hosts retain creation metadata on Session.header, not as getters. */
+  header?: UsageSessionHeader
+  /** Exact fork prefix, distinct from the resume/construction seed length. */
+  inheritedEventCount?: number
+  /** Immutable current live log; avoids the persistence backend's batching lag. */
+  snapshotEvents?(): readonly UsageSessionEvent[]
+  /** Legacy direct parent; modern hosts expose header.parentSession instead. */
   parentSession?: string
   /** 0 for a root session; the delegation depth for a subagent. */
   delegationDepth?: number

package/src/model-names.ts

@@ -26,6 +26,40 @@ async function lookup<T>(read: (signal: AbortSignal) => Promise<T>, timeoutMs: n
   }
 }
 
+/** Resolve provider route ids to the labels the model selector shows. Both
+ *  catalogs are presentational and synchronous on the host runtime, so this is
+ *  a plain in-process read rather than a per-request lookup: a missing service,
+ *  a throwing adapter, or an unexpected promise all resolve to an empty map and
+ *  every surface falls back to the raw historical route id. */
+export function resolveProviderNames(llm?: UsageLlmService): Record<string, string> {
+  const names: Record<string, string> = Object.create(null)
+  if (!llm) return names
+  try {
+    for (const provider of catalog(llm.listProviders?.())) {
+      const name = provider.name?.trim()
+      if (provider.id && name) names[provider.id] = name
+    }
+  } catch {
+    // Metadata is auxiliary: a broken catalog must never fail the range query.
+  }
+  try {
+    for (const entry of catalog(llm.listConfigurableProviders?.())) {
+      const name = entry.displayName?.trim()
+      if (entry.provider && name && names[entry.provider] === undefined) names[entry.provider] = name
+    }
+  } catch {
+    // Same contract as above.
+  }
+  return names
+}
+
+/** Both catalogs are declared synchronous, but a host that publishes them over
+ *  a remote face would hand back a promise; treat anything that is not an array
+ *  as "no metadata" instead of throwing mid-query. */
+function catalog<T>(value: readonly T[] | undefined): readonly T[] {
+  return Array.isArray(value) ? value : []
+}
+
 /** Resolve each distinct route once per range query. Unknown/deleted providers
  *  fall back to their bare historical model names in aggregateSamples(). */
 export async function resolveModelNames(

package/src/query.ts

@@ -123,6 +123,12 @@ export function aggregateSamples(
   // tracked alongside the token volume.
   const modelCache = new Map<string, { hit: number; miss: number }>()
   const providerCache = new Map<string, { hit: number; miss: number }>()
+  // Cross-dimension splits: the two ranked lists render as side-by-side cards
+  // whose rows explain themselves on hover (which providers served this model,
+  // which models this provider served), so both directions are tracked here
+  // in the same pass rather than by re-walking the samples per row.
+  const modelProviderTotals = new Map<string, Map<string, number>>()
+  const providerModelTotals = new Map<string, Map<string, number>>()
   const active = new Set<string>()
   // Per-bucket accumulation (the reasonix dayTotals): the stacked trend chart
   // reads the bucket's byModel / byProvider, so every token-bearing sample
@@ -178,6 +184,18 @@ export function aggregateSamples(
     modelProviders.set(model, sources)
     modelTotals.set(model, (modelTotals.get(model) ?? 0) + total)
     providerTotals.set(provider, (providerTotals.get(provider) ?? 0) + total)
+    let modelSplitMap = modelProviderTotals.get(model)
+    if (!modelSplitMap) {
+      modelSplitMap = new Map()
+      modelProviderTotals.set(model, modelSplitMap)
+    }
+    modelSplitMap.set(provider, (modelSplitMap.get(provider) ?? 0) + total)
+    let providerSplitMap = providerModelTotals.get(provider)
+    if (!providerSplitMap) {
+      providerSplitMap = new Map()
+      providerModelTotals.set(provider, providerSplitMap)
+    }
+    providerSplitMap.set(model, (providerSplitMap.get(model) ?? 0) + total)
     const mc = modelCache.get(model) ?? { hit: 0, miss: 0 }
     mc.hit += sample.cacheReadTokens
     mc.miss += missSide
@@ -228,8 +246,8 @@ export function aggregateSamples(
     })
   }
 
-  out.models = modelsSorted(modelTotals, modelCache, modelProviders)
-  out.providers = providersSorted(providerTotals, providerCache)
+  out.models = modelsSorted(modelTotals, modelCache, modelProviders, modelProviderTotals)
+  out.providers = providersSorted(providerTotals, providerCache, providerModelTotals)
   out.topModel = out.models[0]?.model ?? ''
   out.topProvider = out.providers[0]?.provider ?? ''
   if (out.tokens > 0) {
@@ -243,23 +261,61 @@ function modelsSorted(
   totals: Map<string, number>,
   cache: Map<string, { hit: number; miss: number }>,
   sources: Map<string, Set<string>>,
+  splits: Map<string, Map<string, number>>,
 ): ModelTokenUsage[] {
   const out: ModelTokenUsage[] = []
   for (const [model, tokens] of totals) {
     const c = cache.get(model)
     const providers = [...(sources.get(model) ?? [])].sort()
-    out.push({ model, provider: providers.length === 1 ? providers[0]! : '', providers, tokens, percent: 0, cacheHit: c?.hit ?? 0, cacheMiss: c?.miss ?? 0 })
+    out.push({
+      model,
+      provider: providers.length === 1 ? providers[0]! : '',
+      providers,
+      providerTokens: providerSplit(splits.get(model)),
+      tokens,
+      percent: 0,
+      cacheHit: c?.hit ?? 0,
+      cacheMiss: c?.miss ?? 0,
+    })
   }
   out.sort((a, b) => b.tokens - a.tokens || a.model.localeCompare(b.model))
   return out
 }
 
-function providersSorted(totals: Map<string, number>, cache: Map<string, { hit: number; miss: number }>): ProviderTokenUsage[] {
+function providersSorted(
+  totals: Map<string, number>,
+  cache: Map<string, { hit: number; miss: number }>,
+  splits: Map<string, Map<string, number>>,
+): ProviderTokenUsage[] {
   const out: ProviderTokenUsage[] = []
   for (const [provider, tokens] of totals) {
     const c = cache.get(provider)
-    out.push({ provider, tokens, percent: 0, cacheHit: c?.hit ?? 0, cacheMiss: c?.miss ?? 0 })
+    out.push({
+      provider,
+      tokens,
+      percent: 0,
+      cacheHit: c?.hit ?? 0,
+      cacheMiss: c?.miss ?? 0,
+      modelTokens: modelSplit(splits.get(provider)),
+    })
   }
   out.sort((a, b) => b.tokens - a.tokens)
   return out
 }
+
+/** One model's per-provider split, largest first (ties by id for a stable
+ *  order across refreshes). Empty when the response carries no cross data. */
+function providerSplit(split: Map<string, number> | undefined): Array<{ provider: string; tokens: number }> {
+  if (split === undefined) return []
+  return [...split]
+    .map(([provider, tokens]) => ({ provider, tokens }))
+    .sort((a, b) => b.tokens - a.tokens || a.provider.localeCompare(b.provider))
+}
+
+/** One provider's per-model split, largest first (ties by name). */
+function modelSplit(split: Map<string, number> | undefined): Array<{ model: string; tokens: number }> {
+  if (split === undefined) return []
+  return [...split]
+    .map(([model, tokens]) => ({ model, tokens }))
+    .sort((a, b) => b.tokens - a.tokens || a.model.localeCompare(b.model))
+}

package/src/routes.ts

@@ -12,7 +12,7 @@
  */
 
 import type { Context, UsageLlmService } from './context-types.ts'
-import { resolveModelNames } from './model-names.ts'
+import { resolveModelNames, resolveProviderNames } from './model-names.ts'
 import type { UsageHttpRequest, UsageHttpResponse, UsageWebRoute } from './context-types.ts'
 import type { UsageStore, UsageDayRow, UsageHourRow } from './store.ts'
 import type { UsageCollector } from './collector.ts'
@@ -167,7 +167,19 @@ export async function aggregateRange(
       }
     }
   })()
-  return aggregateSamples(samples, { from, to }, granularity)
+  const stats = aggregateSamples(samples, { from, to }, granularity)
+  // Provider labels ride along with the aggregate: the ranked provider card
+  // shows the selector's display name, and the hover detail names the models
+  // underneath it. Only providers actually present in the range are included,
+  // so the payload stays proportional to the ranking it decorates.
+  const resolved = resolveProviderNames(llm)
+  const providerNames: Record<string, string> = Object.create(null)
+  for (const provider of stats.providers) {
+    const label = resolved[provider.provider]
+    if (label !== undefined) providerNames[provider.provider] = label
+  }
+  if (Object.keys(providerNames).length > 0) stats.providerNames = providerNames
+  return stats
 }
 
 /** Build the single fenced prefix route serving the /token-total/api JSON RPC.