troxy-cli 1.30.1 → 1.30.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "troxy-cli",
-  "version": "1.30.1",
+  "version": "1.30.3",
   "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

@@ -235,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, ts }) {
+function reportRow({ sid, usage, requested, arm, cold, score, compact, rateLimits, ts, effort, effortAsked, surfaces }) {
   const rl = {};
   for (const w of rateLimits || []) {
     if (!WINDOW_LABEL[w.kind]) continue;
@@ -247,7 +247,8 @@ 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, ts,
+    rate_limits: rl, ts, effort: effort || null, effort_requested: effortAsked || null,
+    surface: (surfaces || []).includes('desktop') ? 'desktop' : (surfaces || []).includes('terminal') ? 'terminal' : null,
   };
 }
 
@@ -256,7 +257,9 @@ 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, ts: await $.clock.now() }));
+  let surfaces = [];
+  try { surfaces = await $.session.surfaces(); } catch {}
+  pending.push(reportRow({ ...meta, sid: await $.session.id(), usage, compact: compacting, rateLimits, surfaces, ts: await $.clock.now() }));
   if (pending.length > REPORT_KEEP_ROWS) pending = pending.slice(-REPORT_KEEP_ROWS);
 }
 
@@ -510,6 +513,24 @@ function stepModel({ arm, requested, switched, cold, score, warm }) {
   return w !== null && rq !== null && RANK[w] <= RANK[rq] ? warm : requested;
 }
 
+// Effort swap: an easy prompt (scorer) runs at lower effort, so the model thinks and
+// writes less and makes fewer tool calls. Never raised. Claude Code sends the change
+// per message, which keeps the prompt cache (tested 2026-10-20: about 65 cache tokens
+// written on a changed turn, same as an unchanged one). Off unless switched on
+// (config effortSwap, or TROXY_EFFORT_SWAP=1 for an A/B run) until it is measured.
+const EFFORT_RANK = { low: 0, medium: 1, high: 2, xhigh: 3, max: 4 };
+const EFFORT_LOW_BELOW = 0.4;
+const EFFORT_MEDIUM_BELOW = 0.85;
+function stepEffort({ arm, requested, score, on }) {
+  if (!on || arm !== 'treated' || score == null || !(requested in EFFORT_RANK)) return requested;
+  const cap = score < EFFORT_LOW_BELOW ? 'low' : score < EFFORT_MEDIUM_BELOW ? 'medium' : null;
+  return cap && EFFORT_RANK[cap] < EFFORT_RANK[requested] ? cap : requested;
+}
+async function effortSwapOn($) {
+  if ((await $.env.get('TROXY_EFFORT_SWAP')) === '1') return true;
+  return Boolean((await troxyConfig($)).effortSwap);
+}
+
 async function* routeStep($, e, next) {
   // Main loop only: a subagent keeps whatever model it was given.
   if (e.agentId) {
@@ -552,8 +573,13 @@ async function* routeStep($, e, next) {
   }
   try { await rememberAsked($, sid, want, model); } catch {} // a missed write only loses this on resume
   if (model !== want && turn) turn.ratio = PRICE[tierOf(want)] / PRICE[tierOf(model)];
-  const result = yield* next(model === e.model ? e : { ...e, model });
-  try { await noteStep($, result, { requested: want, arm, cold: isCold, score: decision ? decision.score : null }); } catch {} // a missed row only thins the dashboard
+  let effort = e.effort;
+  if (!(await $.store.get('paused'))) {
+    try { effort = stepEffort({ arm, requested: e.effort, score: decision ? decision.score : null, on: await effortSwapOn($) }); } catch {}
+  }
+  const sent = model === e.model && effort === e.effort ? e : { ...e, model, ...(effort === undefined ? {} : { effort }) };
+  const result = yield* next(sent);
+  try { await noteStep($, result, { requested: want, arm, cold: isCold, score: decision ? decision.score : null, effort: sent.effort, effortAsked: e.effort }); } catch {} // a missed row only thins the dashboard
   return result;
 }
 
@@ -629,4 +655,4 @@ export function register(on) {
 }
 
 // Exported for tests only - not part of the mod's runtime contract.
-export const _internal = { reportRow, noteStep, flushReport, pendingRows: () => pending, troxyConfig, askedFor, rememberAsked, asked, armCompact, cancelCompact, toDomainAndFields, guardBash, failClosed, parseScore, asRequest, pickModel, troxyCommand, modRouteFile, estimateTokens, MODELS, savedLine, sessionLine, addTurn, withKept, statusText, compactPlan, savingsText, fetchSavings, scorePrompt, routeStep, stepModel, lastSent };
+export const _internal = { stepEffort, reportRow, noteStep, flushReport, pendingRows: () => pending, troxyConfig, askedFor, rememberAsked, asked, armCompact, cancelCompact, toDomainAndFields, guardBash, failClosed, parseScore, asRequest, pickModel, troxyCommand, modRouteFile, estimateTokens, MODELS, savedLine, sessionLine, addTurn, withKept, statusText, compactPlan, savingsText, fetchSavings, scorePrompt, routeStep, stepModel, lastSent };

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

@@ -403,3 +403,40 @@ test('usage report: a server error keeps the rows for the next turn', async () =
   await flushReport($);
   assert.equal(pendingRows().length, 0);
 });
+
+test('stepEffort: easy prompts drop to low, middle ones to medium, never raised, off unless on', () => {
+  const { stepEffort } = _internal;
+  const on = { arm: 'treated', on: true };
+  assert.equal(stepEffort({ ...on, requested: 'high', score: 0.1 }), 'low');
+  assert.equal(stepEffort({ ...on, requested: 'xhigh', score: 0.6 }), 'medium');
+  assert.equal(stepEffort({ ...on, requested: 'high', score: 0.9 }), 'high');     // hard: kept
+  assert.equal(stepEffort({ ...on, requested: 'low', score: 0.6 }), 'low');       // never raised
+  assert.equal(stepEffort({ ...on, requested: 'medium', score: 0.6 }), 'medium');
+  assert.equal(stepEffort({ ...on, requested: 'high', score: null }), 'high');    // no score: no change
+  assert.equal(stepEffort({ ...on, requested: undefined, score: 0.1 }), undefined); // model without effort
+  assert.equal(stepEffort({ ...on, requested: 16000, score: 0.1 }), 16000);       // a numeric budget: left alone
+  assert.equal(stepEffort({ arm: 'holdout', on: true, requested: 'high', score: 0.1 }), 'high');
+  assert.equal(stepEffort({ arm: 'treated', on: false, requested: 'high', score: 0.1 }), 'high');
+});
+
+test('routeStep: with the effort swap on, an easy prompt goes out at low effort and the row records it', async () => {
+  const { MODELS: M, routeStep, scorePrompt, pendingRows } = _internal;
+  const $ = { ...routingApi(),
+    env: { get: async (k) => (k === 'TROXY_EFFORT_SWAP' ? '1' : undefined) },
+    fs: { write: async () => {}, read: async () => { throw new Error('no config'); } } };
+  await scorePrompt($, { text: 'reply only ok', origin: { kind: 'composer' } }, async (e) => e);
+  let sent;
+  const gen = routeStep($, { model: M.opus, effort: 'high' }, async function* (e) { sent = e; return { usage: { model: e.model, output_tokens: 1 } }; });
+  for await (const _ of gen) { /* drain */ }
+  assert.equal(sent.effort, 'low');
+  assert.equal(pendingRows().at(-1).effort, 'low');
+  assert.equal(pendingRows().at(-1).effort_requested, 'high');
+});
+
+test('reportRow: surface is desktop when the app draws the session, terminal otherwise, null in -p', () => {
+  const { reportRow } = _internal;
+  const base = { sid: 's', usage: { model: 'm' } };
+  assert.equal(reportRow({ ...base, surfaces: ['terminal', 'desktop'] }).surface, 'desktop');
+  assert.equal(reportRow({ ...base, surfaces: ['terminal'] }).surface, 'terminal');
+  assert.equal(reportRow({ ...base, surfaces: [] }).surface, null);
+});