basalt-ui 1.12.0 → 1.13.0

package/dist/agent/adapter.js

@@ -113,6 +113,7 @@ function createAdapterThreadsStore(adapter, opts) {
     return seq;
   }
   const chains = /* @__PURE__ */ new Map();
+  const failedCreateIds = /* @__PURE__ */ new Set();
   function enqueue(threadIds, task) {
     const ids = [...new Set(threadIds)];
     const prior = ids.map((id) => chains.get(id)).filter((p) => p !== void 0);
@@ -137,9 +138,16 @@ function createAdapterThreadsStore(adapter, opts) {
     const tokenAtIssue = errorToken;
     recompute();
     enqueue(i.threadIds, async () => {
+      const [soleThreadId] = i.threadIds;
+      if (!i.isCreate && i.threadIds.length === 1 && soleThreadId !== void 0 && failedCreateIds.has(soleThreadId)) {
+        drop(patch);
+        recompute();
+        return;
+      }
       try {
         await i.commit();
       } catch (cause) {
+        if (i.isCreate) for (const threadId of i.threadIds) failedCreateIds.add(threadId);
         drop(patch);
         error = cause;
         errorToken += 1;
@@ -201,6 +209,7 @@ function createAdapterThreadsStore(adapter, opts) {
     mutate({
       threadIds: [id],
       apply: (threads) => threads.some((t) => t.id === id) ? [...threads] : [thread, ...threads],
+      isCreate: true,
       commit: () => adapter.createThread({
         id,
         ...createOpts?.meta !== void 0 ? { meta: createOpts.meta } : {}
@@ -337,7 +346,7 @@ function threadsStoreAdapterContract(makeAdapter) {
   }
   return [
     define("createThread then listThreads returns the thread with empty defaults", async (a) => {
-      const id = crypto.randomUUID();
+      const id = mintThreadId();
       await a.createThread({ id });
       const threads = await a.listThreads();
       const found = threads.filter((t) => t.id === id);
@@ -352,17 +361,17 @@ function threadsStoreAdapterContract(makeAdapter) {
       assert(typeof thread.updatedAt === "number", "updatedAt must be a number");
     }),
     define("createThread persists meta", async (a) => {
-      const id = crypto.randomUUID();
+      const id = mintThreadId();
       await a.createThread({ id, meta: { source: "contract" } });
       const thread = await loadOrThrow(a, id);
       assert(thread.meta?.["source"] === "contract", "meta did not round-trip");
     }),
     define("loadThread returns null for an unknown id", async (a) => {
-      const thread = await a.loadThread(crypto.randomUUID());
+      const thread = await a.loadThread(mintThreadId());
       assert(thread === null, "loadThread must return null (not throw, not undefined) when absent");
     }),
     define("appendMessage is idempotent on message.id", async (a) => {
-      const id = crypto.randomUUID();
+      const id = mintThreadId();
       await a.createThread({ id });
       const msg = message("contract-msg-1");
       await a.appendMessage({ threadId: id, message: msg });
@@ -375,7 +384,7 @@ function threadsStoreAdapterContract(makeAdapter) {
       assert(thread.messages[0]?.id === "contract-msg-1", "the retained message has the wrong id");
     }),
     define("appendMessage preserves order for distinct ids", async (a) => {
-      const id = crypto.randomUUID();
+      const id = mintThreadId();
       await a.createThread({ id });
       await a.appendMessage({ threadId: id, message: message("contract-msg-1") });
       await a.appendMessage({ threadId: id, message: message("contract-msg-2") });
@@ -386,7 +395,7 @@ function threadsStoreAdapterContract(makeAdapter) {
       );
     }),
     define("setStatus round-trips", async (a) => {
-      const id = crypto.randomUUID();
+      const id = mintThreadId();
       await a.createThread({ id });
       await a.setStatus({ threadId: id, status: "streaming" });
       assert((await loadOrThrow(a, id)).status === "streaming", "status did not become 'streaming'");
@@ -394,7 +403,7 @@ function threadsStoreAdapterContract(makeAdapter) {
       assert((await loadOrThrow(a, id)).status === "error", "status did not become 'error'");
     }),
     define("setOutcome round-trips", async (a) => {
-      const id = crypto.randomUUID();
+      const id = mintThreadId();
       await a.createThread({ id });
       const outcome = { title: "Title", summary: "Summary", status: "done" };
       await a.setOutcome({ threadId: id, outcome });
@@ -404,7 +413,7 @@ function threadsStoreAdapterContract(makeAdapter) {
       assert(thread.outcome?.status === "done", "outcome.status did not round-trip");
     }),
     define("setResumeToken round-trips and clears with undefined", async (a) => {
-      const id = crypto.randomUUID();
+      const id = mintThreadId();
       await a.createThread({ id });
       await a.setResumeToken({ threadId: id, token: "tok-1" });
       assert((await loadOrThrow(a, id)).resumeToken === "tok-1", "resumeToken did not round-trip");
@@ -415,14 +424,14 @@ function threadsStoreAdapterContract(makeAdapter) {
       );
     }),
     define("markRead marks the thread read", async (a) => {
-      const id = crypto.randomUUID();
+      const id = mintThreadId();
       await a.createThread({ id });
       assert((await loadOrThrow(a, id)).read === false, "a new thread must start unread");
       await a.markRead(id);
       assert((await loadOrThrow(a, id)).read === true, "markRead did not set read");
     }),
     define("listThreads reflects a write that has already resolved", async (a) => {
-      const id = crypto.randomUUID();
+      const id = mintThreadId();
       await a.createThread({ id });
       await a.appendMessage({ threadId: id, message: message("contract-msg-raw") });
       await a.setStatus({ threadId: id, status: "streaming" });
@@ -440,7 +449,7 @@ function threadsStoreAdapterContract(makeAdapter) {
     define(
       "dependent writes issued straight after createThread resolves are honoured",
       async (a) => {
-        const id = crypto.randomUUID();
+        const id = mintThreadId();
         await a.createThread({ id });
         await a.markRead(id);
         await a.appendMessage({ threadId: id, message: message("contract-msg-dep") });
@@ -455,7 +464,7 @@ function threadsStoreAdapterContract(makeAdapter) {
       }
     ),
     define("removeThread removes the thread", async (a) => {
-      const id = crypto.randomUUID();
+      const id = mintThreadId();
       await a.createThread({ id });
       await a.removeThread(id);
       assert(await a.loadThread(id).then((t) => t === null), "loadThread must be null after remove");
@@ -463,7 +472,7 @@ function threadsStoreAdapterContract(makeAdapter) {
       assert(!threads.some((t) => t.id === id), "listThreads still contains the removed thread");
     }),
     define("removeThread of an unknown id does not throw", async (a) => {
-      await a.removeThread(crypto.randomUUID());
+      await a.removeThread(mintThreadId());
     })
   ];
 }

package/dist/agent/ai-sdk-transport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ai-sdk-transport.d.ts","sourceRoot":"","sources":["../../src/agent/ai-sdk-transport.ts"],"names":[],"mappings":"AAmDA,OAAO,KAAK,EAAE,SAAS,EAAkB,MAAM,SAAS,CAAA;AACxD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAA;AAmB1D,MAAM,MAAM,qBAAqB,GAAG;IAClC,kFAAkF;IAClF,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,+CAA+C;IAC/C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAA;IACnD,oFAAoF;IACpF,QAAQ,CAAC,WAAW,CAAC,EAAE,kBAAkB,CAAA;IACzC;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAA;CACzC,CAAA;AAID,MAAM,MAAM,cAAc,CAAC,KAAK,GAAG,SAAS,IAAI,uBAAuB,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG;IACvF;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,uBAAuB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;CAC/E,CAAA;AAwRD;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,KAAK,GAAG,SAAS,EAC9C,OAAO,EAAE,qBAAqB,GAC7B,cAAc,CAAC,KAAK,CAAC,CA6CvB"}
+{"version":3,"file":"ai-sdk-transport.d.ts","sourceRoot":"","sources":["../../src/agent/ai-sdk-transport.ts"],"names":[],"mappings":"AAoDA,OAAO,KAAK,EAAE,SAAS,EAAkB,MAAM,SAAS,CAAA;AACxD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAA;AAmB1D,MAAM,MAAM,qBAAqB,GAAG;IAClC,kFAAkF;IAClF,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,+CAA+C;IAC/C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAA;IACnD,oFAAoF;IACpF,QAAQ,CAAC,WAAW,CAAC,EAAE,kBAAkB,CAAA;IACzC;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAA;CACzC,CAAA;AAID,MAAM,MAAM,cAAc,CAAC,KAAK,GAAG,SAAS,IAAI,uBAAuB,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG;IACvF;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,uBAAuB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;CAC/E,CAAA;AAwRD;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,KAAK,GAAG,SAAS,EAC9C,OAAO,EAAE,qBAAqB,GAC7B,cAAc,CAAC,KAAK,CAAC,CAkDvB"}

package/dist/agent/ai-sdk-transport.js

@@ -1,4 +1,5 @@
 import { assertNever } from "../register.js";
+import { mintMessageId, mintThreadId } from "./id.js";
 import { TERMINAL_TOOL_STATES } from "./parts.js";
 function createAiSdkResolver(options) {
   let resolved;
@@ -161,7 +162,10 @@ function aiSdkTransport(options) {
         yield { id: `${chatId}#start`, type: "start", runId: chatId, resumeToken: chatId };
         const { httpTransport, readUIMessageStream: readStream } = await resolveAiSdk();
         const userMessage = {
-          id: crypto.randomUUID(),
+          // This id is what AI SDK's own backend persistence/dedup keys turns hang off — the same
+          // idempotency-key cost as basalt's own ChatMessage.id (see mintMessageId's doc), so
+          // mintMessageId, not mintThreadId, is the right helper here.
+          id: mintMessageId(),
           role: "user",
           parts: [{ type: "text", text: input }]
         };
@@ -182,7 +186,7 @@ function aiSdkTransport(options) {
       }
     };
   }
-  const fixedChatId = crypto.randomUUID();
+  const fixedChatId = mintThreadId();
   return {
     ...makeTransport(fixedChatId),
     forThread: (chatId) => makeTransport(chatId)

package/dist/agent/id.d.ts

@@ -1,33 +1,81 @@
 /**
- * Id-minting helpers shared by the thread stores: `mintThreadId` (a client-side thread id, used by
- * both `./thread`'s `createThreadsStore` and `./adapter`'s `createAdapterThreadsStore`) and
- * `withPartIds` (stamps sequence ids onto streamed parts). Related in theme — both mint an id a
- * store needs — unrelated in mechanism; grouped here because they're the two id-minting leaves the
- * two thread stores both sit above.
+ * Id-minting helpers shared across the agent layer: `mintThreadId` (a low-stakes client-side id —
+ * threads, run/chat namespaces — used by `./thread`'s `createThreadsStore`, `./adapter`'s
+ * `createAdapterThreadsStore`/`threadsStoreAdapterContract`, `./use-agent-stream`'s per-send run
+ * id, and `aiSdkTransport`'s fixed chat id), `mintMessageId` (the higher-stakes id `appendMessage`
+ * treats as its only idempotency key), and `withPartIds` (stamps sequence ids onto streamed
+ * parts). Grouped here because they're the id-minting leaves every store/hook/transport in this
+ * layer sits above — not because they share a mechanism (`mintMessageId` deliberately diverges
+ * from `mintThreadId` on rung 3; see its own doc).
  */
 /**
- * Mints a client-side thread id. `crypto.randomUUID()` exists only in SECURE CONTEXTS (HTTPS or
- * localhost) — a consumer served over plain HTTP on a LAN hostname (a homelab dashboard on a bare
- * IP, a staging box) would otherwise have `create()`, about the most basic user action a thread
- * store has, throw a plain TypeError. A store used from a browser must not throw on a user gesture
- * — the same principle already applied twice this release (`spliceText` clamps rather than throws,
- * `coalesceParts` degrades rather than throws).
+ * Mints a client-side id for a LOW-COLLISION-COST use: a thread id, a per-send run-id namespace, a
+ * fixed chat id — anything minted client-side that is NOT the idempotency key some write depends
+ * on. `crypto.randomUUID()` exists only in SECURE CONTEXTS (HTTPS or localhost) — a consumer served
+ * over plain HTTP on a LAN hostname (a homelab dashboard on a bare IP, a staging box) would
+ * otherwise have `create()`, about the most basic user action a thread store has, throw a plain
+ * TypeError. A store used from a browser must not throw on a user gesture — the same principle
+ * already applied twice this release (`spliceText` clamps rather than throws, `coalesceParts`
+ * degrades rather than throws).
  *
  * Fallback chain, each rung reached only when the one above it is unavailable:
  *   1. `crypto.randomUUID()` — cryptographically random, RFC 4122 UUID. The normal path.
  *   2. `crypto.getRandomValues()` — still cryptographically random; hand-assembled into a UUIDv4
- *      (the version/variant bits are set per RFC 4122, since this rung hands back raw bytes, not a
- *      formatted UUID).
+ *      via `assembleUuidV4`.
  *   3. No usable `crypto` at all (missing entirely, or missing both methods above — an old WebView,
  *      an SSR shim). NOT cryptographically random and NOT collision-resistant in general. This rung
- *      exists solely so `create()` never throws on such a host. It is acceptable ONLY because this
- *      id is minted a handful of times per client session and is not the idempotency key any write
- *      here depends on — `ThreadsStoreAdapter.appendMessage`'s idempotency key is the MESSAGE id,
- *      not this thread id, so a collision on this rung costs a locally merged/duplicated thread, not
- *      silent data loss on the append path. Do not reuse this rung for anything with a higher
- *      collision cost than that.
+ *      exists solely so a caller never throws on such a host. It is acceptable ONLY because an id
+ *      minted here is minted a handful of times per client session and is not the idempotency key
+ *      any write depends on — `ThreadsStoreAdapter.appendMessage`'s idempotency key is the MESSAGE
+ *      id (see `mintMessageId`), not this one, so a collision on this rung costs a locally
+ *      merged/duplicated thread (or two runs sharing a part-id namespace), not silent data loss on
+ *      the append path. Do not reuse this rung for anything with a higher collision cost than that
+ *      — see `mintMessageId` for the id that needs one.
  */
 export declare function mintThreadId(): string;
+/**
+ * Mints a message id — the value `ThreadsStoreAdapter.appendMessage` treats as its ONLY
+ * idempotency key (see that method's contract doc in `./adapter`). Shares `mintThreadId`'s rungs
+ * 1-2 (`crypto.randomUUID()`, then `crypto.getRandomValues()` assembled into a UUIDv4) — both are
+ * cryptographically random and collision-resistant, and rung 2 is the fix that actually matters in
+ * practice (a plain-HTTP/LAN host still has `getRandomValues`; only `randomUUID` is secure-context-
+ * gated).
+ *
+ * Rung 3 deliberately DIVERGES from `mintThreadId`: it THROWS instead of degrading to a
+ * non-random fallback. A thread id's rung-3 collision costs a locally merged/duplicated thread —
+ * annoying, recoverable, visible. A message id's collision cost is different IN KIND, not degree:
+ * `appendMessage` is idempotent on this id, so two messages that collide are not two rows, they
+ * are ONE — the second write silently no-ops and its content is gone, with nothing downstream able
+ * to tell. Degrading here would trade a loud, debuggable failure for silent, permanent data loss.
+ *
+ * This deliberately diverges from this layer's other standing rule — render-path code degrades,
+ * never throws (`spliceText` clamps, `coalesceParts` degrades, a consumer fence renderer must not
+ * take the message down) — because minting a message id is NOT render-path code. It runs once, in
+ * the write path that constructs a message before handing it to a store (`start()`,
+ * `consumeAndFinalize`'s finalize step, `finalizeStop`, `aiSdkTransport`'s per-turn user message),
+ * never inside the per-chunk accumulation/render loop those functions guard. A host with no usable
+ * `crypto` at all (missing both `randomUUID` and `getRandomValues`) is vanishingly rare — no
+ * runtime with a DOM/fetch surface worth targeting ships without a Crypto object — and an uncaught
+ * throw here is a loud, debuggable failure rather than a message silently vanishing with no trace,
+ * but WHERE it surfaces differs by call site (audited, not assumed — this paragraph previously
+ * claimed a single shared catch handled all of them, which was false):
+ *   - `consumeAndFinalize`'s own assistantMessage mint runs inside that function's try/catch, so a
+ *     throw there is correctly turned into `onFailureStatus` ('error' from `start()`, 'interrupted'
+ *     from the mount-time resume) — a visibly stuck-then-settled run, as originally claimed.
+ *   - `useAgentThreadRuns.start()`'s userMessage mint runs BEFORE any state is touched
+ *     (`appendMessage`/`setStatus`/the controller registration all come after it), so a throw there
+ *     is a true no-op that propagates synchronously out of `start()` itself — not a stuck run at
+ *     all, since nothing ever started. See `UseAgentThreadRunsReturn.start`'s `@throws` doc.
+ *   - `finalizeStop`'s stoppedMessage mint is wrapped in its own try/catch precisely so a throw
+ *     here cannot wedge the thread at 'streaming' forever (stop() has already torn down this run's
+ *     bookkeeping by the time finalizeStop runs, so a second stop() is always a no-op) — see
+ *     `finalizeStop`'s doc for the guarded behavior and the resulting 'error' status.
+ * A stuck spinner is debuggable; silently discarded chat history is not — that half of the
+ * original claim stands regardless of which of the three paths above catches it.
+ *
+ * @throws {Error} when neither `crypto.randomUUID` nor `crypto.getRandomValues` is available.
+ */
+export declare function mintMessageId(): string;
 /**
  * withPartIds — stamps a stable id onto every draft part arriving without one.
  *

package/dist/agent/id.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"id.d.ts","sourceRoot":"","sources":["../../src/agent/id.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,YAAY,IAAI,MAAM,CAgBrC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAuB,WAAW,CAAC,KAAK,SAAS;IAAE,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,EAC9D,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,cAAc,CAAC,KAAK,CAAC,GAC5B,cAAc,CAAC,KAAK,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,CAUxC"}
+{"version":3,"file":"id.d.ts","sourceRoot":"","sources":["../../src/agent/id.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAmBH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,YAAY,IAAI,MAAM,CAQrC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,aAAa,IAAI,MAAM,CAYtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAuB,WAAW,CAAC,KAAK,SAAS;IAAE,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,EAC9D,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,cAAc,CAAC,KAAK,CAAC,GAC5B,cAAc,CAAC,KAAK,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,CAUxC"}

package/dist/agent/id.js

@@ -1,18 +1,31 @@
+function assembleUuidV4(bytes) {
+  const hex = Array.from({ length: 16 }, (_, i) => {
+    const raw = bytes.at(i) ?? 0;
+    const byte = i === 6 ? raw & 15 | 64 : i === 8 ? raw & 63 | 128 : raw;
+    return byte.toString(16).padStart(2, "0");
+  }).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
 function mintThreadId() {
   if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
     return crypto.randomUUID();
   }
   if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
-    const bytes = crypto.getRandomValues(new Uint8Array(16));
-    const hex = Array.from({ length: 16 }, (_, i) => {
-      const raw = bytes.at(i) ?? 0;
-      const byte = i === 6 ? raw & 15 | 64 : i === 8 ? raw & 63 | 128 : raw;
-      return byte.toString(16).padStart(2, "0");
-    }).join("");
-    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+    return assembleUuidV4(crypto.getRandomValues(new Uint8Array(16)));
   }
   return `id-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
 }
+function mintMessageId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    return assembleUuidV4(crypto.getRandomValues(new Uint8Array(16)));
+  }
+  throw new Error(
+    "mintMessageId: no usable crypto (both randomUUID and getRandomValues are unavailable) \u2014 refusing to mint a non-random message id, since ThreadsStoreAdapter.appendMessage treats this id as its only idempotency key and a collision would silently drop a message."
+  );
+}
 async function* withPartIds(runId, source) {
   let n = 0;
   for await (const part of source) {
@@ -25,6 +38,7 @@ async function* withPartIds(runId, source) {
   }
 }
 export {
+  mintMessageId,
   mintThreadId,
   withPartIds
 };

package/dist/agent/thread.d.ts

@@ -109,6 +109,10 @@ export type ThreadsStore<TPart = AgentPart> = {
      * store built with `createAdapterThreadsStore` (./adapter), where it stays `false` until the
      * first `listThreads` SUCCEEDS. Pair it with `error` — `!hydrated && error !== undefined` is a
      * failed load, `!hydrated && error === undefined` is still loading.
+     *
+     * Gating an empty state on this is the CALLER's job when hand-assembling `ThreadFeed` /
+     * `ThreadDetailPanel`; the shipped `ThreadWorkspace` already does it internally, so an
+     * async store never flashes "no threads yet" through it before it actually knows.
      */
     readonly hydrated: boolean;
     /**

package/dist/agent/thread.d.ts.map

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

package/dist/agent/use-agent-stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-agent-stream.d.ts","sourceRoot":"","sources":["../../src/agent/use-agent-stream.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AACvC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AACxC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAIjD,iDAAiD;AACjD,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,GAAG,OAAO,CAAA;AAIlE,MAAM,MAAM,oBAAoB,CAAC,KAAK,EAAE,MAAM,IAAI;IAChD,qEAAqE;IACrE,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,CAAA;IACvB,gCAAgC;IAChC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAA;IAC7B,oEAAoE;IACpE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC/C,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,CAAA;IACzB,kEAAkE;IAClE,QAAQ,CAAC,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CACzC,CAAA;AAID;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,KAAK,SAAS,QAAQ,GAAG,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,EAClF,SAAS,GACV,EAAE;IACD,SAAS,EAAE,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;CACzC,GAAG,oBAAoB,CAAC,KAAK,EAAE,MAAM,CAAC,CA0EtC"}
+{"version":3,"file":"use-agent-stream.d.ts","sourceRoot":"","sources":["../../src/agent/use-agent-stream.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AACvC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AACxC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAIjD,iDAAiD;AACjD,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,GAAG,OAAO,CAAA;AAIlE,MAAM,MAAM,oBAAoB,CAAC,KAAK,EAAE,MAAM,IAAI;IAChD,qEAAqE;IACrE,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,CAAA;IACvB,gCAAgC;IAChC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAA;IAC7B,oEAAoE;IACpE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC/C,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,CAAA;IACzB,kEAAkE;IAClE,QAAQ,CAAC,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CACzC,CAAA;AAID;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,KAAK,SAAS,QAAQ,GAAG,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,EAClF,SAAS,GACV,EAAE;IACD,SAAS,EAAE,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;CACzC,GAAG,oBAAoB,CAAC,KAAK,EAAE,MAAM,CAAC,CA6EtC"}

package/dist/agent/use-agent-stream.js

@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useRef, useState } from "react";
-import { withPartIds } from "./id.js";
+import { mintThreadId, withPartIds } from "./id.js";
 import { isStartPart } from "./parts.js";
 import { mergePart } from "./merge.js";
 function useAgentStream({
@@ -25,7 +25,7 @@ function useAgentStream({
       setParts([]);
       setError(void 0);
       setStatus("streaming");
-      const runId = crypto.randomUUID();
+      const runId = mintThreadId();
       try {
         for await (const part of withPartIds(runId, transport.stream(input, controller.signal))) {
           if (controllerRef.current !== controller) return;

package/dist/agent/use-agent-thread-runs.d.ts

@@ -46,18 +46,39 @@ export type UseAgentThreadRunsArgs<TPart = AgentPart> = {
 export type UseAgentThreadRunsReturn<TPart = AgentPart> = {
     /** Live stream state per thread id, for threads with a run in progress or just completed. */
     readonly runs: ReadonlyMap<string, ThreadRunState<TPart>>;
-    /** Start a new turn on `threadId`. No-op if that thread already has a stream in flight. */
+    /**
+     * Start a new turn on `threadId`. No-op if that thread already has a stream in flight.
+     *
+     * @throws {Error} synchronously, before any state is touched, on a host with no usable
+     * `crypto` at all (see `mintMessageId` in `./id.ts` — the id it mints here is the new user
+     * ChatMessage's idempotency key, so it degrades to a throw rather than a silent collision).
+     * This throw is a true no-op: it happens before `appendMessage`/`setStatus`/the run's
+     * controller are registered, so nothing is left half-started — the thread is exactly as it was
+     * before the call. A caller invoking `start` from an event handler on a target that must
+     * tolerate this (very old WebViews, non-DOM SSR shims) should wrap the call in its own
+     * try/catch; this rung is vanishingly rare in practice (see `mintMessageId`'s own doc).
+     */
     readonly start: (threadId: string, input: string) => void;
     /**
      * Replay the last user input sent on `threadId` (same code path as `start`). No-op if
      * `threadId` has never had a turn started, or already has one in flight.
+     *
+     * @throws {Error} same condition and same true-no-op guarantee as `start` — see its doc.
      */
     readonly retry: (threadId: string) => void;
     /**
-     * Abort the in-flight stream for `threadId` (no-op if idle). Preserves whatever content had
-     * already arrived: if the run had accumulated any parts, they're persisted as an assistant
+     * Abort the in-flight stream for `threadId` (true no-op only if BOTH `controllersRef` and
+     * `runs` have nothing for it — i.e. the thread genuinely isn't live). Preserves whatever content
+     * had already arrived: if the run had accumulated any parts, they're persisted as an assistant
      * ChatMessage with `finish: 'stopped'` (unless that message already landed — see finalizeStop),
      * then distilled into an outcome and the thread is settled to 'done'.
+     *
+     * Defense-in-depth: if `runs` reports `threadId` as `'streaming'` but no controller is
+     * registered for it (a phantom entry — not reachable via any path in this hook today, since the
+     * unmount-cleanup effect and `finalizeStop` both tear down `controllersRef` and `runs` together,
+     * but guarded against here so nothing in this file can EVER wedge a thread the UI shows as live
+     * with no way to reach a terminal state), `stop()` still settles it instead of silently
+     * no-opping forever.
      */
     readonly stop: (threadId: string) => void;
     /** Abort every in-flight stream across all threads, settling each the same way stop() would. */

package/dist/agent/use-agent-thread-runs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-agent-thread-runs.d.ts","sourceRoot":"","sources":["../../src/agent/use-agent-thread-runs.ts"],"names":[],"mappings":"AA4CA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AACvC,OAAO,KAAK,EAAgB,eAAe,EAAE,MAAM,WAAW,CAAA;AAE9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AACxC,OAAO,KAAK,EAA6B,YAAY,EAAE,MAAM,UAAU,CAAA;AAEvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAIjD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,cAAc,CAAC,KAAK,GAAG,SAAS,IAAI;IAC9C,yFAAyF;IACzF,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;IAC5B,iEAAiE;IACjE,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,CAAA;CACxB,CAAA;AAID,MAAM,MAAM,sBAAsB,CAAC,KAAK,GAAG,SAAS,IAAI;IACtD;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,SAAS,EACd,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,GAC7B,CAAC,CAAC,QAAQ,EAAE,MAAM,KAAK,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAA;IACzD,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC,KAAK,CAAC,CAAA;IACnC,uFAAuF;IACvF,QAAQ,CAAC,cAAc,EAAE,eAAe,CAAC,KAAK,CAAC,CAAA;IAC/C;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,KAAK,EAAE,CAAA;CAClD,CAAA;AAID,MAAM,MAAM,wBAAwB,CAAC,KAAK,GAAG,SAAS,IAAI;IACxD,6FAA6F;IAC7F,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,KAAK,CAAC,CAAC,CAAA;IACzD,2FAA2F;IAC3F,QAAQ,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACzD;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;IAC1C;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;IACzC,gGAAgG;IAChG,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAA;CAC7B,CAAA;AAkND;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,SAAS,QAAQ,GAAG,SAAS,EAAE,EACrE,SAAS,EACT,KAAK,EACL,cAAc,EACd,WAAW,GACZ,EAAE,sBAAsB,CAAC,KAAK,CAAC,GAAG,wBAAwB,CAAC,KAAK,CAAC,CAkPjE"}
+{"version":3,"file":"use-agent-thread-runs.d.ts","sourceRoot":"","sources":["../../src/agent/use-agent-thread-runs.ts"],"names":[],"mappings":"AA4CA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AACvC,OAAO,KAAK,EAAgB,eAAe,EAAE,MAAM,WAAW,CAAA;AAE9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AACxC,OAAO,KAAK,EAA6B,YAAY,EAAE,MAAM,UAAU,CAAA;AAEvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAIjD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,cAAc,CAAC,KAAK,GAAG,SAAS,IAAI;IAC9C,yFAAyF;IACzF,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;IAC5B,iEAAiE;IACjE,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,CAAA;CACxB,CAAA;AAID,MAAM,MAAM,sBAAsB,CAAC,KAAK,GAAG,SAAS,IAAI;IACtD;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,SAAS,EACd,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,GAC7B,CAAC,CAAC,QAAQ,EAAE,MAAM,KAAK,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAA;IACzD,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC,KAAK,CAAC,CAAA;IACnC,uFAAuF;IACvF,QAAQ,CAAC,cAAc,EAAE,eAAe,CAAC,KAAK,CAAC,CAAA;IAC/C;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,KAAK,EAAE,CAAA;CAClD,CAAA;AAID,MAAM,MAAM,wBAAwB,CAAC,KAAK,GAAG,SAAS,IAAI;IACxD,6FAA6F;IAC7F,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,KAAK,CAAC,CAAC,CAAA;IACzD;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACzD;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;IAC1C;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;IACzC,gGAAgG;IAChG,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAA;CAC7B,CAAA;AAuRD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,SAAS,QAAQ,GAAG,SAAS,EAAE,EACrE,SAAS,EACT,KAAK,EACL,cAAc,EACd,WAAW,GACZ,EAAE,sBAAsB,CAAC,KAAK,CAAC,GAAG,wBAAwB,CAAC,KAAK,CAAC,CAgSjE"}

package/dist/agent/use-agent-thread-runs.js

@@ -1,10 +1,10 @@
 import { useCallback, useEffect, useRef, useState } from "react";
-import { withPartIds } from "./id.js";
+import { mintMessageId, mintThreadId, withPartIds } from "./id.js";
 import { mergePart } from "./merge.js";
 import { isStartPart } from "./parts.js";
 import { isResumable } from "./transport.js";
 function defaultToUserParts(input) {
-  return [{ id: crypto.randomUUID(), type: "text", text: input }];
+  return [{ id: mintThreadId(), type: "text", text: input }];
 }
 function buildDoneSnapshot(priorThread, threadId, userMessage, assistantMessage) {
   const updatedAt = Date.now();
@@ -59,7 +59,9 @@ async function consumeAndFinalize(args) {
       return;
     }
     const assistantMessage = {
-      id: crypto.randomUUID(),
+      // appendMessage's idempotency key — mintMessageId, never mintThreadId (see that helper's
+      // doc): a collided id here would silently drop this message, not merge a duplicate thread.
+      id: mintMessageId(),
       role: "assistant",
       parts,
       createdAt: Date.now(),
@@ -101,24 +103,43 @@ async function consumeAndFinalize(args) {
 }
 async function finalizeStop(args) {
   const { threadId, parts, alreadyAppended, storeRef, resolveOutcome, setRuns } = args;
+  let appendFailed = false;
   if (!alreadyAppended && parts.length > 0) {
-    const stoppedMessage = {
-      id: crypto.randomUUID(),
-      role: "assistant",
-      parts,
-      createdAt: Date.now(),
-      finish: "stopped"
-    };
-    storeRef.current.appendMessage(threadId, stoppedMessage);
+    try {
+      const stoppedMessage = {
+        // Same idempotency-key reasoning as consumeAndFinalize's assistantMessage — mintMessageId.
+        // This can throw on rung 3 (no usable crypto — see ./id.ts) just like appendMessage
+        // (consumer code) can throw for its own reasons; both are caught below so neither can
+        // wedge the thread — see this function's doc.
+        id: mintMessageId(),
+        role: "assistant",
+        parts,
+        createdAt: Date.now(),
+        finish: "stopped"
+      };
+      storeRef.current.appendMessage(threadId, stoppedMessage);
+    } catch {
+      appendFailed = true;
+    }
+  }
+  let settleFailed = appendFailed;
+  try {
+    storeRef.current.setStatus(threadId, appendFailed ? "error" : "done");
+  } catch {
+    settleFailed = true;
+  }
+  try {
+    storeRef.current.setResumeToken(threadId, void 0);
+  } catch {
+    settleFailed = true;
   }
-  storeRef.current.setStatus(threadId, "done");
-  storeRef.current.setResumeToken(threadId, void 0);
   setRuns((prev) => {
     if (!prev.has(threadId)) return prev;
     const next = new Map(prev);
     next.delete(threadId);
     return next;
   });
+  if (settleFailed) return;
   const snapshot = storeRef.current.threads.find((thread) => thread.id === threadId);
   if (snapshot === void 0) return;
   const outcome = await resolveOutcome(snapshot);
@@ -155,9 +176,20 @@ function useAgentThreadRuns({
   };
   useEffect(
     () => () => {
+      const abortedThreadIds = Array.from(controllersRef.current.keys());
       controllersRef.current.forEach((controller) => controller.abort());
       controllersRef.current.clear();
       appendedRef.current.clear();
+      if (abortedThreadIds.length === 0) return;
+      setRuns((prev) => {
+        let next;
+        for (const threadId of abortedThreadIds) {
+          if (!prev.has(threadId)) continue;
+          next ??= new Map(prev);
+          next.delete(threadId);
+        }
+        return next ?? prev;
+      });
     },
     []
   );
@@ -206,7 +238,8 @@ function useAgentThreadRuns({
       if (controllersRef.current.has(threadId)) return;
       lastInputRef.current.set(threadId, input);
       const userMessage = {
-        id: crypto.randomUUID(),
+        // Same idempotency-key reasoning as consumeAndFinalize's assistantMessage — mintMessageId.
+        id: mintMessageId(),
         role: "user",
         parts: toUserPartsRef.current(input),
         createdAt: Date.now()
@@ -248,7 +281,14 @@ function useAgentThreadRuns({
   const stop = useCallback(
     (threadId) => {
       const controller = controllersRef.current.get(threadId);
-      if (controller === void 0) return;
+      if (controller === void 0) {
+        if (!runsRef.current.has(threadId)) return;
+        const parts2 = runsRef.current.get(threadId)?.parts ?? [];
+        const alreadyAppended2 = appendedRef.current.has(threadId);
+        appendedRef.current.delete(threadId);
+        void finalizeStop({ threadId, parts: parts2, alreadyAppended: alreadyAppended2, storeRef, resolveOutcome, setRuns });
+        return;
+      }
       controllersRef.current.delete(threadId);
       const parts = runsRef.current.get(threadId)?.parts ?? [];
       controller.abort();

package/dist/agent-chat/index.d.ts

@@ -14,6 +14,10 @@ export { ThreadWorkspace } from './thread-workspace.js';
 export type { ThreadWorkspaceProps } from './thread-workspace.js';
 export { ThreadFeed } from './thread-feed.js';
 export type { ThreadFeedProps } from './thread-feed.js';
+export { ThreadFeedRow } from './thread-feed-row.js';
+export type { ThreadFeedRowProps } from './thread-feed-row.js';
+export type { MessageAffordances } from './message-affordances.js';
+export type { VirtualizeOptions, VirtualizeProps } from './virtualize.js';
 export { ThreadOutcomeCard } from './thread-outcome-card.js';
 export type { ThreadOutcomeCardProps } from './thread-outcome-card.js';
 export { ThreadDetailPanel } from './thread-detail-panel.js';

package/dist/agent-chat/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agent-chat/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACpD,YAAY,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAG9D,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC1C,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAGpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AACzD,YAAY,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AAGnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AACzD,YAAY,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AAGnE,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrC,YAAY,EAAE,kBAAkB,EAAE,cAAc,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAGnG,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AACxE,YAAY,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAA;AAG7D,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AACtC,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agent-chat/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACpD,YAAY,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAG9D,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC1C,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAGpD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACjD,YAAY,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAO3D,YAAY,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAC/D,YAAY,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAGtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AACzD,YAAY,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AAGnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AACzD,YAAY,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AAGnE,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrC,YAAY,EAAE,kBAAkB,EAAE,cAAc,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAGnG,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AACxE,YAAY,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAA;AAG7D,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AACtC,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA"}

package/dist/agent-chat/index.js

@@ -1,5 +1,6 @@
 import { ThreadWorkspace } from "./thread-workspace.js";
 import { ThreadFeed } from "./thread-feed.js";
+import { ThreadFeedRow } from "./thread-feed-row.js";
 import { ThreadOutcomeCard } from "./thread-outcome-card.js";
 import { ThreadDetailPanel } from "./thread-detail-panel.js";
 import { Composer } from "./composer.js";
@@ -9,6 +10,7 @@ export {
   Composer,
   ThreadDetailPanel,
   ThreadFeed,
+  ThreadFeedRow,
   ThreadOutcomeCard,
   ThreadTranscript,
   ThreadWorkspace,