troxy-cli 1.19.0 → 1.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "troxy-cli",
-  "version": "1.19.0",
+  "version": "1.20.0",
   "description": "Control layer for AI agents: check payments, emails, logins and destructive actions against your policies",
   "homepage": "https://troxy.io",
   "bugs": {

package/src/hook-report.js

@@ -15,6 +15,7 @@ import { api }        from './api.js';
 // happening here than the conversation that just finished.
 
 const REPORT_TIMEOUT_MS = 2500;
+const MAX_EXCERPT_LEN = 4000; // matches classify.py's MAX_EXCERPT_LEN
 
 // Fields this file is allowed to touch from a transcript entry. Deliberately
 // narrow: extractUsage() below only ever reads these keys off a transcript
@@ -44,6 +45,24 @@ export function extractUsage(entry) {
   };
 }
 
+// A second, equally narrow allowlist function, same discipline as
+// extractUsage above: this is the ONLY place in the whole hook that reads
+// message text at all, and it exists on purpose for the transient
+// classifier (classify.py on the backend) - the excerpt it returns is sent
+// once, classified once, and never stored anywhere, on either side of the
+// wire. Everywhere else in this file continues to only ever touch usage
+// numbers. Returns the LAST text block of an entry, since a single
+// assistant turn can carry several content blocks (thinking, tool_use,
+// text) and only the final text block is what the user actually saw as
+// the reply.
+export function extractReplyText(entry) {
+  if (!entry || entry.type !== 'assistant') return null;
+  const content = entry.message?.content;
+  if (!Array.isArray(content)) return null;
+  const textBlock = content.find(b => b?.type === 'text' && typeof b.text === 'string');
+  return textBlock ? textBlock.text : null;
+}
+
 // Claude Code writes one JSONL line per content block (thinking/tool_use/
 // text), not one per turn or even one per model call - a single real API
 // response is split across several consecutive lines that all share the
@@ -99,7 +118,19 @@ export function usageForCurrentTurn(transcriptPath) {
   // genuinely different turns.
   const turnKey = Array.from(seen.keys()).sort().join(',').slice(0, 200);
 
-  return { tokens: totalTokens, model: lastModel, turnKey };
+  // turnLines is most-recent-first (built by walking the transcript
+  // backward), so the first entry with a text block is the final reply the
+  // user actually saw - not an earlier "thinking" block from mid-turn tool
+  // use. Truncated client-side too so an oversized excerpt never leaves
+  // this machine in the first place, not just rejected on arrival.
+  let replyText = null;
+  for (const entry of turnLines) {
+    replyText = extractReplyText(entry);
+    if (replyText) break;
+  }
+  const contentExcerpt = replyText ? replyText.slice(0, MAX_EXCERPT_LEN) : null;
+
+  return { tokens: totalTokens, model: lastModel, turnKey, contentExcerpt };
 }
 
 function withTimeout(promise, ms) {
@@ -147,11 +178,15 @@ export async function runHookReport() {
     const sessionId = payload?.session_id || '';
     const turnKey = sessionId ? `${sessionId}:${usage.turnKey}` : null;
 
+    const body = { model: usage.model, actual_tokens: usage.tokens, turn_key: turnKey };
+    // content_excerpt is optional and additive - the backend classifies it
+    // if present, samples/rate-limits on its own, and silently skips when
+    // it isn't. Sending it is not required for the usage report itself to
+    // succeed.
+    if (usage.contentExcerpt) body.content_excerpt = usage.contentExcerpt;
+
     await withTimeout(
-      api.reportVerifiedUsage(
-        { model: usage.model, actual_tokens: usage.tokens, turn_key: turnKey },
-        apiKey,
-      ),
+      api.reportVerifiedUsage(body, apiKey),
       REPORT_TIMEOUT_MS,
     );
   } catch {

package/src/tests/hook-report.test.js

@@ -16,7 +16,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 
-import { usageForCurrentTurn, extractUsage } from '../hook-report.js';
+import { usageForCurrentTurn, extractUsage, extractReplyText } from '../hook-report.js';
 
 let dir;
 beforeEach(() => { dir = fs.mkdtempSync(path.join(os.tmpdir(), 'troxy-transcript-')); });
@@ -34,6 +34,10 @@ function assistantLine(messageId, usage, model = 'claude-sonnet-5') {
   return { type: 'assistant', message: { id: messageId, model, usage } };
 }
 
+function assistantLineWithText(messageId, usage, text, model = 'claude-sonnet-5') {
+  return { type: 'assistant', message: { id: messageId, model, usage, content: [{ type: 'text', text }] } };
+}
+
 const USAGE_A = { input_tokens: 2, output_tokens: 1176, cache_creation_input_tokens: 4134, cache_read_input_tokens: 244103 };
 
 describe('extractUsage', () => {
@@ -137,3 +141,64 @@ describe('usageForCurrentTurn', () => {
     assert.doesNotThrow(() => usageForCurrentTurn(transcriptPath()));
   });
 });
+
+describe('extractReplyText', () => {
+  it('reads the text block from an assistant entry', () => {
+    const entry = assistantLineWithText('msg_1', { input_tokens: 1, output_tokens: 1 }, 'hello there');
+    assert.equal(extractReplyText(entry), 'hello there');
+  });
+
+  it('returns null for a non-assistant entry', () => {
+    assert.equal(extractReplyText({ type: 'user', message: { content: [{ type: 'text', text: 'hi' }] } }), null);
+  });
+
+  it('returns null when there is no text block (e.g. a tool_use-only entry)', () => {
+    const entry = { type: 'assistant', message: { content: [{ type: 'tool_use', name: 'Read' }] } };
+    assert.equal(extractReplyText(entry), null);
+  });
+
+  it('returns null when content is missing entirely', () => {
+    assert.equal(extractReplyText({ type: 'assistant', message: {} }), null);
+  });
+});
+
+describe('usageForCurrentTurn: content excerpt', () => {
+  it('returns the final text reply as contentExcerpt', () => {
+    writeLines([
+      { type: 'user', message: { content: [{ type: 'text', text: 'hi' }] } },
+      assistantLineWithText('msg_1', { input_tokens: 1, output_tokens: 1 }, 'the actual reply'),
+    ]);
+    const result = usageForCurrentTurn(transcriptPath());
+    assert.equal(result.contentExcerpt, 'the actual reply');
+  });
+
+  it('picks the LAST text block when the turn has several (e.g. thinking then a tool call then a final reply)', () => {
+    writeLines([
+      { type: 'user', message: { content: [{ type: 'text', text: 'hi' }] } },
+      assistantLineWithText('msg_1', { input_tokens: 1, output_tokens: 1 }, 'intermediate note'),
+      { type: 'assistant', message: { id: 'msg_1', usage: { input_tokens: 1, output_tokens: 1 }, content: [{ type: 'tool_use', name: 'Read' }] } },
+      assistantLineWithText('msg_2', { input_tokens: 1, output_tokens: 1 }, 'final reply to the user'),
+    ]);
+    const result = usageForCurrentTurn(transcriptPath());
+    assert.equal(result.contentExcerpt, 'final reply to the user');
+  });
+
+  it('is null when the turn produced no text block at all', () => {
+    writeLines([
+      { type: 'user', message: { content: [{ type: 'text', text: 'hi' }] } },
+      assistantLine('msg_1', { input_tokens: 1, output_tokens: 1 }),
+    ]);
+    const result = usageForCurrentTurn(transcriptPath());
+    assert.equal(result.contentExcerpt, null);
+  });
+
+  it('truncates an oversized reply before it ever leaves usageForCurrentTurn', () => {
+    const longText = 'x'.repeat(10000);
+    writeLines([
+      { type: 'user', message: { content: [{ type: 'text', text: 'hi' }] } },
+      assistantLineWithText('msg_1', { input_tokens: 1, output_tokens: 1 }, longText),
+    ]);
+    const result = usageForCurrentTurn(transcriptPath());
+    assert.equal(result.contentExcerpt.length, 4000);
+  });
+});