@adecore/agents 0.31.8 → 0.31.10

package/dist/usage/scanner.js

@@ -1,7 +1,8 @@
 import { createHash } from 'node:crypto';
 import { mkdir, open, readFile, readdir, stat } from 'node:fs/promises';
 import { join } from 'node:path';
-import { zstdDecompressSync } from 'node:zlib';
+import { Readable } from 'node:stream';
+import { createZstdDecompress } from 'node:zlib';
 import { errorText } from '../error-text.js';
 import { isNotFound, writeAtomic } from '../fs.js';
 import { decodeIndex, encodeIndex } from './index-file.js';
@@ -12,41 +13,58 @@ import { hostLogMightCarryUsage, parseHostUsageLine } from './readers/host-log.j
 import { cloneCodexState, codexMightCarryUsage, createCodexState, parseCodexLine } from './readers/codex.js';
 import { usageRoots } from './roots.js';
 const HASH_CHUNK_BYTES = 65536;
+// How much of a transcript is read at once. Codex writes sessions of more than a gigabyte, which read whole held several times their size.
+const READ_CHUNK_BYTES = 1 << 20;
 const CODEX_PARSER_VERSION = 2;
-/*
- * Hashes the bytes before `from` and returns the rest, in one pass over one handle, so verifying
- * what a transcript committed and parsing what it added never reads a byte twice.
- */
-async function readHashed(path, from) {
+const NEWLINE = 0x0a;
+/* Hashes the first `length` bytes of a file into `hash`, a chunk at a time. */
+async function hashPrefix(path, length, hash) {
     const handle = await open(path, 'r');
     try {
-        const hash = createHash('sha256');
-        const chunk = Buffer.alloc(Math.min(from, HASH_CHUNK_BYTES));
+        const chunk = Buffer.alloc(Math.min(length, HASH_CHUNK_BYTES));
         let offset = 0;
-        while (offset < from) {
-            const { bytesRead } = await handle.read(chunk, 0, Math.min(chunk.length, from - offset), offset);
+        while (offset < length) {
+            const { bytesRead } = await handle.read(chunk, 0, Math.min(chunk.length, length - offset), offset);
             if (bytesRead === 0) {
                 break;
             }
             hash.update(chunk.subarray(0, bytesRead));
             offset += bytesRead;
         }
-        const { size } = await handle.stat();
-        const bytes = Buffer.alloc(Math.max(0, size - from));
-        let filled = 0;
-        while (filled < bytes.length) {
-            const { bytesRead } = await handle.read(bytes, filled, bytes.length - filled, from + filled);
-            if (bytesRead === 0) {
-                break;
-            }
-            filled += bytesRead;
-        }
-        return { bytes: bytes.subarray(0, filled), hash };
+        return hash;
     }
     finally {
         await handle.close();
     }
 }
+/*
+ * Hands every whole line of a byte stream to `onLine` and hashes it with its newline, holding no more
+ * than a chunk and the line it is in. Lines are split on the byte, which never occurs inside a UTF-8 sequence.
+ */
+export async function forEachLine(chunks, hash, onLine) {
+    let consumed = 0;
+    let pending = [];
+    for await (const piece of chunks) {
+        const chunk = Buffer.from(piece.buffer, piece.byteOffset, piece.byteLength);
+        let start = 0;
+        let newline = chunk.indexOf(NEWLINE, start);
+        while (newline !== -1) {
+            const end = newline + 1;
+            const line = pending.length === 0 ? chunk.subarray(start, end) : Buffer.concat([...pending, chunk.subarray(start, end)]);
+            pending = [];
+            hash.update(line);
+            consumed += line.length;
+            onLine(line.toString('utf8', 0, line.length - 1));
+            start = end;
+            newline = chunk.indexOf(NEWLINE, start);
+        }
+        if (start < chunk.length) {
+            // A copy: the stream may hand the same memory out again for its next chunk.
+            pending.push(Buffer.from(chunk.subarray(start)));
+        }
+    }
+    return { consumed, rest: Buffer.concat(pending).toString('utf8') };
+}
 /* Covers every committed byte, since a transcript can be rewritten after an unchanged session header. */
 function headOf(hash) {
     // Older indexes hashed only the first 4 KB; they cannot establish that the rest stayed unchanged.
@@ -79,54 +97,68 @@ async function listUsageFiles(dir, provider, out = []) {
     }
     return out;
 }
+/* The bytes of a file from `from` to its end, a chunk at a time. */
+async function* fileChunks(path, from) {
+    const handle = await open(path, 'r');
+    try {
+        let position = from;
+        for (;;) {
+            // A buffer per chunk: a decompressor may still hold the one before.
+            const chunk = Buffer.alloc(READ_CHUNK_BYTES);
+            const { bytesRead } = await handle.read(chunk, 0, chunk.length, position);
+            if (bytesRead === 0) {
+                return;
+            }
+            position += bytesRead;
+            yield chunk.subarray(0, bytesRead);
+        }
+    }
+    finally {
+        await handle.close();
+    }
+}
+/* The bytes of a file from `from` on, decompressed for a `.zst` one; a failure on either side ends the iteration with it. */
+function readBytes(path, from, compressed) {
+    if (!compressed) {
+        return fileChunks(path, from);
+    }
+    const source = Readable.from(fileChunks(path, from));
+    const decompressed = createZstdDecompress();
+    source.on('error', (error) => decompressed.destroy(error));
+    return source.pipe(decompressed);
+}
+/* The usage record of one transcript line, when it carries one. */
+function parseLine(raw, provider, codex) {
+    const line = raw.endsWith('\r') ? raw.slice(0, -1) : raw;
+    if (line === '') {
+        return null;
+    }
+    if (provider === 'claude') {
+        return claudeMightCarryUsage(line) ? parseClaudeLine(line) : null;
+    }
+    if (provider === 'codex') {
+        return codex !== null && codexMightCarryUsage(line) ? parseCodexLine(line, codex) : null;
+    }
+    // Claude Code and Codex write transcripts of their own, Grok a file read whole; every other provider is a log its host keeps.
+    return hostLogMightCarryUsage(line) ? parseHostUsageLine(line, provider) : null;
+}
 /*
  * Reads what a file added since the last scan. Only whole lines count towards the offset; the piece
  * after the last newline is a line still being written, so it is parsed for what it is worth and
  * read again next time. The Codex state is snapshotted before that tail for the same reason.
  */
-function parseChunk(text, provider, from, state) {
-    const end = text.lastIndexOf('\n');
-    const whole = end === -1 ? '' : text.slice(0, end);
-    const tail = text.slice(end + 1);
-    const read = (chunk, codex) => {
-        const records = [];
-        for (const raw of chunk.split('\n')) {
-            const line = raw.endsWith('\r') ? raw.slice(0, -1) : raw;
-            if (line === '') {
-                continue;
-            }
-            if (provider === 'claude') {
-                if (claudeMightCarryUsage(line)) {
-                    const record = parseClaudeLine(line);
-                    if (record !== null) {
-                        records.push(record);
-                    }
-                }
-                continue;
-            }
-            if (provider === 'codex') {
-                if (codex !== null && codexMightCarryUsage(line)) {
-                    const record = parseCodexLine(line, codex);
-                    if (record !== null) {
-                        records.push(record);
-                    }
-                }
-                continue;
-            }
-            // Claude Code and Codex write transcripts of their own, Grok a file read whole; every other provider is a log its host keeps.
-            if (hostLogMightCarryUsage(line)) {
-                const record = parseHostUsageLine(line, provider);
-                if (record !== null) {
-                    records.push(record);
-                }
-            }
-        }
-        return records;
-    };
+async function parseLines(chunks, hash, provider, from, state) {
     const codex = provider === 'codex' ? (state ?? createCodexState()) : null;
-    const counted = read(whole, codex);
+    const records = [];
+    const read = await forEachLine(chunks, hash, (line) => {
+        const record = parseLine(line, provider, codex);
+        if (record !== null) {
+            records.push(record);
+        }
+    });
     const committed = codex === null ? null : cloneCodexState(codex);
-    return { records: counted, tail: read(tail, codex), offset: from + (end === -1 ? 0 : Buffer.byteLength(whole, 'utf8') + 1), codex: committed };
+    const tail = parseLine(read.rest, provider, codex);
+    return { records, tail: tail === null ? [] : [tail], offset: from + read.consumed, codex: committed };
 }
 /*
  * The account a record of a root belongs to, as a record keeps it (absent for the default account):
@@ -275,18 +307,13 @@ export class UsageScanner {
             known.provider === provider &&
             info.size > known.size &&
             known.head?.startsWith('sha256:') === true;
-        let read = compressed
-            ? { bytes: zstdDecompressSync(await readFile(path)), hash: createHash('sha256') }
-            : await readHashed(path, appended ? known.offset : 0);
         // A file only counts as grown while it starts the way it did; one rewritten larger is read again from the start.
-        const grown = appended && headOf(read.hash) === known.head;
-        if (appended && !grown) {
-            read = await readHashed(path, 0);
-        }
-        const from = grown ? known.offset : 0;
-        const parsed = parseChunk(read.bytes.toString('utf8'), provider, from, grown ? known.codex : null);
-        read.hash.update(read.bytes.subarray(0, parsed.offset - from));
-        const before = grown ? known.records : [];
+        const prefix = appended ? await hashPrefix(path, known.offset, createHash('sha256')) : null;
+        const grown = prefix !== null && known !== undefined && headOf(prefix) === known.head ? known : null;
+        const hash = grown === null || prefix === null ? createHash('sha256') : prefix;
+        const from = grown?.offset ?? 0;
+        const parsed = await parseLines(readBytes(path, from, compressed), hash, provider, from, grown?.codex ?? null);
+        const before = grown?.records ?? [];
         const entry = {
             provider,
             size: info.size,
@@ -296,7 +323,7 @@ export class UsageScanner {
             records: foldByKey([...before, ...withAccount(parsed.records, accountOf)]),
             tail: withAccount(parsed.tail, accountOf),
             codex: parsed.codex,
-            head: headOf(read.hash),
+            head: headOf(hash),
             ...(provider === 'codex' ? { parserVersion: CODEX_PARSER_VERSION, compressed } : {})
         };
         this.index.set(key, entry);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/agents",
-  "version": "0.31.8",
+  "version": "0.31.10",
   "description": "Node-compatible agent chat hosts, providers, accounts, usage and durable task coordination.",
   "type": "module",
   "exports": {
@@ -81,8 +81,8 @@
     "test": "bun --conditions=source test"
   },
   "dependencies": {
-    "@adecore/agent-contracts": "0.31.8",
-    "@adecore/intelligent-ui": "0.31.8",
+    "@adecore/agent-contracts": "0.31.10",
+    "@adecore/intelligent-ui": "0.31.10",
     "zod": "^4.6.5"
   },
   "devDependencies": {

package/src/chat/acp-backend.ts

@@ -63,6 +63,9 @@ export interface AcpAgentSpec {
     onContextReport?(): void;
     // The slash commands a session offers (without the slash), each time the agent lists them.
     onCommands?(commands: string[]): void;
+    // True takes the session titles the agent sends (`session_info_update`) as the chat's suggested title. Absent leaves
+    // naming the chat to the host, since an agent may rename the session after every turn.
+    adoptTitles?: boolean;
     // A permission request the host answers itself, in any runtime mode: true allows it once without asking the
     // person, for a call the host already guards. A throw counts as false.
     autoAllow?(request: AcpPermissionRequest): boolean;
@@ -121,7 +124,7 @@ export class AcpBackend implements ChatBackend {
         this.host = host;
         this.spec = spec;
         this.client = spec.client ?? DEFAULT_ACP_CLIENT;
-        this.protocol = new AcpProtocol(launch.generation, spec.modes ?? {}, acpStopWords(spec.name));
+        this.protocol = new AcpProtocol(launch.generation, spec.modes ?? {}, acpStopWords(spec.name), spec.adoptTitles === true);
     }
 
     get running(): boolean {
@@ -420,7 +423,7 @@ export class AcpBackend implements ChatBackend {
                 if (this.transport === transport && this.prompt === turn) {
                     this.prompt = null;
                     this.report(result);
-                    this.emitAll(this.protocol.finish(turn.cancelled ? { stopReason: 'cancelled' } : result, turn.promptId));
+                    this.emitAll(this.protocol.finish(result, turn.promptId, turn.cancelled));
                 }
             })
             .catch((error: unknown) => {
@@ -469,7 +472,11 @@ export class AcpBackend implements ChatBackend {
         if (!answer) {
             return false;
         }
-        return this.respond(requestId, answer.rpcId, answer.result);
+        if (!this.respond(requestId, answer.rpcId, answer.result)) {
+            return false;
+        }
+        this.emitAll(answer.events);
+        return true;
     }
 
     /* ACP asks no questions of its own; an agent asks in its message and the next prompt answers. */

package/src/chat/acp-protocol.ts

@@ -133,6 +133,15 @@ function contextWindowOf(meta: unknown): number | null {
     return typeof tokens === 'number' && Number.isSafeInteger(tokens) && tokens > 0 ? tokens : null;
 }
 
+/*
+ * The context tokens an agent counts outside the protocol, in `_meta.totalTokens`: Grok CLI 1.0.62 sends no `usage_update`
+ * and puts the session's count there, on every `session/update` notification and on the `session/prompt` response.
+ */
+function vendorContextTokens(meta: unknown): number | null {
+    const tokens = isRecord(meta) ? meta.totalTokens : undefined;
+    return typeof tokens === 'number' && Number.isSafeInteger(tokens) && tokens > 0 ? tokens : null;
+}
+
 const AuthMethodSchema = z.looseObject({ id: z.string(), name: z.string() });
 
 const InitializeResponseSchema = z.looseObject({
@@ -296,6 +305,9 @@ function sessionState(options: ConfigOption[], modes: unknown, models: unknown):
     const thought = thoughtOption(options);
     const modeState = ModeStateSchema.safeParse(modes);
     const modelState = ModelStateSchema.safeParse(models);
+    const entries = modelState.success ? validItems(ModelEntrySchema, modelState.data.availableModels) : [];
+    // Grok CLI 1.0.62 offers its models as a config option too, but names their windows only in the older field.
+    const windows = new Map(entries.map((model) => [model.modelId, contextWindowOf(model._meta)]));
     return {
         models: modelOption
             ? {
@@ -304,14 +316,14 @@ function sessionState(options: ConfigOption[], modes: unknown, models: unknown):
                       id: value.value,
                       name: value.name,
                       description: null,
-                      contextWindow: contextWindowOf(value._meta)
+                      contextWindow: contextWindowOf(value._meta) ?? windows.get(value.value) ?? null
                   })),
                   configId: modelOption.id
               }
             : modelState.success
               ? {
                     current: modelState.data.currentModelId,
-                    models: validItems(ModelEntrySchema, modelState.data.availableModels).map((model) => ({
+                    models: entries.map((model) => ({
                         id: model.modelId,
                         name: model.name,
                         description: model.description ?? null,
@@ -452,6 +464,8 @@ interface ToolState {
     // What the thread last heard, so an update that changes nothing about the row sends nothing.
     shown: string | null;
     settled: boolean;
+    // A person turned the call down, so whatever diff it carries was never written.
+    refused: boolean;
 }
 
 // `Edit` would have the thread draw a diff of nothing until the agent sends one.
@@ -467,6 +481,9 @@ const KIND_NAMES: Record<string, string> = {
 // A session's title comes from its opening prompts; later ones are not kept.
 const KEPT_PROMPTS = 3;
 
+// What Copilot CLI 1.0.101 writes as a message of its own after a call a person turned down; the thread shows the refusal already.
+const REFUSAL_LINE = 'Info: Operation cancelled by user';
+
 function foldSpace(text: string): string {
     return text.replace(/\s+/g, ' ').trim();
 }
@@ -551,7 +568,7 @@ function toolOutput(tool: ToolState): string | null {
         return tool.rawOutput;
     }
     if (isRecord(tool.rawOutput)) {
-        const text = rawField(tool.rawOutput, 'output', 'stdout', 'content', 'result', 'error');
+        const text = rawField(tool.rawOutput, 'output', 'stdout', 'content', 'result', 'error', 'message');
         return text ?? JSON.stringify(tool.rawOutput);
     }
     return null;
@@ -601,18 +618,28 @@ export class AcpProtocol {
     private readonly modes: AcpModeMap;
     private readonly words: AcpStopWords;
     private readonly tools = new Map<string, ToolState>();
-    private readonly permissions = new Map<string, { rpcId: number | string; options: Array<z.infer<typeof PermissionOptionSchema>> }>();
-    private text: { ref: string; messageId: string | null; text: string } | null = null;
+    private readonly permissions = new Map<string, { rpcId: number | string; toolCallId: string; options: Array<z.infer<typeof PermissionOptionSchema>> }>();
+    // `held` while the message may still be the refusal line, whose chunks the thread has not heard yet.
+    private text: { ref: string; messageId: string | null; text: string; held: boolean } | null = null;
+    // Set by a refusal until the next message shows whether it is the refusal line.
+    private refusalLine = false;
     private thought: { ref: string; text: string } | null = null;
     private counter = 0;
     private costUsd = 0;
+    // Set by the first `usage_update`; from then on a count outside the protocol is never read.
+    private standardUsage = false;
+    private vendorTokens: number | null = null;
     // The opening prompts of the process, whitespace folded, which an agent may hand back as the session's title.
     private readonly prompts: string[] = [];
 
-    constructor(generation: number, modes: AcpModeMap, words: AcpStopWords) {
+    private readonly titles: boolean;
+
+    // `titles` takes the session titles the agent sends as the chat's suggested title.
+    constructor(generation: number, modes: AcpModeMap, words: AcpStopWords, titles = false) {
         this.generation = generation;
         this.modes = modes;
         this.words = words;
+        this.titles = titles;
     }
 
     /* One `session/update` notification; empty for another session, an unknown update or one that does not parse. */
@@ -621,7 +648,10 @@ export class AcpProtocol {
         if (!notification.success || notification.data.sessionId !== sessionId) {
             return [];
         }
-        const update = notification.data.update;
+        return [...this.mapUpdate(notification.data.update), ...this.vendorUsage(notification.data._meta)];
+    }
+
+    private mapUpdate(update: z.infer<typeof SessionNotificationSchema>['update']): BackendEvent[] {
         switch (update.sessionUpdate) {
             case 'agent_message_chunk':
                 return this.messageChunk(update);
@@ -651,6 +681,7 @@ export class AcpProtocol {
                 if (!usage.success) {
                     return [];
                 }
+                this.standardUsage = true;
                 const cost = usage.data.cost?.currency === 'USD' ? usage.data.cost.amount : undefined;
                 if (cost !== undefined) {
                     this.costUsd = cost;
@@ -658,6 +689,9 @@ export class AcpProtocol {
                 return [{ type: 'usage', contextTokens: usage.data.used, contextWindow: usage.data.size, ...(cost === undefined ? {} : { costUsd: cost }) }];
             }
             case 'session_info_update': {
+                if (!this.titles) {
+                    return [];
+                }
                 const title = cleanTitle(update.title);
                 return title === null || this.restatesPrompt(title) ? [] : [{ type: 'title', title }];
             }
@@ -666,6 +700,16 @@ export class AcpProtocol {
         }
     }
 
+    /* The fallback for an agent that sends no `usage_update`: its own count of the context, once each time it changes. */
+    private vendorUsage(meta: unknown): BackendEvent[] {
+        const tokens = this.standardUsage ? null : vendorContextTokens(meta);
+        if (tokens === null || tokens === this.vendorTokens) {
+            return [];
+        }
+        this.vendorTokens = tokens;
+        return [{ type: 'usage', contextTokens: tokens }];
+    }
+
     /* Notes a prompt sent to the agent, so a title that only repeats its start is not taken for a name. */
     prompted(text: string): void {
         if (this.prompts.length < KEPT_PROMPTS) {
@@ -698,7 +742,7 @@ export class AcpProtocol {
         const tool = this.tools.get(request.data.toolCall.toolCallId)!;
         const row = toolRow(tool);
         const options = request.data.options;
-        this.permissions.set(requestId, { rpcId, options });
+        this.permissions.set(requestId, { rpcId, toolCallId: request.data.toolCall.toolCallId, options });
         events.push({
             type: 'approval.requested',
             requestId,
@@ -716,9 +760,9 @@ export class AcpProtocol {
     /*
      * The answer to a permission request: allow once, reject, or allow always only when the agent offered it.
      * A decision the agent offered no option for falls to the narrower one, and a refusal with no reject option
-     * at all is a cancelled outcome.
+     * at all is a cancelled outcome. A refusal draws the call's row again without its diff.
      */
-    answer(requestId: string, decision: ApprovalDecision): { rpcId: number | string; result: unknown } | null {
+    answer(requestId: string, decision: ApprovalDecision): { rpcId: number | string; result: unknown; events: BackendEvent[] } | null {
         const pending = this.permissions.get(requestId);
         if (!pending) {
             return null;
@@ -739,7 +783,14 @@ export class AcpProtocol {
                 : decision === 'allow'
                   ? byKind('allow_once', 'allow_always')
                   : byKind('reject_once', 'reject_always');
-        return { rpcId: pending.rpcId, result: { outcome: optionId === null ? { outcome: 'cancelled' } : { outcome: 'selected', optionId } } };
+        const result = { outcome: optionId === null ? { outcome: 'cancelled' } : { outcome: 'selected', optionId } };
+        const tool = this.tools.get(pending.toolCallId);
+        if (decision !== 'deny' || tool === undefined) {
+            return { rpcId: pending.rpcId, result, events: [] };
+        }
+        tool.refused = true;
+        this.refusalLine = true;
+        return { rpcId: pending.rpcId, result, events: this.toolCall({ toolCallId: pending.toolCallId }, false) };
     }
 
     /* Every permission request still open, answered as cancelled, which the protocol asks of a client that cancels a turn. */
@@ -757,11 +808,17 @@ export class AcpProtocol {
         return this.permissions.has(requestId);
     }
 
-    /* The end of a turn, from the `stopReason` of its `session/prompt` response. */
-    finish(result: unknown, promptId: string | undefined): BackendEvent[] {
+    /*
+     * The end of a turn, from the `stopReason` of its `session/prompt` response. Only a turn the client cancelled
+     * (`cancelled`) ends aborted: Grok 1.0.62 answers `cancelled` by itself when a person turns a call down, and
+     * that ends its turn the way any answer does.
+     */
+    finish(result: unknown, promptId: string | undefined, cancelled = false): BackendEvent[] {
         const parsed = PromptResponseSchema.safeParse(result);
-        const reason = parsed.success ? parsed.data.stopReason : 'end_turn';
-        const events = [...this.closeText(), ...this.closeThought()];
+        const stopReason = parsed.success ? parsed.data.stopReason : 'end_turn';
+        const reason = cancelled ? 'cancelled' : stopReason === 'cancelled' ? 'end_turn' : stopReason;
+        this.refusalLine = false;
+        const events = [...this.closeText(), ...this.closeThought(), ...this.vendorUsage(isRecord(result) ? result._meta : undefined)];
         const base = { ...(promptId === undefined ? {} : { promptId }), costUsd: this.costUsd };
         switch (reason) {
             case 'cancelled':
@@ -784,6 +841,7 @@ export class AcpProtocol {
 
     /* A turn that ended without a `stopReason`: the request failed, or was cancelled before the agent said so. */
     abort(promptId: string | undefined, error: string | null): BackendEvent[] {
+        this.refusalLine = false;
         const base = { ...(promptId === undefined ? {} : { promptId }), costUsd: this.costUsd };
         return [
             ...this.closeText(),
@@ -803,10 +861,17 @@ export class AcpProtocol {
             events.push(...this.closeText());
         }
         if (this.text === null) {
-            this.text = { ref: messageId === null ? `message-${++this.counter}` : `message-${messageId}`, messageId, text: '' };
+            this.text = { ref: messageId === null ? `message-${++this.counter}` : `message-${messageId}`, messageId, text: '', held: this.refusalLine };
+            this.refusalLine = false;
+        }
+        const text = this.text;
+        text.text += chunk.data.content.text;
+        if (text.held && !REFUSAL_LINE.startsWith(text.text)) {
+            text.held = false;
+            events.push({ type: 'text.delta', ref: text.ref, text: text.text });
+        } else if (!text.held) {
+            events.push({ type: 'text.delta', ref: text.ref, text: chunk.data.content.text });
         }
-        this.text.text += chunk.data.content.text;
-        events.push({ type: 'text.delta', ref: this.text.ref, text: chunk.data.content.text });
         return events;
     }
 
@@ -827,7 +892,10 @@ export class AcpProtocol {
     private closeText(): BackendEvent[] {
         const text = this.text;
         this.text = null;
-        return text === null ? [] : [{ type: 'text.done', ref: text.ref, text: text.text }];
+        if (text === null || (text.held && text.text === REFUSAL_LINE)) {
+            return [];
+        }
+        return [{ type: 'text.done', ref: text.ref, text: text.text }];
     }
 
     private closeThought(): BackendEvent[] {
@@ -850,7 +918,8 @@ export class AcpProtocol {
             diffs: [],
             text: [],
             shown: null,
-            settled: false
+            settled: false,
+            refused: false
         };
         tool.title = call.title ?? tool.title;
         tool.name = call.name ?? tool.name;
@@ -869,7 +938,7 @@ export class AcpProtocol {
         }
         this.tools.set(call.toolCallId, tool);
         const events: BackendEvent[] = [];
-        const row = toolRow(tool);
+        const row = toolRow(tool.refused ? { ...tool, diffs: [] } : tool);
         const shown = JSON.stringify(row);
         if (shown !== tool.shown) {
             tool.shown = shown;

package/src/chat/chat-session.ts

@@ -1963,6 +1963,17 @@ export class ChatSession {
             this.refuseStop(event.taskId, event.message);
             return;
         }
+        /*
+         * A CLI that counts its tokens but names no window, in a chat that has none yet: the catalog may have learned the
+         * model's window since the chat began, as an ACP agent's catalog does from the first session that reports its models.
+         */
+        if (event.type === 'usage' && event.contextWindow === undefined && event.contextTokens !== undefined && this.thread.info.usage.contextWindow === null) {
+            const contextWindow = this.options.provider.catalog.contextWindowFor(this.launchedSelection ?? this.thread.info.selection);
+            if (contextWindow !== null) {
+                this.emit(this.projector.project(generation, { ...event, contextWindow }));
+                return;
+            }
+        }
         /*
          * A CLI reports the window it was started on. A pick made since waits for the restart the next
          * send does, so its report may not put the old size back under a meter that already reads the new one.