@dudousxd/nestjs-agent-react 0.14.0 → 0.15.0

package/dist/index.js

@@ -1,6 +1,246 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
+// src/client.ts
+var AgentHttpError = class extends Error {
+  static {
+    __name(this, "AgentHttpError");
+  }
+  status;
+  method;
+  path;
+  constructor(status, method, path, statusText) {
+    super(`Agent request failed: ${method} ${path} \u2192 ${status} ${statusText}`), this.status = status, this.method = method, this.path = path;
+    this.name = "AgentHttpError";
+  }
+};
+var HEADER_RUN_ID = "x-agent-run-id";
+var HEADER_THREAD_ID = "x-agent-thread-id";
+var AgentClient = class {
+  static {
+    __name(this, "AgentClient");
+  }
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /** `POST /agent/chat` → the turn's SSE stream. Throws {@link AgentHttpError} on a non-2xx. */
+  async openChatStream(request) {
+    const response = await this.fetchImpl()(`${this.baseUrl()}/agent/chat`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        accept: "text/event-stream",
+        ...await this.resolveHeaders(),
+        ...request.headers
+      },
+      body: JSON.stringify(request.body),
+      ...this.credentials(),
+      ...request.signal !== void 0 ? {
+        signal: request.signal
+      } : {}
+    });
+    if (!response.ok || !response.body) {
+      throw new AgentHttpError(response.status, "POST", "/agent/chat", response.statusText);
+    }
+    return streamResponse(response);
+  }
+  /**
+  * `GET /agent/chat/:runId/stream[?after=<seq>]` → the run's SSE stream, or `null` when nothing is
+  * streaming under that id (404).
+  */
+  async resumeChatStream(request) {
+    const path = `/agent/chat/${encodeURIComponent(request.runId)}/stream`;
+    const query = request.after !== void 0 && request.after > 0 ? `?after=${request.after}` : "";
+    const response = await this.fetchImpl()(`${this.baseUrl()}${path}${query}`, {
+      method: "GET",
+      headers: {
+        accept: "text/event-stream",
+        ...await this.resolveHeaders(),
+        ...request.headers
+      },
+      ...this.credentials(),
+      ...request.signal !== void 0 ? {
+        signal: request.signal
+      } : {}
+    });
+    if (response.status === 404) {
+      return null;
+    }
+    if (!response.ok || !response.body) {
+      throw new AgentHttpError(response.status, "GET", path, response.statusText);
+    }
+    return streamResponse(response);
+  }
+  /**
+  * Rate a message (`'up'`/`'down'`, optional comment) or clear its rating (`value: null`). Answers
+  * the stored rating.
+  */
+  setMessageFeedback(messageId, input) {
+    return this.request("POST", `/agent/messages/${encodeURIComponent(messageId)}/feedback`, input);
+  }
+  listThreads() {
+    return this.request("GET", "/agent/threads");
+  }
+  /**
+  * The skills this caller can invoke right now, scope-resolved — the same list, built by the same
+  * call, that the model is offered, so what a user can type after a `/` and what the agent can
+  * reach cannot drift apart. `threadId` reaches the host's own resolver, which may scope a skill to
+  * one conversation; omitted, the server reads it as a brand-new thread.
+  */
+  listSkills(threadId) {
+    const query = threadId === void 0 ? "" : `?threadId=${encodeURIComponent(threadId)}`;
+    return this.request("GET", `/agent/skills${query}`);
+  }
+  /**
+  * The tools this caller can reach through `agent` (the default agent when omitted), each with the
+  * server-declared `presentation` a chat narrates it by — the same list the model is offered.
+  * Prefer {@link useToolCatalog}, which fetches it once and shares it.
+  */
+  listTools(agent) {
+    const query = agent === void 0 ? "" : `?agent=${encodeURIComponent(agent)}`;
+    return this.request("GET", `/agent/tools${query}`);
+  }
+  getThread(id) {
+    return this.request("GET", `/agent/threads/${encodeURIComponent(id)}`);
+  }
+  deleteThread(id) {
+    return this.request("DELETE", `/agent/threads/${encodeURIComponent(id)}`);
+  }
+  forkFromMessage(threadId, messageId) {
+    return this.request("POST", `/agent/threads/${encodeURIComponent(threadId)}/fork-from/${encodeURIComponent(messageId)}`);
+  }
+  renameThread(id, title) {
+    return this.updateThread(id, {
+      title
+    });
+  }
+  /** General `PATCH /agent/threads/:threadId` — title and/or the thread's pinned default agent. */
+  updateThread(id, patch) {
+    return this.request("PATCH", `/agent/threads/${encodeURIComponent(id)}`, patch);
+  }
+  /**
+  * Uploads a file (image/PDF) for a vision-capable model turn. Multipart, field name `file` —
+  * mirrors the backend's `POST /agent/attachments`. The returned {@link MessageAttachment} is
+  * what a caller then rides on `sendMessage({ text }, { body: { attachments: [...] } })`.
+  */
+  async uploadAttachment(file, options = {}) {
+    const formData = new FormData();
+    formData.append("file", file);
+    const response = await this.fetchImpl()(`${this.baseUrl()}/agent/attachments`, {
+      method: "POST",
+      headers: {
+        accept: "application/json",
+        ...await this.resolveHeaders()
+      },
+      body: formData,
+      ...this.credentials(),
+      ...options.signal !== void 0 ? {
+        signal: options.signal
+      } : {}
+    });
+    return this.handleResponse(response, "POST", "/agent/attachments");
+  }
+  promoteThread(id) {
+    return this.request("POST", `/agent/threads/${encodeURIComponent(id)}/promote`);
+  }
+  truncateFromMessage(threadId, messageId) {
+    return this.request("DELETE", `/agent/threads/${encodeURIComponent(threadId)}/from/${encodeURIComponent(messageId)}`);
+  }
+  getQuotaToday() {
+    return this.request("GET", "/agent/quota/today");
+  }
+  cancelStream(runId) {
+    return this.request("POST", `/agent/chat/${encodeURIComponent(runId)}/cancel`);
+  }
+  /**
+  * `remember` approves later calls of the same tool in the same thread; `via` names the surface
+  * the decision came through (the server records `'web'` when omitted).
+  */
+  approveToolCall(input) {
+    return this.request("POST", "/agent/tool-call/approve", input);
+  }
+  rejectToolCall(input) {
+    return this.request("POST", "/agent/tool-call/reject", input);
+  }
+  /**
+  * Settle a parked question set. `answers` is questionId → chosen option values; a question left
+  * out takes the pre-picked default the request carried, resolved server-side against the request
+  * the run already holds. Omit the whole object and the user has confirmed every pre-picked
+  * answer — which is the point of the surface, so it is a valid submission rather than a blank.
+  */
+  answerToolCall(input) {
+    return this.request("POST", "/agent/tool-call/answer", input);
+  }
+  /**
+  * Decline to answer and let the agent proceed on its own pre-picked values. Lands on the same
+  * values a confirmation would, and persists differently on purpose — only one of them is
+  * evidence the user chose them.
+  */
+  skipToolCall(input) {
+    return this.request("POST", "/agent/tool-call/skip", input);
+  }
+  fetchImpl() {
+    return this.options.fetch ?? globalThis.fetch;
+  }
+  baseUrl() {
+    return (this.options.baseUrl ?? "").replace(/\/$/, "");
+  }
+  async resolveHeaders() {
+    const dynamic = await this.options.getHeaders?.() ?? {};
+    return {
+      ...this.options.headers,
+      ...dynamic
+    };
+  }
+  credentials() {
+    return this.options.credentials !== void 0 ? {
+      credentials: this.options.credentials
+    } : {};
+  }
+  async request(method, path, body) {
+    const response = await this.fetchImpl()(`${this.baseUrl()}${path}`, {
+      method,
+      headers: {
+        accept: "application/json",
+        ...body !== void 0 ? {
+          "content-type": "application/json"
+        } : {},
+        ...await this.resolveHeaders()
+      },
+      ...body !== void 0 ? {
+        body: JSON.stringify(body)
+      } : {},
+      ...this.credentials()
+    });
+    return this.handleResponse(response, method, path);
+  }
+  async handleResponse(response, method, path) {
+    if (!response.ok) {
+      throw new AgentHttpError(response.status, method, path, response.statusText);
+    }
+    if (response.status === 204) return void 0;
+    const text = await response.text();
+    if (!text) return void 0;
+    return JSON.parse(text);
+  }
+};
+function streamResponse(response) {
+  const body = response.body;
+  const runId = response.headers?.get(HEADER_RUN_ID) ?? void 0;
+  const threadId = response.headers?.get(HEADER_THREAD_ID) ?? void 0;
+  return {
+    body,
+    ...runId ? {
+      runId
+    } : {},
+    ...threadId ? {
+      threadId
+    } : {}
+  };
+}
+__name(streamResponse, "streamResponse");
+
 // src/reasoning/timing.ts
 import { useEffect, useRef, useState } from "react";
 var REASONING_METADATA_KEY = "agent";
@@ -61,8 +301,11 @@ function formatElapsed(ms) {
 __name(formatElapsed, "formatElapsed");
 
 // src/agent-chat-transport.ts
-var HEADER_RUN_ID = "x-agent-run-id";
-var HEADER_THREAD_ID = "x-agent-thread-id";
+var DEFAULT_RECONNECT = {
+  maxAttempts: 6,
+  baseDelayMs: 500,
+  maxDelayMs: 8e3
+};
 var ASK_TOOL_NAME = "ask";
 var AgentChatTransport = class {
   static {
@@ -79,8 +322,26 @@ var AgentChatTransport = class {
   * several entries under each id — which React renders as duplicate keys.
   */
   attemptLive = false;
+  backend;
   constructor(options = {}) {
     this.options = options;
+    this.backend = options.backend ?? new AgentClient({
+      ...options.baseUrl !== void 0 ? {
+        baseUrl: options.baseUrl
+      } : {},
+      ...options.headers !== void 0 ? {
+        headers: options.headers
+      } : {},
+      ...options.getHeaders !== void 0 ? {
+        getHeaders: options.getHeaders
+      } : {},
+      ...options.credentials !== void 0 ? {
+        credentials: options.credentials
+      } : {},
+      ...options.fetch !== void 0 ? {
+        fetch: options.fetch
+      } : {}
+    });
   }
   /** Run id of the most recent stream — HITL approve/reject target this. */
   get runId() {
@@ -113,26 +374,25 @@ var AgentChatTransport = class {
         ...options.body ?? {},
         message
       };
-      const response = await this.fetchImpl()(`${this.baseUrl()}/agent/chat`, {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          accept: "text/event-stream",
-          ...await this.resolveHeaders(options.headers)
-        },
-        body: JSON.stringify(body),
-        ...this.options.credentials !== void 0 ? {
-          credentials: this.options.credentials
+      const headers = headerRecord(options.headers);
+      const response = await this.backend.openChatStream({
+        body,
+        ...headers !== void 0 ? {
+          headers
+        } : {},
+        ...options.abortSignal ? {
+          signal: options.abortSignal
+        } : {}
+      });
+      this.captureHeaderMeta(response);
+      return this.toChunkStream(response, {
+        ...headers !== void 0 ? {
+          headers
         } : {},
         ...options.abortSignal ? {
           signal: options.abortSignal
         } : {}
       });
-      if (!response.ok || !response.body) {
-        throw new Error(`Agent chat request failed: ${response.status} ${response.statusText}`);
-      }
-      this.captureHeaderMeta(response.headers);
-      return this.toChunkStream(response.body);
     } catch (error) {
       this.attemptLive = false;
       throw error;
@@ -145,51 +405,41 @@ var AgentChatTransport = class {
     if (runId === void 0) return null;
     this.attemptLive = true;
     try {
-      const response = await this.fetchImpl()(`${this.baseUrl()}/agent/chat/${encodeURIComponent(runId)}/stream`, {
-        method: "GET",
-        headers: {
-          accept: "text/event-stream",
-          ...await this.resolveHeaders(options.headers)
-        },
-        ...this.options.credentials !== void 0 ? {
-          credentials: this.options.credentials
+      const headers = headerRecord(options.headers);
+      const response = await this.backend.resumeChatStream({
+        runId,
+        ...headers !== void 0 ? {
+          headers
         } : {}
       });
-      if (response.status === 404) {
+      if (response === null) {
         this.attemptLive = false;
         return null;
       }
-      if (!response.ok || !response.body) {
-        throw new Error(`Agent stream reconnect failed: ${response.status} ${response.statusText}`);
-      }
-      this.captureHeaderMeta(response.headers);
-      return this.toChunkStream(response.body);
+      this.captureHeaderMeta(response);
+      return this.toChunkStream(response, {
+        runId,
+        ...headers !== void 0 ? {
+          headers
+        } : {}
+      });
     } catch (error) {
       this.attemptLive = false;
       throw error;
     }
   }
-  fetchImpl() {
-    return this.options.fetch ?? globalThis.fetch;
-  }
-  baseUrl() {
-    return (this.options.baseUrl ?? "").replace(/\/$/, "");
+  captureHeaderMeta(response) {
+    if (response.runId) this.currentRunId = response.runId;
+    if (response.threadId) this.currentThreadId = response.threadId;
   }
-  async resolveHeaders(perRequest) {
-    const dynamic = await this.options.getHeaders?.() ?? {};
-    const extra = perRequest instanceof Headers ? Object.fromEntries(perRequest.entries()) : perRequest ?? {};
+  reconnectPolicy() {
+    const configured = this.options.reconnect;
+    if (configured === false) return null;
     return {
-      ...this.options.headers,
-      ...dynamic,
-      ...extra
+      ...DEFAULT_RECONNECT,
+      ...configured
     };
   }
-  captureHeaderMeta(headers) {
-    const runId = headers.get(HEADER_RUN_ID);
-    const threadId = headers.get(HEADER_THREAD_ID);
-    if (runId) this.currentRunId = runId;
-    if (threadId) this.currentThreadId = threadId;
-  }
   recordMeta(meta) {
     this.currentRunId = meta.runId;
     this.currentThreadId = meta.threadId;
@@ -208,10 +458,66 @@ var AgentChatTransport = class {
   * call plus its tool execution; text and reasoning open lazily and close at the step boundary, so
   * tool-call cards (input streaming → output) render live between the prose.
   */
-  toChunkStream(source) {
-    const reader = source.getReader();
-    const decoder = new TextDecoder();
+  toChunkStream(source, context) {
+    let reader = source.body.getReader();
+    let decoder = new TextDecoder();
     let buffer = "";
+    let streamRunId = source.runId ?? context.runId;
+    let lastSeq;
+    let cancelled = false;
+    const backend = this.backend;
+    const policy = this.reconnectPolicy();
+    const notify = /* @__PURE__ */ __name((state) => this.options.onConnectionChange?.(state), "notify");
+    const aborted = /* @__PURE__ */ __name(() => cancelled || context.signal?.aborted === true, "aborted");
+    const canResume = /* @__PURE__ */ __name(() => policy !== null && lastSeq !== void 0 && streamRunId !== void 0 && !aborted(), "canResume");
+    const resume = /* @__PURE__ */ __name(async () => {
+      const runId = streamRunId;
+      const after = lastSeq ?? 0;
+      const { maxAttempts, baseDelayMs, maxDelayMs } = policy;
+      for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        notify({
+          status: "reconnecting",
+          runId,
+          attempt,
+          after
+        });
+        await delay(Math.min(maxDelayMs, baseDelayMs * 2 ** (attempt - 1)), context.signal);
+        if (aborted()) return "aborted";
+        try {
+          const next = await backend.resumeChatStream({
+            runId,
+            after,
+            ...context.headers !== void 0 ? {
+              headers: context.headers
+            } : {},
+            ...context.signal !== void 0 ? {
+              signal: context.signal
+            } : {}
+          });
+          if (next === null) {
+            notify({
+              status: "gone",
+              runId
+            });
+            return "gone";
+          }
+          reader = next.body.getReader();
+          decoder = new TextDecoder();
+          buffer = "";
+          notify({
+            status: "live"
+          });
+          return "resumed";
+        } catch {
+          if (aborted()) return "aborted";
+        }
+      }
+      notify({
+        status: "failed",
+        runId
+      });
+      return "failed";
+    }, "resume");
     let started = false;
     let stepOpen = false;
     let stepIndex = 0;
@@ -222,7 +528,10 @@ var AgentChatTransport = class {
     let reasoningSeq = 0;
     const announced = /* @__PURE__ */ new Set();
     const toolMetadata = /* @__PURE__ */ new Map();
-    const record = /* @__PURE__ */ __name((meta) => this.recordMeta(meta), "record");
+    const record = /* @__PURE__ */ __name((meta) => {
+      streamRunId = meta.runId;
+      this.recordMeta(meta);
+    }, "record");
     const endAttempt = /* @__PURE__ */ __name(() => {
       this.attemptLive = false;
     }, "endAttempt");
@@ -231,7 +540,12 @@ var AgentChatTransport = class {
         function ensureStarted() {
           if (started) return;
           started = true;
-          controller.enqueue({
+          controller.enqueue(streamRunId !== void 0 ? {
+            type: "start",
+            messageMetadata: {
+              runId: streamRunId
+            }
+          } : {
             type: "start"
           });
         }
@@ -487,33 +801,67 @@ var AgentChatTransport = class {
           endAttempt();
         }
         __name(finish, "finish");
+        function fail(errorText, start = true) {
+          if (start) ensureStarted();
+          controller.enqueue({
+            type: "error",
+            errorText
+          });
+          controller.close();
+          endAttempt();
+        }
+        __name(fail, "fail");
+        async function recover(error) {
+          if (!canResume()) {
+            if (error === void 0) {
+              finish();
+            } else {
+              fail(error instanceof Error ? error.message : "Agent stream error", false);
+            }
+            return false;
+          }
+          const outcome = await resume();
+          if (outcome === "resumed") return true;
+          if (outcome === "failed") {
+            fail("Lost the connection to the agent stream");
+          } else {
+            finish();
+          }
+          return false;
+        }
+        __name(recover, "recover");
         try {
           while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-              finish();
+            let result;
+            try {
+              result = await reader.read();
+            } catch (error) {
+              if (await recover(error)) continue;
+              return;
+            }
+            if (result.done) {
+              if (await recover(void 0)) continue;
               return;
             }
-            buffer += decoder.decode(value, {
+            buffer += decoder.decode(result.value, {
               stream: true
             });
             let separator = buffer.indexOf("\n\n");
             while (separator !== -1) {
               const rawEvent = buffer.slice(0, separator);
               buffer = buffer.slice(separator + 2);
+              separator = buffer.indexOf("\n\n");
               const frame = parseSseFrame(rawEvent);
+              if (frame.id !== void 0) {
+                if (lastSeq !== void 0 && frame.id <= lastSeq) continue;
+                lastSeq = frame.id;
+              }
               if (frame.event === "done") {
                 finish();
                 return;
               }
               if (frame.event === "error") {
-                ensureStarted();
-                controller.enqueue({
-                  type: "error",
-                  errorText: parseErrorText(frame.data)
-                });
-                controller.close();
-                endAttempt();
+                fail(parseErrorText(frame.data));
                 return;
               }
               if (frame.event === "meta") {
@@ -523,19 +871,14 @@ var AgentChatTransport = class {
                 const event = parseEvent(frame.data);
                 if (event) emit(event);
               }
-              separator = buffer.indexOf("\n\n");
             }
           }
         } catch (error) {
-          controller.enqueue({
-            type: "error",
-            errorText: error instanceof Error ? error.message : "Agent stream error"
-          });
-          controller.close();
-          endAttempt();
+          fail(error instanceof Error ? error.message : "Agent stream error", false);
         }
       },
       cancel() {
+        cancelled = true;
         void reader.cancel();
         endAttempt();
       }
@@ -544,17 +887,22 @@ var AgentChatTransport = class {
 };
 function parseSseFrame(raw) {
   let event;
+  let id;
   const dataLines = [];
   for (const line of raw.split("\n")) {
     if (line.startsWith("event:")) {
       event = line.slice("event:".length).trim();
+    } else if (line.startsWith("id:")) {
+      const parsed = Number(line.slice("id:".length).trim());
+      if (Number.isSafeInteger(parsed) && parsed > 0) id = parsed;
     } else if (line.startsWith("data:")) {
       dataLines.push(line.slice("data:".length).trimStart());
     }
   }
   return {
     event,
-    data: dataLines.length > 0 ? dataLines.join("\n") : void 0
+    data: dataLines.length > 0 ? dataLines.join("\n") : void 0,
+    id
   };
 }
 __name(parseSseFrame, "parseSseFrame");
@@ -584,26 +932,293 @@ function parseErrorText(data) {
   }
   return "Agent run failed";
 }
-__name(parseErrorText, "parseErrorText");
-function parseEvent(data) {
-  try {
-    const parsed = JSON.parse(data);
-    if (parsed !== null && typeof parsed === "object" && "kind" in parsed) {
-      return parsed;
-    }
-  } catch {
+__name(parseErrorText, "parseErrorText");
+function parseEvent(data) {
+  try {
+    const parsed = JSON.parse(data);
+    if (parsed !== null && typeof parsed === "object" && "kind" in parsed) {
+      return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+__name(parseEvent, "parseEvent");
+function extractText(message) {
+  let text = "";
+  for (const part of message.parts ?? []) {
+    if (part.type === "text") text += part.text;
+  }
+  return text;
+}
+__name(extractText, "extractText");
+function headerRecord(headers) {
+  if (headers === void 0) return void 0;
+  return headers instanceof Headers ? Object.fromEntries(headers.entries()) : headers;
+}
+__name(headerRecord, "headerRecord");
+function delay(ms, signal) {
+  if (ms <= 0 || signal?.aborted) return Promise.resolve();
+  return new Promise((resolve) => {
+    const timer = setTimeout(done, ms);
+    function done() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve();
+    }
+    __name(done, "done");
+    signal?.addEventListener("abort", done, {
+      once: true
+    });
+  });
+}
+__name(delay, "delay");
+
+// src/backend.ts
+var AgentBackendUnsupportedError = class extends Error {
+  static {
+    __name(this, "AgentBackendUnsupportedError");
+  }
+  method;
+  constructor(method) {
+    super(`The agent backend does not implement ${method}()`), this.method = method;
+    this.name = "AgentBackendUnsupportedError";
+  }
+};
+function requireBackendMethod(backend, name) {
+  const method = backend[name];
+  if (typeof method !== "function") {
+    throw new AgentBackendUnsupportedError(name);
+  }
+  return method.bind(backend);
+}
+__name(requireBackendMethod, "requireBackendMethod");
+
+// src/feedback/use-message-feedback.ts
+import { useCallback, useRef as useRef2, useState as useState2 } from "react";
+function useMessageFeedback(options) {
+  const latest = useRef2(options);
+  latest.current = options;
+  const [local, setLocal] = useState2(/* @__PURE__ */ new Map());
+  const [pending, setPending] = useState2(/* @__PURE__ */ new Set());
+  const [error, setError] = useState2(null);
+  const localRef = useRef2(local);
+  localRef.current = local;
+  const resolved = useRef2(/* @__PURE__ */ new Map());
+  const feedbackOf = useCallback((message) => {
+    const mine = local.get(message.id);
+    if (mine !== void 0) return mine.feedback;
+    return metadataOf(message).feedback ?? null;
+  }, [
+    local
+  ]);
+  const isPending = useCallback((message) => pending.has(message.id), [
+    pending
+  ]);
+  const storedIdFor = useCallback(async (message) => {
+    const runId = metadataOf(message).runId;
+    if (runId === void 0) return message.id;
+    const known = resolved.current.get(message.id);
+    if (known !== void 0) return known;
+    const { backend, threadId } = latest.current;
+    const thread = typeof threadId === "function" ? threadId() : threadId;
+    if (thread === void 0) {
+      throw new Error("useMessageFeedback: a streamed message needs `threadId` to be rated");
+    }
+    const detail = await backend.getThread(thread);
+    const row = [
+      ...detail.messages
+    ].reverse().find((candidate) => candidate.role === "assistant" && candidate.runId === runId);
+    if (row === void 0) {
+      throw new Error(`useMessageFeedback: run ${runId} has no persisted answer yet`);
+    }
+    resolved.current.set(message.id, row.id);
+    return row.id;
+  }, []);
+  const rate = useCallback(async (message, value, comment) => {
+    const setFeedback = requireBackendMethod(latest.current.backend, "setMessageFeedback");
+    const had = localRef.current.get(message.id);
+    const optimistic = value === null ? null : {
+      value,
+      ...comment !== void 0 && comment.trim().length > 0 ? {
+        comment: comment.trim()
+      } : {},
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    setLocal((current) => new Map(current).set(message.id, {
+      feedback: optimistic
+    }));
+    setPending((current) => new Set(current).add(message.id));
+    try {
+      const storedId = await storedIdFor(message);
+      const { feedback } = await setFeedback(storedId, {
+        value,
+        ...comment !== void 0 ? {
+          comment
+        } : {}
+      });
+      setLocal((current) => new Map(current).set(message.id, {
+        feedback
+      }));
+      setError(null);
+    } catch (caught) {
+      setLocal((current) => {
+        const next = new Map(current);
+        if (had === void 0) next.delete(message.id);
+        else next.set(message.id, had);
+        return next;
+      });
+      const failure = caught instanceof Error ? caught : new Error(String(caught));
+      setError(failure);
+      throw failure;
+    } finally {
+      setPending((current) => {
+        const next = new Set(current);
+        next.delete(message.id);
+        return next;
+      });
+    }
+  }, [
+    storedIdFor
+  ]);
+  const toggle = useCallback((message, value) => {
+    const mine = localRef.current.get(message.id);
+    const current = mine !== void 0 ? mine.feedback : metadataOf(message).feedback ?? null;
+    return rate(message, current?.value === value ? null : value);
+  }, [
+    rate
+  ]);
+  return {
+    feedbackOf,
+    isPending,
+    rate,
+    toggle,
+    error
+  };
+}
+__name(useMessageFeedback, "useMessageFeedback");
+function metadataOf(message) {
+  const metadata = message.metadata;
+  return metadata !== null && typeof metadata === "object" ? metadata : {};
+}
+__name(metadataOf, "metadataOf");
+
+// src/threads/threads-events.ts
+var listeners = /* @__PURE__ */ new WeakMap();
+function notifyThreads(backend, event) {
+  for (const listener of listeners.get(backend) ?? []) {
+    listener(event);
   }
-  return null;
 }
-__name(parseEvent, "parseEvent");
-function extractText(message) {
-  let text = "";
-  for (const part of message.parts ?? []) {
-    if (part.type === "text") text += part.text;
-  }
-  return text;
+__name(notifyThreads, "notifyThreads");
+function onThreadsEvent(backend, listener) {
+  let set = listeners.get(backend);
+  if (set === void 0) {
+    set = /* @__PURE__ */ new Set();
+    listeners.set(backend, set);
+  }
+  set.add(listener);
+  return () => {
+    set.delete(listener);
+  };
 }
-__name(extractText, "extractText");
+__name(onThreadsEvent, "onThreadsEvent");
+
+// src/threads/use-threads.ts
+import { useCallback as useCallback2, useEffect as useEffect2, useRef as useRef3, useState as useState3 } from "react";
+function useThreads(options) {
+  const { backend, enabled = true } = options;
+  const [threads, setThreads] = useState3([]);
+  const [isLoading, setIsLoading] = useState3(enabled);
+  const [error, setError] = useState3(null);
+  const threadsRef = useRef3(threads);
+  threadsRef.current = threads;
+  const generation = useRef3(0);
+  const refresh = useCallback2(async () => {
+    const mine = ++generation.current;
+    setIsLoading(true);
+    try {
+      const list = await backend.listThreads();
+      if (mine !== generation.current) return;
+      setThreads(list);
+      setError(null);
+    } catch (caught) {
+      if (mine !== generation.current) return;
+      setError(caught instanceof Error ? caught : new Error(String(caught)));
+    } finally {
+      if (mine === generation.current) setIsLoading(false);
+    }
+  }, [
+    backend
+  ]);
+  useEffect2(() => {
+    if (!enabled) return;
+    void refresh();
+    return onThreadsEvent(backend, (event) => {
+      if (event.type === "title") {
+        setThreads((current) => current.map((thread) => thread.id === event.threadId ? {
+          ...thread,
+          title: event.title
+        } : thread));
+      } else if (event.type === "removed") {
+        setThreads((current) => current.filter((thread) => thread.id !== event.threadId));
+      } else {
+        void refresh();
+      }
+    });
+  }, [
+    backend,
+    enabled,
+    refresh
+  ]);
+  const rename = useCallback2(async (id, title) => {
+    const before = threadsRef.current;
+    setThreads((current) => current.map((thread) => thread.id === id ? {
+      ...thread,
+      title
+    } : thread));
+    try {
+      await backend.updateThread(id, {
+        title
+      });
+      notifyThreads(backend, {
+        type: "title",
+        threadId: id,
+        title
+      });
+    } catch (caught) {
+      setThreads(before);
+      throw caught;
+    }
+  }, [
+    backend
+  ]);
+  const remove = useCallback2(async (id) => {
+    const before = threadsRef.current;
+    setThreads((current) => current.filter((thread) => thread.id !== id));
+    try {
+      await backend.deleteThread(id);
+      notifyThreads(backend, {
+        type: "removed",
+        threadId: id
+      });
+    } catch (caught) {
+      setThreads(before);
+      throw caught;
+    }
+  }, [
+    backend
+  ]);
+  return {
+    threads,
+    isLoading,
+    error,
+    refresh,
+    rename,
+    remove
+  };
+}
+__name(useThreads, "useThreads");
 
 // src/background-runs.ts
 function asReceipt(output) {
@@ -652,170 +1267,11 @@ function backgroundRunsFromThread(messages) {
 }
 __name(backgroundRunsFromThread, "backgroundRunsFromThread");
 
-// src/client.ts
-var AgentHttpError = class extends Error {
-  static {
-    __name(this, "AgentHttpError");
-  }
-  status;
-  method;
-  path;
-  constructor(status, method, path, statusText) {
-    super(`Agent request failed: ${method} ${path} \u2192 ${status} ${statusText}`), this.status = status, this.method = method, this.path = path;
-    this.name = "AgentHttpError";
-  }
-};
-var AgentClient = class {
-  static {
-    __name(this, "AgentClient");
-  }
-  options;
-  constructor(options = {}) {
-    this.options = options;
-  }
-  listThreads() {
-    return this.request("GET", "/agent/threads");
-  }
-  /**
-  * The skills this caller can invoke right now, scope-resolved — the same list, built by the same
-  * call, that the model is offered, so what a user can type after a `/` and what the agent can
-  * reach cannot drift apart. `threadId` reaches the host's own resolver, which may scope a skill to
-  * one conversation; omitted, the server reads it as a brand-new thread.
-  */
-  listSkills(threadId) {
-    const query = threadId === void 0 ? "" : `?threadId=${encodeURIComponent(threadId)}`;
-    return this.request("GET", `/agent/skills${query}`);
-  }
-  /**
-  * The tools this caller can reach through `agent` (the default agent when omitted), each with the
-  * server-declared `presentation` a chat narrates it by — the same list the model is offered.
-  * Prefer {@link useToolCatalog}, which fetches it once and shares it.
-  */
-  listTools(agent) {
-    const query = agent === void 0 ? "" : `?agent=${encodeURIComponent(agent)}`;
-    return this.request("GET", `/agent/tools${query}`);
-  }
-  getThread(id) {
-    return this.request("GET", `/agent/threads/${encodeURIComponent(id)}`);
-  }
-  deleteThread(id) {
-    return this.request("DELETE", `/agent/threads/${encodeURIComponent(id)}`);
-  }
-  forkFromMessage(threadId, messageId) {
-    return this.request("POST", `/agent/threads/${encodeURIComponent(threadId)}/fork-from/${encodeURIComponent(messageId)}`);
-  }
-  renameThread(id, title) {
-    return this.updateThread(id, {
-      title
-    });
-  }
-  /** General `PATCH /agent/threads/:threadId` — title and/or the thread's pinned default agent. */
-  updateThread(id, patch) {
-    return this.request("PATCH", `/agent/threads/${encodeURIComponent(id)}`, patch);
-  }
-  /**
-  * Uploads a file (image/PDF) for a vision-capable model turn. Multipart, field name `file` —
-  * mirrors the backend's `POST /agent/attachments`. The returned {@link MessageAttachment} is
-  * what a caller then rides on `sendMessage({ text }, { body: { attachments: [...] } })`.
-  */
-  async uploadAttachment(file) {
-    const fetchImpl = this.options.fetch ?? globalThis.fetch;
-    const baseUrl = (this.options.baseUrl ?? "").replace(/\/$/, "");
-    const dynamic = await this.options.getHeaders?.() ?? {};
-    const formData = new FormData();
-    formData.append("file", file);
-    const response = await fetchImpl(`${baseUrl}/agent/attachments`, {
-      method: "POST",
-      headers: {
-        accept: "application/json",
-        ...this.options.headers,
-        ...dynamic
-      },
-      body: formData,
-      ...this.options.credentials !== void 0 ? {
-        credentials: this.options.credentials
-      } : {}
-    });
-    return this.handleResponse(response, "POST", "/agent/attachments");
-  }
-  promoteThread(id) {
-    return this.request("POST", `/agent/threads/${encodeURIComponent(id)}/promote`);
-  }
-  truncateFromMessage(threadId, messageId) {
-    return this.request("DELETE", `/agent/threads/${encodeURIComponent(threadId)}/from/${encodeURIComponent(messageId)}`);
-  }
-  getQuotaToday() {
-    return this.request("GET", "/agent/quota/today");
-  }
-  cancelStream(runId) {
-    return this.request("POST", `/agent/chat/${encodeURIComponent(runId)}/cancel`);
-  }
-  /**
-  * `remember` approves later calls of the same tool in the same thread; `via` names the surface
-  * the decision came through (the server records `'web'` when omitted).
-  */
-  approveToolCall(input) {
-    return this.request("POST", "/agent/tool-call/approve", input);
-  }
-  rejectToolCall(input) {
-    return this.request("POST", "/agent/tool-call/reject", input);
-  }
-  /**
-  * Settle a parked question set. `answers` is questionId → chosen option values; a question left
-  * out takes the pre-picked default the request carried, resolved server-side against the request
-  * the run already holds. Omit the whole object and the user has confirmed every pre-picked
-  * answer — which is the point of the surface, so it is a valid submission rather than a blank.
-  */
-  answerToolCall(input) {
-    return this.request("POST", "/agent/tool-call/answer", input);
-  }
-  /**
-  * Decline to answer and let the agent proceed on its own pre-picked values. Lands on the same
-  * values a confirmation would, and persists differently on purpose — only one of them is
-  * evidence the user chose them.
-  */
-  skipToolCall(input) {
-    return this.request("POST", "/agent/tool-call/skip", input);
-  }
-  async request(method, path, body) {
-    const fetchImpl = this.options.fetch ?? globalThis.fetch;
-    const baseUrl = (this.options.baseUrl ?? "").replace(/\/$/, "");
-    const dynamic = await this.options.getHeaders?.() ?? {};
-    const response = await fetchImpl(`${baseUrl}${path}`, {
-      method,
-      headers: {
-        accept: "application/json",
-        ...body !== void 0 ? {
-          "content-type": "application/json"
-        } : {},
-        ...this.options.headers,
-        ...dynamic
-      },
-      ...body !== void 0 ? {
-        body: JSON.stringify(body)
-      } : {},
-      ...this.options.credentials !== void 0 ? {
-        credentials: this.options.credentials
-      } : {}
-    });
-    return this.handleResponse(response, method, path);
-  }
-  async handleResponse(response, method, path) {
-    if (!response.ok) {
-      throw new AgentHttpError(response.status, method, path, response.statusText);
-    }
-    if (response.status === 204) return void 0;
-    const text = await response.text();
-    if (!text) return void 0;
-    return JSON.parse(text);
-  }
-};
-
 // src/components/chat-input.tsx
-import React2, { useEffect as useEffect3, useState as useState3 } from "react";
+import React2, { useEffect as useEffect4, useState as useState5 } from "react";
 
 // src/components/use-speech-recognition.ts
-import { useCallback, useEffect as useEffect2, useMemo, useRef as useRef2, useState as useState2 } from "react";
+import { useCallback as useCallback3, useEffect as useEffect3, useMemo, useRef as useRef4, useState as useState4 } from "react";
 function getRecognitionCtor() {
   if (typeof window === "undefined") return null;
   const scope = window;
@@ -823,15 +1279,15 @@ function getRecognitionCtor() {
 }
 __name(getRecognitionCtor, "getRecognitionCtor");
 function useSpeechRecognition({ lang = "en-US", onFinalTranscript, onInterimTranscript }) {
-  const recognitionRef = useRef2(null);
-  const [isListening, setIsListening] = useState2(false);
+  const recognitionRef = useRef4(null);
+  const [isListening, setIsListening] = useState4(false);
   const ctor = useMemo(() => getRecognitionCtor(), []);
   const isSupported = ctor !== null;
-  const finalRef = useRef2(onFinalTranscript);
-  const interimRef = useRef2(onInterimTranscript);
+  const finalRef = useRef4(onFinalTranscript);
+  const interimRef = useRef4(onInterimTranscript);
   finalRef.current = onFinalTranscript;
   interimRef.current = onInterimTranscript;
-  useEffect2(() => {
+  useEffect3(() => {
     if (!ctor) return;
     const recognition = new ctor();
     recognition.lang = lang;
@@ -870,7 +1326,7 @@ function useSpeechRecognition({ lang = "en-US", onFinalTranscript, onInterimTran
     ctor,
     lang
   ]);
-  const start = useCallback(() => {
+  const start = useCallback3(() => {
     const recognition = recognitionRef.current;
     if (!recognition) return;
     try {
@@ -880,7 +1336,7 @@ function useSpeechRecognition({ lang = "en-US", onFinalTranscript, onInterimTran
       console.warn("SpeechRecognition start failed", error);
     }
   }, []);
-  const stop = useCallback(() => {
+  const stop = useCallback3(() => {
     const recognition = recognitionRef.current;
     if (!recognition) return;
     try {
@@ -899,8 +1355,8 @@ __name(useSpeechRecognition, "useSpeechRecognition");
 
 // src/components/chat-input.tsx
 function ChatInput({ onSubmit, disabled, placeholder, rows = 2, enableSpeech = true, speechLang = "en-US", sendLabel = "Send", onStop, isStreaming = false, stopLabel = "Stop generating", className, textareaClassName, sendButtonClassName, micButtonClassName, stopButtonClassName, renderMic }) {
-  const [value, setValue] = useState3("");
-  const [interim, setInterim] = useState3("");
+  const [value, setValue] = useState5("");
+  const [interim, setInterim] = useState5("");
   const speech = useSpeechRecognition({
     lang: speechLang,
     onFinalTranscript: /* @__PURE__ */ __name((text) => {
@@ -911,7 +1367,7 @@ function ChatInput({ onSubmit, disabled, placeholder, rows = 2, enableSpeech = t
     }, "onFinalTranscript"),
     onInterimTranscript: /* @__PURE__ */ __name((text) => setInterim(text), "onInterimTranscript")
   });
-  useEffect3(() => {
+  useEffect4(() => {
     if (!speech.isListening) setInterim("");
   }, [
     speech.isListening
@@ -978,7 +1434,7 @@ __name(ChatInput, "ChatInput");
 import React3 from "react";
 
 // src/transcript/use-chat-transcript.ts
-import { useCallback as useCallback3, useEffect as useEffect5, useRef as useRef4, useState as useState5 } from "react";
+import { useCallback as useCallback5, useEffect as useEffect6, useRef as useRef6, useState as useState7 } from "react";
 
 // src/transcript/model.ts
 import { readElicitationInput, validateElicitationAnswer as validateElicitationAnswer2 } from "@dudousxd/nestjs-agent-core";
@@ -1955,11 +2411,11 @@ function formatCostUsd(cost) {
 __name(formatCostUsd, "formatCostUsd");
 
 // src/transcript/use-stick-to-bottom.ts
-import { useCallback as useCallback2, useEffect as useEffect4, useRef as useRef3, useState as useState4 } from "react";
+import { useCallback as useCallback4, useEffect as useEffect5, useRef as useRef5, useState as useState6 } from "react";
 function useStickToBottom({ contentKey, threshold = 32 }) {
-  const containerRef = useRef3(null);
-  const [isAtBottom, setIsAtBottom] = useState4(true);
-  const measure = useCallback2(() => {
+  const containerRef = useRef5(null);
+  const [isAtBottom, setIsAtBottom] = useState6(true);
+  const measure = useCallback4(() => {
     const element = containerRef.current;
     if (!element) {
       return;
@@ -1969,7 +2425,7 @@ function useStickToBottom({ contentKey, threshold = 32 }) {
   }, [
     threshold
   ]);
-  const scrollToBottom = useCallback2(() => {
+  const scrollToBottom = useCallback4(() => {
     const element = containerRef.current;
     if (!element) {
       return;
@@ -1977,7 +2433,7 @@ function useStickToBottom({ contentKey, threshold = 32 }) {
     element.scrollTop = element.scrollHeight;
     setIsAtBottom(true);
   }, []);
-  const setContainer = useCallback2((element) => {
+  const setContainer = useCallback4((element) => {
     containerRef.current = element;
     if (element) {
       measure();
@@ -1985,7 +2441,7 @@ function useStickToBottom({ contentKey, threshold = 32 }) {
   }, [
     measure
   ]);
-  useEffect4(() => {
+  useEffect5(() => {
     if (isAtBottom) {
       scrollToBottom();
     }
@@ -1994,7 +2450,7 @@ function useStickToBottom({ contentKey, threshold = 32 }) {
     isAtBottom,
     scrollToBottom
   ]);
-  const getContainerProps = useCallback2(() => ({
+  const getContainerProps = useCallback4(() => ({
     ref: setContainer,
     onScroll: measure
   }), [
@@ -2016,14 +2472,14 @@ var DEFAULT_LOAD_EARLIER_STEP = 50;
 var DEFAULT_COPY_RESET_MS = 1500;
 function useChatTranscript(options) {
   const { messages, status, initialVisibleCount = DEFAULT_VISIBLE_COUNT, loadEarlierStep = DEFAULT_LOAD_EARLIER_STEP, followUps, stickToBottomThreshold } = options;
-  const latest = useRef4(options);
+  const latest = useRef6(options);
   latest.current = options;
-  const [visibleCount, setVisibleCount] = useState5(initialVisibleCount);
-  const [stopRequested, setStopRequested] = useState5(false);
-  const isStreaming = status === "streaming";
+  const [visibleCount, setVisibleCount] = useState7(initialVisibleCount);
+  const [stopRequested, setStopRequested] = useState7(false);
+  const isStreaming = status === "streaming" || status === "reconnecting";
   const isBusy = status === "submitted" || isStreaming;
   const isEmpty = messages.length === 0;
-  useEffect5(() => {
+  useEffect6(() => {
     if (!isBusy) {
       setStopRequested(false);
     }
@@ -2040,16 +2496,16 @@ function useChatTranscript(options) {
     streamingMessageId,
     options
   });
-  const stop = useCallback3(() => {
+  const stop = useCallback5(() => {
     const current = latest.current;
-    if (current.status !== "submitted" && current.status !== "streaming") {
+    if (current.status !== "submitted" && current.status !== "streaming" && current.status !== "reconnecting") {
       return;
     }
     setStopRequested(true);
     void current.onStop?.();
   }, []);
-  const loadEarlier = useCallback3(() => setVisibleCount((count) => count + (latest.current.loadEarlierStep ?? DEFAULT_LOAD_EARLIER_STEP)), []);
-  const showAll = useCallback3(() => setVisibleCount(latest.current.messages.length), []);
+  const loadEarlier = useCallback5(() => setVisibleCount((count) => count + (latest.current.loadEarlierStep ?? DEFAULT_LOAD_EARLIER_STEP)), []);
+  const showAll = useCallback5(() => setVisibleCount(latest.current.messages.length), []);
   const scroll = useStickToBottom({
     contentKey: contentSignature(messages),
     ...stickToBottomThreshold !== void 0 ? {
@@ -2085,7 +2541,7 @@ function useChatTranscript(options) {
 __name(useChatTranscript, "useChatTranscript");
 function useTranscriptItem(options) {
   const { message, isStreaming = false } = options;
-  const messagesRef = useRef4([
+  const messagesRef = useRef6([
     message
   ]);
   if (messagesRef.current[0] !== message) {
@@ -2103,13 +2559,13 @@ function useTranscriptItem(options) {
 }
 __name(useTranscriptItem, "useTranscriptItem");
 function useTranscriptItems({ messages, visibleStart, streamingMessageId, options }) {
-  const [drafts, setDrafts] = useState5(() => /* @__PURE__ */ new Map());
-  const [copied, setCopied] = useState5(() => /* @__PURE__ */ new Set());
-  const [openReasoning, setOpenReasoning] = useState5(() => /* @__PURE__ */ new Map());
-  const [picks, setPicks] = useState5(() => /* @__PURE__ */ new Map());
-  const [settling, setSettling] = useState5(() => /* @__PURE__ */ new Map());
-  const [settleErrors, setSettleErrors] = useState5(() => /* @__PURE__ */ new Map());
-  const latest = useRef4({
+  const [drafts, setDrafts] = useState7(() => /* @__PURE__ */ new Map());
+  const [copied, setCopied] = useState7(() => /* @__PURE__ */ new Set());
+  const [openReasoning, setOpenReasoning] = useState7(() => /* @__PURE__ */ new Map());
+  const [picks, setPicks] = useState7(() => /* @__PURE__ */ new Map());
+  const [settling, setSettling] = useState7(() => /* @__PURE__ */ new Map());
+  const [settleErrors, setSettleErrors] = useState7(() => /* @__PURE__ */ new Map());
+  const latest = useRef6({
     options,
     drafts,
     picks,
@@ -2121,23 +2577,23 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
     picks,
     messages
   };
-  const copyTimers = useRef4(/* @__PURE__ */ new Map());
-  useEffect5(() => () => {
+  const copyTimers = useRef6(/* @__PURE__ */ new Map());
+  useEffect6(() => () => {
     for (const timer of copyTimers.current.values()) {
       clearTimeout(timer);
     }
     copyTimers.current.clear();
   }, []);
-  const callbackCache = useRef4(/* @__PURE__ */ new Map());
-  const reasoningToggleCache = useRef4(/* @__PURE__ */ new Map());
-  const toggleReasoning = useCallback3((key, open) => {
+  const callbackCache = useRef6(/* @__PURE__ */ new Map());
+  const reasoningToggleCache = useRef6(/* @__PURE__ */ new Map());
+  const toggleReasoning = useCallback5((key, open) => {
     setOpenReasoning((current) => {
       const next = new Map(current);
       next.set(key, open ?? !(current.get(key) ?? false));
       return next;
     });
   }, []);
-  const stableToggle = useCallback3((key) => {
+  const stableToggle = useCallback5((key) => {
     let cached = reasoningToggleCache.current.get(key);
     if (!cached) {
       cached = /* @__PURE__ */ __name((open) => toggleReasoning(key, open), "cached");
@@ -2147,10 +2603,10 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
   }, [
     toggleReasoning
   ]);
-  const pick = useCallback3((toolCallId, questionId, values) => {
+  const pick = useCallback5((toolCallId, questionId, values) => {
     setPicks((current) => new Map(current).set(pickKey(toolCallId, questionId), values));
   }, []);
-  const settle = useCallback3((toolCallId, action, send) => {
+  const settle = useCallback5((toolCallId, action, send) => {
     setSettleErrors((current) => {
       if (!current.has(toolCallId)) {
         return current;
@@ -2174,7 +2630,7 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
       failed(error);
     }
   }, []);
-  const answer = useCallback3((toolCallId) => {
+  const answer = useCallback5((toolCallId) => {
     const current = latest.current;
     const onAnswer = current.options.onAnswer;
     if (!onAnswer) {
@@ -2184,7 +2640,7 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
   }, [
     settle
   ]);
-  const skip = useCallback3((toolCallId) => {
+  const skip = useCallback5((toolCallId) => {
     const onSkip = latest.current.options.onSkip;
     if (onSkip) {
       settle(toolCallId, "skip", () => onSkip(toolCallId));
@@ -2192,7 +2648,7 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
   }, [
     settle
   ]);
-  const approve = useCallback3((toolCallId, options2) => {
+  const approve = useCallback5((toolCallId, options2) => {
     const onApprove = latest.current.options.onApprove;
     if (onApprove) {
       settle(toolCallId, "approve", () => options2 === void 0 ? onApprove(toolCallId) : onApprove(toolCallId, options2));
@@ -2200,7 +2656,7 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
   }, [
     settle
   ]);
-  const reject = useCallback3((toolCallId) => {
+  const reject = useCallback5((toolCallId) => {
     const onReject = latest.current.options.onReject;
     if (onReject) {
       settle(toolCallId, "reject", () => onReject(toolCallId));
@@ -2208,7 +2664,7 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
   }, [
     settle
   ]);
-  const callbacksFor = useCallback3((id) => {
+  const callbacksFor = useCallback5((id) => {
     const cached = callbackCache.current.get(id);
     if (cached) {
       return cached;
@@ -2831,7 +3287,11 @@ function createSkillsSource(options) {
       if (cached) {
         return cached;
       }
-      const pending = options.client.listSkills(threadId).then((entries) => entries.map(toItem)).catch((error) => {
+      const listSkills = options.client.listSkills;
+      if (listSkills === void 0) {
+        return Promise.reject(new AgentBackendUnsupportedError("listSkills"));
+      }
+      const pending = listSkills.call(options.client, threadId).then((entries) => entries.map(toItem)).catch((error) => {
         byThread.delete(key);
         throw error;
       });
@@ -2861,18 +3321,18 @@ function toItem(entry) {
 __name(toItem, "toItem");
 
 // src/composer/use-composer-autocomplete.ts
-import { useCallback as useCallback4, useEffect as useEffect6, useId, useLayoutEffect, useMemo as useMemo2, useRef as useRef5, useState as useState6 } from "react";
+import { useCallback as useCallback6, useEffect as useEffect7, useId, useLayoutEffect, useMemo as useMemo2, useRef as useRef7, useState as useState8 } from "react";
 function useComposerAutocomplete(options) {
   const { value, sources, acceptOnTab = true } = options;
-  const latest = useRef5(options);
+  const latest = useRef7(options);
   latest.current = options;
-  const inputRef = useRef5(null);
-  const [caret, setCaret] = useState6(value.length);
-  const [items, setItems] = useState6([]);
-  const [isLoading, setLoading] = useState6(false);
-  const [error, setError] = useState6(null);
-  const [activeIndex, setActiveIndex] = useState6(0);
-  const [dismissedIndex, setDismissedIndex] = useState6(null);
+  const inputRef = useRef7(null);
+  const [caret, setCaret] = useState8(value.length);
+  const [items, setItems] = useState8([]);
+  const [isLoading, setLoading] = useState8(false);
+  const [error, setError] = useState8(null);
+  const [activeIndex, setActiveIndex] = useState8(0);
+  const [dismissedIndex, setDismissedIndex] = useState8(null);
   const safeCaret = Math.min(caret, value.length);
   const match = useMemo2(() => findActiveTrigger(value, safeCaret, sources), [
     value,
@@ -2880,16 +3340,16 @@ function useComposerAutocomplete(options) {
     sources
   ]);
   const isActive = match !== null && dismissedIndex !== match.index;
-  const matchRef = useRef5(match);
+  const matchRef = useRef7(match);
   matchRef.current = match;
-  const caretRef = useRef5(safeCaret);
+  const caretRef = useRef7(safeCaret);
   caretRef.current = safeCaret;
-  const itemsRef = useRef5(items);
+  const itemsRef = useRef7(items);
   itemsRef.current = items;
-  const activeIndexRef = useRef5(activeIndex);
+  const activeIndexRef = useRef7(activeIndex);
   activeIndexRef.current = activeIndex;
   const requestKey = isActive && match ? `${match.source.id}\0${match.query}` : null;
-  useEffect6(() => {
+  useEffect7(() => {
     const current = matchRef.current;
     if (requestKey === null || current === null) {
       setItems([]);
@@ -2939,23 +3399,23 @@ function useComposerAutocomplete(options) {
   const activeItem = isOpen ? items[activeIndex] ?? null : null;
   const reactId = useId();
   const listboxId = options.id ?? `agent-autocomplete-${reactId}`;
-  const optionId = useCallback4((index) => `${listboxId}-option-${index}`, [
+  const optionId = useCallback6((index) => `${listboxId}-option-${index}`, [
     listboxId
   ]);
-  const highlight = useCallback4((index) => {
+  const highlight = useCallback6((index) => {
     const total = itemsRef.current.length;
     if (total === 0) return;
     setActiveIndex((index % total + total) % total);
   }, []);
-  const moveHighlight = useCallback4((delta) => highlight(activeIndexRef.current + delta), [
+  const moveHighlight = useCallback6((delta) => highlight(activeIndexRef.current + delta), [
     highlight
   ]);
-  const dismiss = useCallback4(() => {
+  const dismiss = useCallback6(() => {
     const current = matchRef.current;
     if (current) setDismissedIndex(current.index);
   }, []);
-  const pendingCaret = useRef5(null);
-  const accept = useCallback4((item) => {
+  const pendingCaret = useRef7(null);
+  const accept = useCallback6((item) => {
     const current = matchRef.current;
     if (!current) return;
     const chosen = item ?? itemsRef.current[activeIndexRef.current];
@@ -2972,10 +3432,10 @@ function useComposerAutocomplete(options) {
     pendingCaret.current = null;
     inputRef.current?.setSelectionRange(position, position);
   });
-  const readCaret = useCallback4((element) => {
+  const readCaret = useCallback6((element) => {
     setCaret(element.selectionStart ?? element.value.length);
   }, []);
-  const onKeyDown = useCallback4((event) => {
+  const onKeyDown = useCallback6((event) => {
     if (!isOpen) return;
     const hasItems = itemsRef.current.length > 0;
     switch (event.key) {
@@ -3013,23 +3473,23 @@ function useComposerAutocomplete(options) {
     dismiss,
     moveHighlight
   ]);
-  const onChange = useCallback4((event) => {
+  const onChange = useCallback6((event) => {
     readCaret(event.target);
     const next = findActiveTrigger(event.target.value, event.target.selectionStart ?? event.target.value.length, latest.current.sources);
     setDismissedIndex((current) => current !== null && next?.index === current ? current : null);
   }, [
     readCaret
   ]);
-  const onSelect = useCallback4((event) => readCaret(event.currentTarget), [
+  const onSelect = useCallback6((event) => readCaret(event.currentTarget), [
     readCaret
   ]);
-  const onClick = useCallback4((event) => readCaret(event.currentTarget), [
+  const onClick = useCallback6((event) => readCaret(event.currentTarget), [
     readCaret
   ]);
-  const setInput = useCallback4((element) => {
+  const setInput = useCallback6((element) => {
     inputRef.current = element;
   }, []);
-  const getInputProps = useCallback4(() => ({
+  const getInputProps = useCallback6(() => ({
     ref: setInput,
     onChange,
     onKeyDown,
@@ -3057,7 +3517,7 @@ function useComposerAutocomplete(options) {
     activeIndex,
     optionId
   ]);
-  const getListboxProps = useCallback4(() => ({
+  const getListboxProps = useCallback6(() => ({
     id: listboxId,
     role: "listbox",
     "aria-label": match?.source.label ?? match?.source.id ?? "Suggestions"
@@ -3065,7 +3525,7 @@ function useComposerAutocomplete(options) {
     listboxId,
     match
   ]);
-  const getOptionProps = useCallback4((index) => ({
+  const getOptionProps = useCallback6((index) => ({
     id: optionId(index),
     role: "option",
     "aria-selected": index === activeIndex
@@ -3099,7 +3559,7 @@ function isPromise(value) {
 __name(isPromise, "isPromise");
 
 // src/presentation/use-tool-catalog.ts
-import { useCallback as useCallback5, useEffect as useEffect7, useMemo as useMemo3, useState as useState7 } from "react";
+import { useCallback as useCallback7, useEffect as useEffect8, useMemo as useMemo3, useState as useState9 } from "react";
 var shared = /* @__PURE__ */ new WeakMap();
 function load(client, agent) {
   let byAgent = shared.get(client);
@@ -3110,6 +3570,9 @@ function load(client, agent) {
   const key = agent ?? "";
   const cached = byAgent.get(key);
   if (cached !== void 0) return cached;
+  if (client.listTools === void 0) {
+    return Promise.reject(new AgentBackendUnsupportedError("listTools"));
+  }
   const request = client.listTools(agent).catch((error) => {
     byAgent.delete(key);
     throw error;
@@ -3120,11 +3583,11 @@ function load(client, agent) {
 __name(load, "load");
 function useToolCatalog(options) {
   const { client, agent, enabled = true } = options;
-  const [entries, setEntries] = useState7([]);
-  const [isLoading, setLoading] = useState7(enabled);
-  const [error, setError] = useState7(null);
-  const [generation, setGeneration] = useState7(0);
-  useEffect7(() => {
+  const [entries, setEntries] = useState9([]);
+  const [isLoading, setLoading] = useState9(enabled);
+  const [error, setError] = useState9(null);
+  const [generation, setGeneration] = useState9(0);
+  useEffect8(() => {
     if (!enabled) {
       setLoading(false);
       return;
@@ -3150,7 +3613,7 @@ function useToolCatalog(options) {
     enabled,
     generation
   ]);
-  const refresh = useCallback5(() => {
+  const refresh = useCallback7(() => {
     shared.get(client)?.delete(agent ?? "");
     setGeneration((current) => current + 1);
   }, [
@@ -3171,7 +3634,7 @@ function useToolCatalog(options) {
 __name(useToolCatalog, "useToolCatalog");
 
 // src/approvals/countdown.ts
-import { useEffect as useEffect8, useRef as useRef6, useState as useState8 } from "react";
+import { useEffect as useEffect9, useRef as useRef8, useState as useState10 } from "react";
 function approvalCountdown(expiresAt, now = Date.now()) {
   const deadline = expiresAt == null ? Number.NaN : Date.parse(expiresAt);
   if (!Number.isFinite(deadline)) {
@@ -3189,10 +3652,10 @@ function approvalCountdown(expiresAt, now = Date.now()) {
 __name(approvalCountdown, "approvalCountdown");
 function useApprovalCountdown(expiresAt, options = {}) {
   const { intervalMs = 1e3 } = options;
-  const nowRef = useRef6(options.now ?? Date.now);
+  const nowRef = useRef8(options.now ?? Date.now);
   nowRef.current = options.now ?? Date.now;
-  const [state, setState] = useState8(() => approvalCountdown(expiresAt, nowRef.current()));
-  useEffect8(() => {
+  const [state, setState] = useState10(() => approvalCountdown(expiresAt, nowRef.current()));
+  useEffect9(() => {
     const read = /* @__PURE__ */ __name(() => approvalCountdown(expiresAt, nowRef.current()), "read");
     const first = read();
     setState(first);
@@ -3358,7 +3821,12 @@ function storedMessageToUiMessage(message) {
   return {
     id: message.id,
     role: message.role,
-    parts
+    parts,
+    ...message.feedback !== void 0 ? {
+      metadata: {
+        feedback: message.feedback
+      }
+    } : {}
   };
 }
 __name(storedMessageToUiMessage, "storedMessageToUiMessage");
@@ -3394,14 +3862,21 @@ function mergeTurn(rows) {
   }
   const parts = rows.flatMap((row) => storedMessageToUiMessage(row).parts);
   const usage = sumUsage(rows);
+  const feedback = lastRow.feedback;
+  const metadata = {
+    ...usage !== void 0 ? {
+      usage
+    } : {},
+    ...feedback !== void 0 ? {
+      feedback
+    } : {}
+  };
   return {
     id: lastRow.id,
     role: lastRow.role,
     parts,
-    ...usage !== void 0 ? {
-      metadata: {
-        usage
-      }
+    ...Object.keys(metadata).length > 0 ? {
+      metadata
     } : {}
   };
 }
@@ -3422,20 +3897,21 @@ __name(sumUsage, "sumUsage");
 
 // src/use-agent-chat.ts
 import { useChat } from "@ai-sdk/react";
-import { useCallback as useCallback6, useEffect as useEffect9, useMemo as useMemo4, useRef as useRef7, useState as useState9 } from "react";
+import { useCallback as useCallback8, useEffect as useEffect10, useMemo as useMemo4, useRef as useRef9, useState as useState11 } from "react";
 function useAgentChat(options) {
-  const latest = useRef7(options);
+  const latest = useRef9(options);
   latest.current = options;
-  const [runId, setRunId] = useState9(options.resumeRunId);
-  const runIdRef = useRef7(runId);
+  const [runId, setRunId] = useState11(options.resumeRunId);
+  const runIdRef = useRef9(runId);
   runIdRef.current = runId;
-  const settlingRunIdRef = useRef7(void 0);
-  const autoResumeRunIdRef = useRef7(void 0);
-  const [autoResume, setAutoResume] = useState9(false);
-  const [activeRunId, setActiveRunId] = useState9(null);
-  const regenerateNext = useRef7(false);
-  const createdThreadId = useRef7(void 0);
+  const settlingRunIdRef = useRef9(void 0);
+  const autoResumeRunIdRef = useRef9(void 0);
+  const [autoResume, setAutoResume] = useState11(false);
+  const [activeRunId, setActiveRunId] = useState11(null);
+  const regenerateNext = useRef9(false);
+  const createdThreadId = useRef9(void 0);
   const client = useMemo4(() => {
+    if (options.backend) return options.backend;
     if (options.client) return options.client;
     return new AgentClient({
       ...options.baseUrl !== void 0 ? {
@@ -3450,7 +3926,11 @@ function useAgentChat(options) {
       getHeaders: /* @__PURE__ */ __name(async () => mergeHeaders(latest.current), "getHeaders")
     });
   }, []);
-  useEffect9(() => {
+  const [connection, setConnection] = useState11({
+    status: "live"
+  });
+  const resyncAfterSettle = useRef9(false);
+  useEffect10(() => {
     if (!options.resume || options.threadId === void 0) return;
     let cancelled = false;
     const threadId = options.threadId;
@@ -3477,23 +3957,26 @@ function useAgentChat(options) {
       if (latest.current.threadId === void 0 && meta.threadId && createdThreadId.current !== meta.threadId) {
         createdThreadId.current = meta.threadId;
         latest.current.onThreadCreated?.(meta.threadId);
+        notifyThreads(client, {
+          type: "changed"
+        });
       }
     }
     __name(onMeta, "onMeta");
     return new AgentChatTransport({
-      ...options.baseUrl !== void 0 ? {
-        baseUrl: options.baseUrl
-      } : {},
-      ...options.credentials !== void 0 ? {
-        credentials: options.credentials
-      } : {},
-      ...options.fetch !== void 0 ? {
-        fetch: options.fetch
+      backend: client,
+      ...options.reconnect !== void 0 ? {
+        reconnect: options.reconnect
       } : {},
+      onConnectionChange: /* @__PURE__ */ __name((state) => {
+        if (state.status === "gone") resyncAfterSettle.current = true;
+        setConnection(state.status === "gone" ? {
+          status: "live"
+        } : state);
+      }, "onConnectionChange"),
       ...options.agent !== void 0 ? {
         agent: options.agent
       } : {},
-      getHeaders: /* @__PURE__ */ __name(async () => mergeHeaders(latest.current), "getHeaders"),
       getBody: /* @__PURE__ */ __name(() => {
         const current = latest.current;
         const pageContext = current.getPageContext?.() ?? null;
@@ -3519,7 +4002,7 @@ function useAgentChat(options) {
       }, "onAttemptStart")
     });
   }, []);
-  const backgroundRef = useRef7(() => Promise.resolve());
+  const backgroundRef = useRef9(() => Promise.resolve());
   const chat = useChat({
     transport,
     resume: options.resumeRunId !== void 0 || autoResume,
@@ -3533,7 +4016,15 @@ function useAgentChat(options) {
       latest.current.onData?.(part);
       if (part.type === "data-title") {
         const title = part.data?.title;
-        if (typeof title === "string") latest.current.onTitle?.(title);
+        if (typeof title === "string") {
+          latest.current.onTitle?.(title);
+          const threadId = latest.current.threadId ?? createdThreadId.current;
+          if (threadId !== void 0) notifyThreads(client, {
+            type: "title",
+            threadId,
+            title
+          });
+        }
       }
     }, "onData"),
     onFinish: /* @__PURE__ */ __name(({ isError }) => {
@@ -3547,16 +4038,36 @@ function useAgentChat(options) {
           runId: settledRunId,
           status: isError ? "failed" : "completed"
         });
+        notifyThreads(client, {
+          type: "changed"
+        });
+      }
+      setConnection({
+        status: "live"
+      });
+      if (resyncAfterSettle.current) {
+        resyncAfterSettle.current = false;
+        void resyncFromThread();
       }
     }, "onFinish")
   });
-  const chatRef = useRef7(chat);
+  const chatRef = useRef9(chat);
   chatRef.current = chat;
-  const turnInFlight = useRef7(false);
-  const isTurnInFlight = useCallback6(() => turnInFlight.current || transport.isAttemptLive, [
+  async function resyncFromThread() {
+    const threadId = latest.current.threadId ?? createdThreadId.current;
+    if (threadId === void 0) return;
+    try {
+      const thread = await client.getThread(threadId);
+      chatRef.current.setMessages(storedThreadToUiMessages(thread.messages));
+    } catch {
+    }
+  }
+  __name(resyncFromThread, "resyncFromThread");
+  const turnInFlight = useRef9(false);
+  const isTurnInFlight = useCallback8(() => turnInFlight.current || transport.isAttemptLive, [
     transport
   ]);
-  const sendMessage = useCallback6(async (...args) => {
+  const sendMessage = useCallback8(async (...args) => {
     if (isTurnInFlight()) return;
     turnInFlight.current = true;
     try {
@@ -3567,15 +4078,15 @@ function useAgentChat(options) {
   }, [
     isTurnInFlight
   ]);
-  const addToolResult = useCallback6(({ tool, toolCallId, output }) => chatRef.current.addToolResult({
+  const addToolResult = useCallback8(({ tool, toolCallId, output }) => chatRef.current.addToolResult({
     tool,
     toolCallId,
     output
   }), []);
-  const [threads, setThreads] = useState9([]);
-  const [quota, setQuota] = useState9(null);
-  const [backgroundRuns, setBackgroundRuns] = useState9([]);
-  const refreshBackground = useCallback6(async () => {
+  const [threads, setThreads] = useState11([]);
+  const [quota, setQuota] = useState11(null);
+  const [backgroundRuns, setBackgroundRuns] = useState11([]);
+  const refreshBackground = useCallback8(async () => {
     const threadId = latest.current.threadId ?? createdThreadId.current;
     if (threadId === void 0) {
       return;
@@ -3600,7 +4111,7 @@ function useAgentChat(options) {
   ]);
   backgroundRef.current = refreshBackground;
   const isWorking = backgroundRuns.some((run) => run.status === "running");
-  useEffect9(() => {
+  useEffect10(() => {
     if (options.background !== true || options.threadId === void 0) {
       return;
     }
@@ -3610,7 +4121,7 @@ function useAgentChat(options) {
     options.threadId,
     refreshBackground
   ]);
-  useEffect9(() => {
+  useEffect10(() => {
     const every = latest.current.backgroundPollMs ?? 5e3;
     if (latest.current.background !== true || !isWorking || every <= 0) {
       return;
@@ -3621,27 +4132,29 @@ function useAgentChat(options) {
     isWorking,
     refreshBackground
   ]);
-  const loadThreads = useCallback6(async () => {
+  const loadThreads = useCallback8(async () => {
     const list = await client.listThreads();
     setThreads(list);
     return list;
   }, [
     client
   ]);
-  const loadThread = useCallback6((id) => client.getThread(id), [
+  const loadThread = useCallback8((id) => client.getThread(id), [
     client
   ]);
-  const deleteThread = useCallback6(async (id) => {
+  const deleteThread = useCallback8(async (id) => {
     await client.deleteThread(id);
     setThreads((current) => current.filter((thread) => thread.id !== id));
   }, [
     client
   ]);
-  const forkThread = useCallback6((threadId, messageId) => client.forkFromMessage(threadId, messageId), [
+  const forkThread = useCallback8((threadId, messageId) => requireBackendMethod(client, "forkFromMessage")(threadId, messageId), [
     client
   ]);
-  const renameThread = useCallback6(async (id, title) => {
-    await client.renameThread(id, title);
+  const renameThread = useCallback8(async (id, title) => {
+    await client.updateThread(id, {
+      title
+    });
     setThreads((current) => current.map((thread) => thread.id === id ? {
       ...thread,
       title
@@ -3649,24 +4162,24 @@ function useAgentChat(options) {
   }, [
     client
   ]);
-  const promoteThread = useCallback6(async (id) => {
-    await client.promoteThread(id);
+  const promoteThread = useCallback8(async (id) => {
+    await requireBackendMethod(client, "promoteThread")(id);
     await loadThreads();
   }, [
     client,
     loadThreads
   ]);
-  const truncateFromMessage = useCallback6((threadId, messageId) => client.truncateFromMessage(threadId, messageId).then(() => void 0), [
+  const truncateFromMessage = useCallback8((threadId, messageId) => requireBackendMethod(client, "truncateFromMessage")(threadId, messageId).then(() => void 0), [
     client
   ]);
-  const loadQuota = useCallback6(async () => {
-    const today = await client.getQuotaToday();
+  const loadQuota = useCallback8(async () => {
+    const today = await requireBackendMethod(client, "getQuotaToday")();
     setQuota(today);
     return today;
   }, [
     client
   ]);
-  const cancel = useCallback6(async () => {
+  const cancel = useCallback8(async () => {
     chatRef.current.stop();
     const activeRunId2 = runIdRef.current;
     if (activeRunId2) {
@@ -3678,8 +4191,8 @@ function useAgentChat(options) {
   }, [
     client
   ]);
-  const approve = useCallback6(async ({ toolCallId, remember, via }) => {
-    await client.approveToolCall({
+  const approve = useCallback8(async ({ toolCallId, remember, via }) => {
+    await requireBackendMethod(client, "approveToolCall")({
       toolCallId,
       ...remember === true ? {
         remember: true
@@ -3691,8 +4204,8 @@ function useAgentChat(options) {
   }, [
     client
   ]);
-  const reject = useCallback6(async ({ toolCallId, reason, via }) => {
-    await client.rejectToolCall({
+  const reject = useCallback8(async ({ toolCallId, reason, via }) => {
+    await requireBackendMethod(client, "rejectToolCall")({
       toolCallId,
       ...reason !== void 0 ? {
         reason
@@ -3704,8 +4217,8 @@ function useAgentChat(options) {
   }, [
     client
   ]);
-  const answer = useCallback6(async ({ toolCallId, answers }) => {
-    await client.answerToolCall({
+  const answer = useCallback8(async ({ toolCallId, answers }) => {
+    await requireBackendMethod(client, "answerToolCall")({
       toolCallId,
       ...answers !== void 0 ? {
         answers
@@ -3714,14 +4227,14 @@ function useAgentChat(options) {
   }, [
     client
   ]);
-  const skip = useCallback6(async ({ toolCallId }) => {
-    await client.skipToolCall({
+  const skip = useCallback8(async ({ toolCallId }) => {
+    await requireBackendMethod(client, "skipToolCall")({
       toolCallId
     });
   }, [
     client
   ]);
-  const regenerate = useCallback6(() => {
+  const regenerate = useCallback8(() => {
     if (isTurnInFlight()) return;
     regenerateNext.current = true;
     turnInFlight.current = true;
@@ -3736,8 +4249,13 @@ function useAgentChat(options) {
     isWorking,
     refresh: refreshBackground
   };
+  const getThreadId = useCallback8(() => latest.current.threadId ?? createdThreadId.current, []);
+  const status = connection.status === "reconnecting" ? "reconnecting" : chat.status;
   return {
     ...chat,
+    status,
+    /** Where the live stream stands — see {@link StreamConnectionState}. */
+    connection,
     sendMessage,
     addToolResult,
     /** Sub-agents this conversation started and did not wait for. */
@@ -3745,6 +4263,14 @@ function useAgentChat(options) {
     runId,
     /** The `resume`-fetched thread's active run id, or `null` once resolved with none. */
     activeRunId,
+    /**
+    * The thread this chat is on right now: the `threadId` option, else the one the backend created
+    * on the first send. A getter, because the created id is learned mid-stream.
+    */
+    getThreadId,
+    /** The backend this chat talks to — pass it to `useThreads`, `useMessageFeedback`, … */
+    backend: client,
+    /** Same object as {@link backend}; kept for callers that read it under its old name. */
     client,
     threads,
     loadThreads,
@@ -3774,6 +4300,7 @@ async function mergeHeaders(options) {
 }
 __name(mergeHeaders, "mergeHeaders");
 export {
+  AgentBackendUnsupportedError,
   AgentChatTransport,
   AgentClient,
   AgentHttpError,
@@ -3803,10 +4330,13 @@ export {
   inferResultView,
   isActionCall,
   loadStoredSpeechLang,
+  notifyThreads,
+  onThreadsEvent,
   persistSpeechLang,
   phraseFor,
   readPath,
   readReasoningMs,
+  requireBackendMethod,
   resolveResultView,
   storedMessageToUiMessage,
   storedThreadToUiMessages,
@@ -3817,8 +4347,10 @@ export {
   useChatTranscript,
   useComposerAutocomplete,
   useElapsed,
+  useMessageFeedback,
   useSpeechRecognition,
   useStickToBottom,
+  useThreads,
   useToolCatalog,
   useTranscriptItem,
   validateElicitationAnswer as validateAnswer,