@adecore/agents 0.36.0 → 0.37.1

package/dist/chat/codex-backend.js

@@ -473,8 +473,11 @@ export class CodexBackend {
         }
         const turnId = this.protocol.turnId;
         if (!turnId) {
-            // Codex refuses a steer without the turn it is meant for, and there is none left to join.
-            return false;
+            // An optional question can outlive its turn; its answer resumes the same chat as plain text.
+            this.turnUnnamed = true;
+            this.promptId = null;
+            this.request('turn/start', this.turnStartParams(textInput(answer.text)));
+            return true;
         }
         this.request('turn/steer', { threadId: this.threadId, expectedTurnId: turnId, input: textInput(answer.text) });
         return true;
@@ -484,6 +487,9 @@ export class CodexBackend {
         return answer?.kind === 'respond' ? this.respond(requestId, answer.rpcId, answer.result) : this.protocol.dismissQuestion(requestId);
     }
     declineRequest(requestId, _message) {
+        if (this.protocol.dismissQuestion(requestId)) {
+            return true;
+        }
         const answer = this.protocol.declineRequest(requestId);
         if (!this.transport || !answer) {
             return false;

package/dist/chat/codex-protocol.js

@@ -237,7 +237,7 @@ export class CodexProtocol {
         const threadId = frame.method === 'thread/started' ? (isRecord(params.thread) ? str(params.thread.id) : null) : str(params.threadId);
         if (threadId !== null && this.ownThreadId !== null && threadId !== this.ownThreadId) {
             if (frame.method === 'turn/completed') {
-                this.withdrawOwner(threadId, isRecord(params.turn) ? str(params.turn.id) : null, events);
+                this.withdrawOwner(threadId, isRecord(params.turn) ? str(params.turn.id) : null, events, isRecord(params.turn) && params.turn.status === 'completed');
             }
             else if (frame.method === 'thread/closed') {
                 this.withdrawOwner(threadId, null, events);
@@ -367,7 +367,7 @@ export class CodexProtocol {
         this.pending.delete(requestId);
         return { rpcId: pending.rpcId, result: { decision: codexDecision(decision, pending) } };
     }
-    /* What answers a question, the reply to a blocking one or the text that steers a running turn. */
+    /* An RPC reply, or plain text that continues the chat, for a question that still waits. */
     questionAnswer(requestId, answers) {
         const pending = this.pending.get(requestId);
         if (pending?.type !== 'question') {
@@ -437,10 +437,10 @@ export class CodexProtocol {
             this.toolInputs.delete(this.toolInputs.keys().next().value);
         }
     }
-    withdrawOwner(threadId, turnId, events) {
+    withdrawOwner(threadId, turnId, events, keepAsyncQuestions = false) {
         const belongs = (owner) => owner.threadId === threadId && (turnId === null || owner.turnId === null || owner.turnId === turnId);
         for (const [requestId, pending] of this.pending) {
-            if (belongs(pending)) {
+            if (belongs(pending) && !(keepAsyncQuestions && pending.type === 'question' && pending.async === true)) {
                 this.pending.delete(requestId);
                 events.push({ type: 'request.withdrawn', requestId });
             }
@@ -598,7 +598,13 @@ export class CodexProtocol {
                     if (!completed || this.pending.has(ref)) {
                         return;
                     }
-                    this.pending.set(ref, { ...this.owner(params), type: 'question', rpcId: null, questionIds: questions.map((question) => question.id) });
+                    this.pending.set(ref, {
+                        ...this.owner(params),
+                        type: 'question',
+                        rpcId: null,
+                        questionIds: questions.map((question) => question.id),
+                        async: true
+                    });
                     events.push({ type: 'question.requested', requestId: ref, questions, async: true });
                     return;
                 }
@@ -713,7 +719,7 @@ export class CodexProtocol {
         const limit = status === 'failed' && isRecord(turn.error) ? this.limitOf(turn.error.codexErrorInfo) : null;
         const turnId = str(turn.id) ?? this.codexTurnId;
         this.codexTurnId = null;
-        this.withdrawOwner(str(params.threadId) ?? this.ownThreadId, turnId, events);
+        this.withdrawOwner(str(params.threadId) ?? this.ownThreadId, turnId, events, status === 'completed');
         // A terminal session still open as the turn ends is one Codex left running; it only completes once its process does.
         for (const [ref, processId] of this.openTerminals) {
             this.backgroundTerminals.set(ref, processId);
@@ -790,7 +796,7 @@ export class CodexProtocol {
                 continue;
             }
             row.settled = true;
-            this.withdrawOwner(threadId, null, events);
+            this.withdrawOwner(threadId, null, events, status === 'completed');
             settled = true;
             events.push({ type: 'task.done', ref: row.ref, summary: collabAgentOutput({ [threadId]: state }), ok: status === 'completed' });
         }
@@ -834,7 +840,7 @@ export class CodexProtocol {
         }
         if ((kind === 'completed' || kind === 'interrupted') && row !== undefined && !row.settled) {
             row.settled = true;
-            this.withdrawOwner(threadId, null, events);
+            this.withdrawOwner(threadId, null, events, kind === 'completed');
             events.push({ type: 'task.done', ref: row.ref, summary: null, ok: kind === 'completed' });
         }
     }

package/dist/chat/thread.d.ts

@@ -5,6 +5,7 @@ export declare class ChatThread {
     private readonly order;
     private historyGeneration;
     private readonly indices;
+    private readonly requests;
     private readonly holds;
     constructor(info: ChatInfo, items?: ChatItem[]);
     get(id: string): ChatItem | undefined;
@@ -25,6 +26,7 @@ export declare class ChatThread {
     setStatus(status: AgentStatus): ChatEvent;
     statusFor(activeTurnId: string | null): AgentStatus;
     pending(): Array<ChatApprovalItem | ChatQuestionItem>;
+    private indexRequest;
     private syncRequests;
     history(limit?: number, cursor?: string): ChatHistoryResult;
     subagentsBefore(start: number): ChatSubagentItem[];

package/dist/chat/thread.js

@@ -13,6 +13,7 @@ export class ChatThread {
     order = [];
     historyGeneration = randomUUID();
     indices = new Map();
+    requests = new Map();
     // What the host asks a person beside the CLI's own requests, such as a card a verb waits on.
     holds = new Set();
     constructor(info, items = []) {
@@ -21,6 +22,7 @@ export class ChatThread {
             this.items.set(item.id, item);
             this.indices.set(item.id, this.order.length);
             this.order.push(item.id);
+            this.indexRequest(item);
         }
         this.syncRequests();
     }
@@ -45,7 +47,9 @@ export class ChatThread {
             this.order.push(item.id);
         }
         this.items.set(item.id, item);
-        if (item.kind === 'approval' || item.kind === 'question') {
+        const wasPending = this.requests.has(item.id);
+        this.indexRequest(item);
+        if (wasPending || item.kind === 'approval' || item.kind === 'question') {
             this.syncRequests();
         }
         return { type: 'item', item, historyIndex: this.indices.get(item.id) };
@@ -89,6 +93,7 @@ export class ChatThread {
     reset(patch) {
         this.items.clear();
         this.indices.clear();
+        this.requests.clear();
         this.historyGeneration = randomUUID();
         this.order.length = 0;
         this.info = { ...this.info, ...patch };
@@ -126,13 +131,21 @@ export class ChatThread {
     }
     /* A request can outlive the turn it came in, when work the CLI runs beside its turns asked it. */
     statusFor(activeTurnId) {
-        if (this.pending().length > 0 || this.holds.size > 0) {
+        if (this.requests.size > 0 || this.holds.size > 0) {
             return 'needs-you';
         }
         return activeTurnId === null ? 'idle' : 'running';
     }
     pending() {
-        return this.list().filter((item) => (item.kind === 'approval' && item.decision === 'pending') || (item.kind === 'question' && item.state === 'pending'));
+        return [...this.requests.values()].sort((left, right) => this.indices.get(left.id) - this.indices.get(right.id));
+    }
+    indexRequest(item) {
+        if ((item.kind === 'approval' && item.decision === 'pending') || (item.kind === 'question' && item.state === 'pending')) {
+            this.requests.set(item.id, item);
+        }
+        else {
+            this.requests.delete(item.id);
+        }
     }
     /*
      * `info.requests` follows the request items, so whatever event comes next carries what the chat waits on,

package/package.json

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

package/src/chat/codex-backend.ts

@@ -503,8 +503,11 @@ export class CodexBackend implements ChatBackend {
         }
         const turnId = this.protocol.turnId;
         if (!turnId) {
-            // Codex refuses a steer without the turn it is meant for, and there is none left to join.
-            return false;
+            // An optional question can outlive its turn; its answer resumes the same chat as plain text.
+            this.turnUnnamed = true;
+            this.promptId = null;
+            this.request('turn/start', this.turnStartParams(textInput(answer.text)));
+            return true;
         }
         this.request('turn/steer', { threadId: this.threadId, expectedTurnId: turnId, input: textInput(answer.text) });
         return true;
@@ -516,6 +519,9 @@ export class CodexBackend implements ChatBackend {
     }
 
     declineRequest(requestId: string, _message: string): boolean {
+        if (this.protocol.dismissQuestion(requestId)) {
+            return true;
+        }
         const answer = this.protocol.declineRequest(requestId);
         if (!this.transport || !answer) {
             return false;

package/src/chat/codex-protocol.ts

@@ -285,7 +285,12 @@ export class CodexProtocol {
         const threadId = frame.method === 'thread/started' ? (isRecord(params.thread) ? str(params.thread.id) : null) : str(params.threadId);
         if (threadId !== null && this.ownThreadId !== null && threadId !== this.ownThreadId) {
             if (frame.method === 'turn/completed') {
-                this.withdrawOwner(threadId, isRecord(params.turn) ? str(params.turn.id) : null, events);
+                this.withdrawOwner(
+                    threadId,
+                    isRecord(params.turn) ? str(params.turn.id) : null,
+                    events,
+                    isRecord(params.turn) && params.turn.status === 'completed'
+                );
             } else if (frame.method === 'thread/closed') {
                 this.withdrawOwner(threadId, null, events);
             }
@@ -416,7 +421,7 @@ export class CodexProtocol {
         return { rpcId: pending.rpcId, result: { decision: codexDecision(decision, pending) } };
     }
 
-    /* What answers a question, the reply to a blocking one or the text that steers a running turn. */
+    /* An RPC reply, or plain text that continues the chat, for a question that still waits. */
     questionAnswer(requestId: string, answers: Record<string, string>): CodexAnswer | null {
         const pending = this.pending.get(requestId);
         if (pending?.type !== 'question') {
@@ -494,10 +499,10 @@ export class CodexProtocol {
         }
     }
 
-    private withdrawOwner(threadId: string | null, turnId: string | null, events: BackendEvent[]): void {
+    private withdrawOwner(threadId: string | null, turnId: string | null, events: BackendEvent[], keepAsyncQuestions = false): void {
         const belongs = (owner: RequestOwner): boolean => owner.threadId === threadId && (turnId === null || owner.turnId === null || owner.turnId === turnId);
         for (const [requestId, pending] of this.pending) {
-            if (belongs(pending)) {
+            if (belongs(pending) && !(keepAsyncQuestions && pending.type === 'question' && pending.async === true)) {
                 this.pending.delete(requestId);
                 events.push({ type: 'request.withdrawn', requestId });
             }
@@ -664,7 +669,13 @@ export class CodexProtocol {
                     if (!completed || this.pending.has(ref)) {
                         return;
                     }
-                    this.pending.set(ref, { ...this.owner(params), type: 'question', rpcId: null, questionIds: questions.map((question) => question.id) });
+                    this.pending.set(ref, {
+                        ...this.owner(params),
+                        type: 'question',
+                        rpcId: null,
+                        questionIds: questions.map((question) => question.id),
+                        async: true
+                    });
                     events.push({ type: 'question.requested', requestId: ref, questions, async: true });
                     return;
                 }
@@ -805,7 +816,7 @@ export class CodexProtocol {
         const limit = status === 'failed' && isRecord(turn.error) ? this.limitOf(turn.error.codexErrorInfo) : null;
         const turnId = str(turn.id) ?? this.codexTurnId;
         this.codexTurnId = null;
-        this.withdrawOwner(str(params.threadId) ?? this.ownThreadId, turnId, events);
+        this.withdrawOwner(str(params.threadId) ?? this.ownThreadId, turnId, events, status === 'completed');
         // A terminal session still open as the turn ends is one Codex left running; it only completes once its process does.
         for (const [ref, processId] of this.openTerminals) {
             this.backgroundTerminals.set(ref, processId);
@@ -886,7 +897,7 @@ export class CodexProtocol {
                 continue;
             }
             row.settled = true;
-            this.withdrawOwner(threadId, null, events);
+            this.withdrawOwner(threadId, null, events, status === 'completed');
             settled = true;
             events.push({ type: 'task.done', ref: row.ref, summary: collabAgentOutput({ [threadId]: state }), ok: status === 'completed' });
         }
@@ -931,7 +942,7 @@ export class CodexProtocol {
         }
         if ((kind === 'completed' || kind === 'interrupted') && row !== undefined && !row.settled) {
             row.settled = true;
-            this.withdrawOwner(threadId, null, events);
+            this.withdrawOwner(threadId, null, events, kind === 'completed');
             events.push({ type: 'task.done', ref: row.ref, summary: null, ok: kind === 'completed' });
         }
     }

package/src/chat/thread.ts

@@ -24,6 +24,7 @@ export class ChatThread {
     private readonly order: string[] = [];
     private historyGeneration = randomUUID();
     private readonly indices = new Map<string, number>();
+    private readonly requests = new Map<string, ChatApprovalItem | ChatQuestionItem>();
     // What the host asks a person beside the CLI's own requests, such as a card a verb waits on.
     private readonly holds = new Set<string>();
 
@@ -33,6 +34,7 @@ export class ChatThread {
             this.items.set(item.id, item);
             this.indices.set(item.id, this.order.length);
             this.order.push(item.id);
+            this.indexRequest(item);
         }
         this.syncRequests();
     }
@@ -61,7 +63,9 @@ export class ChatThread {
             this.order.push(item.id);
         }
         this.items.set(item.id, item);
-        if (item.kind === 'approval' || item.kind === 'question') {
+        const wasPending = this.requests.has(item.id);
+        this.indexRequest(item);
+        if (wasPending || item.kind === 'approval' || item.kind === 'question') {
             this.syncRequests();
         }
         return { type: 'item', item, historyIndex: this.indices.get(item.id)! };
@@ -111,6 +115,7 @@ export class ChatThread {
     reset(patch: Partial<ChatInfo>): ChatEvent {
         this.items.clear();
         this.indices.clear();
+        this.requests.clear();
         this.historyGeneration = randomUUID();
         this.order.length = 0;
         this.info = { ...this.info, ...patch };
@@ -151,17 +156,22 @@ export class ChatThread {
 
     /* A request can outlive the turn it came in, when work the CLI runs beside its turns asked it. */
     statusFor(activeTurnId: string | null): AgentStatus {
-        if (this.pending().length > 0 || this.holds.size > 0) {
+        if (this.requests.size > 0 || this.holds.size > 0) {
             return 'needs-you';
         }
         return activeTurnId === null ? 'idle' : 'running';
     }
 
     pending(): Array<ChatApprovalItem | ChatQuestionItem> {
-        return this.list().filter(
-            (item): item is ChatApprovalItem | ChatQuestionItem =>
-                (item.kind === 'approval' && item.decision === 'pending') || (item.kind === 'question' && item.state === 'pending')
-        );
+        return [...this.requests.values()].sort((left, right) => this.indices.get(left.id)! - this.indices.get(right.id)!);
+    }
+
+    private indexRequest(item: ChatItem): void {
+        if ((item.kind === 'approval' && item.decision === 'pending') || (item.kind === 'question' && item.state === 'pending')) {
+            this.requests.set(item.id, item);
+        } else {
+            this.requests.delete(item.id);
+        }
     }
 
     /*