@xh/hoist-chat-kit 1.0.0 → 2.0.0-SNAPSHOT.1793828979839

package/CHANGELOG.md

@@ -12,6 +12,42 @@
   3. Plain ASCII punctuation only. Use " - " for in-sentence breaks, never an em dash.
 -->
 
+## 2.0.0-SNAPSHOT - unreleased
+
+### 💥 Breaking Changes (upgrade difficulty: 🟢 LOW - remove the busy-line settings)
+
+See [`docs/upgrade-notes/v2-upgrade-notes.md`](docs/upgrade-notes/v2-upgrade-notes.md) for
+detailed, step-by-step upgrade instructions with before/after code examples.
+
+* `ChatStatusRegion` now shows only what stops a send or needs the user's action. A reply in
+  progress, or one waiting for the user's answer, shows no line, as the reply shows its progress.
+* Removed the busy line's settings: `showStopHint` and `assistantName` on `ChatStatusRegion`,
+  `ChatStatusRegion.defaults` with its `ChatStatusRegionDefaults` type, and
+  `ChatKit.defaults.busyIcon`. The Stop button names Esc in its tooltip.
+* Removed the `xh-chat-status-region__lead`, `xh-chat-status-region__hint`,
+  `xh-chat-status-region--busy` and `xh-chat-status-region--attention` classes, which the region no
+  longer renders.
+
+### 🎁 New Features
+
+* `ChatThreadsModel` now blocks sends while the store lists a thread as running and its last reply
+  was left running, or it has no messages yet. `getChatComposerStatus()` reports the block with
+  Refresh Status, or as `detached` when the last reply is.
+
+### 🐞 Bug Fixes
+
+* Fixed Refresh Status in a `ChatThreadsModel` chat to reload the thread list too. The list could
+  show a thread as running after its run had finished.
+* Fixed a reply left running on the server, live, loaded or replayed, to show its unfinished server
+  calls and sub-agents as "Not finished yet", not as failed, cancelled or "Stopped". Once the
+  conversation moves past the reply, it reads as complete and its open work closes.
+
+### ✨ Styles
+
+* Added the `xh-chat-timeline--detached`, `xh-chat-timeline__item--unfinished`,
+  `xh-chat-tool-call--unfinished` and `xh-chat-tool-call__glyph--unfinished` classes. A detached
+  reply's timeline no longer takes `xh-chat-timeline--stopped`.
+
 ## 1.0.0 - 2026-11-02
 
 The first release of Hoist Chat Kit, a library of chat components for Hoist React applications.

package/core/ChatKit.ts

@@ -17,13 +17,6 @@ export interface ChatKitDefaults {
      */
     assistantIcon: () => ReactElement;
 
-    /**
-     * Returns the icon beside "Assistant is working" in the composer's status region, for an
-     * app with a busy glyph of its own. Called for each use. Return null from it for no icon.
-     * Null for the kit's own spinner. Default null.
-     */
-    busyIcon: () => ReactElement;
-
     /**
      * What a chat spinner does under reduced motion - when the browser reports
      * `prefers-reduced-motion: reduce`, or inside an element with class `xh-chat--reduced-motion`.
@@ -122,7 +115,6 @@ export class ChatKit {
     /** Kit-wide settings - see {@link ChatKitDefaults}. */
     static defaults: ChatKitDefaults = {
         assistantIcon: () => Icon.ai(),
-        busyIcon: null,
         reducedMotionSpinner: 'static',
         stallAfterMs: 30_000,
         drafts: 'local',

package/core/ChatModel.ts

@@ -84,7 +84,9 @@ import {genChatId} from '../impl/LangUtils';
 import {
     createTextPart,
     getClientToolCalls,
+    isDetachedReply,
     SETTLE_REASONS,
+    settleOpenCalls,
     settleOpenParts,
     settleStreamingParts,
     updatePart
@@ -548,7 +550,8 @@ export class ChatModel extends HoistModel implements ChatComposerHost, ChatTrans
     @computed
     get waitingToolCalls(): ChatToolCallPart[] {
         const {lastMessage} = this;
-        if (this.isBusy || !lastMessage?.isAssistant) return [];
+        // A detached reply's open calls wait on the server, not the user.
+        if (this.isBusy || !lastMessage?.isAssistant || isDetachedReply(lastMessage)) return [];
         const isPausedOnInterrupts = !!this.pausedInterruptSet;
         return lastMessage.toolCalls.filter(
             it =>
@@ -717,7 +720,7 @@ export class ChatModel extends HoistModel implements ChatComposerHost, ChatTrans
         this.modelTools = tools.filter(
             it => it.sendToModel ?? (it.execute != null || !!it.interactive)
         );
-        this.messages = restoreMessages(initialMessages);
+        this.messages = this.restore(initialMessages);
         this.addArtifactsOf(this.messages);
         tools.forEach(it => {
             if (it.interactive && !it.execute && !it.renderer) {
@@ -798,7 +801,8 @@ export class ChatModel extends HoistModel implements ChatComposerHost, ChatTrans
     /**
      * Stop following the current turn, without cancelling it. The message is kept as 'aborted',
      * as with `stop`. In server mode, a turn with a step in flight is marked `metadata.detached`,
-     * as the server finishes it on its own, and a reload of the thread later shows its answer.
+     * as the server finishes it on its own, and a reload of the thread later shows its answer. Its
+     * unfinished tool calls and sub-agents stay open, where a stop closes them as cancelled.
      */
     detach() {
         this.abortTurn('detach');
@@ -1135,7 +1139,8 @@ export class ChatModel extends HoistModel implements ChatComposerHost, ChatTrans
      * that was pending or streaming becomes 'aborted', with its unfinished tool calls failed. A
      * paused turn at the end of the history stays paused, so the user can still answer its tool
      * calls - or send a new message, which closes them. A paused turn earlier in the history is
-     * closed.
+     * closed. So is a detached reply - see {@link detach} - except at the end of the history,
+     * where its unfinished tool calls and sub-agents stay open.
      *
      * In server mode, a turn still running on the server is detached rather than cancelled - see
      * {@link detach}.
@@ -1709,6 +1714,30 @@ export class ChatModel extends HoistModel implements ChatComposerHost, ChatTrans
         }
     }
 
+    /** Messages from stored specs, closed as `loadMessages` describes. */
+    private restore(specs: ChatMessageSpec[]): ChatMessage[] {
+        const messages = restoreMessages(specs),
+            last = messages[messages.length - 1];
+        if (isDetachedReply(last)) messages[messages.length - 1] = this.closeClientCalls(last);
+        return messages;
+    }
+
+    /**
+     * A detached reply with the open calls that the browser would run or answer closed - those to
+     * a tool of the chat with an `execute`, or an interactive one. The turn that would run them
+     * is over, and the server never does. Calls the server runs, display tools included, stay open.
+     */
+    private closeClientCalls(message: ChatMessage): ChatMessage {
+        return settleOpenCalls(
+            message,
+            it => {
+                const spec = it.providerExecuted ? null : this.getOwnToolSpec(it.toolName);
+                return !!(spec?.execute || spec?.interactive);
+            },
+            SETTLE_REASONS.interrupted
+        );
+    }
+
     /** The spec for a tool in `tools`, or null - the only kind that runs or answers a call. */
     private getOwnToolSpec(name: string): ChatToolSpec {
         return this.tools.find(it => it.name === name) ?? null;
@@ -1759,7 +1788,7 @@ export class ChatModel extends HoistModel implements ChatComposerHost, ChatTrans
         this.abortTurn(reason);
         this._threadId = threadId ?? genChatId();
         this.isThreadIdProvisional = threadId == null || !hasHistory(specs);
-        this.messages = restoreMessages(specs);
+        this.messages = this.restore(specs);
         this.interruptSet = restoreInterruptSet(this.messages);
         // A history rebuilt from events, rather than saved by the chat, has no marks on the
         // server calls that a paused reply's interrupts wait on.
@@ -1788,7 +1817,8 @@ export class ChatModel extends HoistModel implements ChatComposerHost, ChatTrans
         if (this.interruptSet) this.setInterruptSet(declineRest(this.interruptSet));
         this.closePausedTurn();
 
-        const history = getHistory(),
+        // A detached reply the conversation moves past gets no more results.
+        const history = getHistory().map(it => (isDetachedReply(it) ? closeMovedPast(it) : it)),
             userMessage = findLast(history, it => it.isUser),
             message = new ChatMessage({role: 'assistant', status: 'pending'}),
             turn = createTurn(message, 0, true, {
@@ -1871,10 +1901,11 @@ export class ChatModel extends HoistModel implements ChatComposerHost, ChatTrans
             this.logError('Could not check the reply for catalog UI', e);
         }
 
-        const settled = settleOpenParts(
-            message,
-            SETTLE_REASONS[status],
-            status === 'aborted'
+        // A detached reply's work goes on on the server, so its open calls and sub-agents stay open.
+        const settled = (
+            detached
+                ? this.closeClientCalls(settleStreamingParts(message))
+                : settleOpenParts(message, SETTLE_REASONS[status], status === 'aborted')
         ).withChanges({
             status,
             error: error ? errorText(error) : null,
@@ -2158,7 +2189,8 @@ function stopTurnClock(turn: ChatTurn): number {
 
 /**
  * Messages from stored specs, with anything left in progress closed - see `loadMessages`. A
- * paused turn at the end of the specs stays paused.
+ * paused turn at the end of the specs stays paused. So does the open work of a detached reply at
+ * the end, which the server may still finish.
  */
 function restoreMessages(specs: ChatMessageSpec[]): ChatMessage[] {
     const messages = specs.map(it => new ChatMessage(it)),
@@ -2178,11 +2210,29 @@ function restoreMessages(specs: ChatMessageSpec[]): ChatMessage[] {
                     status: 'aborted'
                 });
             default:
-                return settleOpenParts(message, SETTLE_REASONS.interrupted);
+                if (!isDetachedReply(message)) {
+                    return settleOpenParts(message, SETTLE_REASONS.interrupted);
+                }
+                return idx === lastIdx ? settleStreamingParts(message) : closeMovedPast(message);
         }
     });
 }
 
+/**
+ * A detached reply that the conversation moved past, as complete, with its open work closed - as
+ * for a paused reply the user moved past. The chat will not learn how its run ended.
+ */
+function closeMovedPast(message: ChatMessage): ChatMessage {
+    // A call approved for a resume gets no result either, once nothing follows the reply.
+    const parts = message.parts.map(it =>
+        it.type === 'toolCall' && it.awaitsResume ? {...it, awaitsResume: false} : it
+    );
+    return settleOpenParts(message.withChanges({parts}), SETTLE_REASONS.complete).withChanges({
+        status: 'complete',
+        metadata: omit(message.metadata, 'detached')
+    });
+}
+
 /** The tools a catalog adds to a chat - see {@link ChatModelConfig.catalog}. */
 function getCatalogTools(catalog: ChatUiCatalog, historyMode: ChatHistoryMode): ChatToolSpec[] {
     if (!catalog) return [];

package/core/README.md

@@ -418,6 +418,15 @@ chatModel.runOptions = {documentIds: selectedIds, profile: 'thorough'};
 | `clear()`, `loadMessages()` | Discarded | No | As for `detach()` |
 | `destroy()` | Discarded | No | The run goes on |
 
+A detached reply keeps the server's unfinished tool calls and sub-agents open, as the server may
+still finish them. Calls to a tool of the chat with an `execute`, or an interactive one, close as
+interrupted, as the turn that would run them is over. The same holds for the last reply of a
+history loaded with `loadMessages()`, if it is detached.
+
+When the next turn starts, the reply becomes `complete`, without `metadata.detached`. Its open work
+closes as "No result - the conversation moved on", so that the history a request sends has a
+result for every call. A reply that a stop ended closes its open work as cancelled.
+
 The turn's signal aborts with a `ChatAbortError`. Its `name` is `AbortError`, and its `reason` is
 `stop`, `detach`, `clear`, `load` or `destroy`. A client tool can read the reason from
 `context.signal.reason`. In client mode, a detach and a clear only abort, as a stop does, with no
@@ -930,7 +939,10 @@ The composer's status region holds the thread's next action. `ChatComposerModel.
 reads it as a `ChatComposerStatus`: a `type`, the reply's display status, at most one `action`,
 and the reason. `getChatComposerStatus()` is the same reading as a pure function. One status
 shows at a time, in this order: blocked, offline, failed or detached, stalled, waiting to retry,
-paused, busy, and a restored draft.
+paused, busy, and a restored draft. A send that `ChatThreadsModel` blocks while the server runs the
+turn offers Refresh Status, and reads as detached when the last reply is. The desktop
+`ChatStatusRegion` shows a line only for what stops a send or needs the user's action - see
+[Recover from a failed reply](../desktop/cmp/chat/README.md#recover-from-a-failed-reply).
 
 The action for a failure depends on whether a resend is safe. `isChatRetrySafe(message,
 historyMode)` decides it:
@@ -1177,7 +1189,7 @@ The kit records these keys in the `metadata` of an assistant message:
 | `retryAfterSeconds` | Wait the backend asked for before a retry, on a failed run. |
 | `runId` | Id of the latest run, from `RUN_STARTED`. |
 | `serverId` | The server's id for the message, from `xh.chat.message` or `RUN_FINISHED`. Also set on a user message. |
-| `detached` | True on a reply left running on the server by `detach()`, `clear()` or `loadMessages()`, in server mode. |
+| `detached` | True on a reply left running on the server by `detach()`, `clear()` or `loadMessages()`, in server mode. Its unfinished tool calls and sub-agents stay open - see [Stop or detach a turn](#stop-or-detach-a-turn). |
 | `feedback` | The user's rating, as `{rating, comment?}`. History usually restores the rating alone. |
 | `artifacts` | `ChatArtifact[]` that the reply's tools produced, for generative UI. Restored to `artifacts` with the history. |
 | `catalogVersion` | Version of the chat's catalog, on a reply that shows its UI. |
@@ -1393,7 +1405,6 @@ Fields of `ChatKit.defaults`. See `ChatKit.ts`.
 | Field | Type | Description |
 |-------|------|-------------|
 | `assistantIcon` | `() => ReactElement` | Returns the icon that marks the assistant. A component's `assistantIcon` prop overrides it. Default `() => Icon.ai()`. |
-| `busyIcon` | `() => ReactElement` | Returns the icon beside "Assistant is working" in the status region. Return null from it for no icon. Null for the kit's spinner. Default null. |
 | `reducedMotionSpinner` | `'static' \| 'spin'` | Under reduced motion, `static` swaps the chat's spinners for a static icon, and `spin` keeps Hoist's spinner. Default `static`. |
 | `stallAfterMs` | `number` | Milliseconds with no data from the server before a reply shows as stalled. `ChatModelConfig.stallAfterMs` overrides it. Default 30,000. |
 | `drafts` | `'local' \| 'memory'` | Where the composer keeps its unsent draft text: local storage, per thread, or memory only. Default `local`. See [Keep drafts](#keep-drafts). |

package/core/composer/ChatComposerModel.ts

@@ -271,8 +271,7 @@ export class ChatComposerModel extends HoistModel {
     }
 
     /**
-     * The status the composer's status region shows now, or null - see
-     * {@link getChatComposerStatus}.
+     * The thread's status for the composer now, or null - see {@link getChatComposerStatus}.
      *
      * @param now - epoch millis to read the clock-based states at. Default now.
      */

package/core/composer/ChatComposerStatus.ts

@@ -3,8 +3,9 @@ import type {ChatHistoryMode} from '../ChatModel';
 import {type ChatReplyStatus, getChatReplyStatus} from '../ChatReplyStatus';
 
 /**
- * What the composer's status region shows - the one thing about the thread that the user should
- * know before the next send, with at most one action. See {@link getChatComposerStatus}.
+ * The thread's status for the composer - the one thing about the thread that the user should know
+ * before the next send, with at most one action. See {@link getChatComposerStatus}. The desktop
+ * `ChatStatusRegion` shows only those that stop a send or need the user's action.
  *
  *  - `blocked` - the host gives a reason that sending must wait.
  *  - `offline` - the browser is offline. The draft is kept, and nothing sends by itself.
@@ -39,7 +40,7 @@ export type ChatComposerStatusType =
  */
 export type ChatComposerAction = 'tryAgain' | 'refreshStatus' | 'cancelRetry' | 'discardDraft';
 
-/** The status the composer's status region shows - see {@link getChatComposerStatus}. */
+/** The thread's status for the composer - see {@link getChatComposerStatus}. */
 export interface ChatComposerStatus {
     type: ChatComposerStatusType;
 
@@ -105,12 +106,14 @@ export interface ChatComposerStatusSpec {
 }
 
 /**
- * The status the composer's status region shows, or null to show nothing. A pure function of its
- * input, so a component re-reads it as the clock ticks.
+ * The thread's status for the composer, or null for none. A pure function of its input, so a
+ * component re-reads it as the clock ticks. It reports every status, for a layout of an app's
+ * own - the desktop `ChatStatusRegion` shows a line for some of them only.
  *
  * One status shows at a time, the first that applies in this order: blocked, offline, failed or
  * detached, stalled, waiting to retry, paused, busy, and a restored draft. A reply the server
- * interrupted or cancelled counts as failed.
+ * interrupted or cancelled counts as failed. A send that a thread layer blocks while the server
+ * runs the thread's turn offers Refresh Status, and reads as detached if the last reply is.
  *
  * A failure that is retry-safe offers Try Again. One that is not offers Refresh Status if the host
  * can refresh, else Try Again, and says the run may still be running. A retry-safe failure for
@@ -146,7 +149,17 @@ export function getChatComposerStatus(spec: ChatComposerStatusSpec): ChatCompose
             ...changes
         });
 
-    if (sendBlockedReason) return status('blocked', {reason: sendBlockedReason});
+    // A send blocked while the server runs the turn can refresh to learn when it ends. A reply
+    // left running says so itself, so that block shows as the reply's status.
+    if (sendBlockedReason) {
+        const isRunOnServer = sendBlockedReason === RUN_ON_SERVER_REASON;
+        if (!isRunOnServer || replyStatus !== 'detached') {
+            return status('blocked', {
+                reason: sendBlockedReason,
+                action: isRunOnServer && canRefreshStatus ? 'refreshStatus' : null
+            });
+        }
+    }
     if (isOffline) return status('offline');
 
     switch (replyStatus) {
@@ -202,6 +215,13 @@ export function isChatRetrySafe(
     return !(historyMode === 'server' && KIT_UNSAFE_CODES.includes(errorCode));
 }
 
+/**
+ * The reason `ChatThreadsModel` gives for a send it blocks while the server runs a turn that the
+ * chat does not follow.
+ * @internal
+ */
+export const RUN_ON_SERVER_REASON = 'Wait for the reply to finish.';
+
 //------------------
 // Implementation
 //------------------

package/core/impl/messageUtils.ts

@@ -61,6 +61,35 @@ export function settleOpenParts(
     return settleParts(message, reason, isCancelled, endedAt);
 }
 
+/**
+ * A copy of a message with the open tool calls that `isClosed` picks closed with `reason`, as
+ * failed - or denied if they awaited approval. Other parts stay as they are. Returns the same
+ * message if no call was picked.
+ *
+ * @param endedAt - the time to record on the calls it ends. Default now.
+ * @internal
+ */
+export function settleOpenCalls(
+    message: ChatMessage,
+    isClosed: (call: ChatToolCallPart) => boolean,
+    reason: string,
+    endedAt: number = null
+): ChatMessage {
+    const calls = message.toolCalls.filter(it => !isToolCallFinal(it) && isClosed(it));
+    if (!calls.length) return message;
+    const settled = settleOpenParts(message.withChanges({parts: calls}), reason, false, endedAt),
+        byId = new Map(settled.parts.map(it => [it.id, it]));
+    return message.withChanges({parts: message.parts.map(it => byId.get(it.id) ?? it)});
+}
+
+/**
+ * True for a reply left running on the server - `aborted`, with `metadata.detached`.
+ * @internal
+ */
+export function isDetachedReply(message: ChatMessage): boolean {
+    return message?.status === 'aborted' && !!message.metadata.detached;
+}
+
 /**
  * Why `settleOpenParts` closed a tool call, by how its turn ended.
  * @internal

package/core/replayChatEvents.ts

@@ -62,7 +62,8 @@ export interface ChatReplayOptions {
  *    chat then offers to refresh its status, as after the user left a live reply running.
  *
  * Anything a turn leaves open, such as a tool call with no result, is closed as the live chat
- * would close it, at the time of the turn's last event. An interrupt that a later run answered
+ * would close it, at the time of the turn's last event. A detached turn's open tool calls and
+ * sub-agents stay open, as the server may still finish them. An interrupt that a later run answered
  * counts as delivered. The user's answers to it are not among the events.
  *
  * A record that the decoder rejects fails the reply, as it would fail a live stream, with the
@@ -98,12 +99,15 @@ export function replayChatEvents(
         isStopped = decodeError != null || opts.status === 'aborted' || !isEnded;
     message = isStopped ? reducer.settleText(message) : reducer.finish(message);
 
+    // A turn with no end goes on on the server, so its open calls and sub-agents stay open - but
+    // for the calls of its earlier steps, which ended with their runs.
     const status = decodeError ? 'error' : (opts.status ?? endStatus(message, reducer, isEnded)),
+        isDetached = !isEnded && opts.status == null && !decodeError,
         times = runs.map(runTimes).filter(it => it != null),
         endedAt = max(times.map(it => it[1])) ?? null,
         settleAt = endedAt ?? Date.now(),
         settled =
-            status === 'paused'
+            status === 'paused' || isDetached
                 ? settleStreamingParts(settleEarlierCalls(message, lastIdx, settleAt), settleAt)
                 : settleOpenParts(message, SETTLE_REASONS[status], status === 'aborted', settleAt);
 
@@ -118,9 +122,7 @@ export function replayChatEvents(
         const elapsedMs = sumBy(times, ([start, end]) => end - start);
         replyMetadata = {...replyMetadata, elapsedMs, ...(status === 'paused' ? {} : {endedAt})};
     }
-    if (!isEnded && opts.status == null && !decodeError) {
-        replyMetadata = {...replyMetadata, detached: true};
-    }
+    if (isDetached) replyMetadata = {...replyMetadata, detached: true};
     // The server took each answer that a later run carried.
     if (replyMetadata.interrupts) {
         replyMetadata = {
@@ -205,9 +207,9 @@ function splitRuns(events: ChatEvent[]): ChatEvent[][] {
 }
 
 /**
- * A paused reply with the tool calls of its earlier steps closed. A call the browser ran has its
- * result in the next step's request, not among the events, so it would otherwise wait on the user
- * again. Other parts stay as they are, such as a sub-agent that waits on the reply's interrupts.
+ * A paused or detached reply with the tool calls of its earlier steps closed. A call the browser
+ * ran has its result in the next step's request, not among the events, so it would otherwise stay
+ * open. Other parts stay as they are, such as a sub-agent that waits on the reply's interrupts.
  */
 function settleEarlierCalls(message: ChatMessage, step: number, endedAt: number): ChatMessage {
     const calls = message.toolCalls.filter(it => it.step < step),

package/desktop/cmp/chat/ChatComposer.ts

@@ -348,6 +348,7 @@ function sendButton(
                 key: 'stop',
                 icon: Icon.stop({prefix: 'fas'}),
                 text: 'Stop',
+                tooltip: 'Stop (Esc)',
                 outlined: true,
                 ...stopProps,
                 className: classNames('xh-chat-composer__stop', stopProps.className),

package/desktop/cmp/chat/ChatMessageView.ts

@@ -84,6 +84,7 @@ import {
 } from './impl/groupParts';
 import {ChatSourceLinks, findSidePanel} from './impl/ChatSourceLinks';
 import {jsonView} from './impl/JsonView';
+import {replyDetachedProvider} from './impl/ReplyDetached';
 import {useChatMarkdownComponents} from './ChatMarkdownComponents';
 import {formatFailureDetails, getFailureCause, isReplyNotSent} from './impl/ReplyFailure';
 
@@ -621,50 +622,58 @@ function assistantContent(
             className: 'xh-chat-message__main',
             items: [
                 props.showHeader === false ? null : messageHeader(props, context),
-                div({
-                    className: 'xh-chat-message__body',
-                    items: [
-                        ...withInterrupts(
-                            runs,
-                            message,
-                            chatModel,
-                            runs.map((run, idx) =>
-                                run.type === 'process'
-                                    ? processRun(
-                                          run,
-                                          props,
-                                          impl,
-                                          context,
-                                          references,
-                                          markerSources
-                                      )
-                                    : run.type === 'timeline'
-                                      ? timelineBlock(run, props, context, idx < runs.length - 1)
-                                      : renderGroup(
-                                            run,
-                                            props,
-                                            impl,
-                                            context,
-                                            references,
-                                            markerSources
-                                        )
-                            )
-                        ),
-                        // With no header to show its status, a reply that waits for its first
-                        // content shows a working cue in its body - after any answered questions.
-                        props.showHeader === false &&
-                        message.isStreaming &&
-                        isEmpty(runs) &&
-                        chatModel
-                            ? workingCue({
-                                  key: 'working',
-                                  message,
-                                  chatModel,
-                                  isLast: props.isLast
-                              })
-                            : null,
-                        replyNotice(props, chatModel)
-                    ]
+                replyDetachedProvider({
+                    value: getChatReplyStatus({message}) === 'detached',
+                    item: div({
+                        className: 'xh-chat-message__body',
+                        items: [
+                            ...withInterrupts(
+                                runs,
+                                message,
+                                chatModel,
+                                runs.map((run, idx) =>
+                                    run.type === 'process'
+                                        ? processRun(
+                                              run,
+                                              props,
+                                              impl,
+                                              context,
+                                              references,
+                                              markerSources
+                                          )
+                                        : run.type === 'timeline'
+                                          ? timelineBlock(
+                                                run,
+                                                props,
+                                                context,
+                                                idx < runs.length - 1
+                                            )
+                                          : renderGroup(
+                                                run,
+                                                props,
+                                                impl,
+                                                context,
+                                                references,
+                                                markerSources
+                                            )
+                                )
+                            ),
+                            // With no header to show its status, a reply that waits for its first
+                            // content shows a working cue in its body - after any answered questions.
+                            props.showHeader === false &&
+                            message.isStreaming &&
+                            isEmpty(runs) &&
+                            chatModel
+                                ? workingCue({
+                                      key: 'working',
+                                      message,
+                                      chatModel,
+                                      isLast: props.isLast
+                                  })
+                                : null,
+                            replyNotice(props, chatModel)
+                        ]
+                    })
                 }),
                 !isNoAnswer && references.length
                     ? chatSources({sources: toSourceList(references), links: impl.sourceLinks})

package/desktop/cmp/chat/ChatPanel.ts

@@ -82,10 +82,7 @@ export interface ChatPanelProps
      */
     messageListProps?: Omit<ChatMessageListProps, 'model' | 'modelConfig' | 'modelRef'>;
 
-    /**
-     * Props for the status region above the composer - for example `showStopHint`. Its
-     * `assistantName` defaults to the message list's.
-     */
+    /** Props for the status region above the composer. */
     statusRegionProps?: Omit<ChatStatusRegionProps, 'model' | 'modelConfig' | 'modelRef'>;
 }
 
@@ -177,7 +174,6 @@ export const [ChatPanel, chatPanel] = hoistCmp.withFactory<ChatPanelProps>({
                         items: [
                             chatStatusRegion({
                                 model: model.composerModel,
-                                assistantName: messageListProps?.assistantName,
                                 ...statusRegionProps
                             }),
                             chatComposer({

package/desktop/cmp/chat/ChatStatusRegion.scss

@@ -11,14 +11,6 @@
   min-width: 0;
   padding: 0 2px 0 var(--xh-chat-composer-status-inset);
 
-  &--busy {
-    color: var(--xh-chat-busy-color);
-  }
-
-  &--attention {
-    color: var(--xh-chat-attention-color);
-  }
-
   &--warning {
     color: var(--xh-chat-warning-color);
   }