@runuai/host 0.8.27 → 0.8.29

package/lib/agents/claude.ts

@@ -23,6 +23,7 @@
 import { newId } from "../ulid";
 import { createAgentTransport, type LineTransport } from "./transport";
 import { register } from "./registry";
+import { extractResultUsage } from "./usage";
 import type {
   AgentEvent,
   AgentEventHandler,
@@ -119,15 +120,17 @@ export function mapClaudeLine(raw: string): AgentEvent[] {
   // --- turn result ------------------------------------------------------
   if (type === "result") {
     const text = typeof json.result === "string" ? json.result : "";
+    const usage = extractResultUsage(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/cursor.ts

@@ -31,11 +31,13 @@ import { spawn, type ChildProcess } from "node:child_process";
 
 import { newId } from "../ulid";
 import { register } from "./registry";
+import { extractResultUsage } from "./usage";
 import type {
   AgentEvent,
   AgentEventHandler,
   AgentKind,
   AgentSession,
+  AgentUsage,
   RosterAgent,
 } from "./types";
 
@@ -83,6 +85,9 @@ export interface MappedCursorLine {
   finalText?: string;
   sessionId?: string;
   errorText?: string;
+  /** Token/cost from the result envelope — Cursor uses the Claude-compatible
+   *  shape (usage + total_cost_usd + modelUsage). ADR-071 metering. */
+  usage?: AgentUsage;
 }
 
 export function mapCursorLine(line: string): MappedCursorLine {
@@ -131,6 +136,7 @@ export function mapCursorLine(line: string): MappedCursorLine {
           ? m.result
           : "cursor turn failed"
         : undefined,
+      usage: extractResultUsage(m),
     };
   }
   // thinking / user / other → nothing.
@@ -235,6 +241,9 @@ export class CursorSession implements AgentSession {
     let acc = "";
     let sawText = false;
     let buf = "";
+    // Usage rides the result line but turn_complete fires on process exit;
+    // capture it here and attach it below (ADR-071 metering).
+    let turnUsage: AgentUsage | undefined;
     const consume = (chunk: string): void => {
       buf += chunk;
       let nl: number;
@@ -279,6 +288,7 @@ export class CursorSession implements AgentSession {
           });
         }
         if (m.end) {
+          if (m.usage) turnUsage = m.usage;
           if (m.errorText) this.emit({ type: "error", message: m.errorText });
           const finalText = m.finalText ?? acc;
           if (sawText || finalText) {
@@ -307,7 +317,7 @@ export class CursorSession implements AgentSession {
             message: `cursor exited ${code ?? "null"}${tail ? `: ${tail}` : ""}`,
           });
         }
-        this.emit({ type: "turn_complete" });
+        this.emit({ type: "turn_complete", usage: turnUsage });
         resolve();
       };
       child.on("exit", (code) => finish(code));

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/agents/usage.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared token/cost extraction for the Claude-Code-compatible stream-json
+ * `result` envelope (ADR-071 metering). Claude Code AND Cursor Agent both emit
+ * this exact shape — `usage` token breakdown, an exact `total_cost_usd`, and
+ * per-model `modelUsage` — so both engines share this one extractor.
+ *
+ * Codex (app-server protocol) and Kimi/Grok (plain text streams) report no
+ * token/cost data, so they have no extractor.
+ */
+
+import type { AgentUsage } from "./types";
+
+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;
+}
+
+/** Pull AgentUsage from a `result` line, or undefined when none is reported. */
+export function extractResultUsage(
+  json: Record<string, unknown>,
+): AgentUsage | undefined {
+  const u = isObj(json.usage) ? json.usage : {};
+  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: num(json.total_cost_usd),
+  };
+  // Nothing usable reported → omit rather than send an empty object.
+  return Object.values(usage).some((v) => v !== undefined) ? usage : undefined;
+}

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.29",
   "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";