@adecore/agents 0.31.9 → 0.31.11

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.