@artooi/ag-ui-web-component 0.38.0 → 0.40.0

package/CHANGELOG.md

@@ -7,6 +7,518 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.40.0] — 2026-09-17
+
+### Changed
+
+- **An `askUserRenderer` that throws now hands the question to the built-in
+  question card.** A throw, or a rejected promise, used to escape the `ask_user`
+  tool: its card settled as an error quoting the host's message, that message
+  went on to the agent as the tool result although it was never written for the
+  model, and the pending wait was never closed, so the next Stop aborted the
+  signal of a question that had already ended.
+
+  The renderer decides how the question looks, not whether it is asked -- the
+  same rule `approvalRenderer` follows -- so it now falls back to the built-in
+  card, with a `console.warn` naming the tool call, and the run carries on as if
+  no renderer had been set. The exception is a rejection after the signal has
+  fired, which is how a renderer is expected to honour Stop: that wait resolves
+  with an empty answer, as the built-in card does on the same signal, with no
+  card drawn and no warning.
+
+- **On a small viewport the composer stays at the foot of the panel, with the
+  greeting over the space above it.** Until a conversation had something in it,
+  `page` -- and an `embedded` panel that opts into a greeting -- centred the
+  composer between the greeting and the foot at every width. Centring is a shape
+  for a screen with room to spare: on a phone the on-screen keyboard takes the
+  room, and the composer was left halfway up what remained with an empty band
+  under it, which is the part of the screen a thumb is already on. At 600px wide
+  and below it now stays at the foot, directly over the keyboard, and the
+  greeting takes the space above it. The prompts in `data-starters`, or
+  whatever a host slots as `empty`, go to the foot with it and sit against the
+  composer: a prompt chip is a way into the conversation, and next to the field
+  it starts it reads as one. The greeting takes the middle of what they leave,
+  and the middle of the transcript where there are none.
+  `data-small-viewport="off"` keeps the centred shape at every width, as it
+  keeps the rest of the desktop layout.
+
+### Fixed
+
+- **A tool card called with no arguments stops drawing an empty ARGUMENTS
+  heading.** The card hides the region rather than framing an empty object, but
+  the region declares its own `display`, which beats the user-agent rule for
+  the hidden attribute, so 42px of card was drawn holding a heading over
+  nothing -- on every call an agent made with no arguments, in the display mode
+  that shows arguments by default, and on a pending card's result region too.
+
+- **A checkpoint continuation is let go of when its first save fails.** The
+  save runs through `conversationStore` synchronously inside the send, and a
+  store is the host's to replace: the built-in one swallows a write the browser
+  refused, a server-backed one need not. A throw there left the element holding
+  a client that would never run, so every later Resume or Fork was refused for
+  it with no way to clear it -- the composer's button is Send until a run
+  reports a start, so Stop was never offered -- and `sharedState` went on
+  writing into the dead client, which the next run then sent stale. The failure
+  is now reported with a `console.warn` and the panel takes another pick.
+
+- **A turn typed between picking a checkpoint and its run starting is parked
+  rather than raced.** The composer learns a run is going from its first event,
+  a request round trip behind the pick, so its button was still Send: a turn
+  sent in that window started a second run against the conversation the
+  continuation had already frozen to save against, and whichever saved last
+  dropped the other's turn from the store while both answers streamed into one
+  transcript. The composer now queues it, as it does during a run, and sends it
+  when the continuation settles. `sendMessage` no-ops in the same window, as it
+  already did during a run.
+
+- **An empty row of skill chips stops taking space above the composer.** The
+  row is hidden whenever the host offers no skills, which is most elements most
+  of the time, but it declares its own `display`, and an author display beats
+  the user-agent rule for the hidden attribute. So it kept its 20px of padding
+  under every placement: a band of panel between the transcript and the
+  composer, reading as the gap under whatever the transcript ended with. The
+  palette and the queued row beside it were fixed for this reason already, and
+  a tool card's payload regions turned out to be a fourth case, below.
+
+- **A checkpoint continuation waits for the run in flight.** Picking Resume or
+  Fork while an answer was streaming started a second run beside it, and an
+  earlier continuation kept streaming where Stop no longer reached it. The pick
+  is now refused with a composer hint, as Retry is; the run in flight is left
+  alone and the typed turn stays in the composer. `continueWhileRunning` is new
+  in the string table.
+
+- **A continued exchange is kept with its conversation.** It was never saved,
+  so a reload lost it, and the next message went out without it and with the
+  shared state from before the continuation. Each save now writes the
+  conversation with the exchange after it, through the existing `saveMessages`
+  -- `ClientConversationStore` is unchanged -- and the next message carries
+  both. After continuing from an earlier run, what is saved is what the
+  transcript shows, not only the turns up to that run. `sharedState` reads a
+  running continuation, and `AgUiClient.annotatedMessages` is new: the history
+  in the form a save writes it, with how each tool call ended.
+
+- **A full-screen panel stays on the visible screen when a keyboard opens under
+  the field.** To show the composer, iOS Safari pans the visible area down the
+  page, and a panel anchored at the top of the screen stayed where it was: sized
+  to the visible height, it showed only its lower part, with the header and the
+  greeting off the top and an empty band above the keyboard. That covered
+  `page`, `full`, `side` and `sidebar`, and at phone width the corner placements
+  too, because they become the whole screen there, and their keyboard lift never
+  moved them: a box with its top, height and bottom all set ignores the bottom.
+  The element now also publishes how far the visible area is panned, as
+  `--ag-ui-visual-viewport-inset-top`, and every panel anchored at the top moves
+  down by as much of it as goes past the host's `--ag-ui-viewport-inset-top`.
+  `--ag-ui-keyboard-inset-top` outranks that, as `--ag-ui-keyboard-inset` does
+  at the bottom; `0px` opts out.
+
+  The same panel with a bar reserved at the top also ran past the bottom of the
+  visible area by the bar's height whenever a keyboard was up, pan or no pan:
+  the measured height replaced the host's box rather than being cut from it, so
+  the bar stayed in the position and left the height. The height is now the
+  host's box cut to the visible area.
+
+  At the deepest pan, the one that shows a composer docked at the foot of the
+  screen, the panel still went back to the top of the page at full height. The
+  element read the page's height from `innerHeight`, which iOS Safari reports
+  less the pan for as long as the pan lasts; at that depth it equals the visible
+  height, so the element took the two viewports to agree and withdrew its
+  measurements. The band below the visible area came out as nothing at any pan
+  too, leaving a bottom-anchored panel behind the keyboard. The page's height
+  is now read from the root element's `clientHeight`, which an iPhone reported
+  unchanged through the pan.
+
+- **A full-screen panel no longer runs under Safari's bars with no keyboard
+  up.** Where nothing has been measured, the panel's height fell back to
+  `100vh`, which iOS Safari resolves to the screen with its bars collapsed, so
+  on a page that never scrolls them away the foot of the panel sat under the
+  address bar: 40px on the iPhone measured, with a docked composer in it. The
+  fallback is now `100dvh`, the screen with the bars as they are.
+
+- **An element removed from the document and inserted again is one element.**
+  Every insertion built the chrome again into the same shadow root, so a
+  re-inserted `<ag-ui-chat>` had two headers, two composers, a second set of
+  resize grips, and the conversation drawn a second time beneath the first. The
+  listeners on its long-lived parts were added again too:
+  - one click on Stop cancelled the run three times;
+  - one press of the built-in theme toggle flipped it twice, so it appeared to
+    do nothing;
+  - a dropped or pasted file was added twice;
+  - one arrow press moved the launcher two steps.
+
+  With `data-threads-url`, a second remote store wrapped the first, so every
+  rename and delete reached the server twice. Frameworks do this without being
+  asked (a portal, a keyed list, a move between containers), and removing and
+  re-inserting is the documented way to apply a connect-time attribute written
+  late.
+
+  Connecting now builds the chrome in place of the last connection's, and ties
+  every listener on a long-lived part to the connection, so leaving the document
+  removes them. The upload tray and the mic are mounted afresh. The thread store
+  is wrapped once, and a `data-threads-url` removed while detached takes its
+  remote store away. The transcript is rebuilt from history, as `reload()`
+  rebuilds it. The composer's recall history is kept. Re-inserting still applies
+  the attributes as they stand when the element comes back. A host that called
+  `offerQuoteInPage()` calls it again after re-inserting, as before.
+
+## [0.39.0] — 2026-09-17
+
+### Changed
+
+- **An empty conversation under `placement="page"` now greets the user, with the
+  composer centred beneath the greeting.** A full-page chat used to open on a
+  blank transcript with the composer at the foot of the screen, which is the
+  layout of a conversation in progress rather than one waiting to start. The
+  page now shows *Hello, {name}* over a centred composer until the conversation
+  has something in it, then lays out as before.
+
+  This changes what any existing `page` host shows on upgrade, which is why it
+  is listed here. **`data-greeting="off"` restores the previous layout.** No
+  other placement changes by default; `embedded` opts in with `data-greeting`,
+  and the corner placements and the sidebar never show it, because a panel
+  opened from a launcher is already mid-task.
+
+  The surface it adds:
+
+  - `user-name` / `userName`, a live attribute for the name. Presentation only:
+    unlike `user-key` it scopes nothing and is never sent. Absent or blank gives
+    *Hello there*.
+  - `greeting` and `greetingNoName` in the string table.
+  - A `greeting` slot and part, so a host can replace or restyle the text; the
+    `empty` slot and `data-starters` still render beneath it.
+  - `--ag-ui-greeting-font` and `--ag-ui-greeting-size`.
+  - `data-empty`, stamped on the element while the conversation is empty, and
+    documented as a styling hook for the chrome around a full-page chat.
+
+  The centring is two equal flexible halves either side of the composer's rows,
+  so the rows stay centred as a draft or an attachment tray grows them, and
+  nothing in the DOM moves: focus, the caret and IME composition are untouched.
+  Every condition in its selectors is held by a Chromium test that fails with
+  that condition removed, since a stylesheet has no coverage to fall back on.
+
+  **Only a send moves the composer, and it slides.** It moves on send rather
+  than on the first keystroke, because a field that moves under the caret moves
+  during IME composition too, and because taking the greeting away before
+  anything is committed would mean bringing it back when the draft is deleted.
+  The slide uses `--ag-ui-motion`, so reduced motion jumps straight to the
+  dock, and the rule over the composer fades in with it rather than being drawn
+  at its destination while the composer is still on the way. Every other way
+  out of the empty state -- a restored conversation, a thread picked from the
+  list, a continued run -- and every way back into it snap, because each is a
+  change of context rather than a continuation of what the user was doing.
+
+  A conversation a slow store is still fetching is held in the docked layout
+  with the greeting hidden, so a page restoring an existing conversation never
+  paints a centred composer that then drops when the messages land. A new chat
+  started during that fetch greets at once rather than waiting on it.
+
+- **Internal restructuring: `ag_ui_chat.ts` is split into modules that each own
+  one concern.** The element was one class of more than six thousand lines in
+  which a single concern -- the transcript, the run handlers -- was spread over
+  a dozen separate stretches of the file. Each concern moves into a controller
+  in the directory it already belonged to, holding its own private state, and
+  the element keeps its public members as delegations with their documentation
+  unchanged.
+
+  What has moved, each into the directory its concern already had:
+
+  - The panel's placement -- the dragged launcher, the dragged header, the
+    eight resize grips, the corner the panel opens from and the persisted
+    record of all of it -- is `PanelPlacement` in `src/ui/placement/`.
+  - Quoting a selection, in the transcript and over the host page, is
+    `TranscriptQuoteOffer` in `src/ui/excerpts/`.
+  - The skill catalog -- its three sources, their merge into the chips and the
+    palette, and what a pick does to the composer -- is `SkillCatalog` in
+    `src/skills/`.
+  - The composer's attachments (the tray and the picker, drop and paste routes
+    into it) and its mic are `ComposerAttachments` and `ComposerVoice` in
+    `src/ui/composer/`.
+  - Which storage keys are the element's -- the namespace it claims in the
+    document, the keys its layout preferences live under, and the built-in
+    conversation store scoped to them -- is `StorageScope` in `src/core/`.
+  - The answer streaming into its bubble is `AnswerStream` in
+    `src/ui/transcript/`, a delegated sub-agent's progress is
+    `SubAgentProgress` in `src/ui/progress/`, and the registry of activity
+    renderers and the blocks they drew is `ActivityRegistry` in `src/core/`.
+  - The decision a run is suspended on, which Stop abandons, is
+    `PendingDecision` in `src/ui/interrupts/`: one owner where four places
+    used to write one field.
+  - The frontend tools the agent is offered -- the host's, the built-ins, the
+    `ask_user` question, what the current round advertised, and the server's
+    labels for its own tools -- are `ToolCatalog` in `src/tools/`.
+  - The transcript -- its bubbles, the open answer group, the pending dots, the
+    reasoning region, the tool cards and the scroller that follows the foot --
+    is `Transcript` in `src/ui/transcript/`, and the action row under a
+    finished answer is `AnswerActions` beside it.
+  - Running the frontend tool calls a round produced and answering the
+    server's interrupts -- the page each round's context described, the
+    confirmation gate and the tools the user waived it for, and the approval
+    cards -- is `ToolDispatch` in `src/tools/`.
+  - The AG-UI event handlers a run is drawn by, and what one interaction
+    accumulates for the host until it settles -- the tool calls it made, the
+    keys it invalidated, and whether it already said how it ended -- are
+    `RunHandlers` in `src/core/`. The screen-reader status region the run and
+    its tool calls report into is `RunAnnouncer` in `src/ui/progress/`.
+  - Which conversation is on screen and how one gets there -- the active
+    thread, restoring it from the store, switching, renaming and deleting from
+    the conversation list, and continuing a run from the checkpoint panel -- is
+    `ConversationHistory` in `src/ui/history/`, beside the list and the panel
+    it drives.
+  - What held no state of its own became plain functions. The builders of the
+    element's shell -- a header control, an icon holder, a glyph slot, the
+    adopted stylesheet -- and the readers of the launcher's icon URL and its
+    unread badge switch are in `src/ui/shell/`. The starter prompts are beside
+    the suggestion chips, the composer's sizing is in `src/ui/composer/`,
+    whether a placement can collapse is beside whether it can be dragged, and
+    the tool-round limit is read in `src/core/`. The attachment tray's `accept`
+    list is split by the same comma tokeniser the other opt-in lists use.
+
+  Nothing a consumer can see changes. Every declaration file the package
+  already emitted was compared byte for byte before and after each step, and
+  the moves altered one: the internal `core/utils.d.ts` gained the shared comma
+  tokeniser. No declaration reachable from the package entry point imports
+  that file or any of the new modules' declarations, so a consumer's types
+  cannot reach them. No test was edited to make a move pass.
+
+  The public declarations do differ from the previous release, by the other
+  entries in this release and not by this one. The bundle differs by this one
+  as well: on its own it asks a re-vendor for no host wiring, and it is still a
+  different build.
+
+- **A new chat puts focus in the composer.** Starting a conversation is a
+  request to type one, but pressing *New chat* left focus on the button, so a
+  keyboard user emptied the composer and then had to find their way back to it.
+  `newChat()` now focuses the composer whichever control called it -- the
+  header's button, the history list's own, or a host's -- unless the widget is
+  collapsed and the composer is not on screen. It does so without scrolling, so
+  a host resetting a chat further down the page from its own code does not move
+  the page to it.
+
+- **The conversation list now slides over the transcript at every width,
+  including a wide full page, where it used to dock beside it.** Under
+  `placement="page"` with at least 900px of panel, opening the list padded the
+  rows over to make room for it, so the conversation, the centred greeting and
+  the composer all moved sideways the moment it opened. It is now the same
+  slide-over there as under every other placement and width: a modal dialog
+  over a backdrop, with nothing behind it moving. `data-threads-docked` and
+  `--ag-ui-threads-rail-width` no longer exist, so host CSS written against
+  either can be deleted.
+
+- **The answer well and the controls inside the panel keep round corners when
+  the panel's frame is square.** Under `placement="page"` and `"sidebar"`, and
+  on a small viewport, the frame is square because it meets the edge of the
+  window. Those placements squared it by setting the theme's radius to 0, so
+  everything else that reads that radius went square with it: the answer well,
+  the conversation list's *New chat* button and filter field, and a run
+  notice's *Undo*, beside message bubbles and a composer that stayed round. They
+  now square only the frame, through a new `--ag-ui-panel-radius`, and the
+  corners inside keep `--ag-ui-radius` (12px unless set). The floating and
+  embedded panels look as they did.
+
+  **A host that sets `--ag-ui-radius` under one of those placements now gets a
+  square frame**, where the token used to round the frame too. Set
+  `--ag-ui-panel-radius` to round it again. The well also gains
+  `--ag-ui-well-radius`, beside `--ag-ui-well-bg` and `--ag-ui-well-border`, to
+  round it apart from the rest of the panel.
+
+### Fixed
+
+- **Stop ends a checkpoint continuation.** While a resumed or forked run was
+  streaming, the composer offered Stop and pressing it did nothing; New chat,
+  switching conversations and removing the element left it streaming too, so the
+  rest of the resumed answer drew itself into whatever came next. The element
+  cancelled only the conversation's own client, and a continuation runs on a
+  client of its own. Every path that stops the conversation's run now stops a
+  continuation as well.
+
+- **A run cut off by New chat or a thread switch stays with the conversation it
+  belonged to.** Cancelling closes the request, but the run finishes a moment
+  later, and by then the element had moved on. So its "Stopped" note appeared at
+  the top of the new conversation; its truncated exchange was saved under the new
+  thread, which the drawer then listed as a second copy of the old one; and its
+  `ag-ui-run-finished` reported a server-side tool as the host's own, because the
+  record of what streamed back had been cleared with the transcript. Where a host
+  tool's handler was still running -- which cancelling cannot interrupt -- and the
+  user sent the next message before it returned, the old run's settle also put the
+  new run's Stop button back to Send, and one event carried both runs' tools while
+  the new run's own reported none.
+
+  Each conversation's runs now keep their bookkeeping apart. A run left behind by
+  a reset still reports what it ran, since a stopped run may already have written
+  something, and saves to the thread it was started in; nothing else it does
+  reaches the conversation that replaced it.
+
+- **A resumed or forked run now carries the page's shared state, reports the
+  state it changes, and stops at `data-max-tool-rounds`.** A checkpoint
+  continuation sent an empty state object, so an agent whose tools read the
+  page's state resumed without it; a `STATE_SNAPSHOT` it streamed never reached
+  `ag-ui-state`; and on a page that had raised the tool-round bound, the resumed
+  half of a form-filling task still stopped at ten.
+
+  The continuation's client was built separately from the conversation's own,
+  and both options arrived after continuations did, so each was wired into one
+  construction only. There is now one construction, and a continuation differs
+  from the conversation's client only in its endpoint, its empty seed, and in
+  not writing the conversation store -- which it never did, deliberately: its
+  agent holds only the new turn and its answer, so saving them would replace the
+  stored conversation with its last exchange.
+
+- **Text a user or a server wrote could rewrite the label it was put into.**
+  Every string-table template was filled with `template.replace("{token}",
+  value)`, and a string replacement interprets dollar patterns in the value: `$&`
+  inserts the matched token and `` $` `` and `$'` the text either side of it. So a
+  queued message reading `costs $& more` was labelled
+  `Do not send "costs {text} more"`, and the same went for a tool name in the
+  confirmation prompt, a skill id in the "Using skill" notice and an agent name
+  on a delegation row. The skill hint was two replacements chained, so a skill
+  titled with `{fields}` in it was filled twice.
+
+  A string pattern also fills only its first occurrence, so a translation that
+  used a token twice was left half filled. That one reached every fill, the
+  numeric ones included.
+
+  Every fill -- seventeen, across the element, the confirmation card, the
+  attachment tray, the voice button and the relative timestamps -- now goes
+  through one helper that fills every occurrence in a single pass with a replacer
+  function, whose return value is never interpreted. Each file that filled has a
+  test that failed against the old fill.
+
+- **A closed slash-command palette and an empty queued-messages row still took
+  up space.** Both set the hidden attribute and both declare their own
+  `display`, which beats the browser's rule for hidden elements -- the defect the
+  attachment tray's own hidden rule was written for. The palette is mounted on
+  every element and closed nearly all of the time, so it painted 2px of border
+  and its shadow as a line above the composer; the queued row kept 10px of
+  padding. Measured in Chromium, which is where the new tests live, because
+  happy-dom lays out no boxes and reports both as zero either way.
+
+- **Opening the conversation list or the checkpoints panel did not move focus
+  into it.** Each asks for focus as it opens -- the list on *New chat*, the
+  checkpoints panel on its first row or itself -- but both eased their
+  visibility in so the exit could play, and a transition starts at its first
+  value: at the instant of the call the panel was still hidden, so the browser
+  dropped it and focus stayed wherever it had been, at every placement and under
+  reduced motion. A keyboard user opened a modal dialog they were not in.
+  Visibility now changes at once on the way in and is delayed on the way out, so
+  the list's slide and the panel's fade are unchanged. happy-dom computes no
+  transitions, which is why the unit tests of the same calls passed; the new
+  tests are in Chromium.
+
+- **A new `user-key` now gets its own confirmation cards.** A tool one principal
+  waived with *Always allow* kept running without a card for whoever signed in
+  next in the same tab, because the waiver lives in the element's memory rather
+  than in the stored conversation that changing `user-key` purges. `user-key`
+  exists because a sign-out is a navigation inside one tab, not a remount, so the
+  element outlives the person who clicked -- and the next person's destructive
+  calls ran on that click, with nothing on screen to say anyone had been asked.
+
+  Changing the key, or removing it, now forgets every waiver along with the
+  transcript. The first key to arrive keeps them, for the same reason it keeps
+  the conversation on screen: it names the user who was already there.
+
+- **A `confirmPredicate` that throws now refuses the call, and the run carries
+  on.** A throw, or a rejected promise, used to end the whole run on an error
+  bubble quoting the host's own message, and left that call's tool card reading
+  "running..." for good, because dispatch had already taken the card out of the
+  sweep that settles leftovers when a run ends. The handler did not run, but
+  nothing on screen said so and the agent was never told.
+
+  The call now fails closed: no confirmation card, no handler, the tool card
+  settles as declined, and the agent receives the new `confirmCheckFailed`
+  string as the result and goes on to its next round, as it does after a
+  decline. It is refused rather than put to a card because for a tool with no
+  `x-destructive` flag the predicate is the only guard, and one click would run
+  what the host's policy could not vouch for. The error is reported with
+  `console.warn`, as a failed `render` already is, and is not sent to the
+  endpoint: unlike a handler's message, it was never written for the model.
+
+- **An `approvalRenderer` that throws now hands the decision to the built-in
+  approval card.** A throw, or a rejected promise, used to end the run on an
+  error bubble quoting the host's message without ever answering the server's
+  interrupt, and the sweep that settles leftover cards at the end of a run then
+  marked the gated call a green "done" -- for a call that never ran and that
+  nobody had been asked about. One failing interrupt took every other interrupt
+  in its batch down with it.
+
+  The renderer decides how the question looks, not whether it is asked, so it
+  now falls back to the built-in card for that interrupt, with a `console.warn`
+  naming the interrupt, the way a failed `render` falls back to the default.
+  Nothing runs without a click, and the run carries on as if no renderer had
+  been set. The exception is a rejection after the signal has fired, which is
+  how a renderer is expected to honour Stop: that wait resolves as denied, as
+  the built-in card does on the same signal, with no card drawn and no warning.
+
+- **Reloading the page while a tool call waits for approval now shows that call
+  as not finished, where it showed a spinner that never stopped.** The run loop
+  saves a round's history when its stream ends, which is before it asks about a
+  gated call, runs a frontend tool or collects a server-side approval. A reload in
+  that window left the call stored with no result, and the request that would
+  have produced one had died with the page, so the restored card had no Approve
+  or Decline and nothing left to settle it. The next message then went out
+  carrying a tool call with no result, which several model providers reject.
+
+  The card now settles as not finished, and the conversation carries the same
+  not-finished result the client gives any call a run left open, so the next
+  request is a valid turn and a later reload shows the same. It is not declined,
+  although Stop declines an open card, because Stop is a person answering the
+  question and a reload is not: the saved history looks the same whether the
+  round was waiting on a person or on a frontend tool the reload killed, so a
+  decline would be unproven for the first and false for the second, and "not
+  finished" is true of both. A server-side approval left open by a
+  reload comes back the same way. A navigating tool's call is unchanged: it
+  resumes from the page it landed on. A restored card for a call that an earlier
+  round went past without a result settles as not finished too, and the restore
+  now gives that call its result as well, at the end of its own round.
+
+- **A request sent after a reload no longer carries the element's `outcome`
+  labels to the server.** The label that lets a reload replay a declined or
+  failed card is written onto the stored copy of a tool message only, and the
+  README promises it is never sent. A restore seeds the next agent from that
+  stored copy, though, so every tool message restored with a label went out
+  with it on the next request. The client now takes the labels off the history
+  it is seeded with and keeps them beside it, so the request carries none, the
+  restored cards still settle as they did, and the next save writes each label
+  back.
+
+- **A request no longer carries a tool call without a result, however the run
+  that made the call ended.** Several model providers reject such a turn, so the
+  conversation could not continue past it, and a live run left one in four ways
+  with no reload involved: Stop while the stream was still arriving, Stop on an
+  open server-side approval, a round that ended on `RUN_ERROR` after emitting
+  calls, and a call naming a tool nothing on the page owns. Each was guarded,
+  if at all, where it happened, and the guards between them left gaps.
+
+  The client now answers every call still open before each request it makes,
+  in one place, so a path nobody listed cannot send one either. The answer goes
+  at the end of the round that made the call, where a provider looks for it.
+  It says the call did not finish, in the new `callNotFinished` string, with
+  the outcome `interrupted`, pydantic-ai's word for the same thing, because
+  nobody refused it; the card settles to a new **not finished** status in the
+  same words, with its own `--ag-ui-tool-icon-interrupted` glyph, where it used
+  to claim "done" over "No result returned.". The decline stays where a person
+  declined: an approval Stop closed while it was open is answered with
+  `declinedAction`, and one already approved when Stop landed is answered as not
+  finished. The calls a resumed approval is answering are left for the server.
+  `UiStrings.noResult` is no longer drawn and is deprecated, and a server's own
+  `interrupted` outcome now renders as not finished rather than as done.
+
+- **Stop during a frontend tool no longer lets the next call in the same round
+  run.** The loop checked for Stop between rounds but not between the calls of
+  one round, so when the agent asked for two page actions at once and Stop was
+  pressed while the first ran, the second ran anyway as soon as the first
+  returned, after the person had asked for the run to end. A handler already
+  running still completes and keeps its result, since it cannot be aborted, but
+  the calls after it no longer start, and each is answered as not finished.
+
+- **Changing `user-key` no longer sends the previous principal's shared state
+  on the next principal's first run.** A handover purges the stored
+  conversation, the transcript and the tools waived with Always allow, but
+  `sharedState` survived it, and it holds whatever the agent last wrote into it
+  for the principal who left. The next client is seeded from it, so it went out
+  as `RunAgentInput.state` on the new principal's first request. It is now
+  cleared on the handover. New chat still keeps it, because shared state is the
+  page's object and the same person is still editing it, and the first key to
+  arrive keeps it for the same reason it keeps the conversation.
+
 ## [0.38.0] — 2026-09-14
 
 ### Changed
@@ -3614,7 +4126,9 @@ hosts that both arrange the page the way it expects.
 ### Notes
 - First release — exercising the automated npm OIDC publish pipeline end-to-end.
 
-[Unreleased]: https://github.com/Artui/ag-ui-web-component/compare/v0.38.0...HEAD
+[Unreleased]: https://github.com/Artui/ag-ui-web-component/compare/v0.40.0...HEAD
+[0.40.0]: https://github.com/Artui/ag-ui-web-component/compare/v0.39.0...v0.40.0
+[0.39.0]: https://github.com/Artui/ag-ui-web-component/compare/v0.38.0...v0.39.0
 [0.38.0]: https://github.com/Artui/ag-ui-web-component/compare/v0.37.0...v0.38.0
 [0.37.0]: https://github.com/Artui/ag-ui-web-component/compare/v0.36.0...v0.37.0
 [0.36.0]: https://github.com/Artui/ag-ui-web-component/compare/v0.35.2...v0.36.0