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

package/dist/core/ag_ui_chat.d.ts

@@ -518,9 +518,12 @@ export declare class AgUiChat extends HTMLElement {
      * History is truncated to the most recent user message inclusive and the run
      * repeats, so the agent answers what it was asked rather than being told its
      * last answer was wrong. Returns `false` when there is nothing to retry, or
-     * while anything that refuses a send is in flight: a run, a send or another
+     * while anything that holds a send is in flight: a run, a send or another
      * retry whose run has not started yet, a checkpoint continuation, or a
-     * reload's restore that will resume a run. Also `false` when host code it
+     * restore of the stored conversation that is still loading. It does not wait
+     * for a restore as a send does: nothing is on screen to retry yet, and after
+     * the load it would re-ask the previous visit's last question. Also `false`
+     * when host code it
      * runs before its run starts -- the store's save, or an activity or tool
      * renderer the replay draws through -- has stopped it by starting a new chat
      * or changing `user-key`. A tool or context provider that stops it does so
@@ -560,16 +563,41 @@ export declare class AgUiChat extends HTMLElement {
      * `attachments` are durable {@link AttachmentRef}s — what {@link attachFile}
      * resolves to and what {@link ATTACHMENT_EVENT} reports.
      *
-     * No-ops on an empty message, and while a run or a picked checkpoint's
-     * continuation is in flight, since a second concurrent run would orphan the
-     * first. A send is in flight from the moment it is taken rather than from
-     * its run's start, so this no-ops from a {@link SUBMIT_EVENT} listener and
-     * for a second call in the same task too.
+     * Resolves `true` once the turn has been handed to the client for its run,
+     * which is when the interaction settles, frontend-tool rounds included; a
+     * run a tool or context provider then stops still counts, as it does for
+     * {@link retryLastTurn}. Resolves `false` when nothing was sent.
+     *
+     * Nothing is sent for an empty message, nor while a run or a picked
+     * checkpoint's continuation is in flight, since a second concurrent run
+     * would orphan the first. A send is in flight from the moment it is taken
+     * rather than from its run's start, so nothing is sent from a
+     * {@link SUBMIT_EVENT} listener or for a second call in the same task
+     * either. Nor with no `endpoint`, which says so in the transcript. Nor
+     * behind a reload's restore that will resume a run a navigating tool
+     * interrupted, since that restore ends by starting the run.
+     *
+     * **While the element restores a stored conversation with no run to resume
+     * -- on connect, {@link reload}, a thread picked from the drawer, a change
+     * from one `user-key` to another -- it waits, then sends.** The turn has to follow the
+     * conversation it is part of: sent at once, it went out without it, the
+     * conversation was then drawn under it, and its save replaced the stored
+     * one. So the bubble, the {@link SUBMIT_EVENT} and the request all come after
+     * the replay, by the length of the store's load. A New chat, a thread
+     * switch, a change from one `user-key` to another, a reload or the element
+     * leaving the page while it waits drops it, resolving `false`: the
+     * conversation it was addressed to is no longer on screen. Leaving the page
+     * resolves it only once the load answers or the element is back, since
+     * that is when the restore learns it was stopped. A first `user-key` on an
+     * anonymous conversation adopts it rather than replacing it, and stops
+     * nothing. A second call while one waits is
+     * refused, as a second call in the same task is.
+     *
      * Unlike the built-in Send it does not queue: it returns, and the caller
      * keeps what it tried to send. Nor does it consult the tray -- what you pass
      * is what is sent.
      */
-    sendMessage(content: string, attachments?: readonly AttachmentRef[]): Promise<void>;
+    sendMessage(content: string, attachments?: readonly AttachmentRef[]): Promise<boolean>;
     /**
      * Queue a file for upload into the attachment tray, exactly as the file
      * picker and drag-and-drop do — validation, progress chip, and all.

package/dist/core/ag_ui_chat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ag_ui_chat.d.ts","sourceRoot":"","sources":["../../src/core/ag_ui_chat.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ag_ui_chat.d.ts","sourceRoot":"","sources":["../../src/core/ag_ui_chat.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -987,6 +987,7 @@ var DEFAULT_UI_STRINGS = {
   notConnected: "This chat isn\u2019t connected to an agent, so the message wasn\u2019t 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: "\u201C{title}\u201D needs {fields} \u2014 fill it in below, then send.",
   message: "Message",
   inputPlaceholder: "Ask anything\u2026",
@@ -1736,13 +1737,17 @@ var ToolDispatch = class {
    * 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) {
     if (skillNameFrom(call) !== null) {
       return null;
     }
     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);
@@ -1796,7 +1801,9 @@ var ToolDispatch = class {
       if (!accepted) {
         const message = this.#host.strings().declinedAction;
         card.settle(TOOL_CALL_STATUS.DECLINED, message);
-        this.#host.transcript.showPending();
+        if (this.#host.conversation() === conversation) {
+          this.#host.transcript.showPending();
+        }
         return { content: message, outcome: TOOL_OUTCOME.DENIED };
       }
       if (signal.aborted) {
@@ -1821,7 +1828,9 @@ var ToolDispatch = class {
       }
       const content = JSON.stringify(result ?? null);
       card.settle(TOOL_CALL_STATUS.DONE, content);
-      this.#host.transcript.showPending();
+      if (this.#host.conversation() === conversation) {
+        this.#host.transcript.showPending();
+      }
       return { content };
     } catch (error) {
       if (this.#host.tenure() !== tenure) {
@@ -1832,7 +1841,9 @@ var ToolDispatch = class {
       }
       const message = error instanceof Error ? error.message : String(error);
       card.settle(TOOL_CALL_STATUS.ERROR, message);
-      this.#host.transcript.showPending();
+      if (this.#host.conversation() === conversation) {
+        this.#host.transcript.showPending();
+      }
       return { content: `Error: ${message}`, error: message, outcome: TOOL_OUTCOME.FAILED };
     }
   }
@@ -3073,6 +3084,8 @@ var VoiceInput = class {
   #capTimer = null;
   #hitCap = false;
   #disposed = false;
+  /** Identifies the newest start; an older one that settles is stale. */
+  #startToken = {};
   constructor(options) {
     this.#transcribe = options.transcribe;
     this.#onText = options.onText;
@@ -3102,31 +3115,42 @@ var VoiceInput = class {
     await this.#start();
   }
   async #start() {
+    const token = {};
+    this.#startToken = token;
     let stream;
     try {
       stream = await navigator.mediaDevices.getUserMedia({ audio: true });
     } catch {
-      this.#fail(this.#strings.transcriptionFailed);
-      return;
+      stream = null;
     }
-    if (this.#disposed) {
-      for (const track of stream.getTracks()) {
+    if (token !== this.#startToken || this.#disposed) {
+      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;
+    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 {
+      this.#fail(this.#strings.transcriptionFailed);
+      return;
+    }
     this.#capTimer = setTimeout(() => {
       this.#hitCap = true;
       this.#stop();
@@ -3152,8 +3176,8 @@ var VoiceInput = class {
    * 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() {
@@ -4166,8 +4190,6 @@ function toolStatusFromOutcome(outcome) {
 }
 
 // src/ui/history/conversation_history.ts
-var UNHELD = Object.freeze({ release: () => {
-} });
 var ConversationHistory = class {
   #host;
   /** The active thread's id. Empty until the element connects. */
@@ -4204,6 +4226,17 @@ var ConversationHistory = class {
    * reaches it. `null` when none is running.
    */
   #continuation = 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 = null;
   constructor(host) {
     this.#host = host;
   }
@@ -4245,6 +4278,13 @@ var ConversationHistory = class {
     this.#restored = [];
     this.#cleared += 1;
     this.#generation += 1;
+    this.#endWait();
+  }
+  /** Settle what waits on the restore now loading, if anything does, and forget it. */
+  #endWait() {
+    const end = this.#loading;
+    this.#loading = null;
+    end?.();
   }
   /** Delete the active thread if nothing was ever sent in it. */
   reapUnsent() {
@@ -4349,7 +4389,10 @@ var ConversationHistory = class {
       return;
     }
     if (this.#host.running() || this.#continuation !== null) {
-      this.#refuse(this.#host.strings().continueWhileRunning);
+      const strings = this.#host.strings();
+      this.#refuse(
+        this.#loading === null ? strings.continueWhileRunning : strings.continueWhileLoading
+      );
       return;
     }
     const content = this.#host.input.value.trim();
@@ -4435,16 +4478,30 @@ var ConversationHistory = class {
    * 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,
@@ -4457,8 +4514,8 @@ var ConversationHistory = class {
    * 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
@@ -4466,10 +4523,6 @@ var ConversationHistory = class {
    * 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() {
     this.#generation += 1;
@@ -4478,7 +4531,11 @@ var ConversationHistory = class {
     const store = this.#host.conversationStore();
     this.#claim = { generation, store, threadId };
     const checkpoint = store.loadCheckpoint(threadId);
-    const hold = checkpoint === null ? UNHELD : this.#host.holdRun();
+    const restored = checkpoint === null ? new Promise((resolve) => {
+      this.#loading = resolve;
+    }) : null;
+    const waiting = this.#loading;
+    const hold = this.#host.holdRun(restored);
     try {
       this.#host.element.setAttribute("data-restoring", "");
       let messages;
@@ -4495,7 +4552,7 @@ var ConversationHistory = class {
       }
       if (messages !== null) {
         const unfinished = this.#host.strings().callNotFinished;
-        const restored = answerUnansweredCalls(
+        const restored2 = answerUnansweredCalls(
           messages,
           // The shape the store holds for a call the client answered the same
           // way: its tool message, with the outcome in its metadata.
@@ -4508,8 +4565,8 @@ var ConversationHistory = class {
           }),
           new Set(checkpoint === null ? [] : [checkpoint.toolCallId])
         );
-        this.#restored = restored;
-        for (const message of restored) {
+        this.#restored = restored2;
+        for (const message of restored2) {
           this.replay(message);
           if (!this.#restoring(generation)) {
             this.#forgetStopped(store, threadId, checkpoint);
@@ -4524,6 +4581,9 @@ var ConversationHistory = class {
       this.#noticeIfRunUnfinished(messages);
     } finally {
       hold.release();
+      if (this.#loading === waiting) {
+        this.#endWait();
+      }
     }
   }
   /**
@@ -17124,6 +17184,26 @@ var AgUiChat = class extends HTMLElement {
    * conversation the handover purged.
    */
   #tenure = {};
+  /**
+   * The conversation on screen: replaced every time the transcript is cleared
+   * for another one -- New chat, a drawer switch, deleting the active thread,
+   * `reload()`, re-insertion and a handover all pass through
+   * {@link #resetConversation} -- and captured by each frontend tool call as it
+   * is dispatched, so the call can tell whether the conversation it was drawn
+   * in is still the one showing.
+   *
+   * A call outlives the reset that stops its run. A handler cannot be aborted,
+   * and a card open at the time is declined, so the call resumes once the new
+   * conversation is showing; drawing the run's pending indicator then put it
+   * in a conversation with no run to take it down.
+   *
+   * Not {@link #tenure}, which only a handover replaces. A reset is not a
+   * change of principal: the call still belongs to someone this element
+   * serves, so it still settles its card, clears its checkpoint and returns
+   * its result, and only the drawing is skipped. The tenure checks end the
+   * call before any of that.
+   */
+  #conversation = {};
   /**
    * The remote store `data-threads-url` wrapped around the conversation store,
    * and the store inside it, so connecting again can wrap that store rather
@@ -17154,9 +17234,9 @@ var AgUiChat = class extends HTMLElement {
    * requests, and the listener's turn drawn between the user's turn and its
    * answer. It is the gap a picked checkpoint closes by counting from the pick,
    * closed the same way for a send. A retry asks for its run the same way, so
-   * it takes the same hold, and so does a restore that will resume a run, from
-   * before it asks the store for the conversation, through the history host's
-   * `holdRun`.
+   * it takes the same hold, and so does every restore, from before it asks the
+   * store for the conversation, through the history host's `holdRun`: until
+   * the store answers, the client can only be built from nothing.
    *
    * Let go of once the run starts, because `running` holds from then until the
    * run settles, and a send held past that would refuse a host's follow-up from
@@ -17166,9 +17246,18 @@ var AgUiChat = class extends HTMLElement {
    * An object rather than a flag, so a send or a retry ending releases only
    * what it took. By the time either ends, the turn queued behind it has
    * usually taken the field for itself, and a Stop lets go of it for the next
-   * send to take; the earlier one ending must release neither.
+   * send to take; the earlier one ending must release neither. It is also how
+   * {@link sendMessage} tells the one hold it waits on from all the others it
+   * refuses behind: see {@link #restoreHold}.
    */
   #sending = null;
+  /**
+   * The hold the latest restore with no run to resume took, and what settles
+   * once that restore has ended or been stopped; `null` when the latest
+   * restore will resume a run. Only meaningful while `#sending` is that hold:
+   * then a host's {@link sendMessage} waits for it rather than refusing.
+   */
+  #restoreHold = null;
   /** The decision a run is suspended on, which a Stop abandons. */
   #decision = new PendingDecision();
   /**
@@ -17261,7 +17350,9 @@ var AgUiChat = class extends HTMLElement {
       threadId: () => this.#history.threadId,
       // Read live and compared, the way each client compares the one it was
       // built with: see #tenure.
-      tenure: () => this.#tenure
+      tenure: () => this.#tenure,
+      // The same, for the conversation on screen: see #conversation.
+      conversation: () => this.#conversation
     });
     this.#runHandlers = new RunHandlers({
       element: this,
@@ -17409,25 +17500,29 @@ var AgUiChat = class extends HTMLElement {
       // A held send or retry is as much in flight to a pick as a run is: it has
       // asked this element's client for a run that has not started, and a
       // continuation started beside it was a second run in one conversation.
-      // So is a restore that will resume a run, which holds through the same
-      // field from before the store answers.
+      // So is a restore, which holds through the same field from before the
+      // store answers.
       running: () => this.#running || this.#sending !== null,
-      // The hold a send takes, taken for a restore that will resume a run, so
-      // what refuses a send held short of its run refuses one made while the
-      // store is still answering: `sendMessage` returns, Send parks the turn,
-      // a Retry and a pick refuse. The same field rather than a flag beside it,
-      // because what lets go of a send's hold is right for this one too. The
-      // resumed run starting lets go, in `#setRunning`, so there is no gap
-      // after the resume is asked for, and a Stop does, in `#cancelRun`. A flag
-      // the restore cleared itself would still be set when the resumed run
-      // settles and sends the parked turn, so that send would be refused after
-      // the turn had left the queue, and lost.
+      // The hold a send takes, taken for every restore, so what refuses a send
+      // held short of its run holds one made while the store is still
+      // answering: Send parks the turn, a Retry and a pick refuse, and
+      // `sendMessage` refuses behind a restore that will resume a run and waits
+      // for one that will not -- `restored` is what it waits on, given only for
+      // that kind. The same field rather than a flag beside it, because what
+      // lets go of a send's hold is right for this one too. The resumed run
+      // starting lets go, in `#setRunning`, so there is no gap after the resume
+      // is asked for, and a Stop does, in `#cancelRun`. A flag the restore
+      // cleared itself would still be set when the resumed run settles and
+      // sends the parked turn, so that send would be refused after the turn had
+      // left the queue, and lost.
       //
-      // Whether the restore was stopped is not read off this hold, because one
-      // with nothing to resume takes none; the restore asks its own generation.
-      holdRun: () => {
+      // Whether the restore was stopped is not read off this hold, because a
+      // host's send that waited takes it over; the restore asks its own
+      // generation.
+      holdRun: (restored) => {
         const hold = {};
         this.#sending = hold;
+        this.#restoreHold = restored === null ? null : { hold, restored };
         return {
           release: () => {
             if (this.#sending === hold) {
@@ -18247,6 +18342,7 @@ var AgUiChat = class extends HTMLElement {
   #resetConversation() {
     this.#client = null;
     this.#runHandlers.detach();
+    this.#conversation = {};
     this.#clearTranscript();
     this.#history.forgetRestored();
   }
@@ -18275,9 +18371,12 @@ var AgUiChat = class extends HTMLElement {
    * History is truncated to the most recent user message inclusive and the run
    * repeats, so the agent answers what it was asked rather than being told its
    * last answer was wrong. Returns `false` when there is nothing to retry, or
-   * while anything that refuses a send is in flight: a run, a send or another
+   * while anything that holds a send is in flight: a run, a send or another
    * retry whose run has not started yet, a checkpoint continuation, or a
-   * reload's restore that will resume a run. Also `false` when host code it
+   * restore of the stored conversation that is still loading. It does not wait
+   * for a restore as a send does: nothing is on screen to retry yet, and after
+   * the load it would re-ask the previous visit's last question. Also `false`
+   * when host code it
    * runs before its run starts -- the store's save, or an activity or tool
    * renderer the replay draws through -- has stopped it by starting a new chat
    * or changing `user-key`. A tool or context provider that stops it does so
@@ -18798,18 +18897,57 @@ var AgUiChat = class extends HTMLElement {
    * `attachments` are durable {@link AttachmentRef}s — what {@link attachFile}
    * resolves to and what {@link ATTACHMENT_EVENT} reports.
    *
-   * No-ops on an empty message, and while a run or a picked checkpoint's
-   * continuation is in flight, since a second concurrent run would orphan the
-   * first. A send is in flight from the moment it is taken rather than from
-   * its run's start, so this no-ops from a {@link SUBMIT_EVENT} listener and
-   * for a second call in the same task too.
+   * Resolves `true` once the turn has been handed to the client for its run,
+   * which is when the interaction settles, frontend-tool rounds included; a
+   * run a tool or context provider then stops still counts, as it does for
+   * {@link retryLastTurn}. Resolves `false` when nothing was sent.
+   *
+   * Nothing is sent for an empty message, nor while a run or a picked
+   * checkpoint's continuation is in flight, since a second concurrent run
+   * would orphan the first. A send is in flight from the moment it is taken
+   * rather than from its run's start, so nothing is sent from a
+   * {@link SUBMIT_EVENT} listener or for a second call in the same task
+   * either. Nor with no `endpoint`, which says so in the transcript. Nor
+   * behind a reload's restore that will resume a run a navigating tool
+   * interrupted, since that restore ends by starting the run.
+   *
+   * **While the element restores a stored conversation with no run to resume
+   * -- on connect, {@link reload}, a thread picked from the drawer, a change
+   * from one `user-key` to another -- it waits, then sends.** The turn has to follow the
+   * conversation it is part of: sent at once, it went out without it, the
+   * conversation was then drawn under it, and its save replaced the stored
+   * one. So the bubble, the {@link SUBMIT_EVENT} and the request all come after
+   * the replay, by the length of the store's load. A New chat, a thread
+   * switch, a change from one `user-key` to another, a reload or the element
+   * leaving the page while it waits drops it, resolving `false`: the
+   * conversation it was addressed to is no longer on screen. Leaving the page
+   * resolves it only once the load answers or the element is back, since
+   * that is when the restore learns it was stopped. A first `user-key` on an
+   * anonymous conversation adopts it rather than replacing it, and stops
+   * nothing. A second call while one waits is
+   * refused, as a second call in the same task is.
+   *
    * Unlike the built-in Send it does not queue: it returns, and the caller
    * keeps what it tried to send. Nor does it consult the tray -- what you pass
    * is what is sent.
    */
   async sendMessage(content, attachments = []) {
-    if (this.#running || this.#sending !== null || this.#history.continuation !== null || content === "" && attachments.length === 0) {
-      return;
+    if (content === "" && attachments.length === 0) {
+      return false;
+    }
+    const restore = this.#restoreHold;
+    if (restore !== null && this.#sending === restore.hold) {
+      const waiting = {};
+      this.#sending = waiting;
+      await restore.restored;
+      if (this.#sending !== waiting) {
+        return false;
+      }
+      this.#sending = null;
+      return this.sendMessage(content, attachments);
+    }
+    if (this.#running || this.#sending !== null || this.#history.continuation !== null) {
+      return false;
     }
     const send = {};
     this.#sending = send;
@@ -18819,9 +18957,11 @@ var AgUiChat = class extends HTMLElement {
       }
       this.#announceTurn(content, attachments);
       if (this.#sending !== send) {
-        return;
+        return false;
       }
+      const connected = this.endpoint !== "";
       await this.#client_send(content, attachments);
+      return connected;
     } finally {
       if (this.#sending === send) {
         this.#sending = null;
@@ -19137,7 +19277,7 @@ function setControlValue(el2, value) {
 }
 
 // src/version.ts
-var VERSION = "0.42.0";
+var VERSION = "0.43.0";
 export {
   ATTACHMENT_EVENT,
   AgUiChat,