troxy-cli 1.30.0 → 1.30.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "troxy-cli",
-  "version": "1.30.0",
+  "version": "1.30.1",
   "description": "A secure control layer for AI agents: policies across payments, messages, logins, destructive actions, model usage, and secrets, all enforceable from the CLI",
   "homepage": "https://troxy.io",
   "bugs": {

package/src/mods/troxy-guard/hooks/register.js

@@ -181,13 +181,19 @@ function sessionLine(t) {
     Object.entries(t.meter).map(([kind, percentUsed]) => ({ kind, percentUsed })));
 }
 
-// Tokens Troxy kept out of the requests of this session (compression + trimming), counted
-// by the server. undefined until something was saved.
-function savingsText(s) {
-  const c = (s && s.compressed_tokens) || 0, t = (s && s.trimmed_tokens) || 0;
+// This session's Troxy work, from the server's count of its calls: how many ran on a
+// lighter model than asked, plus tokens kept out of requests (compression + trimming,
+// API-key setups through the proxy only). A holdout session says so: it is never routed.
+// undefined until there is something to say.
+function savingsText(s, arm) {
+  const calls = (s && s.calls) || 0, routed = (s && s.routed_calls) || 0;
+  const kept = ((s && s.compressed_tokens) || 0) + ((s && s.trimmed_tokens) || 0);
   const k = n => n >= 1e6 ? `${Math.round(n / 1e5) / 10}M`.replace('.0M', 'M') : n >= 1000 ? `${Math.round(n / 1000)}k` : String(n);
-  // Always show, even if 0, so the band is transparent: 0 means no trimming/compression on this turn
-  return `${k(c + t)} tokens not re-sent, thanks to compression and trimming`;
+  if (arm === 'holdout') return calls ? 'comparison session: not routed, so Troxy can measure the difference' : undefined;
+  const parts = [];
+  if (calls) parts.push(`${routed} of ${calls} calls on a lighter model`);
+  if (kept > 0) parts.push(`${k(kept)} tokens not re-sent`);
+  return parts.length ? parts.join(' · ') : undefined;
 }
 
 // This session's savings from the server, or null when there is no key, no session id or
@@ -229,7 +235,7 @@ const REPORT_KEEP_ROWS = 1000; // kept for the next try while Troxy is unreachab
 let pending = [];
 let compacting = false;
 
-function reportRow({ sid, usage, requested, arm, cold, score, compact, rateLimits }) {
+function reportRow({ sid, usage, requested, arm, cold, score, compact, rateLimits, ts }) {
   const rl = {};
   for (const w of rateLimits || []) {
     if (!WINDOW_LABEL[w.kind]) continue;
@@ -241,7 +247,7 @@ function reportRow({ sid, usage, requested, arm, cold, score, compact, rateLimit
     arm: arm || null, switch: arm ? (cold ? 'cold' : 'warm') : null, score: score == null ? null : score,
     compact: Boolean(compact), input_tokens: usage.input_tokens, output_tokens: usage.output_tokens,
     cache_read_tokens: usage.cache_read_input_tokens, cache_creation_tokens: usage.cache_creation_input_tokens,
-    rate_limits: rl,
+    rate_limits: rl, ts,
   };
 }
 
@@ -250,7 +256,7 @@ async function noteStep($, result, meta) {
   if (!usage || !usage.model) return;
   let rateLimits = [];
   try { rateLimits = (await $.session.usage()).rateLimits; } catch {}
-  pending.push(reportRow({ ...meta, sid: await $.session.id(), usage, compact: compacting, rateLimits }));
+  pending.push(reportRow({ ...meta, sid: await $.session.id(), usage, compact: compacting, rateLimits, ts: await $.clock.now() }));
   if (pending.length > REPORT_KEEP_ROWS) pending = pending.slice(-REPORT_KEEP_ROWS);
 }
 
@@ -601,7 +607,7 @@ export function register(on) {
     let savings = null;
     try {
       savings = await fetchSavings($);
-      if (savings) await $.state.set(SAVINGS, savingsText(savings));
+      if (savings) await $.state.set(SAVINGS, savingsText(savings, (await $.state.get(ARM)).value) || null);
     } catch {} // a missed fetch only leaves the band as it was
     if (turn) {
       const { start, ratio } = turn;

package/src/tests/mods-troxy-guard.test.js

@@ -128,14 +128,14 @@ test('compactPlan: big idle sessions compact, small ones and a nearly full bar d
   assert.deepEqual(compactPlan({ tokens: 210000, now, rateLimits: [{ kind: 'seven_day', percentUsed: 99 }] }), { action: 'skip' });
 });
 
-test('savingsText: shows compression + trimming together, 0 when nothing was saved', () => {
+test('savingsText: calls on a lighter model, kept tokens only when there are some, holdout says so', () => {
   const { savingsText } = _internal;
-  assert.equal(savingsText({ compressed_tokens: 5200, trimmed_tokens: 40100 }), '45k tokens not re-sent, thanks to compression and trimming');
-  assert.equal(savingsText({ compressed_tokens: 300, trimmed_tokens: 0 }), '300 tokens not re-sent, thanks to compression and trimming');
-  assert.equal(savingsText({ compressed_tokens: 0, trimmed_tokens: 0 }), '0 tokens not re-sent, thanks to compression and trimming');
-  assert.equal(savingsText({ compressed_tokens: 123277, trimmed_tokens: 154512861 }), '154.6M tokens not re-sent, thanks to compression and trimming');
-  assert.equal(savingsText({ compressed_tokens: 0, trimmed_tokens: 2000000 }), '2M tokens not re-sent, thanks to compression and trimming');
-  assert.equal(savingsText(null), '0 tokens not re-sent, thanks to compression and trimming');
+  assert.equal(savingsText({ calls: 5, routed_calls: 5, compressed_tokens: 0, trimmed_tokens: 0 }), '5 of 5 calls on a lighter model');
+  assert.equal(savingsText({ calls: 4, routed_calls: 1, compressed_tokens: 5200, trimmed_tokens: 40100 }), '1 of 4 calls on a lighter model · 45k tokens not re-sent');
+  assert.equal(savingsText({ calls: 9, routed_calls: 0, compressed_tokens: 123277, trimmed_tokens: 154512861 }), '0 of 9 calls on a lighter model · 154.6M tokens not re-sent');
+  assert.equal(savingsText({ calls: 3, routed_calls: 0 }, 'holdout'), 'comparison session: not routed, so Troxy can measure the difference');
+  assert.equal(savingsText({ calls: 0 }), undefined);
+  assert.equal(savingsText(null), undefined);
 });
 
 test('fetchSavings: sends the saved key and the session id; null without a key or on an error', async () => {
@@ -364,6 +364,7 @@ test('usage report: each request is queued with model, tokens, bar and arm, then
   const row = pendingRows().at(-1);
   assert.equal(row.model, M.sonnet); assert.equal(row.model_requested, M.opus);
   assert.equal(row.arm, 'treated'); assert.equal(row.switch, 'cold'); assert.equal(row.cache_read_tokens, 900);
+  assert.equal(typeof row.ts, 'number');                  // when the request ran, not when the turn ended
   assert.deepEqual(row.rate_limits, { five_hour: { percent_used: 42, resets_at: '2026-10-20T10:00:00Z' } });
   assert.equal(JSON.stringify(row).includes('reply only ok'), false); // never prompt text
   await flushReport($);