@hicaru/pi-rlm 0.3.14 → 0.3.16

package/src/tool/subcall-store.ts

@@ -18,6 +18,9 @@ type MutableSubcall = {
 export interface SubcallTotals {
   readonly costUsd: number;
   readonly tokens: number;
+  /** In/out split (input / output) — mirrors tokens, shown separately in the tree. */
+  readonly tokensIn: number;
+  readonly tokensOut: number;
 }
 
 export class SubcallStore extends EmitterListener {
@@ -25,8 +28,12 @@ export class SubcallStore extends EmitterListener {
 
   private totalCostUsd = 0;
   private totalTokens = 0;
+  private totalTokensIn = 0;
+  private totalTokensOut = 0;
   private rootCostUsd = 0;
   private rootTokens = 0;
+  private rootTokensIn = 0;
+  private rootTokensOut = 0;
 
   constructor(emitter: RlmEmitter, private readonly onChange?: () => void) {
     super();
@@ -52,6 +59,8 @@ export class SubcallStore extends EmitterListener {
       startedAt: Date.now(),
       costUsd: 0,
       tokens: 0,
+      tokensIn: 0,
+      tokensOut: 0,
     });
   }
 
@@ -75,6 +84,14 @@ export class SubcallStore extends EmitterListener {
       sc.tokens += event.tokens;
       this.totalTokens += event.tokens;
     }
+    if (event.tokensIn !== undefined) {
+      sc.tokensIn += event.tokensIn;
+      this.totalTokensIn += event.tokensIn;
+    }
+    if (event.tokensOut !== undefined) {
+      sc.tokensOut += event.tokensOut;
+      this.totalTokensOut += event.tokensOut;
+    }
     if (event.failedCount !== undefined) sc.failedCount = event.failedCount;
     if (event.totalCount !== undefined) sc.totalCount = event.totalCount;
   }
@@ -87,8 +104,8 @@ export class SubcallStore extends EmitterListener {
   }
 
   /** Snapshot running totals. O(1). */
-  getTotals(): { readonly costUsd: number; readonly tokens: number } {
-    return { costUsd: this.totalCostUsd, tokens: this.totalTokens };
+  getTotals(): SubcallTotals {
+    return { costUsd: this.totalCostUsd, tokens: this.totalTokens, tokensIn: this.totalTokensIn, tokensOut: this.totalTokensOut };
   }
 
   /**
@@ -126,33 +143,43 @@ export class SubcallStore extends EmitterListener {
     const taken: RlmSubcall[] = [];
     let costUsd = 0;
     let tokens = 0;
+    let tokensIn = 0;
+    let tokensOut = 0;
     for (const root of children.get(undefined) ?? []) {
       const subtree = settledSubtree(root);
       if (subtree === undefined) continue;
       for (const node of subtree) {
         costUsd += node.costUsd;
         tokens += node.tokens;
+        tokensIn += node.tokensIn;
+        tokensOut += node.tokensOut;
         taken.push(Object.freeze({ ...node, status: node.status as SubcallStatus }));
         this.subcalls.delete(node.id);
       }
     }
     this.totalCostUsd -= costUsd;
     this.totalTokens -= tokens;
-    return { subcalls: taken, totals: { costUsd, tokens } };
+    this.totalTokensIn -= tokensIn;
+    this.totalTokensOut -= tokensOut;
+    return { subcalls: taken, totals: { costUsd, tokens, tokensIn, tokensOut } };
   }
 
   // ── Root usage (delegated from RlmEventAggregator) ──
 
   /** Accumulate root-level usage into shared totals. Called by aggregator. */
-  addRootUsage(costUsd: number, tokens: number): void {
+  addRootUsage(costUsd: number, tokens: number, tokensIn = 0, tokensOut = 0): void {
     this.totalCostUsd += costUsd;
     this.totalTokens += tokens;
+    this.totalTokensIn += tokensIn;
+    this.totalTokensOut += tokensOut;
     this.rootCostUsd += costUsd;
     this.rootTokens += tokens;
+    this.rootTokensIn += tokensIn;
+    this.rootTokensOut += tokensOut;
   }
 
   /** Root engine's OWN spend (driver-model turns only) — never blends sub-call models. */
   getRootUsage(): SubcallTotals {
-    return { costUsd: this.rootCostUsd, tokens: this.rootTokens };
+    return { costUsd: this.rootCostUsd, tokens: this.rootTokens, tokensIn: this.rootTokensIn, tokensOut: this.rootTokensOut };
   }
 }

package/src/ui/config-panel.ts

@@ -1,9 +1,11 @@
 /** Config panel TUI — toggle RLM run parameters with descriptions. */
 
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ThinkingLevel } from "@earendil-works/pi-ai";
 import { getSettingsListTheme } from "@earendil-works/pi-coding-agent";
 import { Container, type SettingItem, SettingsList, Text } from "@earendil-works/pi-tui";
 import type { RlmConfig } from "../core/types.ts";
+import { THINKING_LEVELS } from "../config/settings.ts";
 
 const CHOICES = Object.freeze({
   maxDepth: Object.freeze(["1", "2", "3", "4"]),
@@ -18,6 +20,10 @@ const CHOICES = Object.freeze({
   compaction: Object.freeze(["on", "off"]),
   compactionThresholdPct: Object.freeze(["50", "65", "80", "90"]),
   rootSamplingMaxTokens: Object.freeze(["4096", "8192", "16384", "32768"]),
+  rootSamplingTemperature: Object.freeze(["0", "0.3", "0.7", "1.0", "default"]),
+  smartReasoning: Object.freeze(["default", ...Object.keys(THINKING_LEVELS)]),
+  subSamplingMaxTokens: Object.freeze(["1024", "2048", "4096", "8192"]),
+  subSamplingTemperature: Object.freeze(["0", "0.3", "0.7", "1.0", "default"]),
   sandboxInitTimeoutMs: Object.freeze(["10000", "30000", "60000", "120000"]),
   requestTimeoutMs: Object.freeze(["2", "5", "10", "15", "20"]),
   contextLoader: Object.freeze(["on", "off"]),
@@ -48,6 +54,14 @@ export async function showConfigPanel(ctx: ExtensionContext, config: RlmConfig):
     item("compaction", "Trajectory compaction", config.compaction ? "on" : "off", CHOICES.compaction, "Summarize old turns when history approaches the model context window."),
     item("compactionThresholdPct", "Compaction threshold (%)", String(Math.round(config.compactionThresholdPct * 100)), CHOICES.compactionThresholdPct, "Compact once estimated history tokens reach this share of the root model's context window."),
     item("rootSamplingMaxTokens", "Root model output cap (tok)", String(config.rootSampling?.maxTokens ?? 16384), CHOICES.rootSamplingMaxTokens, "Max output tokens per root-model turn. Lower values keep each turn lean."),
+    item("rootSamplingTemperature", "Root sampling temperature", config.rootSampling?.temperature === undefined ? "default" : String(config.rootSampling?.temperature), CHOICES.rootSamplingTemperature,
+      "Sampling temperature for RLM root turns, finalize included — 0 = deterministic (the r3 reproducibility setting); 'default' = provider default. Applies to RLM-mode runs, rlm() delegation and child recursion; the native Pi agent loop follows Pi's own session settings."),
+    item("smartReasoning", "Root reasoning effort", config.smartReasoning ?? "default", CHOICES.smartReasoning,
+      "Thinking effort for the root model ('default' = none). Only models whose registry entry supports reasoning will think; others silently run without it. Reasoning tokens share the output cap — raise the root output cap when thinking is on."),
+    item("subSamplingMaxTokens", "Worker output cap (tok)", String(config.subSampling?.maxTokens ?? 8192), CHOICES.subSamplingMaxTokens,
+      "Max output tokens per leaf sub-call (llm_query / llm_batch / map_files)."),
+    item("subSamplingTemperature", "Worker sampling temperature", config.subSampling?.temperature === undefined ? "default" : String(config.subSampling?.temperature), CHOICES.subSamplingTemperature,
+      "Sampling temperature for leaf sub-calls; 'default' = provider default. Deterministic extraction (temp 0) is what made the r3 bench stable."),
     item("sandboxInitTimeoutMs", "Sandbox init timeout", String(config.sandboxInitTimeoutMs), CHOICES.sandboxInitTimeoutMs, "How long to wait for the Python worker to start."),
     item("requestTimeoutMs", "Sandbox request timeout (min)", String(Math.round(config.requestTimeoutMs / 60_000)), CHOICES.requestTimeoutMs, "Parent-side watchdog per sandbox request; on breach the Python worker is killed."),
     item("contextLoader", "Context loader", config.contextLoader ? "on" : "off", CHOICES.contextLoader,
@@ -89,6 +103,13 @@ function optionalNumber(value: string, scale = 1): number | undefined {
   return value === "none" ? undefined : Number(value) * scale;
 }
 
+/** Optional temperature: the literal "default" clears it (provider default); else [0, 2]. */
+function optionalTemperature(value: string): number | undefined {
+  if (value === "default") return undefined;
+  const n = Number(value);
+  return Number.isFinite(n) && n >= 0 && n <= 2 ? n : undefined;
+}
+
 /** Pure: returns a new frozen config with `id` set to `value`; unknown ids pass through. */
 export function applySetting(config: RlmConfig, id: string, value: string): RlmConfig {
   switch (id) {
@@ -105,6 +126,24 @@ export function applySetting(config: RlmConfig, id: string, value: string): RlmC
     case "compactionThresholdPct": return Object.freeze({ ...config, compactionThresholdPct: Number(value) / 100 });
     case "rootSamplingMaxTokens":
       return Object.freeze({ ...config, rootSampling: Object.freeze({ ...config.rootSampling, maxTokens: Number(value) }) });
+    case "rootSamplingTemperature": {
+      const t = optionalTemperature(value);
+      // Reject invalid values (NaN / out of range) — keep the current setting.
+      if (t === undefined && value !== "default") return config;
+      return Object.freeze({ ...config, rootSampling: Object.freeze({ ...config.rootSampling, temperature: t }) });
+    }
+    case "smartReasoning":
+      if (value === "default") return Object.freeze({ ...config, smartReasoning: undefined });
+      return Object.hasOwn(THINKING_LEVELS, value)
+        ? Object.freeze({ ...config, smartReasoning: value as ThinkingLevel })
+        : config;
+    case "subSamplingMaxTokens":
+      return Object.freeze({ ...config, subSampling: Object.freeze({ ...config.subSampling, maxTokens: Number(value) }) });
+    case "subSamplingTemperature": {
+      const st = optionalTemperature(value);
+      if (st === undefined && value !== "default") return config;
+      return Object.freeze({ ...config, subSampling: Object.freeze({ ...config.subSampling, temperature: st }) });
+    }
     case "sandboxInitTimeoutMs": return Object.freeze({ ...config, sandboxInitTimeoutMs: Number(value) });
     case "requestTimeoutMs": return Object.freeze({ ...config, requestTimeoutMs: Number(value) * 60_000 });
     case "contextLoader": return Object.freeze({ ...config, contextLoader: value === "on" });

package/src/ui/panel/run-registry.ts

@@ -29,6 +29,8 @@ export interface RunRegistration {
   readonly rootModel?: () => string | undefined;
   /** Root's OWN spend (driver-model turns) — never a subtree sum across models. */
   readonly rootTokens?: () => number;
+  readonly rootTokensIn?: () => number;
+  readonly rootTokensOut?: () => number;
   /** Persistent entries (background work) stay hidden until they hold subcalls. */
   readonly hideWhenEmpty?: boolean;
 }
@@ -44,6 +46,8 @@ export interface RunEntry {
   readonly turns: () => { readonly current: number; readonly max: number };
   readonly rootModel: () => string | undefined;
   readonly rootTokens: () => number;
+  readonly rootTokensIn: () => number;
+  readonly rootTokensOut: () => number;
   readonly hideWhenEmpty: boolean;
 }
 
@@ -66,6 +70,8 @@ export class RunRegistry {
       turns: run.turns ?? (() => DEFAULT_TURNS),
       rootModel: run.rootModel ?? (() => undefined),
       rootTokens: run.rootTokens ?? (() => 0),
+      rootTokensIn: run.rootTokensIn ?? (() => 0),
+      rootTokensOut: run.rootTokensOut ?? (() => 0),
       hideWhenEmpty: run.hideWhenEmpty ?? false,
     };
     this.entries.set(run.runId, entry);
@@ -119,6 +125,8 @@ export class RunRegistry {
         rootPhase: entry.rootPhase(),
         rootModel: entry.rootModel(),
         rootTokens: entry.rootTokens(),
+        rootTokensIn: entry.rootTokensIn(),
+        rootTokensOut: entry.rootTokensOut(),
         subcalls: entry.subcalls(),
       });
     }

package/src/ui/theme.ts

@@ -12,6 +12,12 @@ export function formatTokens(n: number): string {
   return String(n);
 }
 
+/** `190.2k↑ 18.6k↓ tok` — the in/out split. Falls back to plain when out is zero. */
+export function formatTokensSplit(tokensIn: number, tokensOut: number): string {
+  if (tokensOut > 0) return `${formatTokens(tokensIn)}↑ ${formatTokens(tokensOut)}↓ tok`;
+  return `${formatTokens(tokensIn)} tok`;
+}
+
 export function formatDuration(ms: number): string {
   const s = ms / 1000;
   return s < 60 ? `${s.toFixed(1)}s` : `${Math.floor(s / 60)}m${Math.round(s % 60)}s`;

package/src/ui/tree/tree-model.ts

@@ -26,6 +26,8 @@ export interface RunSnapshot {
   readonly rootModel?: string;
   /** Root's OWN token spend (driver-model turns) — never a subtree sum. */
   readonly rootTokens: number;
+  readonly rootTokensIn: number;
+  readonly rootTokensOut: number;
   readonly subcalls: readonly RlmSubcall[];
 }
 
@@ -46,6 +48,8 @@ export interface NodeRow {
   readonly label: string;
   /** The row's OWN token spend for its OWN model — never a subtree sum. */
   readonly tokens: number;
+  readonly tokensIn: number;
+  readonly tokensOut: number;
   readonly model?: string;
 }
 
@@ -64,6 +68,8 @@ export interface GroupRow {
   readonly model?: string;
   /** Sum over members — one model only (the group key pins it), so never a blend. */
   readonly tokens: number;
+  readonly tokensIn: number;
+  readonly tokensOut: number;
   /** SubcallStatus, or "queued" while any member parks on the rate-limit cooldown. */
   readonly icon: SubcallStatus | "queued";
   readonly expandable: boolean;
@@ -147,6 +153,8 @@ export function buildRows(
       phase: sc.phase,
       label: sc.label,
       tokens: sc.tokens,
+      tokensIn: sc.tokensIn,
+      tokensOut: sc.tokensOut,
       model: sc.model,
     });
     if (!expanded || children.length === 0) return;
@@ -181,7 +189,13 @@ export function buildRows(
     const id = `grp:${run.runId}:${entry.key}:${first.id}`;
     const expanded = expandedGroups.has(id);
     let tokens = 0;
-    for (const m of entry.members) tokens += m.tokens;
+    let tokensIn = 0;
+    let tokensOut = 0;
+    for (const m of entry.members) {
+      tokens += m.tokens;
+      tokensIn += m.tokensIn;
+      tokensOut += m.tokensOut;
+    }
     rows.push({
       type: "group",
       id,
@@ -192,6 +206,8 @@ export function buildRows(
       label: entry.label,
       model: entry.model,
       tokens,
+      tokensIn,
+      tokensOut,
       icon: iconOf(entry.status, entry.members.some((m) => m.phase === "queued") ? "queued" : undefined),
       expandable: true,
       expanded,
@@ -218,6 +234,8 @@ export function buildRows(
     phase: run.rootPhase,
     label: run.rootLabel,
     tokens: run.rootTokens,
+    tokensIn: run.rootTokensIn,
+    tokensOut: run.rootTokensOut,
     model: run.rootModel,
   });
   if (!collapsed.has(run.runId)) visitChildren(roots, 0, "");

package/src/ui/tree/tree-rows.ts

@@ -8,7 +8,7 @@
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { formatTokens, spinnerFrame } from "../theme.ts";
+import { formatTokens, formatTokensSplit, spinnerFrame } from "../theme.ts";
 import type { GroupRow, NodeRow, TreeRow } from "./tree-model.ts";
 
 const GLYPHS = Object.freeze({ done: "✓", error: "✗", queued: "◷", expanded: "▾", collapsed: "▸", leaf: " " } as const);
@@ -29,16 +29,16 @@ function iconGlyph(row: NodeRow, theme: Theme): string {
   }
 }
 
-/** Right-hand stats: "4.3k tok · gpt-5-mini" (model only when present). */
-function statsText(tokens: number, model: string | undefined): string {
-  const parts = [`${formatTokens(tokens)} tok`];
+/** Right-hand stats: "190.2k↑ 18.6k↓ tok · gpt-5-mini" (split + model only when present). */
+function statsText(tokens: number, tokensIn: number, tokensOut: number, model: string | undefined): string {
+  const parts = [tokensOut > 0 ? formatTokensSplit(tokensIn, tokensOut) : `${formatTokens(tokens)} tok`];
   if (model !== undefined) parts.push(modelShort(model));
   return parts.join(" · ");
 }
 
 /** Left/right assembly shared by node and group rows — one padding rule, no fork. */
-function assembleLine(left: string, tokens: number, model: string | undefined, selected: boolean, width: number, theme: Theme): string {
-  const right = theme.fg("dim", statsText(tokens, model));
+function assembleLine(left: string, tokens: number, tokensIn: number, tokensOut: number, model: string | undefined, selected: boolean, width: number, theme: Theme): string {
+  const right = theme.fg("dim", statsText(tokens, tokensIn, tokensOut, model));
   const gap = width - visibleWidth(left) - visibleWidth(right) - 1;
   const line = gap > 0 ? `${left}${" ".repeat(gap)}${right}` : `${truncateToWidth(left, width - 1)} `;
   return selected ? theme.fg("accent", line) : line;
@@ -48,7 +48,7 @@ function formatNode(row: NodeRow, selected: boolean, width: number, theme: Theme
   const chevron = row.expandable ? (row.expanded ? GLYPHS.expanded : GLYPHS.collapsed) : GLYPHS.leaf;
   const cursor = selected ? theme.fg("accent", "❯") : " ";
   const left = `${cursor} ${row.prefix}${chevron} ${iconGlyph(row, theme)} ${row.label}`;
-  return assembleLine(left, row.tokens, row.model, selected, width, theme);
+  return assembleLine(left, row.tokens, row.tokensIn, row.tokensOut, row.model, selected, width, theme);
 }
 
 function formatGroup(row: GroupRow, selected: boolean, width: number, theme: Theme): string {
@@ -56,7 +56,7 @@ function formatGroup(row: GroupRow, selected: boolean, width: number, theme: The
   const cursor = selected ? theme.fg("accent", "❯") : " ";
   const icon = row.icon === "done" ? theme.fg("success", GLYPHS.done) : row.icon === "error" ? theme.fg("error", GLYPHS.error) : theme.fg("warning", spinnerFrame());
   const left = `${cursor} ${row.prefix}${chevron} ${icon} ${row.label} ×${row.count}`;
-  return assembleLine(left, row.tokens, row.model, selected, width, theme);
+  return assembleLine(left, row.tokens, row.tokensIn, row.tokensOut, row.model, selected, width, theme);
 }
 
 export function formatRow(row: TreeRow, selected: boolean, width: number, theme: Theme): string {

package/src/util/retry.ts

@@ -17,10 +17,13 @@ import { ProviderCooldown, sleepMs, sharedCooldown } from "./throttle.ts";
 
 // Auth/quota failures must not be retried — they burn attempts and never recover.
 const NON_RETRYABLE_TEXT =
-  /api[ -]?key|unauthorized|forbidden|permission denied|billing|insufficient|balance|quota exceeded|not.?found|context length|too large|invalid request|malformed/i;
-// Transport/server transients — worth another attempt.
+  /api[ -]?key|unauthorized|forbidden|permission denied|billing|insufficient|balance|quota exceeded|not.?found|context length|too large|invalid request|malformed|content.?filter/i;
+// Transport/server transients — worth another attempt. "Provider finish_reason: error" is the
+// generic shape OpenRouter relays when the UPSTREAM kills a generation mid-stream (observed
+// from Cohere's free pool: native_finish_reason "error", no message, no code, partial usage) —
+// HTTP 200, so it is inherently transient-by-nature and must be retried.
 const RETRYABLE_TEXT =
-  /\b429\b|rate.?limit|overloaded|service.?unavailable|upstream|timeout|timed.?out|temporarily|try.?again|econnreset|econnrefused|etimedout|socket hang up|network|1302|速率|频率/i;
+  /\b429\b|rate.?limit|overloaded|service.?unavailable|upstream|timeout|timed.?out|temporarily|try.?again|econnreset|econnrefused|etimedout|socket hang up|network|finish.?reason: ?(error|network_error)|1302|速率|频率/i;
 const RATE_LIMIT_TEXT = /\b429\b|rate.?limit|1302|速率|频率/i;
 
 const NON_RETRYABLE_STATUS = new Set([400, 401, 402, 403, 404, 413, 422]);