Skip to content

The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.

3.2 KB
Raw Blame
import type { CostSource } from '../chatService';
import { callCoreRpc } from '../coreRpcClient';

/** One sub-agent archetype's contribution within a thread. */
interface ThreadSubagentUsage {
  agentId: string;
  inputTokens: number;
  outputTokens: number;
  /** `null` when this archetype's cost is not known. */
  costUsd: number | null;
  runs: number;
}

/** Camel-cased per-thread usage totals consumed by the composer footer. */
interface ThreadTokenUsage {
  threadId: string;
  inputTokens: number;
  outputTokens: number;
  cachedInputTokens: number;
  /** `null` when some turn's cost is not known; never a guessed rate. */
  costUsd: number | null;
  costSource: CostSource;
  turnCount: number;
  lastTurnInputTokens: number;
  lastTurnOutputTokens: number;
  /** Context the last turn ended with: the gauge numerator. `0` when unknown. */
  lastTurnContextTokens: number;
  contextWindow: number;
  model: string | null;
  updated: string | null;
  hasUsage: boolean;
  /** Per-archetype sub-agent breakdown (already included in the totals above). */
  subagents: ThreadSubagentUsage[];
}

/** Wire shape returned by `openhuman.threads_token_usage` (snake_case). */
interface ThreadSubagentUsageWire {
  agent_id: string;
  input_tokens: number;
  output_tokens: number;
  cost_usd: number | null;
  runs: number;
}

interface ThreadTokenUsageWire {
  thread_id: string;
  input_tokens: number;
  output_tokens: number;
  cached_input_tokens: number;
  cost_usd: number | null;
  /** Absent from a core that predates it (whose `cost_usd` is a number). */
  cost_source?: CostSource;
  turn_count: number;
  last_turn_input_tokens: number;
  last_turn_output_tokens: number;
  /** Absent from a core that predates it. */
  last_turn_context_tokens?: number;
  context_window: number;
  model: string | null;
  updated: string | null;
  has_usage: boolean;
  subagents?: ThreadSubagentUsageWire[];
}

interface Envelope<T> {
  data?: T;
}

/**
 * Fetch a thread's persisted token/cost totals from the core (read back from
 * its session transcripts). Returns zeros with `hasUsage: false` for a thread
 * that has no completed turns yet.
 */
export async function fetchThreadTokenUsage(threadId: string): Promise<ThreadTokenUsage> {
  const response = await callCoreRpc<Envelope<ThreadTokenUsageWire>>({
    method: 'openhuman.threads_token_usage',
    params: { thread_id: threadId },
  });
  const d = response?.data;
  if (!d) throw new Error('threads_token_usage returned an empty envelope');
  return {
    threadId: d.thread_id,
    inputTokens: d.input_tokens,
    outputTokens: d.output_tokens,
    cachedInputTokens: d.cached_input_tokens,
    costUsd: d.cost_usd,
    costSource: d.cost_usd === null ? 'unknown' : (d.cost_source ?? 'charged'),
    turnCount: d.turn_count,
    lastTurnInputTokens: d.last_turn_input_tokens,
    lastTurnOutputTokens: d.last_turn_output_tokens,
    lastTurnContextTokens: d.last_turn_context_tokens ?? 0,
    contextWindow: d.context_window,
    model: d.model,
    updated: d.updated,
    hasUsage: d.has_usage,
    subagents: (d.subagents ?? []).map(s => ({
      agentId: s.agent_id,
      inputTokens: s.input_tokens,
      outputTokens: s.output_tokens,
      costUsd: s.cost_usd,
      runs: s.runs,
    })),
  };
}