troxy-cli 1.29.43 → 1.29.45

package/package.json

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

@@ -24,7 +24,7 @@ async function guardBash($, e, next) {
       body: JSON.stringify({ domain: mapped.domain, fields: mapped.fields }),
       signal: controller.signal,
     });
-    result = res.ok ? await res.json() : { decision: 'ESCALATE', reason: 'policy service returned an error' };
+    result = res.ok ? JSON.parse(res.text) : { decision: 'ESCALATE', reason: 'policy service returned an error' };
   } finally {
     clearTimeout(timer);
   }
@@ -121,6 +121,7 @@ const PRICE = { haiku: 1, sonnet: 2, opus: 4 }; // list $/MTok in; output keeps
 const WINDOW_LABEL = { five_hour: '5h', seven_day: '7d' };
 // Drawn in Troxy's teal: the status line can't be colored and shows as a yellow warning.
 const LINE = { plugin: 'troxy-guard', key: 'line' };
+const SAVINGS = { plugin: 'troxy-guard', key: 'savings' }; // the band's compression + trimming text
 const SAVED = { plugin: 'troxy-guard', key: 'saved' }; // { paid, full, meter }; survives a troxy update
 const TROXY_TEAL = '#0a9e88';
 
@@ -157,6 +158,39 @@ 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;
+  if (!(c + t > 0)) return undefined;
+  const k = n => n >= 1000 ? `${Math.round(n / 1000)}k` : String(n);
+  return `${k(c + t)} tokens saved by compression and trimming`;
+}
+
+// This session's savings from the server, or null when there is no key, no session id or
+// the call fails (the band then keeps what it showed).
+async function fetchSavings($) {
+  const sid = await $.session.id();
+  if (!/^[A-Za-z0-9-]{8,64}$/.test(String(sid))) return null;
+  let key = await $.env.get('TROXY_API_KEY');
+  if (!key) {
+    const home = await $.env.get('HOME');
+    if (!home) return null;
+    key = JSON.parse(await $.fs.read(`${home}/.troxy/config.json`)).apiKey;
+  }
+  if (!key) return null;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+  try {
+    const res = await $.http.fetch(`https://api.troxy.io/mcp/session-savings?session_id=${sid}`, {
+      headers: { 'x-troxy-key': key }, signal: controller.signal,
+    });
+    return res.ok ? JSON.parse(res.text) : null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 // /troxy status: everything about this session's Troxy in one place.
 function statusText({ version, paused, totals, rateLimits = [], compactOff = false }) {
   const lines = [`Troxy ${version || ''}`.trim() + ` · routing is ${paused ? 'off' : 'on'}`];
@@ -275,12 +309,20 @@ async function scorePrompt($, e, next) {
   return next(e);
 }
 
+// The model the session last asked for, per session, so a /model switch is seen.
+const lastAsked = new Map();
+
 async function* routeStep($, e, next) {
   // Main loop only: a subagent keeps whatever model it was given.
   if (!decision || e.agentId) return yield* next(e);
+  // The user picked a different model since the last turn: their choice wins
+  // for this turn (the proxy does the same, route_reason 'user_switch').
+  const sid = await $.session.id();
+  const prev = lastAsked.get(sid);
+  lastAsked.set(sid, e.model);
+  if (prev && prev !== e.model) { decision = null; return yield* next(e); }
   const model = pickModel(decision.score, e.model, decision.tokens);
   if (model !== e.model) {
-    const sid = await $.session.id();
     const file = modRouteFile($.plugin.root, sid);
     const key = `${sid}:${e.model}>${model}`;
     if (file && lastNote !== key) {
@@ -325,9 +367,10 @@ export function register(on) {
   on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
     const { value: line } = await $.state.get(LINE); // subscribes the band to the line
     const { value: note } = await $.state.get(COMPACTED);
-    if ((!line && !note) || e.props.hasSurvey) return next(e);
+    const { value: kept } = await $.state.get(SAVINGS);
+    if ((!line && !kept && !note) || e.props.hasSurvey) return next(e);
     const { Text } = $.ui.resolve(e);
-    return h(Text, { color: TROXY_TEAL }, `Troxy ${[line, note].filter(Boolean).join(' · ')}`);
+    return h(Text, { color: TROXY_TEAL }, `Troxy ${[line, kept, note].filter(Boolean).join(' · ')}`);
   });
   // After the answer, so counting never delays a prompt.
   on('turn.complete', async ($, e, next) => {
@@ -343,10 +386,14 @@ export function register(on) {
         if (line) await $.state.set(LINE, line);
       } catch {} // a missed turn only leaves the band as it was
     }
+    try {
+      const text = savingsText(await fetchSavings($));
+      if (text) await $.state.set(SAVINGS, text);
+    } catch {} // a missed fetch only leaves the band as it was
     armCompact($, COMPACT_IDLE_MS);
     return r;
   });
 }
 
 // Exported for tests only - not part of the mod's runtime contract.
-export const _internal = { toDomainAndFields, guardBash, failClosed, parseScore, pickModel, troxyCommand, modRouteFile, estimateTokens, MODELS, savedLine, sessionLine, addTurn, statusText, compactPlan };
+export const _internal = { toDomainAndFields, guardBash, failClosed, parseScore, pickModel, troxyCommand, modRouteFile, estimateTokens, MODELS, savedLine, sessionLine, addTurn, statusText, compactPlan, savingsText, fetchSavings, scorePrompt, routeStep };

package/src/mods/troxy-guard/types/index.d.ts

@@ -3,6 +3,6 @@ export type SessionSaved = { paid: number; full: number; meter: Record<string, n
 
 declare module 'claude-code' {
   interface PluginState {
-    'troxy-guard': { line: BarLine; saved: SessionSaved; compacted: BarLine }
+    'troxy-guard': { line: BarLine; saved: SessionSaved; compacted: BarLine; savings: BarLine }
   }
 }

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

@@ -118,3 +118,60 @@ test('compactPlan: big idle sessions compact, small ones and a nearly full bar d
   // nearly full with no known reset: never spend it
   assert.deepEqual(compactPlan({ tokens: 210000, now, rateLimits: [{ kind: 'seven_day', percentUsed: 99 }] }), { action: 'skip' });
 });
+
+test('savingsText: shows compression + trimming together, nothing when nothing was saved', () => {
+  const { savingsText } = _internal;
+  assert.equal(savingsText({ compressed_tokens: 5200, trimmed_tokens: 40100 }), '45k tokens saved by compression and trimming');
+  assert.equal(savingsText({ compressed_tokens: 300, trimmed_tokens: 0 }), '300 tokens saved by compression and trimming');
+  assert.equal(savingsText({ compressed_tokens: 0, trimmed_tokens: 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 () => {
+  const { fetchSavings } = _internal;
+  const calls = [];
+  const mk = ({ env = {}, config, res = { ok: true, text: '{"compressed_tokens":1}' } } = {}) => ({
+    session: { id: async () => 'abc-12345678' },
+    env: { get: async n => env[n] },
+    fs: { read: async p => { if (!config) throw new Error('missing'); calls.push(p); return JSON.stringify(config); } },
+    http: { fetch: async (url, init) => { calls.push([url, init.headers]); return res; } },
+  });
+  assert.deepEqual(await fetchSavings(mk({ env: { HOME: '/h' }, config: { apiKey: 'txy-1' } })), { compressed_tokens: 1 });
+  assert.deepEqual(calls, ['/h/.troxy/config.json', ['https://api.troxy.io/mcp/session-savings?session_id=abc-12345678', { 'x-troxy-key': 'txy-1' }]]);
+  assert.equal(await fetchSavings(mk({ env: { TROXY_API_KEY: 'txy-2' }, res: { ok: false } })), null);
+  assert.equal(await fetchSavings(mk({ env: { HOME: '/h' }, config: {} })), null);
+  assert.equal(await fetchSavings({ ...mk(), session: { id: async () => 'x' } }), null);
+});
+
+// A fake $ just big enough for scorePrompt + routeStep: the scorer says "easy"
+// (score 0.1) and the context is small, so the mod would route down to haiku.
+function routingApi() {
+  const kv = new Map();
+  return {
+    state: { get: async (k) => ({ value: kv.get(k.key) }), set: async (k, v) => kv.set(k.key, v) },
+    store: { get: async () => undefined },
+    session: { id: async () => 'sess-switch-test', usage: async () => ({ context: { tokens: 1000 }, rateLimits: [] }) },
+    plugin: { root: '/tmp/not-installed' },
+    model: { complete: async () => ({ isAnswered: true, text: '0.1' }) },
+    ui: { log: () => {} },
+    clock: { now: async () => 0 },
+    fs: { write: async () => {} },
+  };
+}
+
+async function runTurn($, model) {
+  const { scorePrompt, routeStep } = _internal;
+  await scorePrompt($, { text: 'reply only ok', origin: { kind: 'composer' } }, async (e) => e);
+  let sent;
+  const gen = routeStep($, { model }, async function* (e) { sent = e.model; });
+  for await (const _ of gen) { /* drain */ }
+  return sent;
+}
+
+test('routeStep: a /model switch is honored for that turn, then routing resumes', async () => {
+  const $ = routingApi();
+  const opus = _internal.MODELS.opus, sonnet = _internal.MODELS.sonnet, haiku = _internal.MODELS.haiku;
+  assert.equal(await runTurn($, opus), haiku);   // first turn: routed down as before
+  assert.equal(await runTurn($, sonnet), sonnet); // user picked sonnet: kept
+  assert.equal(await runTurn($, sonnet), haiku);  // same choice again: routing resumes
+});