@runuai/host 0.9.164 → 0.9.166

package/images/standard/Dockerfile

@@ -34,7 +34,7 @@ ENV ASDF_VERSION=v0.14.1
 # freshness is requalified before any of them moves.
 ENV UAI_CODEX_CLI_VERSION=0.157.0
 ENV UAI_CURSOR_AGENT_VERSION=2026.08.25-3e8eec8
-ENV UAI_GROK_CLI_VERSION=1.0.5
+ENV UAI_GROK_CLI_VERSION=1.0.67
 
 # ---------------------------------------------------------------------------
 # 1. System packages.

package/lib/agent-cli.ts

@@ -322,6 +322,29 @@ async function main() {
     const launch = (a) => a.kind + (a.model ? "/" + a.model : "") + (a.effort ? "/" + a.effort : "");
     if (action === "list") { out(await api("GET", "/api/agent/crew")); return; }
     if (action === "status") { out(await api("GET", "/api/agent/crew-status")); return; }
+    if (action === "store") { out(await api("GET", "/api/agent/crew-store")); return; }
+    if (action === "suggest") {
+      // The Astronaut suggests a persona; a person creates it (ADR-157 addendum).
+      // From the Store (--template) or from scratch (--name and --brief).
+      if (!flags.why || !(flags.template || flags.name)) {
+        console.error('uai: crew suggest needs --template <slug> (see crew store), or --name and --brief for a new one, and --why "<reason>"');
+        process.exit(1);
+      }
+      // --skill repeats, and parseFlags keeps only the last, so read them off the raw argv.
+      const skills = [];
+      for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === "--skill" && rest[i + 1]) skills.push(...rest[++i].split(",").filter(Boolean));
+      }
+      const body = { why: flags.why };
+      if (flags.template) body.template = flags.template;
+      for (const k of ["name", "role", "summary", "brief", "model", "effort"]) if (flags[k]) body[k] = flags[k];
+      if (flags.handle) body.handle = handleOf(flags.handle);
+      if (flags.engine) body.engine = flags.engine;
+      if (skills.length) body.skills = skills;
+      const r = await api("POST", "/api/agent/crew-suggest", body);
+      out("suggested " + r.suggestion.name + " (@" + r.suggestion.handle + "). " + r.message);
+      return;
+    }
     if (action === "add") {
       const personaId = pos[0];
       if (!personaId || !flags.why) {
@@ -367,7 +390,7 @@ async function main() {
       out("removed @" + id);
       return;
     }
-    console.error("uai: crew commands are list, status, add, model and remove (Astronaut only)");
+    console.error("uai: crew commands are list, status, store, suggest, add, model and remove (Astronaut only)");
     process.exit(1);
   }
   const key = group + " " + (action || "");
@@ -572,8 +595,11 @@ async function main() {
         "  uai task history                   (list your past tasks)",
         "  uai task read <taskId>             (full chat of a past task you were on)",
         '  uai dispatch @agent [@agent…] "instruction"   (Secretary only)',
-        "  uai crew list                      (Astronaut only: personas, engines, models, limits, roster)",
+        "  uai crew list                      (Astronaut only: personas with summary, skills and permissions, engines, models, limits, roster)",
         "  uai crew status                    (Astronaut only: each agent's engine, model, account; account usage; credits)",
+        "  uai crew store                     (Astronaut only: the Store's persona and skill templates, names and types only)",
+        '  uai crew suggest --template <slug> --why "<reason>"   (Astronaut only: propose a persona from the Store; a person creates it)',
+        '  uai crew suggest --name <n> --brief <text> [--role <r>] [--summary <s>] [--handle <h>] [--engine <kind>] [--model <m>] [--effort <e>] [--skill <slug|id>]... --why "<reason>"',
         '  uai crew add <personaId> [--as <handle>] [--engine <kind>] [--model <m>] [--effort <e>] [--account <id|label|default>] --why "<reason>"',
         '  uai crew model @agent [--engine <kind>] [--model <m|default>] [--effort <e|default>] [--account <id|label|default>] --why "<reason>"',
         '  uai crew remove @agent --why "<reason>"',

package/lib/agents/codex.ts

@@ -19,6 +19,7 @@
  *   item/agentMessage/delta        → message_delta
  *   item/completed (agentMessage)  → message_complete
  *   item/completed (tool item)     → tool_call
+ *   thread/tokenUsage/updated      → accumulated for its turn
  *   turn/completed                 → turn_complete (+ error if failed)
  *   error                          → error
  *
@@ -49,6 +50,7 @@ import type {
   AgentEventHandler,
   AgentKind,
   AgentSession,
+  AgentUsage,
   RosterAgent,
 } from "./types";
 
@@ -87,6 +89,120 @@ function str(v: unknown, fallback = ""): string {
   return typeof v === "string" ? v : fallback;
 }
 
+function nonNegativeInt(v: unknown): number | undefined {
+  return typeof v === "number" &&
+    Number.isSafeInteger(v) &&
+    v >= 0
+    ? v
+    : undefined;
+}
+
+interface CodexTokenBreakdown {
+  inputTokens: number;
+  outputTokens: number;
+  cachedInputTokens: number;
+}
+
+function codexTokenBreakdown(value: unknown): CodexTokenBreakdown | null {
+  if (!isObj(value)) return null;
+  const inputTokens = nonNegativeInt(value.inputTokens);
+  const outputTokens = nonNegativeInt(value.outputTokens);
+  const cachedInputTokens = nonNegativeInt(value.cachedInputTokens);
+  if (
+    inputTokens === undefined ||
+    outputTokens === undefined ||
+    cachedInputTokens === undefined
+  ) {
+    return null;
+  }
+  return {
+    inputTokens,
+    outputTokens,
+    cachedInputTokens,
+  };
+}
+
+function addBreakdowns(
+  left: CodexTokenBreakdown | undefined,
+  right: CodexTokenBreakdown,
+): CodexTokenBreakdown {
+  return {
+    inputTokens: (left?.inputTokens ?? 0) + right.inputTokens,
+    outputTokens: (left?.outputTokens ?? 0) + right.outputTokens,
+    cachedInputTokens:
+      (left?.cachedInputTokens ?? 0) + right.cachedInputTokens,
+  };
+}
+
+function breakdownDelta(
+  current: CodexTokenBreakdown,
+  previous: CodexTokenBreakdown,
+): CodexTokenBreakdown | null {
+  const delta = {
+    inputTokens: current.inputTokens - previous.inputTokens,
+    outputTokens: current.outputTokens - previous.outputTokens,
+    cachedInputTokens:
+      current.cachedInputTokens - previous.cachedInputTokens,
+  };
+  return Object.values(delta).every((value) => value >= 0) ? delta : null;
+}
+
+/**
+ * Codex 0.157 emits one token update after every model call. `last` is that
+ * call, not the whole turn; `total` is the running thread total. A tool-using
+ * turn therefore emits several updates. Seed an unseen thread from `last`,
+ * then add positive `total` deltas so repeated snapshots add zero. Usage is
+ * kept by turn id and consumed exactly once at its turn/completed boundary.
+ */
+class CodexTurnUsage {
+  private readonly threadTotals = new Map<string, CodexTokenBreakdown>();
+  private readonly turns = new Map<string, CodexTokenBreakdown>();
+
+  observe(params: unknown): void {
+    if (!isObj(params)) return;
+    const threadId = str(params.threadId);
+    const turnId = str(params.turnId);
+    const tokenUsage = isObj(params.tokenUsage) ? params.tokenUsage : null;
+    if (!threadId || !turnId || !tokenUsage) return;
+    const last = codexTokenBreakdown(tokenUsage.last);
+    const total = codexTokenBreakdown(tokenUsage.total);
+    if (!last || !total) return;
+
+    const previousTotal = this.threadTotals.get(threadId);
+    const contribution = previousTotal
+      ? breakdownDelta(total, previousTotal) ?? last
+      : last;
+    this.threadTotals.set(threadId, total);
+    this.turns.set(
+      turnId,
+      addBreakdowns(this.turns.get(turnId), contribution),
+    );
+  }
+
+  complete(params: unknown, model: string | undefined): AgentUsage | undefined {
+    const p = isObj(params) ? params : {};
+    const turn = isObj(p.turn) ? p.turn : {};
+    const turnId = str(turn.id);
+    if (!turnId) return undefined;
+    const usage = this.turns.get(turnId);
+    this.turns.delete(turnId);
+    if (!usage) return undefined;
+    return {
+      ...(model ? { model } : {}),
+      // OpenAI includes cached input inside inputTokens. Uai's shared shape,
+      // like Claude's, keeps fresh input and cache reads in separate columns.
+      // Codex 0.157 does not say whether cacheWriteInputTokens is already in
+      // inputTokens. Leave it in fresh input and do not also report a cache
+      // create until the protocol makes that relationship explicit.
+      inputTokens: Math.max(0, usage.inputTokens - usage.cachedInputTokens),
+      cacheReadTokens: usage.cachedInputTokens,
+      // reasoningOutputTokens is a subset of outputTokens in this protocol
+      // (totalTokens = inputTokens + outputTokens), so do not add it again.
+      outputTokens: usage.outputTokens,
+    };
+  }
+}
+
 /** `item/completed` item types rendered as tool-call cards. */
 const TOOL_ITEM_TYPES = new Set([
   "commandExecution",
@@ -96,6 +212,10 @@ const TOOL_ITEM_TYPES = new Set([
   "webSearch",
 ]);
 
+function turnComplete(usage: AgentUsage | undefined): AgentEvent {
+  return usage ? { type: "turn_complete", usage } : { type: "turn_complete" };
+}
+
 /**
  * Map one Codex JSON-RPC *notification* (method + params) to AgentEvents.
  * Pure and total — an unrecognised method yields [].
@@ -104,6 +224,7 @@ export function mapCodexNotification(
   method: string,
   params: unknown,
   now: number = Date.now(),
+  turnUsage?: AgentUsage,
 ): AgentEvent[] {
   const p = isObj(params) ? params : {};
 
@@ -155,10 +276,10 @@ export function mapCodexNotification(
                 : { resetsAt: accountUsage.resetsAt }),
             }
           : { type: "error", message },
-        { type: "turn_complete" },
+        turnComplete(turnUsage),
       ];
     }
-    return [{ type: "turn_complete" }];
+    return [turnComplete(turnUsage)];
   }
 
   if (method === "error") {
@@ -468,6 +589,8 @@ export class CodexSession implements AgentSession {
   private turnRunning = false;
   private lastRateLimitsReadAt = 0;
   private rateLimitsTimer: ReturnType<typeof setTimeout> | null = null;
+  private readonly turnUsage = new CodexTurnUsage();
+  private actualModel: string | undefined;
 
   constructor(args: {
     taskId: string;
@@ -637,6 +760,13 @@ export class CodexSession implements AgentSession {
     // Notification (method, no id).
     if ("method" in msg) {
       const method = str(msg.method);
+      if (method === "thread/tokenUsage/updated") {
+        this.turnUsage.observe(msg.params);
+      }
+      const completedUsage =
+        method === "turn/completed"
+          ? this.turnUsage.complete(msg.params, this.actualModel)
+          : undefined;
       if (method === "turn/completed") {
         this.turnRunning = false;
         this.clearRateLimitsTimer();
@@ -649,9 +779,17 @@ export class CodexSession implements AgentSession {
         if (isObj(thread) && typeof thread.id === "string") {
           this.threadId = thread.id;
           this.persistThreadId(thread.id);
+          if (typeof thread.model === "string" && thread.model.length > 0) {
+            this.actualModel = thread.model;
+          }
         }
       }
-      for (const ev of mapCodexNotification(method, msg.params)) {
+      for (const ev of mapCodexNotification(
+        method,
+        msg.params,
+        Date.now(),
+        completedUsage,
+      )) {
         this.emit(ev);
       }
     }
@@ -818,8 +956,14 @@ export class CodexSession implements AgentSession {
       threadParams.developerInstructions = this.systemPreamble;
     }
     const result = await this.request("thread/start", threadParams);
+    if (isObj(result) && typeof result.model === "string") {
+      this.actualModel = result.model;
+    }
     if (isObj(result) && isObj(result.thread)) {
       const id = str(result.thread.id) || this.threadId;
+      if (!this.actualModel && typeof result.thread.model === "string") {
+        this.actualModel = result.thread.model;
+      }
       this.threadId = id;
       if (id) this.persistThreadId(id);
     }
@@ -846,6 +990,15 @@ export class CodexSession implements AgentSession {
           isObj(result) && isObj(result.thread) && str(result.thread.id)
             ? str(result.thread.id)
             : threadId;
+        if (isObj(result) && typeof result.model === "string") {
+          this.actualModel = result.model;
+        } else if (
+          isObj(result) &&
+          isObj(result.thread) &&
+          typeof result.thread.model === "string"
+        ) {
+          this.actualModel = result.thread.model;
+        }
         this.threadId = id;
         this.persistThreadId(id);
         return true;

package/lib/agents/grok.ts

@@ -15,11 +15,13 @@
  *
  * Stream-json vocabulary (`--output-format streaming-json`, verified):
  *   {"type":"thought","data":"…"}                 → skipped (internal reasoning)
- *   {"type":"text","data":"…"}                     → message_delta (streamed)
- *   {"type":"end","stopReason","sessionId",…}      → message_complete + turn end
- * Tool calls happen (num_turns>1) but aren't surfaced as events in headless
- * mode, so there are no tool cards — the agent works, you get the streamed
- * answer.
+ *   {"type":"text","data":"…"}                    → message_delta (streamed)
+ *   {"type":"tool_call"|"tool_call_update",…}       → safely skipped (no cards yet)
+ *   {"type":"usage",…}                              → skipped (per model call)
+ *   {"type":"available_commands",…}                 → skipped
+ *   {"type":"end","stopReason","sessionId",…}     → message_complete + turn usage/end
+ * Grok 1.0.67 surfaces tool calls, but tool cards are deliberately outside
+ * this adapter slice. The final `end.usage` aggregates the invocation.
  *
  * AUTH is the operator's Grok subscription: `~/.grok/{auth.json, config.toml}`
  * is docker-cp'd into the container at task-up (the Codex/Kimi config-dir
@@ -49,6 +51,7 @@ import type {
   AgentEventHandler,
   AgentKind,
   AgentSession,
+  AgentUsage,
   RosterAgent,
 } from "./types";
 
@@ -77,9 +80,68 @@ export interface MappedGrokLine {
   end?: boolean;
   /** The session id from the end event, for `-r` on the next turn. */
   sessionId?: string;
+  /** Per-invocation usage from the final end event. */
+  usage?: AgentUsage;
 }
 
-export function mapGrokLine(line: string): MappedGrokLine {
+function nonNegativeInt(value: unknown): number | undefined {
+  return typeof value === "number" &&
+    Number.isSafeInteger(value) &&
+    value >= 0
+    ? value
+    : undefined;
+}
+
+function grokEndUsage(
+  msg: Record<string, unknown>,
+  model: string | undefined,
+): AgentUsage | undefined {
+  if (typeof msg.usage !== "object" || msg.usage === null) return undefined;
+  const raw = msg.usage as Record<string, unknown>;
+  const inputTokens = nonNegativeInt(raw.input_tokens);
+  const cacheReadTokens = nonNegativeInt(raw.cache_read_input_tokens);
+  const cacheCreateTokens = nonNegativeInt(raw.cache_creation_input_tokens);
+  const outputTokens = nonNegativeInt(raw.output_tokens);
+  const reasoningTokens = nonNegativeInt(raw.reasoning_tokens);
+  if (
+    inputTokens === undefined ||
+    cacheReadTokens === undefined ||
+    cacheCreateTokens === undefined ||
+    outputTokens === undefined ||
+    reasoningTokens === undefined
+  ) {
+    return undefined;
+  }
+  const reportedCost = msg.total_cost_usd;
+  const costUsd =
+    typeof reportedCost === "number" &&
+    Number.isFinite(reportedCost) &&
+    reportedCost >= 0
+      ? reportedCost
+      : undefined;
+  return {
+    // `modelUsage` exposes the backend build id (for example
+    // grok-4.5-build), while `model` is the semantic id passed to `-m` and
+    // therefore the id Uai's model guide resolves.
+    ...(model ? { model } : {}),
+    // Headless input_tokens is already uncached; both cache buckets are
+    // additive according to the 1.0.67 headless contract.
+    inputTokens,
+    cacheReadTokens,
+    cacheCreateTokens,
+    // The documented total excludes reasoning_tokens even though it includes
+    // output_tokens. Uai has no separate reasoning column, so include that
+    // distinct billed output once here.
+    outputTokens: outputTokens + reasoningTokens,
+    // Missing cost means unreported/partial, never free.
+    ...(costUsd === undefined ? {} : { costUsd }),
+  };
+}
+
+export function mapGrokLine(
+  line: string,
+  model?: string,
+): MappedGrokLine {
   const trimmed = line.trim();
   if (!trimmed.startsWith("{")) return {};
   let msg: Record<string, unknown>;
@@ -92,9 +154,11 @@ export function mapGrokLine(line: string): MappedGrokLine {
     return { textDelta: msg.data };
   }
   if (msg.type === "end") {
+    const usage = grokEndUsage(msg, model);
     return {
       end: true,
       sessionId: typeof msg.sessionId === "string" ? msg.sessionId : undefined,
+      ...(usage ? { usage } : {}),
     };
   }
   // "thought" (reasoning) and any other types: no user-facing event.
@@ -196,9 +260,10 @@ export class GrokSession implements AgentSession {
         // the same reasoning as --permission-mode bypassPermissions above
         // (live 2026-09-08, first Grok agents with MCP servers).
         GROK_FOLDER_TRUST: "0",
-        // grok 1.0.5 otherwise captures a login-shell environment once and
-        // reuses that static state for LocalNonPersistent commands. Loader
-        // tasks refresh per command, so disable that stale snapshot path.
+        // Grok 1.0.67 still enables login-shell capture by default and honors
+        // GROK_LOGIN_ENV. That capture reuses static state for
+        // LocalNonPersistent commands; loader tasks refresh per command, so
+        // keep the stale snapshot path disabled.
         ...(this.environment.descriptor.envMode === "loader"
           ? { GROK_LOGIN_ENV: GROK_LOADER_LOGIN_ENV }
           : {}),
@@ -215,6 +280,7 @@ export class GrokSession implements AgentSession {
 
     let acc = "";
     let sawText = false;
+    let turnUsage: AgentUsage | undefined;
     let buf = "";
     const consume = (chunk: string): void => {
       buf += chunk;
@@ -222,8 +288,9 @@ export class GrokSession implements AgentSession {
       while ((nl = buf.indexOf("\n")) >= 0) {
         const line = buf.slice(0, nl);
         buf = buf.slice(nl + 1);
-        const m = mapGrokLine(line);
+        const m = mapGrokLine(line, this.model);
         if (m.sessionId) this.sessionId = m.sessionId;
+        if (m.end) turnUsage = m.usage;
         if (typeof m.textDelta === "string") {
           sawText = true;
           acc += m.textDelta;
@@ -253,7 +320,11 @@ export class GrokSession implements AgentSession {
         }
         // Finalize the streamed message (no-op text if the turn produced none).
         if (sawText) this.emit({ type: "message_complete", text: acc });
-        this.emit({ type: "turn_complete" });
+        this.emit(
+          turnUsage
+            ? { type: "turn_complete", usage: turnUsage }
+            : { type: "turn_complete" },
+        );
         resolve();
       };
       child.on("exit", (code) => finish(code));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.9.164",
+  "version": "0.9.166",
   "description": "Uai host — runs ephemeral AI tasks in containers on a machine you control.",
   "license": "MIT",
   "author": "Uai Tech <team@runuai.com>",