@runuai/host 0.9.162 → 0.9.163

package/lib/agents/claude.ts

@@ -23,7 +23,7 @@ import { requireContainerRuntimeOperational } from "../runtime-guard";
 import type { TaskEnvironmentAgentSessionSurface } from "../task-environment/types";
 import { newId } from "../ulid";
 import { createAgentTransport, type LineTransport } from "./transport";
-import { isRateLimitMessage } from "./rate-limit";
+import { rateLimitErrorUsage, resetSecondsToEpochMs } from "./rate-limit";
 import { register } from "./registry";
 import {
   DISPATCH_INPUT_SCHEMA,
@@ -39,6 +39,7 @@ import { extractResultUsage } from "./usage";
 import type {
   AgentEvent,
   AgentEventHandler,
+  AgentAccountUsage,
   AgentKind,
   AgentSession,
   RosterAgent,
@@ -251,12 +252,20 @@ function parseLineObject(raw: string): Record<string, unknown> | null {
  * A malformed line yields []. The mapper is intentionally total and
  * side-effect free.
  */
-export function mapClaudeLine(raw: string): AgentEvent[] {
+export function mapClaudeLine(raw: string, now: number = Date.now()): AgentEvent[] {
   const json = parseLineObject(raw);
   if (!json) return [];
 
   const type = json.type;
 
+  // Claude Code 2.1.306 emits this exact stream-json envelope. Its embedded
+  // schema defines reset timestamps as Unix seconds and utilization as a
+  // fraction (normally 0..1).
+  if (type === "rate_limit_event" && isObj(json.rate_limit_info)) {
+    const usage = mapClaudeRateLimitInfo(json.rate_limit_info, now);
+    return usage ? [{ type: "account_usage", usage }] : [];
+  }
+
   // --- streaming text deltas --------------------------------------------
   if (type === "stream_event" && isObj(json.event)) {
     const event = json.event;
@@ -303,11 +312,22 @@ export function mapClaudeLine(raw: string): AgentEvent[] {
     if (json.is_error === true) {
       // An errored turn still cost tokens — meter it.
       const message = text || "claude returned an error";
+      const accountUsage = rateLimitErrorUsage(message, now);
       return [
+        ...(accountUsage
+          ? [{ type: "account_usage", usage: accountUsage } as const]
+          : []),
         // ADR-076: a rate-limit/usage-cap error is failed over to another
         // account by the orchestrator rather than surfaced to the user.
-        isRateLimitMessage(message)
-          ? { type: "error", message, retryable: "rate_limit" }
+        accountUsage
+          ? {
+              type: "error",
+              message,
+              retryable: "rate_limit",
+              ...(accountUsage.resetsAt === undefined
+                ? {}
+                : { resetsAt: accountUsage.resetsAt }),
+            }
           : { type: "error", message },
         { type: "turn_complete", usage },
       ];
@@ -341,6 +361,92 @@ export function mapClaudeLine(raw: string): AgentEvent[] {
   return [];
 }
 
+const CLAUDE_WINDOW_MINUTES: Readonly<Record<string, number>> = {
+  five_hour: 5 * 60,
+  seven_day: 7 * 24 * 60,
+  seven_day_opus: 7 * 24 * 60,
+  seven_day_sonnet: 7 * 24 * 60,
+  seven_day_overage_included: 7 * 24 * 60,
+};
+
+function utilizationPercent(value: unknown): number | undefined {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return undefined;
+  }
+  return Math.min(100, value * 100);
+}
+
+/** Map Claude Code 2.1.306's embedded `RateLimitInfo` schema. */
+export function mapClaudeRateLimitInfo(
+  info: Record<string, unknown>,
+  observedAt: number = Date.now(),
+): AgentAccountUsage | null {
+  const status =
+    info.status === "allowed"
+      ? "allowed"
+      : info.status === "allowed_warning"
+        ? "warning"
+        : info.status === "rejected"
+          ? "limited"
+          : null;
+  if (!status) return null;
+
+  const windows: AgentAccountUsage["windows"] = [];
+  const seen = new Set<string>();
+  if (isObj(info.unifiedWindows)) {
+    for (const window of [
+      "five_hour",
+      "seven_day",
+      "seven_day_overage_included",
+    ] as const) {
+      const value = info.unifiedWindows[window];
+      if (!isObj(value)) continue;
+      const usedPercent = utilizationPercent(value.utilization);
+      const resetsAt = resetSecondsToEpochMs(value.resetsAt, observedAt);
+      windows.push({
+        window,
+        windowMinutes: CLAUDE_WINDOW_MINUTES[window],
+        ...(usedPercent === undefined ? {} : { usedPercent }),
+        ...(resetsAt === undefined ? {} : { resetsAt }),
+      });
+      seen.add(window);
+    }
+  }
+
+  const rateLimitType =
+    typeof info.rateLimitType === "string" &&
+    info.rateLimitType.length > 0 &&
+    info.rateLimitType.length <= 64
+      ? info.rateLimitType
+      : undefined;
+  const resetsAt = resetSecondsToEpochMs(info.resetsAt, observedAt);
+  if (rateLimitType && !seen.has(rateLimitType)) {
+    const usedPercent = utilizationPercent(info.utilization);
+    windows.push({
+      window: rateLimitType,
+      ...(CLAUDE_WINDOW_MINUTES[rateLimitType] === undefined
+        ? {}
+        : { windowMinutes: CLAUDE_WINDOW_MINUTES[rateLimitType] }),
+      ...(usedPercent === undefined ? {} : { usedPercent }),
+      ...(resetsAt === undefined ? {} : { resetsAt }),
+    });
+  }
+
+  return {
+    status,
+    ...(resetsAt === undefined ? {} : { resetsAt }),
+    ...(typeof info.isUsingOverage === "boolean"
+      ? { usingOverage: info.isUsingOverage }
+      : {}),
+    windows,
+    source: "claude-rate-limit-event",
+    observedAt,
+    ...(rateLimitType === undefined
+      ? {}
+      : { coverage: { kind: "window" as const, window: rateLimitType } }),
+  };
+}
+
 function safeStringify(v: unknown): string {
   if (v === undefined) return "";
   if (typeof v === "string") return v;

package/lib/agents/codex.ts

@@ -40,10 +40,11 @@ import type { TaskEnvironmentAgentSessionSurface } from "../task-environment/typ
 import { newId } from "../ulid";
 import { attachCompatibilityKeysMatch } from "./attach-compatibility";
 import { createAgentTransport, type LineTransport } from "./transport";
-import { isRateLimitMessage } from "./rate-limit";
+import { rateLimitErrorUsage, resetSecondsToEpochMs } from "./rate-limit";
 import { register } from "./registry";
 import type {
   AgentEvent,
+  AgentAccountUsage,
   AgentEventHandler,
   AgentKind,
   AgentSession,
@@ -84,6 +85,11 @@ const CODEX_EFFORTS = ["low", "medium", "high", "xhigh", "max", "ultra"];
 // agentic task work). Update alongside CODEX_EFFORTS.
 const CODEX_DEFAULT_EFFORT = "medium";
 
+/** Account headroom bands are product policy, not protocol magic numbers. */
+export const CODEX_USAGE_WARNING_PERCENT = 90;
+export const CODEX_USAGE_LIMITED_PERCENT = 100;
+export const CODEX_USAGE_POLL_INTERVAL_MS = 5 * 60_000;
+
 // ---------------------------------------------------------------------------
 // Pure protocol mapping — JSON-RPC notification → AgentEvent[].
 // ---------------------------------------------------------------------------
@@ -112,9 +118,15 @@ const TOOL_ITEM_TYPES = new Set([
 export function mapCodexNotification(
   method: string,
   params: unknown,
+  now: number = Date.now(),
 ): AgentEvent[] {
   const p = isObj(params) ? params : {};
 
+  if (method === "account/rateLimits/updated") {
+    const usage = mapCodexRateLimits(p.rateLimits, now);
+    return usage ? [{ type: "account_usage", usage }] : [];
+  }
+
   if (method === "item/agentMessage/delta") {
     const text = str(p.delta);
     return text ? [{ type: "message_delta", text }] : [];
@@ -143,9 +155,20 @@ export function mapCodexNotification(
     const turn = isObj(p.turn) ? p.turn : {};
     if (turn.status === "failed" && isObj(turn.error)) {
       const message = str(turn.error.message, "codex turn failed");
+      const accountUsage = rateLimitErrorUsage(message, now);
       return [
-        isRateLimitMessage(message)
-          ? { type: "error", message, retryable: "rate_limit" }
+        ...(accountUsage
+          ? [{ type: "account_usage", usage: accountUsage } as const]
+          : []),
+        accountUsage
+          ? {
+              type: "error",
+              message,
+              retryable: "rate_limit",
+              ...(accountUsage.resetsAt === undefined
+                ? {}
+                : { resetsAt: accountUsage.resetsAt }),
+            }
           : { type: "error", message },
         { type: "turn_complete" },
       ];
@@ -157,14 +180,88 @@ export function mapCodexNotification(
     const message = isObj(p.error)
       ? str(p.error.message, "codex error")
       : "codex error";
-    return isRateLimitMessage(message)
-      ? [{ type: "error", message, retryable: "rate_limit" }]
+    const accountUsage = rateLimitErrorUsage(message, now);
+    return accountUsage
+      ? [
+          { type: "account_usage", usage: accountUsage },
+          {
+            type: "error",
+            message,
+            retryable: "rate_limit",
+            ...(accountUsage.resetsAt === undefined
+              ? {}
+              : { resetsAt: accountUsage.resetsAt }),
+          },
+        ]
       : [{ type: "error", message }];
   }
 
   return [];
 }
 
+function codexWindow(
+  name: "primary" | "secondary",
+  value: unknown,
+  observedAt: number,
+): AgentAccountUsage["windows"][number] | null {
+  if (!isObj(value) || typeof value.usedPercent !== "number") return null;
+  const usedPercent = Math.min(100, Math.max(0, value.usedPercent));
+  if (!Number.isFinite(usedPercent)) return null;
+  const windowMinutes =
+    typeof value.windowDurationMins === "number" &&
+    Number.isSafeInteger(value.windowDurationMins) &&
+    value.windowDurationMins > 0
+      ? value.windowDurationMins
+      : undefined;
+  // The 0.157 schema says int64; the live app-server read confirms seconds.
+  const resetsAt = resetSecondsToEpochMs(value.resetsAt, observedAt);
+  return {
+    window: name,
+    ...(windowMinutes === undefined ? {} : { windowMinutes }),
+    usedPercent,
+    ...(resetsAt === undefined ? {} : { resetsAt }),
+  };
+}
+
+/** Map the shared RateLimitSnapshot used by the read response and update
+ * notification in Codex app-server 0.157. */
+export function mapCodexRateLimits(
+  value: unknown,
+  observedAt: number = Date.now(),
+): AgentAccountUsage | null {
+  if (!isObj(value)) return null;
+  const windows = (["primary", "secondary"] as const)
+    .map((name) => codexWindow(name, value[name], observedAt))
+    .filter((window): window is NonNullable<typeof window> => window !== null);
+  if (windows.length === 0) return null;
+  const limited = windows.filter(
+    (window) =>
+      (window.usedPercent ?? 0) >= CODEX_USAGE_LIMITED_PERCENT,
+  );
+  const status =
+    limited.length > 0
+      ? "limited"
+      : windows.some(
+            (window) =>
+              (window.usedPercent ?? 0) >= CODEX_USAGE_WARNING_PERCENT,
+          )
+        ? "warning"
+        : "allowed";
+  const limitedResets = limited
+    .map((window) => window.resetsAt)
+    .filter((reset): reset is number => reset !== undefined);
+  const resetsAt =
+    limitedResets.length > 0 ? Math.max(...limitedResets) : undefined;
+  return {
+    status,
+    ...(resetsAt === undefined ? {} : { resetsAt }),
+    windows,
+    source: "codex-rate-limits",
+    observedAt,
+    coverage: { kind: "all-windows" },
+  };
+}
+
 function codexToolTitle(
   itemType: string,
   item: Record<string, unknown>,
@@ -377,10 +474,15 @@ export class CodexSession implements AgentSession {
   >();
   /** permission_request id → the JSON-RPC request id to answer with. */
   private readonly approvals = new Map<string, number | string>();
+  /** Fire-and-forget turn/start ids whose error responses end turn polling. */
+  private readonly turnStartRpcIds = new Set<number>();
 
   private threadId: string | null = null;
   private readonly ready: Promise<void>;
   private readonly attachCompatibilityKey: string | undefined;
+  private turnRunning = false;
+  private lastRateLimitsReadAt = 0;
+  private rateLimitsTimer: ReturnType<typeof setTimeout> | null = null;
 
   constructor(args: {
     taskId: string;
@@ -458,6 +560,9 @@ export class CodexSession implements AgentSession {
     this.proc.onLine((line) => this.onLine(line));
     this.proc.onExit((code) => {
       if (this.closed) return;
+      this.turnRunning = false;
+      this.clearRateLimitsTimer();
+      this.turnStartRpcIds.clear();
       if (code !== 0) {
         const tail = this.proc.stderrTail.trim();
         this.emit({
@@ -507,6 +612,13 @@ export class CodexSession implements AgentSession {
     // Response to one of our requests (id, no method).
     if (hasId && !("method" in msg)) {
       const id = typeof msg.id === "number" ? msg.id : -1;
+      if (this.turnStartRpcIds.delete(id)) {
+        if (isObj(msg.error)) {
+          this.turnRunning = false;
+          this.clearRateLimitsTimer();
+        }
+        return;
+      }
       const waiter = this.pending.get(id);
       if (waiter) {
         this.pending.delete(id);
@@ -540,6 +652,11 @@ export class CodexSession implements AgentSession {
     // Notification (method, no id).
     if ("method" in msg) {
       const method = str(msg.method);
+      if (method === "turn/completed") {
+        this.turnRunning = false;
+        this.clearRateLimitsTimer();
+        this.turnStartRpcIds.clear();
+      }
       // The thread id arrives on `thread/started`; also captured from
       // the `thread/start` response in handshake().
       if (method === "thread/started" && isObj(msg.params)) {
@@ -612,13 +729,15 @@ export class CodexSession implements AgentSession {
   /** Send a JSON-RPC request without awaiting it — for `turn/start`,
    *  whose output streams as notifications and whose response can take
    *  minutes. The eventual response is ignored (no pending waiter). */
-  private fireRequest(method: string, params: unknown): void {
+  private fireRequest(method: string, params: unknown): number {
+    const id = this.nextRpcId++;
     this.proc.writeLine({
       jsonrpc: "2.0",
-      id: this.nextRpcId++,
+      id,
       method,
       params,
     });
+    return id;
   }
 
   private notify(method: string, params: unknown): void {
@@ -654,10 +773,52 @@ export class CodexSession implements AgentSession {
     // (thread gone/corrupt, or the old writer never released the lock).
     if (this.resumeThreadId && (await this.tryResumeThread(this.resumeThreadId))) {
       this.handshakeOk = true;
+      this.readRateLimits();
       return;
     }
     await this.startThread();
     this.handshakeOk = true;
+    this.readRateLimits();
+  }
+
+  /** Best-effort account snapshot. It is intentionally outside `ready`: a
+   * slow usage endpoint must not delay the agent's first turn. */
+  private readRateLimits(): void {
+    if (this.closed) return;
+    this.lastRateLimitsReadAt = Date.now();
+    void this.request("account/rateLimits/read", null)
+      .then((result) => {
+        const usage =
+          isObj(result) && "rateLimits" in result
+            ? mapCodexRateLimits(result.rateLimits)
+            : null;
+        if (usage) this.emit({ type: "account_usage", usage });
+      })
+      .catch(() => {
+        // Usage is advisory. Authentication/turn errors still follow their
+        // normal app-server notifications and must not be duplicated here.
+      });
+  }
+
+  private clearRateLimitsTimer(): void {
+    if (this.rateLimitsTimer !== null) clearTimeout(this.rateLimitsTimer);
+    this.rateLimitsTimer = null;
+  }
+
+  private scheduleRateLimitsRead(): void {
+    this.clearRateLimitsTimer();
+    if (!this.turnRunning || this.closed) return;
+    const wait = Math.max(
+      0,
+      this.lastRateLimitsReadAt + CODEX_USAGE_POLL_INTERVAL_MS - Date.now(),
+    );
+    this.rateLimitsTimer = setTimeout(() => {
+      this.rateLimitsTimer = null;
+      if (!this.turnRunning || this.closed) return;
+      this.readRateLimits();
+      this.scheduleRateLimitsRead();
+    }, wait);
+    this.rateLimitsTimer.unref?.();
   }
 
   private async startThread(): Promise<void> {
@@ -758,10 +919,13 @@ export class CodexSession implements AgentSession {
     // `ready` may have waited across a runtime generation change. Recheck at
     // the turn/start write rather than trusting session construction time.
     requireContainerRuntimeOperational();
-    this.fireRequest("turn/start", {
+    const turnStartId = this.fireRequest("turn/start", {
       threadId: this.threadId,
       input: [{ type: "text", text }],
     });
+    this.turnStartRpcIds.add(turnStartId);
+    this.turnRunning = true;
+    this.scheduleRateLimitsRead();
   }
 
   async interrupt(): Promise<void> {
@@ -791,6 +955,9 @@ export class CodexSession implements AgentSession {
       return;
     }
     this.closed = true;
+    this.turnRunning = false;
+    this.clearRateLimitsTimer();
+    this.turnStartRpcIds.clear();
     for (const waiter of this.pending.values()) {
       waiter.reject(new Error("session closed"));
     }

package/lib/agents/opencode.ts

@@ -44,7 +44,7 @@ import {
   spawnEnvironmentProcess,
   type AgentEnvironmentProcess,
 } from "./proc";
-import { isRateLimitMessage } from "./rate-limit";
+import { rateLimitErrorUsage } from "./rate-limit";
 import { register } from "./registry";
 import type {
   AgentEvent,
@@ -191,7 +191,10 @@ function toolDetail(state: unknown): string {
  * Map a single OpenCode `run --format json` line. Non-JSON lines and events
  * with no user-facing meaning (step_start) map to no events. Total + pure.
  */
-export function mapOpencodeLine(line: string): MappedOpencodeLine {
+export function mapOpencodeLine(
+  line: string,
+  now: number = Date.now(),
+): MappedOpencodeLine {
   const trimmed = line.trim();
   if (!trimmed.startsWith("{")) return { events: [] };
   let msg: Record<string, unknown>;
@@ -248,12 +251,23 @@ export function mapOpencodeLine(line: string): MappedOpencodeLine {
     const data = isObj(err.data) ? err.data : {};
     const message =
       str(data.message) || str(err.name) || "opencode error";
+    const accountUsage = rateLimitErrorUsage(message, now);
     return {
-      events: [
-        isRateLimitMessage(message)
-          ? { type: "error", message, retryable: "rate_limit" }
-          : { type: "error", message },
-      ],
+      events: accountUsage
+        ? [
+            { type: "account_usage", usage: accountUsage },
+            {
+              type: "error",
+              message,
+              retryable: "rate_limit",
+              ...(accountUsage.resetsAt === undefined
+                ? {}
+                : { resetsAt: accountUsage.resetsAt }),
+            },
+          ]
+        : [
+            { type: "error", message },
+          ],
       sessionId,
     };
   }
@@ -421,11 +435,20 @@ export class OpencodeSession implements AgentSession {
           if (code !== 0 && !sawError) {
             const tail = stderr.trim().slice(-500);
             const message = `opencode exited ${code ?? "null"}${tail ? `: ${tail}` : ""}`;
-            this.emit(
-              isRateLimitMessage(message)
-                ? { type: "error", message, retryable: "rate_limit" }
-                : { type: "error", message },
-            );
+            const accountUsage = rateLimitErrorUsage(message);
+            if (accountUsage) {
+              this.emit({ type: "account_usage", usage: accountUsage });
+              this.emit({
+                type: "error",
+                message,
+                retryable: "rate_limit",
+                ...(accountUsage.resetsAt === undefined
+                  ? {}
+                  : { resetsAt: accountUsage.resetsAt }),
+              });
+            } else {
+              this.emit({ type: "error", message });
+            }
           }
           this.emit({
             type: "turn_complete",