@runuai/host 0.8.27 → 0.8.28

package/lib/agents/claude.ts

@@ -28,6 +28,7 @@ import type {
   AgentEventHandler,
   AgentKind,
   AgentSession,
+  AgentUsage,
   RosterAgent,
 } from "./types";
 
@@ -59,6 +60,32 @@ function isObj(v: unknown): v is Record<string, unknown> {
   return typeof v === "object" && v !== null;
 }
 
+function num(v: unknown): number | undefined {
+  return typeof v === "number" && Number.isFinite(v) ? v : undefined;
+}
+
+/**
+ * Token + cost accounting from a Claude `result` line. Claude Code reports the
+ * exact `total_cost_usd` (no estimation needed) plus a token `usage` breakdown
+ * and per-model `modelUsage`. The billed model is the single modelUsage key
+ * (or, on a multi-model turn, joined).
+ */
+function claudeUsage(json: Record<string, unknown>): AgentUsage | undefined {
+  const u = isObj(json.usage) ? json.usage : {};
+  const cost = num(json.total_cost_usd);
+  const models = isObj(json.modelUsage) ? Object.keys(json.modelUsage) : [];
+  const usage: AgentUsage = {
+    model: models.length ? models.join(", ") : undefined,
+    inputTokens: num(u.input_tokens),
+    outputTokens: num(u.output_tokens),
+    cacheReadTokens: num(u.cache_read_input_tokens),
+    cacheCreateTokens: num(u.cache_creation_input_tokens),
+    costUsd: cost,
+  };
+  // Nothing usable reported → omit rather than send an empty object.
+  return Object.values(usage).some((v) => v !== undefined) ? usage : undefined;
+}
+
 /**
  * Map one stream-json stdout line to zero or more AgentEvents.
  *
@@ -119,15 +146,17 @@ export function mapClaudeLine(raw: string): AgentEvent[] {
   // --- turn result ------------------------------------------------------
   if (type === "result") {
     const text = typeof json.result === "string" ? json.result : "";
+    const usage = claudeUsage(json);
     if (json.is_error === true) {
+      // An errored turn still cost tokens — meter it.
       return [
         { type: "error", message: text || "claude returned an error" },
-        { type: "turn_complete" },
+        { type: "turn_complete", usage },
       ];
     }
     return [
       { type: "message_complete", text },
-      { type: "turn_complete" },
+      { type: "turn_complete", usage },
     ];
   }
 

package/lib/agents/types.ts

@@ -82,6 +82,24 @@ export function parseRoster(raw: string): Roster {
 // these to `uai_messages` and streams them to the browser.
 // ---------------------------------------------------------------------------
 
+/**
+ * Token + cost accounting for one turn, extracted from the agent CLI's result
+ * envelope where it reports it (Claude Code gives `usage` + `total_cost_usd`
+ * directly). Powers per-task cost visibility for self-hosted users and the
+ * metering pipeline for managed Uai-provided AI. All fields optional — an
+ * engine that doesn't report a dimension omits it.
+ */
+export interface AgentUsage {
+  /** Model the CLI actually billed (may differ from the configured model, e.g. a sub-agent). */
+  model?: string;
+  inputTokens?: number;
+  outputTokens?: number;
+  cacheReadTokens?: number;
+  cacheCreateTokens?: number;
+  /** Total USD for the turn, as reported by the CLI (authoritative when present). */
+  costUsd?: number;
+}
+
 export type AgentEvent =
   /** A chunk of streaming assistant text. Appended to the in-progress message. */
   | { type: "message_delta"; text: string }
@@ -93,8 +111,9 @@ export type AgentEvent =
   | { type: "permission_request"; id: string; title: string; detail: string }
   /** The agent addressed another agent — uai routes this as a peer message. */
   | { type: "peer_message"; toAgentId: string; text: string }
-  /** The turn (one request → response cycle) is done; agent is idle. */
-  | { type: "turn_complete" }
+  /** The turn (one request → response cycle) is done; agent is idle.
+   *  `usage` carries this turn's token/cost accounting when the CLI reports it. */
+  | { type: "turn_complete"; usage?: AgentUsage }
   /** A recoverable error surfaced by the agent. */
   | { type: "error"; message: string }
   /** The underlying process exited. */

package/lib/orchestrator.ts

@@ -715,6 +715,7 @@ class Orchestrator {
           taskId: channel.taskId,
           agentId,
           aborted,
+          usage: event.usage,
         });
         break;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.8.27",
+  "version": "0.8.28",
   "description": "Uai host — runs ephemeral AI coding tasks in Docker on a machine you control.",
   "license": "MIT",
   "author": "Diogo Perillo <diogo.perillo@gmail.com>",

package/src/protocol.ts

@@ -580,6 +580,16 @@ export type HostEvent =
       taskId: string;
       agentId: string;
       aborted?: boolean;
+      /** Token/cost accounting for the turn, when the engine reports it
+       *  (ADR-071 usage metering — powers per-task cost + managed AI billing). */
+      usage?: {
+        model?: string;
+        inputTokens?: number;
+        outputTokens?: number;
+        cacheReadTokens?: number;
+        cacheCreateTokens?: number;
+        costUsd?: number;
+      };
     }
   | {
       kind: "agent.tool_call";