@artooi/ag-ui-web-component 0.42.0 → 0.44.0

package/src/core/events/feedback_detail.ts

@@ -3,4 +3,25 @@ export interface FeedbackDetail {
   /** The rated message's text, as rendered. */
   readonly content: string;
   readonly rating: "up" | "down";
+  /**
+   * The AG-UI id of the rated assistant message: the id it streamed under, or
+   * the stored message's `id` when it was restored from history.
+   *
+   * What a host stores a rating against. `content` cannot be: two answers can
+   * read the same, and the text says nothing about which stored message it
+   * was. A restored message carries whatever id its store returns: the
+   * built-in browser store keeps the streamed ids, and a server-backed one
+   * keeps them only where the server persists the ids it streamed.
+   */
+  readonly messageId: string;
+  /** The conversation the message belongs to: the element's thread when it was drawn. */
+  readonly threadId: string;
+  /**
+   * The run that streamed the message, as its `RUN_STARTED` named it.
+   *
+   * Present only on a message that arrived live. A restored one has none to
+   * give -- an AG-UI message carries no run id -- so the key is absent there
+   * rather than holding a value that only looks like one.
+   */
+  readonly runId?: string;
 }

package/src/core/run_handlers.ts

@@ -235,7 +235,7 @@ export class RunHandlers {
         this.#host.stream.queue(buffer);
         this.#host.stream.countDelta();
       },
-      onTextEnd: (buffer) => {
+      onTextEnd: (buffer, message) => {
         // A text message that carried no content is a declaration, not an
         // answer, and drawing one puts an empty bubble above every tool call.
         //
@@ -265,7 +265,7 @@ export class RunHandlers {
           this.#host.transcript.revealWords(bubble);
         }
         attachCopyButtons(bubble, this.#host.strings());
-        this.#host.actions.attach(bubble);
+        this.#host.actions.attach(bubble, message);
         this.#host.stream.end();
         this.#host.noteUnread();
       },

package/src/index.ts

@@ -34,6 +34,7 @@ export {
   AgUiClient,
   type AgUiClientConfig,
   type AgUiClientHandlers,
+  type AgUiMessageIds,
   type AgUiRunInputs,
   type AgUiToolCall,
   ConnectionLostError,

package/src/tools/tool_dispatch.ts

@@ -64,6 +64,13 @@ export interface ToolDispatchHost {
    * one the element serves.
    */
   readonly tenure: () => object;
+  /**
+   * The conversation on screen: an identity the element replaces every time it
+   * clears the transcript for another conversation, a handover included. Only
+   * ever compared, so a call can tell whether the conversation it was
+   * dispatched in is still the one it would draw into.
+   */
+  readonly conversation: () => object;
 }
 
 /**
@@ -131,7 +138,10 @@ export class ToolDispatch {
    * check that it has not. A Stop while the host's predicate is pending ends
    * the call there, and one while the card is open declines it. A handover
    * during any of the three leaves the call with no transcript to draw in and
-   * no store to write to, so it does neither.
+   * no store to write to, so it does neither. Any other reset of the
+   * conversation -- New chat, a drawer switch, `reload()` -- leaves the call
+   * its store and its result but not the transcript, so it still settles and
+   * returns, and does not show the run waiting in a conversation it is not in.
    */
   async execute(call: AgUiToolCall): Promise<ToolExecution | null> {
     // A skill load already rendered as a notice on the stream; it is never a
@@ -148,6 +158,7 @@ export class ToolDispatch {
     // chat had just moved to, leaving its own behind, and across a handover
     // it wrote into the next principal's store.
     const tenure = this.#host.tenure();
+    const conversation = this.#host.conversation();
     const threadId = this.#host.threadId();
     const card = this.#host.transcript.cardFor(call);
     this.#host.transcript.forgetCard(call.id);
@@ -270,7 +281,16 @@ export class ToolDispatch {
       if (!accepted) {
         const message = this.#host.strings().declinedAction;
         card.settle(TOOL_CALL_STATUS.DECLINED, message);
-        this.#host.transcript.showPending();
+        // New chat or a drawer switch with the card open declines it too, and
+        // the indicator would land in the conversation that replaced this one,
+        // whose run is not this one and which nothing would take it down from.
+        // Only the drawing is skipped: the refusal is still this run's to send.
+        //
+        // Held by "draws nothing into the new chat when New chat declines the
+        // open card" in tool_dispatch.test.ts.
+        if (this.#host.conversation() === conversation) {
+          this.#host.transcript.showPending();
+        }
         // The one outcome with no error text and no server involvement at all:
         // a person said no in this browser. Nothing else records that, so
         // without the annotation the reload showed a green card for an action
@@ -332,7 +352,16 @@ export class ToolDispatch {
       }
       const content = JSON.stringify(result ?? null);
       card.settle(TOOL_CALL_STATUS.DONE, content);
-      this.#host.transcript.showPending();
+      // The same check for a reset that is not a handover. The result is kept,
+      // as after a Stop, but the conversation on screen is not the one it was
+      // dispatched in, so the run is not shown waiting there.
+      //
+      // Held by "draws nothing into the new chat when a handler resolves after
+      // New chat" in tool_dispatch.test.ts, and for the other resets by the
+      // tests beside it.
+      if (this.#host.conversation() === conversation) {
+        this.#host.transcript.showPending();
+      }
       return { content };
     } catch (error) {
       // The same handover check as on success, and here it also guards a
@@ -358,7 +387,14 @@ export class ToolDispatch {
       // invisible from the host's side and is not one it can take back.
       const message = error instanceof Error ? error.message : String(error);
       card.settle(TOOL_CALL_STATUS.ERROR, message);
-      this.#host.transcript.showPending();
+      // As on success: the failure is still reported, and not drawn as a run
+      // waiting in a conversation the call is no longer in.
+      //
+      // Held by "draws nothing into the new chat when a handler fails after
+      // New chat" in tool_dispatch.test.ts.
+      if (this.#host.conversation() === conversation) {
+        this.#host.transcript.showPending();
+      }
       return { content: `Error: ${message}`, error: message, outcome: TOOL_OUTCOME.FAILED };
     }
   }

package/src/ui/composer/voice_input.ts

@@ -58,6 +58,8 @@ export class VoiceInput {
   #capTimer: ReturnType<typeof setTimeout> | null = null;
   #hitCap = false;
   #disposed = false;
+  /** Identifies the newest start; an older one that settles is stale. */
+  #startToken: object = {};
 
   constructor(options: VoiceInputOptions) {
     this.#transcribe = options.transcribe;
@@ -93,35 +95,66 @@ export class VoiceInput {
   }
 
   async #start(): Promise<void> {
-    let stream: MediaStream;
+    // The button reads idle for the whole of the permission prompt, so a second
+    // click during it is a second start. The latest click wins: this token is
+    // replaced by every start, and whichever one settles while it is not the
+    // newest is stale. It is a token and not an in-flight flag on purpose:
+    // getUserMedia may never settle (a dismissed prompt), and a flag waiting
+    // for it would leave the button dead until reload.
+    const token = {};
+    this.#startToken = token;
+    let stream: MediaStream | null;
     try {
       stream = await navigator.mediaDevices.getUserMedia({ audio: true });
     } catch {
-      this.#fail(this.#strings.transcriptionFailed);
-      return;
+      stream = null;
     }
-    if (this.#disposed) {
-      // The permission prompt outlived the control: the element left, or
-      // user-key changed, while it was open. Recording now would light the
-      // browser's indicator for a button nobody can see or stop, and dispose
-      // has already run, so nothing else would ever release these tracks.
-      for (const track of stream.getTracks()) {
+    if (token !== this.#startToken || this.#disposed) {
+      // Superseded by a later click, or the prompt outlived the control: the
+      // element left, or user-key changed, while it was open. Whatever this
+      // call was granted is released and nothing shared is touched: #stream,
+      // #recorder and the cap timer belong to the newer start, and recording
+      // now on a disposed control would light the browser's indicator for a
+      // button nobody can see or stop (dispose has already run, so nothing
+      // else would ever release these tracks). A refusal is dropped the same
+      // way, so a click nobody is waiting on draws no error over the newer one.
+      for (const track of stream?.getTracks() ?? []) {
         track.stop();
       }
       return;
     }
+    if (stream === null) {
+      this.#fail(this.#strings.transcriptionFailed);
+      return;
+    }
     this.#stream = stream;
     this.#chunks = [];
     this.#hitCap = false;
-    const recorder = new MediaRecorder(stream);
-    recorder.addEventListener("dataavailable", (event) => {
-      this.#chunks.push(event.data);
-    });
-    recorder.addEventListener("stop", () => {
-      void this.#finish(recorder.mimeType);
-    });
-    this.#recorder = recorder;
-    recorder.start();
+    let recorder: MediaRecorder;
+    try {
+      recorder = new MediaRecorder(stream);
+      recorder.addEventListener("dataavailable", (event) => {
+        this.#chunks.push(event.data);
+      });
+      recorder.addEventListener("stop", () => {
+        void this.#finish(recorder.mimeType);
+      });
+      this.#recorder = recorder;
+      recorder.start();
+    } catch {
+      // A granted stream the browser will not record: one whose tracks have
+      // already ended (Chromium throws NotSupportedError from start), a device
+      // that went away between the grant and the start, or no MediaRecorder at
+      // all. It is a refused mic by another route, so it ends the same way: the
+      // tracks are released (the stream is already stored, and nothing else
+      // would stop it), the button shows the failure, and nothing reaches the
+      // click handler, which discards the promise. A recorder whose start threw
+      // can still report "recording" and still holds its listeners, but #fail
+      // clears #recorder, so neither #stop nor dispose can reach it and its stop
+      // listener never runs #finish.
+      this.#fail(this.#strings.transcriptionFailed);
+      return;
+    }
     // Nothing else ends a recording: `MediaRecorder` runs until it is told to
     // stop, so without this the only exits are a second click and `dispose()`.
     this.#capTimer = setTimeout(() => {
@@ -153,8 +186,8 @@ export class VoiceInput {
    * a detached element.
    *
    * Disposal is final: nothing un-disposes an instance, and the host's next
-   * wiring builds a new one. So the disposed flag alone tells a stale
-   * continuation from a live one, and a clip already posted when this runs is
+   * wiring builds a new one. So the disposed flag alone tells a continuation
+   * that outlived the control from a live one, and a clip already posted when this runs is
    * dropped whenever its answer arrives.
    */
   dispose(): void {
@@ -213,9 +246,10 @@ export class VoiceInput {
   }
 
   #fail(message: string): void {
-    // Both callers reach here after an await, a permission prompt or a
-    // transcription, either of which can settle after dispose. A disposed
-    // control has nothing to release and no tooltip to draw.
+    // A transcription that fails can settle after dispose. (A refused prompt
+    // cannot reach here that way: #start drops a stale or disposed refusal
+    // before it calls this.) A disposed control has nothing to release and no
+    // tooltip to draw.
     if (this.#disposed) {
       return;
     }

package/src/ui/history/conversation_history.ts

@@ -98,16 +98,21 @@ export interface ConversationHistoryHost {
   readonly releaseClient: () => void;
   /**
    * Whether an interaction is in flight, which the composer owns: from the
-   * moment a send or a retry is taken, or a restore that will resume a run
-   * starts loading, not only once its run has started.
+   * moment a send or a retry is taken, or a restore starts loading, not only
+   * once its run has started.
    */
   readonly running: () => boolean;
   /**
-   * Hold the composer as a send holds it from the moment it is taken: a send
-   * refuses, the built-in Send parks its turn, a Retry and a pick refuse. Let
-   * go of when the run starts, by a Stop, or by {@link RunHold.release}.
+   * Hold the composer as a send holds it from the moment it is taken: the
+   * built-in Send parks its turn, a Retry and a pick refuse. Let go of when the
+   * run starts, by a Stop, or by {@link RunHold.release}.
+   *
+   * A host's send refuses too, unless `restored` is given: then the hold is a
+   * restore's with no run to resume, and a host's send waits for `restored` to
+   * settle and sends after it, with the conversation drawn. `restored` settles
+   * once that restore has ended, or has been stopped, and never rejects.
    */
-  readonly holdRun: () => RunHold;
+  readonly holdRun: (restored: Promise<void> | null) => RunHold;
   /** Stop the in-flight run. */
   readonly cancelRun: () => void;
   /** Drop the in-memory run and transcript, leaving the thread untouched. */
@@ -120,8 +125,9 @@ export interface ConversationHistoryHost {
  * A hold {@link ConversationHistoryHost.holdRun} took.
  *
  * It says nothing about whether the restore that took it was stopped. A
- * restore asks its generation that, because a restore with no run to resume
- * holds nothing and can be stopped all the same -- see
+ * restore asks its generation that, because a host's send that waited on a
+ * restore with no run to resume takes the hold over from it, and a restore
+ * stopped by a newer one finds that one's hold in its place -- see
  * {@link ConversationHistory.rehydrate}.
  */
 interface RunHold {
@@ -132,14 +138,6 @@ interface RunHold {
   readonly release: () => void;
 }
 
-/**
- * What a restore with no run to resume holds: nothing, so it has nothing to
- * let go of. Every restore awaits the store, the built-in one included, and
- * holding all of them would refuse a host's send made as the element connects.
- * Only a restore that is about to start a run has one to collide with.
- */
-const UNHELD: RunHold = Object.freeze({ release: () => {} });
-
 /**
  * The conversation a restore set out to restore: which restore, by its
  * generation, and the store and thread it reads.
@@ -201,6 +199,17 @@ export class ConversationHistory {
    * reaches it. `null` when none is running.
    */
   #continuation: AgUiClient | null = null;
+  /**
+   * Settles what a host's send waits on while the restore now current, one
+   * with no run to resume, loads and replays; `null` when no such restore is
+   * under way. Called when that restore ends, and as soon as it is stopped by
+   * anything that moves the generation, so a send waiting on a conversation
+   * that is no longer on screen hears so at once rather than when an
+   * abandoned load answers.
+   *
+   * Also what tells a pick refused for a load from one refused for a run.
+   */
+  #loading: (() => void) | null = null;
 
   constructor(host: ConversationHistoryHost) {
     this.#host = host;
@@ -256,6 +265,19 @@ export class ConversationHistory {
     // being left into the new one once the store answered, and handed it to the
     // new chat's client as the history its first turn would carry.
     this.#generation += 1;
+    // A host's send waiting on that restore is addressed to the conversation
+    // just cleared. The element's Stop has let go of it already; this wakes it
+    // to find so, rather than leaving it waiting on a load nobody wants -- for
+    // good, if that load never answers. The drop tests in
+    // `ag_ui_chat_send_during_restore.test.ts` hang without it.
+    this.#endWait();
+  }
+
+  /** Settle what waits on the restore now loading, if anything does, and forget it. */
+  #endWait(): void {
+    const end = this.#loading;
+    this.#loading = null;
+    end?.();
   }
 
   /** Delete the active thread if nothing was ever sent in it. */
@@ -401,7 +423,15 @@ export class ConversationHistory {
       // closed the panel before this ran. The typed turn stays where it is --
       // it is what the user wants sent once the run is done -- and the caret
       // goes back to it, where Escape stops the run.
-      this.#refuse(this.#host.strings().continueWhileRunning);
+      //
+      // A restore with no run to resume holds the composer too, and there is
+      // no answer to wait for and nothing Escape can stop, so it says the
+      // conversation is still loading instead. A restore that will resume a
+      // run keeps the running wording: what it is loading is that run.
+      const strings = this.#host.strings();
+      this.#refuse(
+        this.#loading === null ? strings.continueWhileRunning : strings.continueWhileLoading,
+      );
       return;
     }
     const content = this.#host.input.value.trim();
@@ -553,16 +583,30 @@ export class ConversationHistory {
    * exclusion is held by "resumes with the landed page's result, and its card says
    * so" in `ag_ui_chat_reload_mid_run.test.ts`.
    *
-   * **A restore that resumes holds the composer from before the load.** The
-   * resume is a run, and it starts only once the store has answered. With a
-   * remote store that is a real request, and a send, a Retry or a pick in it
-   * was refused by nothing: each built the conversation's client before the
-   * conversation had loaded, so a send went out carrying none of it and its
-   * first save replaced the stored one, and the resume then ran on that same
-   * client as a second run, answering a call the request no longer held. So
-   * the composer is held as a send holds it, and the resume gives way to
-   * nothing: what was typed parks behind the resumed run and goes out after its
-   * answer, and a host's send or Retry is refused as it is behind any run.
+   * **Every restore holds the composer from before the load.** Until the
+   * store answers, the conversation's client can only be seeded from nothing.
+   * With a remote store that is a real request, and a send, a Retry or a pick
+   * in it was refused by nothing: each built the conversation's client before
+   * the conversation had loaded, so a send went out carrying none of it, its
+   * first save replaced the stored one, and the replay then drew the stored
+   * conversation under the new turn. The client stayed cached without it, so
+   * every later turn went out without it too. So the composer is held as a
+   * send holds it: what was typed parks and goes out after the replay, and a
+   * Retry and a pick are refused -- a Retry has nothing on screen to retry, and
+   * after the load it would re-ask the previous visit's last question.
+   *
+   * **A host's send waits for a restore with no run to resume.** It is
+   * usually a prompt fired as the element mounts, which no host could time
+   * against a load nothing announces, and refusing it would lose the turn.
+   * So it waits for this restore to end, taking the hold over as it does,
+   * and then sends with the conversation drawn above it; what the built-in
+   * Send parked goes out after its run. Stopped while it waits, it is dropped,
+   * as a send stopped by its own submit listener is.
+   *
+   * **A restore that resumes refuses a host's send instead.** The resume is a
+   * run, and the restore ends by starting it, so a send that waited would only
+   * reach that run and be refused there. The resume gives way to nothing: what
+   * was typed parks behind the resumed run and goes out after its answer.
    *
    * The other way round, the resume standing down for the send, was rejected.
    * The send that got in first had already gone out without the conversation,
@@ -575,8 +619,8 @@ export class ConversationHistory {
    * page can each come while the store answers, and from host code the restore
    * runs itself: the activity and tool renderers each replayed message draws
    * through, and `navigationResult`. From then on it draws nothing more and
-   * resumes nothing. The hold cannot say so, because a restore with no run to
-   * resume holds nothing. So the restore asks its generation, which clearing
+   * resumes nothing. The hold cannot say so, because a host's send that
+   * waited may hold it by then. So the restore asks its generation, which clearing
    * the conversation moves on as a newer restore does, and asks it after the
    * load, after each replayed message -- as a Retry asks after each one -- and
    * once more before the resume. Stopped by anything but the element leaving
@@ -584,10 +628,6 @@ export class ConversationHistory {
    * for the run it would have resumed -- unless what replaced it is a restore
    * of the same conversation, still current, which answers for that run
    * instead; see `#forgetStopped`.
-   *
-   * What a restore with no run to resume still does not do is refuse a send
-   * made while it loads. That send goes out without the stored conversation,
-   * and its save replaces it.
    */
   async rehydrate(): Promise<void> {
     // Claimed before awaiting, and checked by `#restoring` wherever the restore
@@ -618,7 +658,22 @@ export class ConversationHistory {
     // `#claimedByCurrent`.
     this.#claim = { generation, store, threadId };
     const checkpoint = store.loadCheckpoint(threadId);
-    const hold = checkpoint === null ? UNHELD : this.#host.holdRun();
+    // What a host's send waits on, for a restore with no run to resume, and
+    // the hold either kind takes. Taken before the load for the same reason
+    // the checkpoint is read before it: the load is the window.
+    //
+    // No earlier wait is left to settle here: every restore but the first
+    // follows a clear of the conversation on screen -- a reload, a thread
+    // switch, a handover, the element coming back -- and `forgetRestored`
+    // settled and forgot it then. So a restore that will resume finds none.
+    const restored =
+      checkpoint === null
+        ? new Promise<void>((resolve) => {
+            this.#loading = resolve;
+          })
+        : null;
+    const waiting = this.#loading;
+    const hold = this.#host.holdRun(restored);
     try {
       // Held while the store answers. A remote store answers after first paint,
       // and a conversation it is still fetching is more likely to have messages
@@ -684,7 +739,21 @@ export class ConversationHistory {
       // the store rejected the load, or the store or the host threw on the way
       // to the resume -- and then this is what sends a turn the composer parked
       // meanwhile, since no run is going to settle and send it.
+      //
+      // A host's send that waited on this restore has taken the hold over, so
+      // the release does nothing and the send goes first; what was parked goes
+      // out after its run. Woken only after the replay, here, rather than when
+      // the store answers, or its turn would be drawn above the conversation.
+      // Only this restore's wait: one that was stopped was woken by what
+      // stopped it, and the wait now current, if any, is a newer restore's.
+      // Waking that one here sent its turn before its conversation was drawn,
+      // which "drops the waiting send on a drawer switch, and a send then
+      // carries the picked thread" in `ag_ui_chat_send_during_restore.test.ts`
+      // holds.
       hold.release();
+      if (this.#loading === waiting) {
+        this.#endWait();
+      }
     }
   }
 
@@ -847,7 +916,20 @@ export class ConversationHistory {
         // wrap words.
         const restoredBubble = this.#host.appendMessage(MESSAGE_ROLE.ASSISTANT, text);
         restoredBubble.classList.add("message--restored");
-        this.#host.actions.attach(restoredBubble);
+        // The stored id, which is the streamed one wherever the store kept
+        // it. A Retry re-renders the turns it keeps through here too, so a
+        // kept answer stays the message it was. No run id: a stored message
+        // does not carry one.
+        //
+        // Narrowed rather than trusted, like the fields below: a host store or
+        // a `data-threads-url` server can return a message with no id, and a
+        // rating that names nothing is a pair of buttons that lead nowhere.
+        // Such an answer keeps its copy and loses only the rating.
+        const id: unknown = message.id;
+        this.#host.actions.attach(
+          restoredBubble,
+          typeof id === "string" && id !== "" ? { messageId: id } : { rateable: false },
+        );
       }
       // Narrowed rather than trusted, for the same reason `messageAttachments`
       // narrows the neighbouring field: anything that throws in this loop aborts

package/src/ui/transcript/answer_actions.ts

@@ -1,4 +1,5 @@
 import { FEEDBACK_EVENT, ICON_RETRY, MESSAGE_ACTIONS } from "../../constants.js";
+import type { AgUiMessageIds } from "../../core/agui_client.js";
 import type { FeedbackDetail } from "../../core/events/feedback_detail.js";
 import { commaTokens } from "../../core/utils.js";
 import { copyPayload } from "../excerpts/copy_payload.js";
@@ -13,6 +14,13 @@ export interface AnswerActionsHost {
   readonly strings: () => UiStrings;
   /** Retry the last turn, as the element's public `retryLastTurn` does. */
   readonly retry: () => void;
+  /** The element's current conversation thread. */
+  readonly threadId: () => string;
+}
+
+/** A finished bubble that is not an answer, and so carries no rating. */
+interface Unrateable {
+  readonly rateable: false;
 }
 
 /**
@@ -55,15 +63,26 @@ export class AnswerActions {
    * something survives to go in it: an empty row still takes its margin, still
    * answers to the `message-actions` part, and still reads to a screen reader
    * as a group of actions with none in it.
+   *
+   * `message` names the answer, which is what a rating is filed under; a bubble
+   * that is not an answer says so instead, and has no id to give.
    */
-  attach(bubble: HTMLDivElement, options: { rateable?: boolean } = {}): void {
+  attach(bubble: HTMLDivElement, message: AgUiMessageIds | Unrateable): void {
     const enabled = this.#enabled();
     const copyable = enabled.has(MESSAGE_ACTIONS.COPY);
     // A failed run is copyable -- error text is what people paste into a bug
     // report -- but not rateable: a rating is a statement about an *answer*,
     // and mixing "the connection dropped" into that signal makes the host's
     // feedback data say less than it did before.
-    const rateable = options.rateable !== false && enabled.has(MESSAGE_ACTIONS.FEEDBACK);
+    const answer = "messageId" in message ? message : null;
+    const rateable = answer !== null && enabled.has(MESSAGE_ACTIONS.FEEDBACK);
+    // Read now rather than at click time. Every path that moves the element to
+    // another thread -- New chat, a switch, a change of principal -- clears
+    // the transcript, so today the two agree; the bubble can only be rated
+    // while the thread it was drawn in is current. Were a later path to change
+    // the thread and keep the bubbles, the thread the message was drawn from is
+    // still the one it is stored in, and that is what a host files it under.
+    const threadId = this.#host.threadId();
     if (copyable || rateable) {
       attachMessageActions(bubble, {
         strings: this.#host.strings(),
@@ -83,7 +102,16 @@ export class AnswerActions {
               onFeedback: (rating: "up" | "down") => {
                 this.#host.element.dispatchEvent(
                   new CustomEvent<FeedbackDetail>(FEEDBACK_EVENT, {
-                    detail: { content: copyPayload(bubble).text, rating },
+                    detail: {
+                      content: copyPayload(bubble).text,
+                      rating,
+                      messageId: answer.messageId,
+                      threadId,
+                      // Omitted rather than undefined: a restored message has
+                      // no run, and a key holding nothing reads as one that
+                      // was looked up and came back empty.
+                      ...(answer.runId === undefined ? {} : { runId: answer.runId }),
+                    },
                     bubbles: true,
                     composed: true,
                   }),

package/src/ui/ui_strings.ts

@@ -120,6 +120,11 @@ export interface UiStrings {
   continueNeedsTurn: string;
   /** Composer hint when a run continuation was picked while a run is in flight. */
   continueWhileRunning: string;
+  /**
+   * Composer hint when a run continuation was picked while the stored
+   * conversation is still loading.
+   */
+  continueWhileLoading: string;
 
   // ── Composer ────────────────────────────────────────────────────────────────
   /** `aria-label` of the message textarea. */
@@ -388,6 +393,7 @@ export const DEFAULT_UI_STRINGS: UiStrings = {
   notConnected: "This chat isn’t connected to an agent, so the message wasn’t sent.",
   continueNeedsTurn: "Type the next turn in the composer first, then pick a run to continue.",
   continueWhileRunning: "Wait for the current answer or stop it, then pick a run to continue.",
+  continueWhileLoading: "Wait for the conversation to finish loading, then pick a run to continue.",
   skillNeeds: "“{title}” needs {fields} — fill it in below, then send.",
 
   message: "Message",

package/src/version.ts

@@ -1 +1 @@
-export const VERSION: string = "0.42.0";
+export const VERSION: string = "0.44.0";