@artooi/ag-ui-web-component 0.26.1 → 0.27.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@artooi/ag-ui-web-component",
-  "version": "0.26.1",
+  "version": "0.27.0",
   "description": "Framework-free <ag-ui-chat> Web Component over the AG-UI protocol. Drop-in chat sidebar with a pluggable client-side tool registry, DOM driver primitives, animations, and destructive-action confirmation modal.",
   "type": "module",
   "main": "./dist/index.js",

package/src/core/ag_ui_chat.ts

@@ -86,7 +86,7 @@ import { RemoteConversationStore } from "./remote_conversation_store.js";
 import { RunIndex } from "./run_index.js";
 import { type TranscribeHandler, transcribeAudio } from "./transcribe_audio.js";
 import { type UploadHandler, uploadAttachment } from "./upload_attachment.js";
-import { withCredentials } from "./utils.js";
+import { mintThread, withCredentials } from "./utils.js";
 
 /** The role a rendered chat message takes. */
 export type MessageRole = (typeof MESSAGE_ROLE)[keyof typeof MESSAGE_ROLE];
@@ -1653,16 +1653,25 @@ export class AgUiChat extends HTMLElement {
   }
 
   /**
-   * Start a fresh conversation: forget the persisted history, drop the
-   * in-memory run state, clear the transcript, and mint a new thread id.
+   * Start a fresh conversation: drop the in-memory run state, clear the
+   * transcript, and mint a new thread id.
+   *
+   * The conversation being left is kept, and stays in the history drawer to
+   * return to. Deleting one is the drawer row's own action; a button that
+   * starts something new must not be the button that destroys what was there.
    */
   newChat(): void {
     // Stop any in-flight run first — discarding the client mid-run would
     // leave the old agent streaming into a cleared transcript.
     this.#cancelRun();
-    this.conversationStore.clear(this.#threadId);
+    // A thread nothing was ever sent in has nothing to come back to, and the
+    // drawer never listed it — so reap it here rather than strand one record
+    // per press of a button whose whole use is being pressed again.
+    if (this.conversationStore.isUnsent?.(this.#threadId) === true) {
+      this.conversationStore.clear(this.#threadId);
+    }
     this.#resetState();
-    this.#threadId = this.conversationStore.threadId();
+    this.#threadId = mintThread(this.conversationStore);
     this.#setRunning(false);
     this.#setUnread(0);
   }

package/src/core/agui_client.ts

@@ -408,6 +408,9 @@ export class AgUiClient {
   #buildSubscriber(pending: AgUiToolCall[], runState: RunState): AgentSubscriber {
     const h = this.#handlers;
     const closed = this.#closedMessageIds;
+    // Read at event time, not captured now: the flag flips mid-run, and the
+    // subscriber is built before the run that a later `cancel()` stops.
+    const cancelled = (): boolean => this.#cancelled;
     // Charts whose patch has been dispatched but not yet applied. Scoped to the
     // subscriber, so it cannot outlive the run that created it.
     const pendingDeltas = new Set<string>();
@@ -510,6 +513,15 @@ export class AgUiClient {
       onRunErrorEvent({ event }) {
         runState.terminal = true;
         runState.errored = true;
+        // Cancelling aborts the response mid-read, and the browser's own words
+        // for that can arrive here as a RUN_ERROR — Chrome's is
+        // "BodyStreamBuffer was aborted". The run is over either way, but a
+        // deliberate stop is not a failure, and reporting it would raise a
+        // warning bubble above the stopped note saying the same thing twice.
+        // The promise route in `#run` reports the cancellation.
+        if (cancelled()) {
+          return;
+        }
         h.onError(event.message);
       },
       onRunFinalized() {
@@ -532,7 +544,19 @@ interface RunState {
  * Whether a rejection came from aborting the run's fetch. Belt-and-suspenders
  * with the `#cancelled` flag: some `@ag-ui/client` versions re-throw the
  * `AbortError` instead of filtering it.
+ *
+ * Aborting a fetch whose body is mid-read does not always surface as an
+ * `AbortError`. Chrome raises `TypeError: BodyStreamBuffer was aborted`, which
+ * is the same event wearing a different name, so a message naming the abort is
+ * read as one too. Narrow on purpose: only a `TypeError`, and only when it says
+ * so — a genuine type error carries no such word, and misreading one as a
+ * cancellation would hide a real failure behind a stopped note.
  */
 function isAbortError(error: unknown): boolean {
-  return error instanceof Error && error.name === "AbortError";
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return (
+    error.name === "AbortError" || (error instanceof TypeError && /abort/i.test(error.message))
+  );
 }

package/src/core/conversation_store.ts

@@ -36,12 +36,24 @@ export interface ThreadMeta {
  * is a small local hint a server store can derive from history and no-op.
  *
  * Thread enumeration backs the chat-history drawer; deleting a thread reuses
- * {@link clear} and "new chat" reuses {@link threadId} after clearing the
- * active thread.
+ * {@link clear}, and "new chat" is {@link newThread} — which leaves the
+ * conversation it moves off of intact, for the drawer to offer back.
  */
 export interface ClientConversationStore {
   /** The active conversation id, generated and persisted on first read. */
   threadId(): string;
+  /**
+   * Start a fresh conversation, make it active, and return its id.
+   *
+   * Existing threads are left where they are: "new chat" adds one, and
+   * {@link clear} is the only method that takes one away.
+   *
+   * Optional, so a store written before this method existed still works. The
+   * caller then mints the id itself and hands it to {@link setActiveThread},
+   * which loses only the store's own record that the thread is new (see
+   * {@link isUnsent}).
+   */
+  newThread?(): string;
   /** Load the persisted message history, or `null` when none exists. */
   loadMessages(threadId: string): Promise<readonly Message[] | null>;
   /** Persist the message history (and refresh the thread's drawer metadata). */
@@ -123,13 +135,12 @@ export class SessionStorageStore implements ClientConversationStore {
   }
 
   threadId(): string {
-    const key = this.#key(THREAD_SUFFIX);
-    const existing = sessionStorage.getItem(key);
-    if (existing !== null) {
-      return existing;
-    }
+    return sessionStorage.getItem(this.#key(THREAD_SUFFIX)) ?? this.newThread();
+  }
+
+  newThread(): string {
     const id = randomUUID();
-    sessionStorage.setItem(key, id);
+    sessionStorage.setItem(this.#key(THREAD_SUFFIX), id);
     sessionStorage.setItem(this.#key(MINTED_SUFFIX + id), "1");
     return id;
   }

package/src/core/remote_conversation_store.ts

@@ -5,7 +5,7 @@ import {
   SessionStorageStore,
   type ThreadMeta,
 } from "./conversation_store.js";
-import { withCredentials } from "./utils.js";
+import { mintThread, withCredentials } from "./utils.js";
 
 /** One row of the server thread index (django-ag-ui's `ThreadsView` wire shape). */
 interface ServerThreadRow {
@@ -69,6 +69,15 @@ export class RemoteConversationStore implements ClientConversationStore {
     this.#local.setActiveThread(threadId);
   }
 
+  /**
+   * Delegated to the local store, which owns the active id — and deliberately
+   * silent on the wire: the server learns of a thread when its first message is
+   * persisted, so an abandoned new chat costs no round-trip and leaves no row.
+   */
+  newThread(): string {
+    return mintThread(this.#local);
+  }
+
   /** Delegated, so wrapping a store does not lose what it knows about its own ids. */
   isUnsent(threadId: string): boolean {
     return this.#local.isUnsent?.(threadId) === true;

package/src/core/utils.ts

@@ -1,4 +1,7 @@
-// Non-exported-from-index helpers shared by the core transport modules.
+// Non-exported-from-index helpers shared by the core modules.
+
+import { randomUUID } from "@ag-ui/client";
+import type { ClientConversationStore } from "./conversation_store.js";
 
 /**
  * Overlay a `credentials` mode onto a fetch `init`, or hand the `init` back
@@ -14,3 +17,24 @@ export function withCredentials(
 ): RequestInit | undefined {
   return credentials === undefined ? init : { ...init, credentials };
 }
+
+/**
+ * Start a new conversation in `store` and return its id.
+ *
+ * `newThread` is optional on the interface, so a store that predates it is
+ * driven the only other way the interface allows: mint an id here and make it
+ * active. That path loses the store's own note that the thread is new, so a
+ * remote store would go on to ask the server for a conversation that cannot
+ * exist yet — which is why every store in this package implements the method.
+ *
+ * What neither path does is clear the thread being left behind. Starting a
+ * conversation is not a reason to destroy the previous one.
+ */
+export function mintThread(store: ClientConversationStore): string {
+  if (store.newThread !== undefined) {
+    return store.newThread();
+  }
+  const id = randomUUID();
+  store.setActiveThread(id);
+  return id;
+}

package/src/version.ts

@@ -1 +1 @@
-export const VERSION: string = "0.26.1";
+export const VERSION: string = "0.27.0";