@adecore/agents 0.20.0 → 0.21.0

package/src/chat/chat-session.ts

@@ -1,6 +1,7 @@
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import type {
     ChatAttachment,
+    ChatAssistantItem,
     ChatCheckpointDiff,
     ChatEvent,
     ChatInfo,
@@ -9,10 +10,17 @@ import type {
     ChatSkill,
     ChatSubagentItem,
     ChatTurnItem,
+    ChatUiAnswer,
+    ChatUiChoiceOrigin,
+    ChatUiChoicePayload,
+    ChatUiQueryState,
     ModelSelection,
     RuntimeMode
 } from '@adecore/agent-contracts';
-import { notResumedNote } from '@adecore/agent-contracts';
+import { GeneratedImageInputSchema, notResumedNote } from '@adecore/agent-contracts';
+import { resolveUiChoice, UiFailure } from '@adecore/intelligent-ui';
+import type { UiCompileOptions } from '@adecore/intelligent-ui/compiler';
+import { UiStream, type UiStreamPreview } from '@adecore/intelligent-ui/stream';
 import type { ChatProvider } from '../providers/provider.ts';
 import type { LimitsUpdate } from '../usage/limits/normalize.ts';
 import type { BackendEvent, BackendLaunch, ChatBackend, TurnInput } from './backend.ts';
@@ -58,6 +66,7 @@ export interface ChatSessionOptions {
     /* The environment of the CLI under the chat's account, asked at every start; throws for an account that cannot start. */
     env(account: string | undefined): Record<string, string>;
     spawn?: SpawnChatProcess;
+    saveGeneratedImage?: BackendLaunch['saveGeneratedImage'];
     // What the agent is told at the start of every process, and what of it a resumed thread hears again; see `BackendLaunch`.
     instructions?(): string | null;
     resumeNote?(): string | null;
@@ -67,6 +76,10 @@ export interface ChatSessionOptions {
     references?: ChatReferences;
     // Trees per turn, so a settled turn can show what the working tree holds against its start.
     checkpoints?: TurnCheckpoints;
+    ui?: {
+        schemas: UiCompileOptions['querySchemas'];
+        observe(item: ChatAssistantItem, final: boolean): void;
+    };
     emit(event: ChatEvent): void;
     /* What a turn said about the plan it runs on. It belongs to the machine, so it leaves the chat. */
     onLimits?(update: LimitsUpdate): void;
@@ -98,6 +111,8 @@ export interface LimitResumeHooks {
 const TITLE_RECHECK_MS = 10_000;
 
 export interface ChatSendExtras {
+    uiChoice?: ChatUiChoiceOrigin;
+    delivery?: 'steer' | 'queue';
     mentions?: string[];
     skills?: string[];
     chats?: string[];
@@ -175,6 +190,9 @@ export class ChatSession {
     private readonly orphans = new Set<string>();
     private pendingPreambles: readonly string[];
     private submission: { turnId: string; input: TurnInput } | null = null;
+    private readonly steering = new Set<string>();
+    private readonly uiStreams = new Map<string, UiStream>();
+    private readonly uiCompiled = new Map<string, UiStreamPreview>();
 
     constructor(options: ChatSessionOptions) {
         this.options = options;
@@ -183,6 +201,24 @@ export class ChatSession {
         this.projector = new ThreadProjector(this.thread, { providerName: options.provider.name });
     }
 
+    get uiPreviews(): ChatEvent[] {
+        const events: ChatEvent[] = [];
+        for (const [itemId, preview] of this.uiCompiled) {
+            const item = this.thread.get(itemId);
+            if (item?.kind === 'assistant' && item.streaming && item.text.length === preview.textLength) {
+                events.push({ type: 'delta', itemId, text: '', ui: preview.blocks, textLength: preview.textLength });
+            }
+        }
+        return events;
+    }
+
+    previewItems(items: ChatItem[]): ChatItem[] {
+        return items.map((item) => {
+            const preview = this.uiCompiled.get(item.id);
+            return item.kind === 'assistant' && preview?.textLength === item.text.length ? { ...item, ui: preview.blocks } : item;
+        });
+    }
+
     get id(): string {
         return this.thread.info.chatId;
     }
@@ -249,9 +285,7 @@ export class ChatSession {
     }
 
     /*
-     * A message while a turn runs joins the queue instead of being refused; the host sends it when
-     * that turn settles. One queue for both providers: Claude's steer and Codex's own queue have
-     * different semantics, and one rule is easier to reason about than a rule per CLI.
+     * Internal follow-ups wait for a new turn. User input goes through `sendInput`, which can steer native work.
      */
     send(text: string, extras: ChatSendExtras = {}): { queued: boolean; turnId: string } {
         const turnId = newId('turn');
@@ -265,6 +299,7 @@ export class ChatSession {
                 turnId,
                 text,
                 createdAt: Date.now(),
+                ...(extras.uiChoice ? { uiChoice: extras.uiChoice } : {}),
                 ...(extras.mentions?.length ? { mentions: extras.mentions } : {}),
                 ...(extras.skills?.length ? { skills: extras.skills } : {}),
                 ...(extras.chats?.length ? { chats: extras.chats } : {}),
@@ -279,11 +314,153 @@ export class ChatSession {
         return { queued: false, turnId };
     }
 
+    updateUiQueries(itemId: string, uiQueries: ChatUiQueryState): void {
+        const item = this.thread.get(itemId);
+        if (this.frozen || item?.kind !== 'assistant' || item.parentToolUseId) {
+            return;
+        }
+        this.thread.upsert({ ...item, uiQueries });
+        this.options.emit({ type: 'delta', itemId, text: '', uiQueries });
+        this.options.persistSoon();
+    }
+
+    choose(payload: ChatUiChoicePayload, queries: Readonly<Record<string, unknown>> = {}): { queued: boolean; turnId: string } {
+        const item = this.thread.get(payload.itemId);
+        const block =
+            item?.kind === 'assistant' && !item.streaming && !item.parentToolUseId ? item.ui?.find((block) => block.id === payload.blockId) : undefined;
+        if (item?.kind !== 'assistant' || !block?.revision || block.revision !== payload.revision) {
+            throw new ChatError('stale-ui-block', 'This completed UI block is no longer available at the requested revision');
+        }
+        const sameBlock = (origin: ChatUiChoiceOrigin | undefined) =>
+            origin?.itemId === item.id && origin.blockId === block.id && origin.revision === block.revision;
+        let previous = item.uiAnswers?.[block.id];
+        if (previous?.revision !== block.revision) {
+            previous = undefined;
+        }
+        // The message is logged first: a crash before its answer marker must not send it a second time.
+        if (!previous) {
+            const sent = this.thread.list().find((entry) => entry.kind === 'user' && sameBlock(entry.uiChoice));
+            const queued = this.queue.find((entry) => sameBlock(entry.uiChoice));
+            const origin = sent?.kind === 'user' ? sent.uiChoice : queued?.uiChoice;
+            const turnId = sent?.turnId ?? queued?.turnId;
+            if (origin && turnId) {
+                previous = { ...origin, turnId, queued: !sent };
+                this.recordUiAnswer(previous);
+            }
+        }
+        if (previous) {
+            if (previous.choiceId !== payload.choiceId) {
+                throw new ChatError('ui-already-answered', 'This UI block was already answered');
+            }
+            return { queued: previous.queued, turnId: previous.turnId };
+        }
+        let selected;
+        try {
+            selected = resolveUiChoice(block, payload.choiceId, payload.values, queries);
+        } catch (error) {
+            throw new ChatError(
+                error instanceof UiFailure ? error.code : 'refused-choice',
+                error instanceof Error ? error.message : 'This choice could not be read'
+            );
+        }
+        const origin: ChatUiChoiceOrigin = {
+            itemId: item.id,
+            blockId: block.id,
+            revision: block.revision,
+            choiceId: payload.choiceId,
+            label: selected.label,
+            sourceAt: item.createdAt,
+            older: this.thread.list().findLast((entry) => entry.kind === 'assistant' && !entry.parentToolUseId)?.id !== item.id,
+            values: selected.values,
+            at: Date.now()
+        };
+        const result = this.send(selected.context, { uiChoice: origin });
+        this.recordUiAnswer({ ...origin, ...result });
+        return result;
+    }
+
+    private recordUiAnswer(answer: ChatUiAnswer): void {
+        const item = this.thread.get(answer.itemId);
+        if (item?.kind !== 'assistant') {
+            return;
+        }
+        if (JSON.stringify(item.uiAnswers?.[answer.blockId]) === JSON.stringify(answer)) {
+            return;
+        }
+        this.options.emit(this.thread.upsert({ ...item, uiAnswers: { ...item.uiAnswers, [answer.blockId]: answer } }));
+        this.options.persist();
+    }
+
+    sendInput(text: string, extras: ChatSendExtras = {}): Promise<{ queued: boolean; turnId: string }> {
+        return this.submitInput(text, extras);
+    }
+
+    private async submitInput(text: string, extras: ChatSendExtras): Promise<{ queued: boolean; turnId: string }> {
+        const backend = this.backend;
+        const turnId = this.info.activeTurnId;
+        if (
+            extras.delivery !== 'steer' ||
+            this.info.queuePaused ||
+            text.startsWith('/') ||
+            !this.busy ||
+            !turnId ||
+            !backend?.steerTurn ||
+            this.pendingStart ||
+            this.replacementWaits()
+        ) {
+            return this.send(text, extras);
+        }
+        const queued = this.send(text, extras);
+        const message = this.queue.find((entry) => entry.turnId === queued.turnId);
+        if (!message) {
+            return queued;
+        }
+        this.steering.add(message.id);
+        try {
+            const references = this.options.references?.(extras.chats) ?? { ids: extras.chats ?? [], note: null };
+            const accepted = await backend.steerTurn({
+                promptId: message.id,
+                text,
+                preamble: references.note,
+                attachments: extras.attachments ?? [],
+                mentions: extras.mentions ?? [],
+                skills: extras.skills ?? []
+            });
+            if (!accepted) {
+                return queued;
+            }
+            this.emit([
+                this.thread.upsert({
+                    id: `user-${message.id}`,
+                    kind: 'user',
+                    createdAt: message.createdAt,
+                    turnId,
+                    text,
+                    mentions: extras.mentions,
+                    skills: extras.skills,
+                    chats: references.ids,
+                    attachments: extras.attachments
+                }),
+                this.thread.patchInfo({ queue: this.queue.filter((entry) => entry.id !== message.id) })
+            ]);
+            this.options.persist();
+            return { queued: false, turnId };
+        } catch (error) {
+            // A lost acknowledgement does not prove rejection. Keep the message for an explicit retry.
+            this.pauseQueue(true);
+            this.options.persist();
+            throw error;
+        } finally {
+            this.steering.delete(message.id);
+            this.drainQueue();
+        }
+    }
+
     /* Drops a queued message and hands it back; null when nothing waits under that id, as once it went out. */
     unqueue(messageId: string): ChatQueuedMessage | null {
         const queue = this.queue;
         const message = queue.find((entry) => entry.id === messageId);
-        if (!message) {
+        if (!message || this.steering.has(message.id)) {
             return null;
         }
         this.setQueue(queue.filter((entry) => entry.id !== messageId));
@@ -294,7 +471,7 @@ export class ChatSession {
     sendNow(messageId: string): boolean {
         const queue = this.queue;
         const message = queue.find((entry) => entry.id === messageId);
-        if (!message) {
+        if (!message || this.steering.has(message.id)) {
             return false;
         }
         this.setQueue([message, ...queue.filter((entry) => entry.id !== messageId)]);
@@ -323,6 +500,7 @@ export class ChatSession {
         const explicit = asked || this.sendAfterReplacement;
         if (
             !next ||
+            this.steering.size > 0 ||
             this.busy ||
             (!explicit && (this.info.queuePaused || (limited !== null && (limited.limit.kind === 'usage' || this.info.resumeAt !== undefined))))
         ) {
@@ -349,7 +527,11 @@ export class ChatSession {
         this.sendAfterReplacement = false;
         this.pauseQueue(false);
         this.setQueue(rest);
-        this.dispatch(next.text, { mentions: next.mentions, skills: next.skills, chats: next.chats, attachments: next.attachments }, next.turnId);
+        this.dispatch(
+            next.text,
+            { mentions: next.mentions, skills: next.skills, chats: next.chats, attachments: next.attachments, uiChoice: next.uiChoice },
+            next.turnId
+        );
     }
 
     private dispatch(text: string, extras: ChatSendExtras, requestedTurnId?: string): void {
@@ -359,7 +541,10 @@ export class ChatSession {
         // A slash command must stay the first thing the CLI reads, as `contextNote` keeps it.
         const references = text.startsWith('/') || !this.options.references ? { ids: [], note: null } : this.options.references(extras.chats);
         const turnId = this.openTurn(text, note, { ...extras, chats: references.ids }, requestedTurnId);
-        const said = [preamble, references.note].filter((part): part is string => part !== null);
+        const choiceNote = extras.uiChoice
+            ? `The person chose ${JSON.stringify(extras.uiChoice.label)} from your UI reply. Their message is the visible context of that choice.`
+            : null;
+        const said = [preamble, references.note, choiceNote].filter((part): part is string => part !== null);
         const input = {
             text,
             preamble: said.length === 0 ? null : said.join('\n\n'),
@@ -478,14 +663,14 @@ export class ChatSession {
 
     /*
      * Starts the chat over: the CLI goes, and the next send starts one without a session to resume.
-     * A turn in the way is refused unless forced, and a forced clear does not wait for it to end,
-     * since the turn disappears with the thread anyway. Writing the empty thread is the caller's.
+     * The thread resets at once; the returned promise lets the host wait for pending attachment
+     * writes before removing their files. Writing the empty thread is the caller's.
      */
-    clear(force: boolean): void {
+    clear(force: boolean): Promise<void> {
         if (this.busy && !force) {
             throw new ChatError('chat-busy', `Chat ${this.id} is still working on the previous message`);
         }
-        void this.dispose();
+        const ended = this.dispose();
         this.generation = nextGeneration();
         this.projector.reset();
         // The fresh CLI hears what the host tells it at launch, as it would on a first turn.
@@ -524,6 +709,7 @@ export class ChatSession {
                 }
             })
         ]);
+        return ended;
     }
 
     /*
@@ -928,6 +1114,7 @@ export class ChatSession {
 
     /* Ends the process and stops listening to it, as the host goes down; the thread stays as it is. */
     freeze(): void {
+        this.clearUi();
         this.clearStartWarning();
         this.clearWorkflowWarnings();
         this.frozen = true;
@@ -936,6 +1123,7 @@ export class ChatSession {
 
     /* Ends the CLI and everything it started; settles once it exited or was sent the SIGKILL. */
     dispose(): Promise<void> {
+        this.clearUi();
         this.clearStartWarning();
         this.clearWorkflowWarnings();
         if (this.titleTimer !== null) {
@@ -1093,10 +1281,26 @@ export class ChatSession {
             const skills = extras.skills?.length ? extras.skills : undefined;
             const chats = extras.chats?.length ? extras.chats : undefined;
             const attachments = extras.attachments?.length ? extras.attachments : undefined;
-            events.push(this.thread.upsert({ id: newId('user'), kind: 'user', createdAt: now, turnId, text, mentions, skills, chats, attachments }));
+            events.push(
+                this.thread.upsert({
+                    id: newId('user'),
+                    kind: 'user',
+                    createdAt: now,
+                    turnId,
+                    text,
+                    mentions,
+                    skills,
+                    chats,
+                    attachments,
+                    ...(extras.uiChoice ? { uiChoice: extras.uiChoice } : {})
+                })
+            );
         }
         events.push(this.thread.patchInfo({ status: this.thread.statusFor(turnId), activeTurnId: turnId }));
         this.emit(events);
+        if (extras.uiChoice) {
+            this.recordUiAnswer({ ...extras.uiChoice, turnId, queued: false });
+        }
         // On disk before the CLI answers, so a host that goes down mid-turn still shows the question.
         this.options.persist();
         return turnId;
@@ -1326,6 +1530,7 @@ export class ChatSession {
             runtimeMode: info.runtimeMode,
             resume: info.agentSessionId,
             generation,
+            saveGeneratedImage: this.options.saveGeneratedImage,
             instructions: this.options.instructions?.() ?? null,
             resumeNote: this.options.resumeNote?.() ?? null,
             ...(folders.length > 0 ? { folders } : {}),
@@ -1677,9 +1882,82 @@ export class ChatSession {
 
     private emit(events: ChatEvent[]): void {
         const delegating = this.delegatingChange(events);
-        for (const event of delegating === null ? events : [...events, delegating]) {
-            this.options.emit(event);
+        for (let event of delegating === null ? events : [...events, delegating]) {
+            if (event.type === 'reset') {
+                this.clearUi();
+            }
+            const item = event.type === 'item' ? event.item : event.type === 'delta' ? this.thread.get(event.itemId) : null;
+            if (item?.kind !== 'assistant' || item.parentToolUseId) {
+                this.options.emit(event);
+                continue;
+            }
+            let stream = this.uiStreams.get(item.id);
+            if (!stream && !item.text.includes('ruimte-ui')) {
+                this.options.emit(event);
+                continue;
+            }
+            if (!stream) {
+                stream = new UiStream({
+                    querySchemas: this.options.ui?.schemas,
+                    id: item.id,
+                    clock: this.options.clock ?? systemClock,
+                    emit: (preview) => {
+                        this.uiCompiled.set(item.id, preview);
+                        this.options.emit({ type: 'delta', itemId: item.id, text: '', ui: preview.blocks, textLength: preview.textLength });
+                    }
+                });
+                this.uiStreams.set(item.id, stream);
+            }
+            this.options.ui?.observe(item, false);
+            const latestAttachment = this.latestUiAttachment(item.turnId);
+            if (event.type === 'item' && !item.streaming) {
+                const ui = stream
+                    .finish(item.text, latestAttachment)
+                    .map((block) => ({ ...block, revision: createHash('sha256').update(JSON.stringify(block)).digest('hex') }));
+                this.uiStreams.delete(item.id);
+                this.uiCompiled.delete(item.id);
+                const diagnostics = [...new Set(ui.flatMap((block) => block.diagnostics.map((diagnostic) => diagnostic.message)))].slice(0, 6);
+                if (diagnostics.length > 0) {
+                    const repair =
+                        `Your last ruimte-ui block had these diagnostics: ${diagnostics.join(' ')} Use the catalog's supported props and components.`.slice(
+                            0,
+                            1200
+                        );
+                    if (!this.pendingPreambles.includes(repair)) {
+                        this.pendingPreambles = [...this.pendingPreambles, repair];
+                    }
+                }
+                const current = this.thread.get(item.id);
+                const completed = { ...item, ui, ...(current?.kind === 'assistant' && current.uiQueries ? { uiQueries: current.uiQueries } : {}) };
+                event = this.thread.upsert(completed);
+                this.options.emit(event);
+                this.options.ui?.observe(completed, true);
+            } else {
+                this.options.emit(event);
+                stream.update(item.text, latestAttachment);
+            }
+        }
+    }
+
+    private latestUiAttachment(turnId: string | null): string | undefined {
+        for (const item of this.thread.list().toReversed()) {
+            if (item.kind !== 'tool' || item.turnId !== turnId || item.name !== 'ImageGeneration' || item.state !== 'done') {
+                continue;
+            }
+            const input = GeneratedImageInputSchema.safeParse(item.input);
+            if (input.success && input.data.attachment?.mime.startsWith('image/')) {
+                return input.data.attachment.id;
+            }
+        }
+        return undefined;
+    }
+
+    private clearUi(): void {
+        for (const stream of this.uiStreams.values()) {
+            stream.dispose();
         }
+        this.uiStreams.clear();
+        this.uiCompiled.clear();
     }
 
     /* Said on the info as well as by the rows, since a client with the thread closed sees only the info. */

package/src/chat/claude-backend.ts

@@ -27,6 +27,8 @@ export class ClaudeBackend implements ChatBackend {
     private stdinClosed = false;
     // The person asked to stop; the result frame that follows closes the turn as aborted.
     private interrupted = false;
+    private readonly steers = new Map<string, { resolve(accepted: boolean): void; reject(reason: Error): void }>();
+    private active = false;
 
     constructor(launch: BackendLaunch, host: BackendHost, options: ClaudeBackendOptions = {}) {
         this.launch = launch;
@@ -72,10 +74,29 @@ export class ClaudeBackend implements ChatBackend {
         // The prefix is what the CLI must see first (ultrathink), then the note about the links, then what was typed.
         const prefix = `${promptPrefix(this.launch.selection)}${input.preamble === null ? '' : `${input.preamble}\n\n`}`;
         const promptId = input.promptId ?? randomUUID();
+        this.active = true;
         this.protocol.beginPrompt(promptId);
         this.write(buildUserMessage({ text: input.text, attachments: input.attachments, prefix, skills: input.skills, promptId }));
     }
 
+    steerTurn(input: TurnInput): Promise<boolean> {
+        if (!this.child || !this.active || this.stdinClosed) {
+            return Promise.resolve(false);
+        }
+        const promptId = input.promptId ?? randomUUID();
+        return new Promise((resolve, reject) => {
+            this.steers.set(promptId, { resolve, reject });
+            this.protocol.beginSteer(promptId);
+            try {
+                const prefix = `${promptPrefix(this.launch.selection)}${input.preamble === null ? '' : `${input.preamble}\n\n`}`;
+                this.write(buildUserMessage({ text: input.text, attachments: input.attachments, prefix, skills: input.skills, promptId }));
+            } catch (error) {
+                this.steers.delete(promptId);
+                reject(error instanceof Error ? error : new Error(errorText(error)));
+            }
+        });
+    }
+
     /* Claude Code folds its context through a slash command, so the session sends it as a turn. */
     compact(): void {
         this.sendTurn({ text: '/compact', preamble: null, attachments: [], mentions: [], skills: [] });
@@ -120,6 +141,7 @@ export class ClaudeBackend implements ChatBackend {
     }
 
     dispose(): Promise<void> {
+        this.rejectSteers('Claude stopped before acknowledging your message');
         const child = this.child;
         this.child = null;
         return child?.end() ?? Promise.resolve();
@@ -165,7 +187,15 @@ export class ClaudeBackend implements ChatBackend {
         } catch {
             return;
         }
+        const echoed = typeof frame === 'object' && frame !== null ? (frame as Record<string, unknown>) : null;
+        if (echoed?.type === 'user' && typeof echoed.uuid === 'string' && echoed.parent_tool_use_id == null) {
+            this.steers.get(echoed.uuid)?.resolve(true);
+            this.steers.delete(echoed.uuid);
+        }
         for (const event of this.protocol.handle(frame)) {
+            if (event.type === 'turn.done') {
+                this.active = false;
+            }
             if (event.type === 'turn.done' && this.interrupted) {
                 this.interrupted = false;
                 this.host.onEvent({ ...event, state: 'aborted' });
@@ -183,7 +213,16 @@ export class ClaudeBackend implements ChatBackend {
         }
     }
 
+    private rejectSteers(reason: string): void {
+        this.active = false;
+        for (const pending of this.steers.values()) {
+            pending.reject(new Error(reason));
+        }
+        this.steers.clear();
+    }
+
     private failed(error: unknown): void {
+        this.rejectSteers(`Claude transport failed: ${errorText(error)}`);
         this.protocol.forgetPending();
         try {
             this.host.onEvent({ type: 'failed', message: `Claude transport failed: ${errorText(error)}`, processAlive: this.running });
@@ -229,6 +268,7 @@ export class ClaudeBackend implements ChatBackend {
             return;
         }
         this.child = null;
+        this.rejectSteers('Claude exited before acknowledging your message');
         this.protocol.forgetPending();
         this.host.onEvent({ type: 'exit', exitCode, ...(stderr === null ? {} : { stderr }) });
     }

package/src/chat/claude-protocol.ts

@@ -147,7 +147,14 @@ export class ClaudeProtocol {
     private apiError: string | null = null;
     private readonly refusedWindows = new Map<string, number | null>();
 
+    private readonly steerIds = new Set<string>();
+
+    beginSteer(promptId: string): void {
+        this.steerIds.add(promptId);
+    }
+
     beginPrompt(promptId: string): void {
+        this.steerIds.clear();
         this.promptId = promptId;
         this.apiError = null;
         this.refusedWindows.clear();
@@ -575,7 +582,12 @@ export class ClaudeProtocol {
     private handleResult(frame: Frame, events: BackendEvent[]): void {
         const echoed = Array.isArray(frame.user_message_uuids) ? frame.user_message_uuids.filter((value): value is string => typeof value === 'string') : [];
         const origin = str(frame.origin) ?? (isRecord(frame.origin) ? str(frame.origin.kind) : null);
-        if (this.promptId !== null && (echoed.length > 0 ? !echoed.includes(this.promptId) : origin !== null && origin !== 'human' && origin !== 'user')) {
+        if (
+            this.promptId !== null &&
+            (echoed.length > 0
+                ? !echoed.includes(this.promptId) && !echoed.some((id) => this.steerIds.has(id))
+                : origin !== null && origin !== 'human' && origin !== 'user')
+        ) {
             if (typeof frame.total_cost_usd === 'number') {
                 events.push({ type: 'usage', costUsd: num(frame.total_cost_usd) });
             }
@@ -586,6 +598,9 @@ export class ClaudeProtocol {
         }
         const promptId = this.promptId !== null && echoed.includes(this.promptId) ? this.promptId : null;
         this.promptId = null;
+        for (const id of echoed) {
+            this.steerIds.delete(id);
+        }
         const failed = frame.is_error === true || (typeof frame.subtype === 'string' && frame.subtype.startsWith('error'));
         const errors = Array.isArray(frame.errors) ? frame.errors.filter((error): error is string => typeof error === 'string') : [];
         const lastUuid = this.lastUuid;