@artooi/ag-ui-web-component 0.15.0 → 0.17.0

package/src/core/ag_ui_chat.ts

@@ -1,9 +1,11 @@
 import type { Context, Interrupt, Message, Tool } from "@ag-ui/core";
 import {
+  ATTACHMENT_EVENT,
   COMPACTION_ACTIVITY_TYPE,
   DEFAULT_ATTACHMENT_MAX_BYTES,
   LOAD_CAPABILITY_TOOL,
   MESSAGE_ROLE,
+  READ_PAGE_TOOL,
   STATE_EVENT,
   SUBMIT_EVENT,
   TOGGLE_EVENT,
@@ -77,6 +79,14 @@ export interface SubmitDetail {
   readonly attachments: readonly AttachmentRef[];
 }
 
+/** `detail` shape of the {@link ATTACHMENT_EVENT} CustomEvent. */
+export interface AttachmentsDetail {
+  /** Durable refs for every file that has finished uploading. */
+  readonly attachments: readonly AttachmentRef[];
+  /** How many files are still uploading; a send now would leave these behind. */
+  readonly pending: number;
+}
+
 /** `detail` shape of the {@link STATE_EVENT} CustomEvent. */
 export interface StateDetail {
   readonly state: Readonly<Record<string, unknown>>;
@@ -87,6 +97,35 @@ export interface ToggleDetail {
   readonly collapsed: boolean;
 }
 
+/**
+ * Attributes read once while connecting, to decide what chrome exists at all.
+ *
+ * Changing one afterwards is silently ignored: the tray, the mic, the skills
+ * menu and the header icon are built (or not) during connect, and no later read
+ * revisits the decision. Observed only so the element can say so — see
+ * `attributeChangedCallback`.
+ *
+ * Deliberately excludes the attributes that *are* re-read per use, where a late
+ * change works and a warning would be wrong: `data-runs-url`,
+ * `data-page-actions`, `data-text-animation`, `data-tool-display`, `endpoint`,
+ * and the CSS-reactive `theme` / `collapsed`.
+ */
+const CONNECT_TIME_ATTRIBUTES = [
+  "data-attachments-url",
+  "data-attachment-accept",
+  "data-attachment-max-bytes",
+  "data-transcribe-url",
+  "data-threads-url",
+  "data-tools-url",
+  "data-skills-url",
+  "data-skills",
+  "data-prompt-chips",
+  "data-slash-commands",
+  "data-theme-toggle",
+  "data-strings",
+  "data-icon-url",
+] as const;
+
 /** Per-tab persistence key for the collapsed state (survives MPA reloads). */
 const COLLAPSED_KEY = "ag-ui-chat:collapsed";
 
@@ -327,6 +366,9 @@ export class AgUiChat extends HTMLElement {
   readonly #voiceSlot: HTMLSpanElement;
   /** Voice-input control; created on connect when transcription is available. */
   #voice: VoiceInput | null = null;
+  /** Whether the element is currently in the DOM; gates the connect-time warning. */
+  #connected = false;
+
   /** Refs attached to the message currently being sent (the context manifest). */
   #runAttachments: readonly AttachmentRef[] = [];
 
@@ -339,6 +381,10 @@ export class AgUiChat extends HTMLElement {
   // the Send⇄Stop button: `agent.isRunning` is false between frontend-tool
   // rounds, but the user must still be able to stop there.
   #running = false;
+  // The page the current round's context describes, captured when that context
+  // was built. `null` until the first round. Compared in `#executeTool` to
+  // catch a page that moved under a round still in flight.
+  #contextHref: string | null = null;
   // Aborting this dismisses (declines) an open confirmation card when the run
   // is cancelled while the card awaits a decision. One controller per card.
   #confirmAbort: AbortController | null = null;
@@ -461,7 +507,7 @@ export class AgUiChat extends HTMLElement {
       agent,
       handlers: this.#handlers(),
       getTools: () => this.getTools(),
-      getContext: () => this.getContext(),
+      getContext: () => this.#buildContext(),
       executeTool: (call) => this.#executeTool(call),
       resolveInterrupts: (interrupts) => this.#resolveInterrupts(interrupts),
       connectionLostMessage: this.#strings.connectionLost,
@@ -475,16 +521,36 @@ export class AgUiChat extends HTMLElement {
     this.#checkpoints.setRuns(index === null ? [] : await index.continuable());
   }
 
-  /** Attributes whose late changes must reflect in already-rendered chrome. */
+  /** Attributes the element reacts to after it has been connected. */
   static get observedAttributes(): string[] {
-    return ["title-text"];
+    return ["title-text", ...CONNECT_TIME_ATTRIBUTES];
   }
 
-  attributeChangedCallback(_name: string, _previous: string | null, value: string | null): void {
-    // Only `title-text` is observed (other attributes are read at use-time or
-    // are CSS-reactive), so update the header title directly. `#strings` is the
-    // resolved table once connected, the English defaults before then.
-    this.#title.textContent = value ?? this.#strings.title;
+  attributeChangedCallback(name: string, previous: string | null, value: string | null): void {
+    if (name === "title-text") {
+      // `#strings` is the resolved table once connected, the English defaults
+      // before then.
+      this.#title.textContent = value ?? this.#strings.title;
+      return;
+    }
+    // Everything else here is read once, in connectedCallback, to build chrome
+    // that then exists (or does not). Setting it afterwards is silently
+    // ignored, and the symptom is an affordance that simply never appears —
+    // which reads as a broken component rather than a mis-timed assignment.
+    // This is the common React/Vue shape: the element mounts on the first
+    // render pass and the framework patches attributes in on the next one.
+    // Observed purely so this can be said out loud.
+    if (previous === value || !this.#connected) {
+      return;
+    }
+    console.warn(
+      `<ag-ui-chat>: "${name}" was changed after the element connected, and is ` +
+        "read only while connecting — this assignment has no effect. Set it " +
+        "before the element enters the DOM (in the markup, or on the element " +
+        "before appending it); frameworks that patch attributes after mount " +
+        "should bind it at creation. To apply a new value now, remove and " +
+        "re-insert the element.",
+    );
   }
 
   /** Declare a frontend tool the agent may call. */
@@ -555,7 +621,7 @@ export class AgUiChat extends HTMLElement {
     }
     return [
       {
-        name: "read_page",
+        name: READ_PAGE_TOOL,
         description:
           "Read the current page's structure (fields, buttons, route). Call after " +
           "acting to observe the result within the same turn.",
@@ -746,6 +812,9 @@ export class AgUiChat extends HTMLElement {
     this.#wireVoice();
     this.#threadId = this.conversationStore.threadId();
     void this.#rehydrate();
+    // Last: everything above reads (and some of it sets) attributes, and none
+    // of that should trip the connect-time warning.
+    this.#connected = true;
   }
 
   /**
@@ -757,6 +826,7 @@ export class AgUiChat extends HTMLElement {
    * `MediaRecorder`.
    */
   disconnectedCallback(): void {
+    this.#connected = false;
     this.#cancelRun();
     this.#attachTray?.dispose();
     this.#voice?.dispose();
@@ -793,12 +863,20 @@ export class AgUiChat extends HTMLElement {
       return;
     }
     const accept = this.getAttribute("data-attachment-accept") ?? "";
-    this.#attachTray = new AttachmentTray({
+    // Bound to the local rather than the field: the hook can only fire from a
+    // tray that exists, so passing it removes a null check no caller can reach.
+    const tray: AttachmentTray = new AttachmentTray({
       upload,
       maxBytes: this.#attachmentMaxBytes(),
       accept,
       strings: this.#strings,
+      // The tray's change hook, surfaced to the host as an event. A host
+      // driving its own composer could otherwise not tell a settled upload from
+      // one still in flight, which is the state sendMessage() has to be called
+      // with knowledge of.
+      onChange: () => this.#dispatchAttachments(tray),
     });
+    this.#attachTray = tray;
     this.#attachSlot.appendChild(this.#attachTray.element);
     this.#fileInput.accept = accept;
     this.#attachButton.hidden = false;
@@ -1181,7 +1259,62 @@ export class AgUiChat extends HTMLElement {
     const checkpoint = this.conversationStore.loadCheckpoint(this.#threadId);
     if (checkpoint !== null) {
       await this.#resumeFrom(checkpoint);
+      return;
+    }
+    this.#noticeIfRunUnfinished(messages);
+  }
+
+  /**
+   * Notice a previous run that never produced a response.
+   *
+   * {@link AgUiClient.send} persists the user's message *before* starting the
+   * run, so a transcript whose last entry is that user message means nothing
+   * ever came back: the page navigated or reloaded mid-run, the tab closed, or
+   * the process died. No extra persistence is needed to detect it — the shape
+   * of the transcript already says so, which is why this needs no
+   * {@link ClientConversationStore} method and no `pagehide` listener (neither
+   * of which fires on a crash or a force-quit anyway).
+   *
+   * The *agent*-initiated reload is not this case: a navigating tool leaves a
+   * checkpoint and resumes, which is why the caller returns early on one before
+   * reaching here.
+   *
+   * Deliberately a notice and never a resume. AG-UI has no
+   * resume-an-aborted-run primitive; re-sending the accumulated messages is
+   * semantically a **new** run, so any server-side tool the agent had already
+   * executed before the interruption would run a second time. Saying plainly
+   * that the answer was lost is the honest option, and the user can re-ask.
+   */
+  /**
+   * Build a round's context, recording which page it describes.
+   *
+   * The AG-UI client re-invokes this at the top of **every** tool round, not
+   * once per `send()`, so the page map the agent sees is already refreshed
+   * between rounds and the href captured here is the page it was shown for
+   * *this* round. {@link #executeTool} compares against it to catch a page that
+   * moved under a round still in flight.
+   */
+  #buildContext(): Context[] {
+    this.#contextHref = window.location.href;
+    return this.getContext();
+  }
+
+  /**
+   * Whether the page moved since the current round's context was built.
+   *
+   * `null` means no round has built context yet (nothing to compare), which is
+   * not a move.
+   */
+  #pageMoved(): boolean {
+    return this.#contextHref !== null && this.#contextHref !== window.location.href;
+  }
+
+  #noticeIfRunUnfinished(messages: readonly Message[] | null): void {
+    const last = messages?.at(-1);
+    if (last === undefined || last.role !== MESSAGE_ROLE.USER) {
+      return;
     }
+    this.#appendNotice("⚠", this.#strings.runInterrupted, "interrupted");
   }
 
   /**
@@ -1603,14 +1736,55 @@ export class AgUiChat extends HTMLElement {
     if (content === "" && attachments.length === 0) {
       return;
     }
+    this.#input.value = "";
+    // A file still uploading does not ride along — `readyRefs()` returns only
+    // settled ones, and `clearReady()` deliberately keeps the rest for a
+    // follow-up. Nothing said so, which is the whole defect: attachments are
+    // frequently the entire point of the message, and the user had no way to
+    // tell theirs had been left behind. Say it before dropping the chips,
+    // while `hasPending()` still describes this send.
+    if (this.#attachTray?.hasPending() === true) {
+      this.#appendNotice(
+        "\u{1F4CE}",
+        this.#strings.attachmentsStillUploading.replace(
+          "{n}",
+          String(this.#attachTray.pendingCount()),
+        ),
+        "attachment-pending",
+      );
+    }
+    // The refs ride the message from here; drop the settled chips, keep any
+    // still uploading for a follow-up message.
+    this.#attachTray?.clearReady();
+    await this.sendMessage(content, attachments);
+  }
+
+  /**
+   * Send a message as if the user had typed it — renders the user bubble,
+   * dispatches {@link SUBMIT_EVENT}, and starts the run.
+   *
+   * The programmatic half of the composer, for a host driving its own input
+   * (a "Ask about this order" button, a command palette, a custom composer
+   * replacing the built-in one). Everything the built-in Send does happens
+   * here; Send itself now reads the composer, clears it, and calls this.
+   *
+   * `attachments` are durable {@link AttachmentRef}s — the shape
+   * {@link attachFile}'s upload resolves to, and the shape
+   * {@link ATTACHMENT_EVENT} reports. Pass them to attach files to the message.
+   *
+   * No-ops while a run is in flight (a second concurrent run would orphan the
+   * first) and for an entirely empty message. Unlike the built-in Send, this
+   * does **not** consult the tray: what you pass is what is sent, so a host
+   * composer stays in charge of its own state.
+   */
+  async sendMessage(content: string, attachments: readonly AttachmentRef[] = []): Promise<void> {
+    if (this.#running || (content === "" && attachments.length === 0)) {
+      return;
+    }
     const bubble = this.appendMessage(MESSAGE_ROLE.USER, content);
     if (attachments.length > 0) {
       bubble.appendChild(renderAttachmentChips(attachments));
     }
-    this.#input.value = "";
-    // The refs are now on the bubble; drop the settled chips, keep any still
-    // uploading for a follow-up message.
-    this.#attachTray?.clearReady();
     // Surfaced to the run via the context manifest until the run settles.
     this.#runAttachments = attachments;
     this.dispatchEvent(
@@ -1623,6 +1797,37 @@ export class AgUiChat extends HTMLElement {
     await this.#client_send(content, attachments);
   }
 
+  /**
+   * Queue a file for upload into the attachment tray, exactly as the file
+   * picker and drag-and-drop do — validation, progress chip, and all.
+   *
+   * Returns `false` when uploads are not configured (no `data-attachments-url`
+   * and no {@link uploadHandler}), which is the only way for a host to tell;
+   * the tray does not exist to report anything in that case.
+   *
+   * Uploading is asynchronous: watch {@link ATTACHMENT_EVENT} for the resulting
+   * {@link AttachmentRef}, and pass it to {@link sendMessage} once `pending`
+   * reaches zero.
+   */
+  attachFile(file: File): boolean {
+    if (this.#attachTray === null) {
+      return false;
+    }
+    this.#attachTray.add(file);
+    return true;
+  }
+
+  /** Tell the host what the tray now holds — see {@link ATTACHMENT_EVENT}. */
+  #dispatchAttachments(tray: AttachmentTray): void {
+    this.dispatchEvent(
+      new CustomEvent<AttachmentsDetail>(ATTACHMENT_EVENT, {
+        detail: { attachments: tray.readyRefs(), pending: tray.pendingCount() },
+        bubbles: true,
+        composed: true,
+      }),
+    );
+  }
+
   async #client_send(content: string, attachments: readonly AttachmentRef[]): Promise<void> {
     if (this.endpoint === "") {
       return;
@@ -1647,7 +1852,7 @@ export class AgUiChat extends HTMLElement {
         agent,
         handlers: this.#handlers(),
         getTools: () => this.getTools(),
-        getContext: () => this.getContext(),
+        getContext: () => this.#buildContext(),
         executeTool: (call) => this.#executeTool(call),
         resolveInterrupts: (interrupts) => this.#resolveInterrupts(interrupts),
         onPersist: (messages) => this.conversationStore.saveMessages(this.#threadId, messages),
@@ -1704,6 +1909,29 @@ export class AgUiChat extends HTMLElement {
       }
       return null;
     }
+    // The page moved under this round. Acting now would target whatever
+    // happens to match on the *new* page — usually nothing, which the handler
+    // would report as a miss anyway, but occasionally a same-named control that
+    // matches silently. That last case is the one worth preventing: it is the
+    // only way the agent acts on the wrong page without either side noticing.
+    //
+    // Placed before the confirmation prompt so the user is never asked to
+    // approve an action that is about to be refused. Navigating tools are
+    // exempt (moving the page is their job — including re-navigating after a
+    // move), as is `read_page`, which is the documented recovery. Gated on a
+    // page-map provider: without one there is no `read_page` to recommend and
+    // the host's tools are not page-scoped in the first place.
+    if (
+      this.getPageMap !== null &&
+      call.name !== READ_PAGE_TOOL &&
+      !isNavigates(tool.parameters) &&
+      this.#pageMoved()
+    ) {
+      const message = this.#strings.pageMoved;
+      card.settle(TOOL_CALL_STATUS.ERROR, message);
+      this.#showPending();
+      return { content: `Error: ${message}`, error: message };
+    }
     if (await this.#needsConfirmation(call, tool)) {
       const request: ConfirmationRequest = { toolName: call.name, args: call.args };
       const confirmText = tool.parameters[X_CONFIRM_KEY];

package/src/core/remote_conversation_store.ts

@@ -92,7 +92,7 @@ export class RemoteConversationStore implements ClientConversationStore {
   }
 
   async loadMessages(threadId: string): Promise<readonly Message[] | null> {
-    const response = await this.#get(this.#url + encodeURIComponent(threadId) + "/");
+    const response = await this.#get(`${this.#url}${encodeURIComponent(threadId)}/`);
     if (response === null || !response.ok) {
       return this.#local.loadMessages(threadId);
     }
@@ -156,7 +156,7 @@ export class RemoteConversationStore implements ClientConversationStore {
   ): Promise<void> {
     const headers = this.#headers();
     try {
-      await fetch(this.#url + encodeURIComponent(threadId) + "/", {
+      await fetch(`${this.#url}${encodeURIComponent(threadId)}/`, {
         method,
         headers: body === undefined ? headers : { ...headers, "content-type": "application/json" },
         body: body === undefined ? null : JSON.stringify(body),

package/src/index.ts

@@ -1,6 +1,7 @@
 // Public surface re-exports. Per CLAUDE.md, this is the only re-export point.
 
 export {
+  ATTACHMENT_EVENT,
   COMPACTION_ACTIVITY_TYPE,
   ELEMENT_TAG,
   LOAD_CAPABILITY_TOOL,
@@ -18,6 +19,7 @@ export {
 } from "./constants.js";
 export {
   AgUiChat,
+  type AttachmentsDetail,
   type MessageRole,
   type StateDetail,
   type SubmitDetail,

package/src/tools/route_map.ts

@@ -33,14 +33,11 @@ const PATH_PARAM_RE = /:([A-Za-z_][A-Za-z0-9_]*)/g;
 
 /** The `:name` path-parameter names declared in a path template, in order. */
 function pathParamNames(path: string): string[] {
-  const names: string[] = [];
-  for (const match of path.matchAll(PATH_PARAM_RE)) {
-    const name = match[1];
-    if (name !== undefined) {
-      names.push(name);
-    }
-  }
-  return names;
+  // Slicing the ":" off the whole match rather than reading the capture group:
+  // the group is mandatory, so under `noUncheckedIndexedAccess` indexing it
+  // forces an `undefined` guard on a case the regex cannot produce — an
+  // unreachable branch no test can ever cover.
+  return [...path.matchAll(PATH_PARAM_RE)].map((match) => match[0].slice(1));
 }
 
 /**

package/src/ui/attachment_tray.ts

@@ -102,6 +102,11 @@ export class AttachmentTray {
     return this.#items.some((item) => item.status === ATTACHMENT_STATUS.UPLOADING);
   }
 
+  /** How many chips are still uploading — the count a send-time notice names. */
+  pendingCount(): number {
+    return this.#items.filter((item) => item.status === ATTACHMENT_STATUS.UPLOADING).length;
+  }
+
   /** Whether the tray holds no chips. */
   isEmpty(): boolean {
     return this.#items.length === 0;

package/src/ui/checkpoint_menu.ts

@@ -48,6 +48,7 @@ export class CheckpointMenu {
     header.setAttribute("part", "checkpoints-header");
     this.#heading = document.createElement("span");
     this.#heading.className = "checkpoints-title";
+    this.#heading.setAttribute("part", "checkpoints-title");
     this.#heading.textContent = strings.checkpoints;
     header.append(this.#heading);
 
@@ -112,6 +113,7 @@ export class CheckpointMenu {
 
     const label = document.createElement("span");
     label.className = "checkpoint-label";
+    label.setAttribute("part", "checkpoint-label");
     // A run id is opaque to a person, so the time is the identifying detail;
     // the id rides `title` for anyone who needs to correlate with server logs.
     label.textContent =

package/src/ui/styles.ts

@@ -11,6 +11,7 @@ export const STYLES = `
   --ag-ui-user-bg: #4f46e5;
   --ag-ui-user-fg: #ffffff;
   --ag-ui-assistant-bg: #f1f1f6;
+  --ag-ui-hover: #e7e7ee;
   --ag-ui-input-bg: var(--ag-ui-bg);
   --ag-ui-tool-bg: var(--ag-ui-assistant-bg);
   --ag-ui-tool-fg: var(--ag-ui-accent);
@@ -80,6 +81,7 @@ export const STYLES = `
   --ag-ui-bg: #15151f;
   --ag-ui-fg: #e8e8f2;
   --ag-ui-assistant-bg: #25253a;
+  --ag-ui-hover: #303049;
   --ag-ui-header-bg: #1f1f30;
   --ag-ui-header-fg: #e8e8f2;
   --ag-ui-border: #33334a;
@@ -92,6 +94,7 @@ export const STYLES = `
     --ag-ui-bg: #15151f;
     --ag-ui-fg: #e8e8f2;
     --ag-ui-assistant-bg: #25253a;
+    --ag-ui-hover: #303049;
     --ag-ui-header-bg: #1f1f30;
     --ag-ui-header-fg: #e8e8f2;
     --ag-ui-border: #33334a;
@@ -107,6 +110,7 @@ export const STYLES = `
   --ag-ui-accent: #3fb950;
   --ag-ui-user-bg: #238636;
   --ag-ui-assistant-bg: #161b22;
+  --ag-ui-hover: #21262d;
   --ag-ui-header-bg: #010409;
   --ag-ui-header-fg: #c9d1d9;
   --ag-ui-border: #30363d;
@@ -514,6 +518,34 @@ export const STYLES = `
   color: var(--ag-ui-muted);
 }
 
+/* Markdown tables. table/thead/tbody/tr/th/td are all in
+   the sanitizer's ALLOWED_TAGS, so an agent emitting one renders it — and until
+   now rendered it entirely unstyled, overflowing the bubble. A wide table
+   scrolls inside its own box rather than stretching the message: the bubble is
+   width-constrained, so without this the columns either crush or push the
+   layout sideways. */
+.message--assistant table {
+  display: block;
+  width: fit-content;
+  max-width: 100%;
+  overflow-x: auto;
+  border-collapse: collapse;
+  font-size: 0.95em;
+}
+
+.message--assistant th,
+.message--assistant td {
+  padding: 6px 10px;
+  border: 1px solid var(--ag-ui-border);
+  text-align: left;
+  vertical-align: top;
+}
+
+.message--assistant th {
+  background: var(--ag-ui-hover);
+  font-weight: 600;
+}
+
 .pending {
   align-self: flex-start;
   display: inline-flex;
@@ -1264,9 +1296,9 @@ export const STYLES = `
   flex-direction: column;
   gap: 0.25rem;
   padding: 0.5rem;
-  border: 1px solid var(--agui-border, #d7d7dc);
+  border: 1px solid var(--ag-ui-border);
   border-radius: 0.5rem;
-  background: var(--agui-surface, #fff);
+  background: var(--ag-ui-assistant-bg);
   box-shadow: 0 6px 24px rgb(0 0 0 / 12%);
   max-height: 60%;
   overflow-y: auto;
@@ -1297,7 +1329,7 @@ export const STYLES = `
 }
 
 .checkpoint-row:hover {
-  background: var(--agui-hover, #f3f3f5);
+  background: var(--ag-ui-hover);
 }
 
 .checkpoint-label {
@@ -1312,7 +1344,7 @@ export const STYLES = `
   font-size: 0.6875rem;
   padding: 0 0.375rem;
   border-radius: 999px;
-  background: var(--agui-hover, #f3f3f5);
+  background: var(--ag-ui-hover);
   opacity: 0.8;
 }
 
@@ -1321,14 +1353,14 @@ export const STYLES = `
   font-size: 0.75rem;
   cursor: pointer;
   padding: 0.125rem 0.5rem;
-  border: 1px solid var(--agui-border, #d7d7dc);
+  border: 1px solid var(--ag-ui-border);
   border-radius: 0.375rem;
   background: transparent;
   color: inherit;
 }
 
 .checkpoint-action:hover {
-  background: var(--agui-hover, #f3f3f5);
+  background: var(--ag-ui-hover);
 }
 
 .drawer-backdrop {

package/src/ui/ui_strings.ts

@@ -53,6 +53,12 @@ export interface UiStrings {
   historyCompacted: string;
   /** Notice shown when the agent loads an agent skill. Token: `{name}`. */
   usingSkill: string;
+  /** Notice shown on mount when the previous run never produced a response. */
+  runInterrupted: string;
+  /** Tool-result content (and card text) when the page moved mid-run. */
+  pageMoved: string;
+  /** Notice when Send ran while a file was still uploading. Token: `{n}`. */
+  attachmentsStillUploading: string;
 
   // ── Composer ────────────────────────────────────────────────────────────────
   /** `aria-label` of the message textarea. */
@@ -201,6 +207,11 @@ export const DEFAULT_UI_STRINGS: UiStrings = {
   navigating: "Navigating…",
   historyCompacted: "Earlier turns condensed to fit the context window ({count} removed)",
   usingSkill: "Using skill {name}",
+  runInterrupted: "The previous response didn’t finish — the page changed before it arrived.",
+  pageMoved:
+    "The page changed since you last looked at it. Call read_page to see the current page, then retry.",
+  attachmentsStillUploading:
+    "{n} file still uploading — it was not sent with this message and is still attached.",
   skillNeeds: "“{title}” needs: {fields}",
 
   message: "Message",

package/src/version.ts

@@ -1 +1 @@
-export const VERSION: string = "0.15.0";
+export const VERSION: string = "0.17.0";