@adecore/agents 0.31.6 → 0.31.8

package/dist/testing/fake-acp-capture.d.ts

@@ -0,0 +1,11 @@
+import type { FakeCli } from './fake-cli.ts';
+export interface AcpCapture {
+    sessionId: string;
+    initialize: unknown;
+    sessionNew: unknown;
+    commands: unknown[];
+    setConfigOption: unknown;
+    promptUpdates: unknown[];
+    promptResponse: unknown;
+}
+export declare function fakeAcpCapture(capture: AcpCapture): FakeCli;

package/dist/testing/fake-acp-capture.js

@@ -0,0 +1,50 @@
+export function fakeAcpCapture(capture) {
+    return (io) => {
+        const send = (frame) => {
+            io.out({ jsonrpc: '2.0', ...frame });
+        };
+        const update = (fields) => {
+            send({ method: 'session/update', params: { sessionId: capture.sessionId, update: fields } });
+        };
+        return {
+            onLine: (line) => {
+                const frame = JSON.parse(line);
+                const id = frame.id;
+                switch (frame.method) {
+                    case undefined:
+                        return;
+                    case 'initialize':
+                        send({ id, result: capture.initialize });
+                        return;
+                    case 'session/new':
+                        update({ sessionUpdate: 'available_commands_update', availableCommands: capture.commands });
+                        send({ id, result: capture.sessionNew });
+                        return;
+                    case 'session/set_config_option':
+                        send({ id, result: capture.setConfigOption });
+                        return;
+                    case 'session/set_mode':
+                    case 'session/close':
+                        send({ id, result: {} });
+                        return;
+                    case 'session/prompt': {
+                        const blocks = Array.isArray(frame.params?.prompt) ? frame.params.prompt : [];
+                        const text = blocks.find((block) => block.type === 'text')?.text;
+                        for (const fields of capture.promptUpdates) {
+                            const named = fields.sessionUpdate === 'session_info_update';
+                            update(named ? { ...fields, title: text } : fields);
+                        }
+                        send({ id, result: capture.promptResponse });
+                        return;
+                    }
+                    case 'session/cancel':
+                        return;
+                    default:
+                        if (id !== undefined) {
+                            send({ id, error: { code: -32601, message: `Method not found: ${String(frame.method)}` } });
+                        }
+                }
+            }
+        };
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/agents",
-  "version": "0.31.6",
+  "version": "0.31.8",
   "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.6",
-    "@adecore/intelligent-ui": "0.31.6",
+    "@adecore/agent-contracts": "0.31.8",
+    "@adecore/intelligent-ui": "0.31.8",
     "zod": "^4.6.5"
   },
   "devDependencies": {

package/src/chat/acp-backend.ts

@@ -357,7 +357,9 @@ export class AcpBackend implements ChatBackend {
         const named: ChatAttachment[] = input.attachments.filter((attachment) => !images.includes(attachment));
         const parts = [this.contextPending, input.preamble, input.text, attachmentNote(named)].filter((part): part is string => part !== null && part !== '');
         this.contextPending = null;
-        return [{ type: 'text', text: parts.join('\n\n') }, ...blocks, ...this.mentionBlocks(input.mentions)];
+        const text = parts.join('\n\n');
+        this.protocol.prompted(text);
+        return [{ type: 'text', text }, ...blocks, ...this.mentionBlocks(input.mentions)];
     }
 
     /*
@@ -577,13 +579,17 @@ export class AcpBackend implements ChatBackend {
         this.emit({ type: 'exit', exitCode, ...(stderr === null ? {} : { stderr }) });
     }
 
-    /* A cancelled turn still spent what it reports. */
+    /* A cancelled turn still spent what it reports. A host that fails to keep it costs the record, never the end of the turn. */
     private report(result: unknown): void {
         const usage = this.spec.onUsage === undefined ? null : promptUsageOf(result);
         if (usage === null) {
             return;
         }
-        this.spec.onUsage?.({ ...usage, sessionId: this.sessionId, cwd: this.launch.cwd, model: this.model ?? this.launch.selection.model });
+        try {
+            this.spec.onUsage?.({ ...usage, sessionId: this.sessionId, cwd: this.launch.cwd, model: this.model ?? this.launch.selection.model });
+        } catch (error) {
+            console.warn(`Could not keep the usage of a ${this.spec.name} turn:`, errorText(error));
+        }
     }
 
     private emitAll(events: BackendEvent[]): void {

package/src/chat/acp-protocol.ts

@@ -1,6 +1,7 @@
 import { isRecord, type ChatFileChange, type RuntimeMode } from '@adecore/agent-contracts';
 import { z } from 'zod';
 import { MODE_ORDER } from '../modes.ts';
+import { cleanTitle } from '../title-file.ts';
 import type { ApprovalDecision, BackendEvent } from './backend.ts';
 
 /*
@@ -463,6 +464,13 @@ const KIND_NAMES: Record<string, string> = {
     other: 'Tool'
 };
 
+// A session's title comes from its opening prompts; later ones are not kept.
+const KEPT_PROMPTS = 3;
+
+function foldSpace(text: string): string {
+    return text.replace(/\s+/g, ' ').trim();
+}
+
 function str(value: unknown): string | null {
     return typeof value === 'string' && value !== '' ? value : null;
 }
@@ -598,6 +606,8 @@ export class AcpProtocol {
     private thought: { ref: string; text: string } | null = null;
     private counter = 0;
     private costUsd = 0;
+    // 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) {
         this.generation = generation;
@@ -647,13 +657,31 @@ export class AcpProtocol {
                 }
                 return [{ type: 'usage', contextTokens: usage.data.used, contextWindow: usage.data.size, ...(cost === undefined ? {} : { costUsd: cost }) }];
             }
-            case 'session_info_update':
-                return str(update.title) === null ? [] : [{ type: 'title', title: update.title as string }];
+            case 'session_info_update': {
+                const title = cleanTitle(update.title);
+                return title === null || this.restatesPrompt(title) ? [] : [{ type: 'title', title }];
+            }
             default:
                 return [];
         }
     }
 
+    /* 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) {
+            this.prompts.push(foldSpace(text));
+        }
+    }
+
+    /*
+     * Whether a title is only the start of a prompt, as Copilot CLI 1.0.101 names a session: with a host's instructions in
+     * front of the message that names every chat after them, and it keeps the host from naming the chat itself.
+     */
+    private restatesPrompt(title: string): boolean {
+        const start = foldSpace(title.endsWith('…') ? title.slice(0, -1) : title);
+        return start !== '' && this.prompts.some((prompt) => prompt.startsWith(start));
+    }
+
     modeEvent(modeId: string): BackendEvent {
         const runtimeMode = runtimeModeOf(modeId, this.modes);
         return { type: 'permissions', permissionMode: modeId, ...(runtimeMode === null ? {} : { effectiveRuntimeMode: runtimeMode }) };

package/src/chat/chat-session.ts

@@ -36,6 +36,7 @@ import { ChatThread } from './thread.ts';
 import { UiReplies, type UiReplyHost } from './ui-replies.ts';
 import { errorText } from '../error-text.ts';
 import { systemClock, type OutboxClock } from '../outbox/outbox-worker.ts';
+import { cleanTitle } from '../title-file.ts';
 
 /* What a host keeps of a chat's turns in git (or anything like it), so a turn can show what it changed. */
 export interface TurnCheckpoints {
@@ -2171,8 +2172,10 @@ export class ChatSession {
             .catch(() => undefined);
     }
 
-    private applyTitle(title: string): void {
-        if (title === this.thread.info.suggestedTitle) {
+    private applyTitle(raw: string): void {
+        // Every info a client reads carries the title, so one it would refuse would leave the chat stuck there.
+        const title = cleanTitle(raw);
+        if (title === null || title === this.thread.info.suggestedTitle) {
             return;
         }
         this.emit([this.thread.patchInfo({ suggestedTitle: title })]);