@adecore/agents 0.31.8 → 0.31.10

package/dist/chat/acp-backend.d.ts

@@ -19,6 +19,7 @@ export interface AcpAgentSpec {
     onUsage?(usage: AcpUsageReport): void;
     onContextReport?(): void;
     onCommands?(commands: string[]): void;
+    adoptTitles?: boolean;
     autoAllow?(request: AcpPermissionRequest): boolean;
 }
 export interface AcpUsageReport extends AcpTurnUsage {

package/dist/chat/acp-backend.js

@@ -49,7 +49,7 @@ export class AcpBackend {
         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() {
         return this.transport !== null;
@@ -340,7 +340,7 @@ export class AcpBackend {
             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) => {
@@ -387,7 +387,11 @@ export class AcpBackend {
         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. */
     respondQuestion() {

package/dist/chat/acp-protocol.d.ts

@@ -99,6 +99,7 @@ interface ToolState {
     text: string[];
     shown: string | null;
     settled: boolean;
+    refused: boolean;
 }
 export declare function toolRow(tool: Pick<ToolState, 'title' | 'name' | 'kind' | 'rawInput' | 'locations' | 'diffs'>): {
     name: string;
@@ -130,12 +131,18 @@ export declare class AcpProtocol {
     private readonly tools;
     private readonly permissions;
     private text;
+    private refusalLine;
     private thought;
     private counter;
     private costUsd;
+    private standardUsage;
+    private vendorTokens;
     private readonly prompts;
-    constructor(generation: number, modes: AcpModeMap, words: AcpStopWords);
+    private readonly titles;
+    constructor(generation: number, modes: AcpModeMap, words: AcpStopWords, titles?: boolean);
     update(sessionId: string, params: unknown): BackendEvent[];
+    private mapUpdate;
+    private vendorUsage;
     prompted(text: string): void;
     private restatesPrompt;
     modeEvent(modeId: string): BackendEvent;
@@ -143,6 +150,7 @@ export declare class AcpProtocol {
     answer(requestId: string, decision: ApprovalDecision): {
         rpcId: number | string;
         result: unknown;
+        events: BackendEvent[];
     } | null;
     cancelPermissions(): Array<{
         requestId: string;
@@ -150,7 +158,7 @@ export declare class AcpProtocol {
         result: unknown;
     }>;
     hasPermission(requestId: string): boolean;
-    finish(result: unknown, promptId: string | undefined): BackendEvent[];
+    finish(result: unknown, promptId: string | undefined, cancelled?: boolean): BackendEvent[];
     abort(promptId: string | undefined, error: string | null): BackendEvent[];
     private messageChunk;
     private thoughtChunk;

package/dist/chat/acp-protocol.js

@@ -96,6 +96,14 @@ function contextWindowOf(meta) {
     const tokens = isRecord(meta) ? meta.totalContextTokens : undefined;
     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) {
+    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({
     protocolVersion: z.number(),
@@ -174,6 +182,9 @@ function sessionState(options, modes, models) {
     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
             ? {
@@ -182,14 +193,14 @@ function sessionState(options, modes, models) {
                     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,
@@ -312,6 +323,8 @@ const KIND_NAMES = {
 };
 // 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) {
     return text.replace(/\s+/g, ' ').trim();
 }
@@ -388,7 +401,7 @@ function toolOutput(tool) {
         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;
@@ -411,16 +424,25 @@ export class AcpProtocol {
     words;
     tools = new Map();
     permissions = new Map();
+    // `held` while the message may still be the refusal line, whose chunks the thread has not heard yet.
     text = null;
+    // Set by a refusal until the next message shows whether it is the refusal line.
+    refusalLine = false;
     thought = null;
     counter = 0;
     costUsd = 0;
+    // Set by the first `usage_update`; from then on a count outside the protocol is never read.
+    standardUsage = false;
+    vendorTokens = null;
     // The opening prompts of the process, whitespace folded, which an agent may hand back as the session's title.
     prompts = [];
-    constructor(generation, modes, words) {
+    titles;
+    // `titles` takes the session titles the agent sends as the chat's suggested title.
+    constructor(generation, modes, words, 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. */
     update(sessionId, params) {
@@ -428,7 +450,9 @@ 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)];
+    }
+    mapUpdate(update) {
         switch (update.sessionUpdate) {
             case 'agent_message_chunk':
                 return this.messageChunk(update);
@@ -458,6 +482,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;
@@ -465,6 +490,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 }];
             }
@@ -472,6 +500,15 @@ export class AcpProtocol {
                 return [];
         }
     }
+    /* The fallback for an agent that sends no `usage_update`: its own count of the context, once each time it changes. */
+    vendorUsage(meta) {
+        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) {
         if (this.prompts.length < KEPT_PROMPTS) {
@@ -501,7 +538,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,
@@ -518,7 +555,7 @@ 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, decision) {
         const pending = this.permissions.get(requestId);
@@ -540,7 +577,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. */
     cancelPermissions() {
@@ -555,11 +599,17 @@ export class AcpProtocol {
     hasPermission(requestId) {
         return this.permissions.has(requestId);
     }
-    /* The end of a turn, from the `stopReason` of its `session/prompt` response. */
-    finish(result, promptId) {
+    /*
+     * 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, promptId, cancelled = false) {
         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':
@@ -581,6 +631,7 @@ export class AcpProtocol {
     }
     /* A turn that ended without a `stopReason`: the request failed, or was cancelled before the agent said so. */
     abort(promptId, error) {
+        this.refusalLine = false;
         const base = { ...(promptId === undefined ? {} : { promptId }), costUsd: this.costUsd };
         return [
             ...this.closeText(),
@@ -599,10 +650,18 @@ 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;
     }
     thoughtChunk(update) {
@@ -621,7 +680,10 @@ export class AcpProtocol {
     closeText() {
         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 }];
     }
     closeThought() {
         const thought = this.thought;
@@ -642,7 +704,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;
@@ -659,7 +722,7 @@ export class AcpProtocol {
         }
         this.tools.set(call.toolCallId, tool);
         const events = [];
-        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/dist/chat/chat-session.js

@@ -1708,6 +1708,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.