@rikcodes/teamclaude 1.1.22-rik.3 → 1.1.22-rik.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rikcodes/teamclaude",
-  "version": "1.1.22-rik.3",
+  "version": "1.1.22-rik.4",
   "description": "Multi-account proxy for Claude Code and Codex: pools Claude Max, ChatGPT/Codex, API-key and third-party backend accounts, and rotates on quota",
   "type": "module",
   "main": "src/index.js",

package/src/throughput.js

@@ -259,7 +259,7 @@ export function niceCeil(v) {
 
 const mod = (/** @type {number} */ x, /** @type {number} */ n) => ((x % n) + n) % n;
 
-/** @typedef {{ chars: number, firstAt: number, lastAt: number, model: string|null }} Stream */
+/** @typedef {{ chars: number, firstAt: number, lastAt: number, model: string|null, counted: boolean }} Stream */
 
 /**
  * The fleet's output rate: tokens generated across every request in the last
@@ -282,6 +282,11 @@ const mod = (/** @type {number} */ x, /** @type {number} */ n) => ((x % n) + n)
  *
  * Generating time runs from the stream's first output event to now, not to its
  * latest one: hidden thinking sends nothing while it thinks.
+ *
+ * A stream can be followed without being counted (`counted` false): its own
+ * live estimate is kept, but it adds nothing to the fleet's reading, books
+ * nothing when it ends and teaches its model nothing. The TUI uses that for
+ * the second leg of one generation (see TUI._markLeg).
  */
 export class ThroughputMeter {
   /** @param {{ now?: () => number, windowSec?: number, ringSec?: number }} [opts] */
@@ -305,22 +310,24 @@ export class ThroughputMeter {
 
   /**
    * Output streamed for request `id`: `chars` of text at `at`, from `model`.
-   * The first call starts the stream's generating time.
-   * @param {unknown} id @param {number} chars @param {number} at @param {string|null} [model]
+   * The first call starts the stream's generating time. `counted` false follows
+   * the stream for its own estimate only (see the class comment).
+   * @param {unknown} id @param {number} chars @param {number} at @param {string|null} [model] @param {boolean} [counted]
    */
-  progress(id, chars, at, model = null) {
+  progress(id, chars, at, model = null, counted = true) {
     const t = time(at);
     if (t === null) return;
     const n = typeof chars === 'number' && Number.isFinite(chars) && chars > 0 ? chars : 0;
     let s = this.streams.get(id);
     if (!s) {
       if (this.streams.size >= MAX_STREAMS) this.streams.delete(this.streams.keys().next().value);
-      s = { chars: 0, firstAt: t, lastAt: t, model: null };
+      s = { chars: 0, firstAt: t, lastAt: t, model: null, counted: true };
       this.streams.set(id, s);
     }
     s.chars += n;
     if (t > s.lastAt) s.lastAt = t;
     if (model) s.model = model;
+    s.counted = counted !== false;
   }
 
   /**
@@ -333,12 +340,16 @@ export class ThroughputMeter {
    * part of its estimate it can vouch for, its visible text, and not the part
    * that was a guess from its model's pace.
    *
+   * A request that is not counted (`counted` false, here or on its stream)
+   * books nothing and teaches nothing: it is only forgotten.
+   *
    * @param {unknown} id
-   * @param {{ outputTokens?: number|null, firstAt?: number|null, lastAt?: number|null, dispatchedAt?: number|null, endedAt?: number|null, model?: string|null }} [r]
+   * @param {{ outputTokens?: number|null, firstAt?: number|null, lastAt?: number|null, dispatchedAt?: number|null, endedAt?: number|null, model?: string|null, counted?: boolean }} [r]
    */
-  finish(id, { outputTokens = null, firstAt = null, lastAt = null, dispatchedAt = null, endedAt = null, model = null } = {}) {
+  finish(id, { outputTokens = null, firstAt = null, lastAt = null, dispatchedAt = null, endedAt = null, model = null, counted = true } = {}) {
     const s = this.streams.get(id);
     this.streams.delete(id);
+    if (counted === false || s?.counted === false) return;
     const end = time(endedAt);
     if (end !== null) this._observe(end);
     const n = tokens(outputTokens);
@@ -402,6 +413,7 @@ export class ThroughputMeter {
     sum += this.ring[mod(sec - w, n)] * (1 - into);
     const from = t - w * 1000;
     for (const s of this.streams.values()) {
+      if (!s.counted) continue;
       const { est, genMs } = this._estimate(s, t);
       if (!est) continue;
       sum += genMs > 0 ? est * (Math.min(genMs, t - from) / genMs) : est;
@@ -410,11 +422,13 @@ export class ThroughputMeter {
     return Number.isFinite(r) && r > 0 ? r : 0;
   }
 
-  /** Whether the reading is anything but a settled zero: a stream in flight, or
-   *  tokens still in the window. The TUI keeps its fast tick for exactly as long.
+  /** Whether the reading is anything but a settled zero: a counted stream in
+   *  flight, or tokens still in the window. The TUI keeps its fast tick for
+   *  exactly as long.
    *  @param {number} [at] */
   recent(at = this.now()) {
-    return this.streams.size > 0 || this.rate(at) > 0;
+    for (const s of this.streams.values()) if (s.counted) return true;
+    return this.rate(at) > 0;
   }
 
   /**

package/src/tui.js

@@ -22,7 +22,7 @@ import { sanitizeText, safeLine } from './safe-text.js';
 // The setting rules live in one module; the CLI, the MCP tools and this screen
 // all read them from there, so they cannot drift apart (#426).
 import { MAX_PROBE_SECONDS, ROUTE_COLORS } from './config-ops.js';
-import { isLocalUpstream } from './provider.js';
+import { isLocalUpstream, providerForPath } from './provider.js';
 import { ThroughputMeter, requestRate, formatRate } from './throughput.js';
 import { renderSpeedo, speedoWidth, SPEEDO_MIN_H, SPEEDO_MAX_H } from './speedo.js';
 
@@ -1099,7 +1099,48 @@ export class TUI {
 
   onRequestRouted(id, info) {
     const r = this.active.get(id);
-    if (r) r.account = info.account == null ? info.account : safeLine(info.account, 64);
+    if (!r) return;
+    r.account = info.account == null ? info.account : safeLine(info.account, 64);
+    if (this._throughputOn()) this._markLeg(r, info.account);
+  }
+
+  /**
+   * Whether this request is the second leg of a generation the fleet meter
+   * already counts, decided once, when the request is first routed.
+   *
+   * A translating sidecar (the Codex one in docs/openai.md) is a local-upstream
+   * account that calls back through this proxy: Claude Code's request goes to
+   * the sidecar, and the sidecar's translation of it comes back in and is served
+   * by a real account. Both legs stream the same generation and both report its
+   * tokens, so counting both doubles it. The outer leg is the one counted: it is
+   * what the client asked for, and the sidecar hands it the translated count.
+   *
+   * The inner leg is recognised by what the sidecar forwards and nothing else
+   * does: the SAME session as a request the proxy is currently serving on a
+   * local upstream, in a DIFFERENT dialect from it (the path says which), since
+   * the leg is that request translated. The session alone is not enough, because
+   * one session runs unrelated requests side by side; those are in the client's
+   * own dialect. A request that is itself on a local upstream is an outer leg,
+   * never an inner one. With no session on either leg nothing can be paired, and
+   * a local backend that does not call back never sends an inner leg, so in both
+   * cases everything is counted, as before.
+   *
+   * O(active) once per routing, never per delta. A nested request still keeps
+   * its own estimate and its own finished rate; it is only left out of the sum.
+   *
+   * @param {Record<string, any>} r the active entry
+   * @param {string|null|undefined} name the account it was routed to
+   */
+  _markLeg(r, name) {
+    const acct = name == null ? null : this.am.accounts.find((/** @type {any} */ a) => a.name === name);
+    r.local = isLocalUpstream(acct);
+    r.dialect ??= providerForPath(r.path || '');
+    if (r.nested !== undefined) return;
+    r.nested = false;
+    if (r.local || !r.sessionId) return;
+    for (const o of this.active.values()) {
+      if (o !== r && o.local && o.sessionId === r.sessionId && o.dialect !== r.dialect) { r.nested = true; return; }
+    }
   }
 
   /**
@@ -1113,7 +1154,7 @@ export class TUI {
    */
   onRequestProgress(id, { chars, at }) {
     const r = this.active.get(id);
-    if (r) this.throughput.progress(id, chars, at, r.model || null);
+    if (r) this.throughput.progress(id, chars, at, r.model || null, !r.nested);
   }
 
   onRequestEnd(id, info) {
@@ -1134,7 +1175,7 @@ export class TUI {
       outputTokens: info.outputTokens, firstAt: info.firstTokenAt, lastAt: info.lastTokenAt,
       dispatchedAt: info.dispatchedAt ?? r?.started ?? null, endedAt: now, model: info.model || r?.model || null,
     };
-    this.throughput.finish(id, timing);
+    this.throughput.finish(id, { ...timing, counted: !r?.nested });
     const tps = r ? requestRate({ ...timing, startedAt: timing.dispatchedAt }) : null;
     const tag = this._sessionTag(sid);
     // The line as it has always read. The rate is kept beside it rather than in