@dudousxd/nestjs-agent-react 0.17.0 → 0.19.0

package/dist/index.js

@@ -125,6 +125,9 @@ var AgentClient = class {
   * what a caller then rides on `sendMessage({ text }, { body: { attachments: [...] } })`.
   */
   async uploadAttachment(file, options = {}) {
+    if (options.onProgress !== void 0 && this.options.fetch === void 0 && typeof XMLHttpRequest !== "undefined") {
+      return this.uploadWithProgress(file, options);
+    }
     const formData = new FormData();
     formData.append("file", file);
     const response = await this.fetchImpl()(`${this.baseUrl()}/agent/attachments`, {
@@ -139,7 +142,47 @@ var AgentClient = class {
         signal: options.signal
       } : {}
     });
-    return this.handleResponse(response, "POST", "/agent/attachments");
+    const attachment = await this.handleResponse(response, "POST", "/agent/attachments");
+    options.onProgress?.(1);
+    return attachment;
+  }
+  async uploadWithProgress(file, { signal, onProgress }) {
+    const headers = {
+      accept: "application/json",
+      ...await this.resolveHeaders()
+    };
+    const url = `${this.baseUrl()}/agent/attachments`;
+    return new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+      xhr.open("POST", url);
+      for (const [name, value] of Object.entries(headers)) xhr.setRequestHeader(name, value);
+      xhr.withCredentials = this.options.credentials === "include";
+      xhr.upload.onprogress = (event) => {
+        if (event.lengthComputable && event.total > 0) onProgress?.(event.loaded / event.total);
+      };
+      xhr.onload = () => {
+        if (xhr.status < 200 || xhr.status >= 300) {
+          reject(new AgentHttpError(xhr.status, "POST", "/agent/attachments", xhr.statusText));
+          return;
+        }
+        onProgress?.(1);
+        resolve(JSON.parse(xhr.responseText));
+      };
+      xhr.onerror = () => reject(new TypeError("Network error while uploading the attachment"));
+      xhr.onabort = () => reject(new DOMException("The upload was aborted", "AbortError"));
+      if (signal !== void 0) {
+        if (signal.aborted) {
+          reject(new DOMException("The upload was aborted", "AbortError"));
+          return;
+        }
+        signal.addEventListener("abort", () => xhr.abort(), {
+          once: true
+        });
+      }
+      const formData = new FormData();
+      formData.append("file", file);
+      xhr.send(formData);
+    });
   }
   promoteThread(id) {
     return this.request("POST", `/agent/threads/${encodeURIComponent(id)}/promote`);
@@ -987,6 +1030,68 @@ function delay(ms, signal) {
 }
 __name(delay, "delay");
 
+// src/attachments/files.ts
+function fileKind(mediaType) {
+  const type = mediaType.toLowerCase();
+  if (type.startsWith("image/")) return "image";
+  if (type === "application/pdf") return "pdf";
+  if (type.startsWith("text/") || type === "application/json") return "text";
+  if (type.startsWith("audio/")) return "audio";
+  if (type.startsWith("video/")) return "video";
+  return "other";
+}
+__name(fileKind, "fileKind");
+function messageFiles(message) {
+  const files = [];
+  for (const part of message.parts) {
+    if (part.type !== "file") continue;
+    const file = part;
+    const filename = file.filename ?? null;
+    const dot = filename?.lastIndexOf(".") ?? -1;
+    const mediaId = file.providerMetadata?.agent?.mediaId;
+    files.push({
+      url: file.url,
+      mediaType: file.mediaType,
+      filename,
+      kind: fileKind(file.mediaType),
+      extension: filename !== null && dot > 0 ? filename.slice(dot + 1).toLowerCase() : null,
+      mediaId: typeof mediaId === "string" ? mediaId : null
+    });
+  }
+  return files;
+}
+__name(messageFiles, "messageFiles");
+function acceptsFile(accept, file) {
+  const rules = (typeof accept === "string" ? accept.split(",") : accept ?? []).map((rule) => rule.trim().toLowerCase()).filter((rule) => rule.length > 0);
+  if (rules.length === 0) return true;
+  const type = file.type.toLowerCase();
+  const name = file.name.toLowerCase();
+  return rules.some((rule) => {
+    if (rule.startsWith(".")) return name.endsWith(rule);
+    if (rule.endsWith("/*")) return type.startsWith(rule.slice(0, -1));
+    return type === rule;
+  });
+}
+__name(acceptsFile, "acceptsFile");
+function filesFromClipboard(data) {
+  if (!data) return [];
+  const files = [];
+  for (const item of Array.from(data.items ?? [])) {
+    if (item.kind !== "file") continue;
+    const file = item.getAsFile();
+    if (file !== null) files.push(file);
+  }
+  return files.length > 0 ? files : Array.from(data.files ?? []);
+}
+__name(filesFromClipboard, "filesFromClipboard");
+function dragHasFiles(data) {
+  return Array.from(data?.types ?? []).includes("Files");
+}
+__name(dragHasFiles, "dragHasFiles");
+
+// src/attachments/use-attachments.ts
+import { useCallback, useEffect as useEffect2, useMemo, useRef as useRef2, useState as useState2 } from "react";
+
 // src/backend.ts
 var AgentBackendUnsupportedError = class extends Error {
   static {
@@ -1007,19 +1112,239 @@ function requireBackendMethod(backend, name) {
 }
 __name(requireBackendMethod, "requireBackendMethod");
 
+// src/attachments/use-attachments.ts
+var DEFAULT_REJECTION = {
+  type: /* @__PURE__ */ __name((file) => `${file.name} is not a supported file type`, "type"),
+  size: /* @__PURE__ */ __name((file) => `${file.name} is too large`, "size"),
+  count: /* @__PURE__ */ __name(() => "Too many files", "count")
+};
+var sequence = 0;
+function useAttachments(options) {
+  const latest = useRef2(options);
+  latest.current = options;
+  const [items, setItems] = useState2([]);
+  const itemsRef = useRef2(items);
+  itemsRef.current = items;
+  const controllers = useRef2(/* @__PURE__ */ new Map());
+  const [dragDepth, setDragDepth] = useState2(0);
+  const patch = useCallback((id, change) => {
+    setItems((current) => current.map((item) => item.id === id ? {
+      ...item,
+      ...change
+    } : item));
+  }, []);
+  const start = useCallback((item) => {
+    const { upload, backend } = latest.current;
+    const run = upload ?? (backend?.uploadAttachment !== void 0 ? backend.uploadAttachment.bind(backend) : void 0);
+    if (run === void 0) {
+      patch(item.id, {
+        status: "error",
+        error: new AgentBackendUnsupportedError("uploadAttachment").message
+      });
+      return;
+    }
+    const controller = new AbortController();
+    controllers.current.set(item.id, controller);
+    run(item.file, {
+      signal: controller.signal,
+      onProgress: /* @__PURE__ */ __name((fraction) => patch(item.id, {
+        progress: Math.max(0, Math.min(1, fraction))
+      }), "onProgress")
+    }).then((attachment) => {
+      if (controller.signal.aborted) return;
+      controllers.current.delete(item.id);
+      patch(item.id, {
+        status: "ready",
+        progress: 1,
+        attachment
+      });
+    }, (error) => {
+      if (controller.signal.aborted) return;
+      controllers.current.delete(item.id);
+      patch(item.id, {
+        status: "error",
+        error: error instanceof Error ? error.message : String(error)
+      });
+    });
+  }, [
+    patch
+  ]);
+  const add = useCallback((files) => {
+    if (files == null) return;
+    const { accept: accept2, maxBytes, maxFiles, describeRejection } = latest.current;
+    const describe = /* @__PURE__ */ __name((reason, file) => describeRejection?.(reason, file) ?? DEFAULT_REJECTION[reason](file), "describe");
+    let room = maxFiles === void 0 ? Number.POSITIVE_INFINITY : maxFiles - itemsRef.current.filter((item) => item.status !== "rejected").length;
+    const staged = [];
+    for (const file of Array.from(files)) {
+      sequence += 1;
+      const base = {
+        id: `att-${sequence}`,
+        file,
+        name: file.name,
+        size: file.size,
+        type: file.type,
+        progress: 0
+      };
+      const reason = !acceptsFile(accept2, file) ? "type" : maxBytes !== void 0 && file.size > maxBytes ? "size" : room <= 0 ? "count" : void 0;
+      if (reason !== void 0) {
+        staged.push({
+          ...base,
+          status: "rejected",
+          error: describe(reason, file)
+        });
+        continue;
+      }
+      room -= 1;
+      const previewUrl = file.type.startsWith("image/") && typeof URL.createObjectURL === "function" ? URL.createObjectURL(file) : void 0;
+      staged.push({
+        ...base,
+        status: "uploading",
+        ...previewUrl ? {
+          previewUrl
+        } : {}
+      });
+    }
+    if (staged.length === 0) return;
+    setItems((current) => [
+      ...current,
+      ...staged
+    ]);
+    for (const item of staged) {
+      if (item.status === "uploading") start(item);
+    }
+  }, [
+    start
+  ]);
+  const release = useCallback((item) => {
+    if (item === void 0) return;
+    controllers.current.get(item.id)?.abort();
+    controllers.current.delete(item.id);
+    if (item.previewUrl !== void 0 && typeof URL.revokeObjectURL === "function") {
+      URL.revokeObjectURL(item.previewUrl);
+    }
+  }, []);
+  const remove = useCallback((id) => {
+    release(itemsRef.current.find((item) => item.id === id));
+    setItems((current) => current.filter((item) => item.id !== id));
+  }, [
+    release
+  ]);
+  const clear = useCallback(() => {
+    for (const item of itemsRef.current) release(item);
+    setItems([]);
+  }, [
+    release
+  ]);
+  const retry = useCallback((id) => {
+    const item = itemsRef.current.find((candidate) => candidate.id === id);
+    if (item === void 0 || item.status !== "error") return;
+    const { error: _previous, ...rest } = item;
+    const again = {
+      ...rest,
+      status: "uploading",
+      progress: 0
+    };
+    setItems((current) => current.map((candidate) => candidate.id === id ? again : candidate));
+    start(again);
+  }, [
+    start
+  ]);
+  useEffect2(() => () => {
+    for (const item of itemsRef.current) release(item);
+  }, [
+    release
+  ]);
+  const onPaste = useCallback((event) => {
+    const files = filesFromClipboard(event.clipboardData);
+    if (files.length === 0) return;
+    event.preventDefault();
+    add(files);
+  }, [
+    add
+  ]);
+  const dropZoneProps = useMemo(() => ({
+    onDragEnter: /* @__PURE__ */ __name((event) => {
+      if (!dragHasFiles(event.dataTransfer)) return;
+      event.preventDefault();
+      setDragDepth((depth) => depth + 1);
+    }, "onDragEnter"),
+    onDragOver: /* @__PURE__ */ __name((event) => {
+      if (dragHasFiles(event.dataTransfer)) event.preventDefault();
+    }, "onDragOver"),
+    onDragLeave: /* @__PURE__ */ __name((event) => {
+      if (!dragHasFiles(event.dataTransfer)) return;
+      setDragDepth((depth) => Math.max(0, depth - 1));
+    }, "onDragLeave"),
+    onDrop: /* @__PURE__ */ __name((event) => {
+      if (!dragHasFiles(event.dataTransfer)) return;
+      event.preventDefault();
+      setDragDepth(0);
+      add(event.dataTransfer?.files);
+    }, "onDrop")
+  }), [
+    add
+  ]);
+  const accept = options.accept;
+  const inputProps = useMemo(() => ({
+    type: "file",
+    accept: typeof accept === "string" ? accept : accept?.join(","),
+    multiple: options.maxFiles === void 0 || options.maxFiles > 1,
+    onChange: /* @__PURE__ */ __name((event) => {
+      const input = event.currentTarget;
+      add(input.files);
+      input.value = "";
+    }, "onChange")
+  }), [
+    accept,
+    options.maxFiles,
+    add
+  ]);
+  return useMemo(() => {
+    const ready = items.filter((item) => item.status === "ready" && item.attachment !== void 0);
+    const attachments = ready.map((item) => item.attachment);
+    return {
+      items,
+      add,
+      remove,
+      retry,
+      clear,
+      isUploading: items.some((item) => item.status === "uploading"),
+      attachments,
+      refs: attachments.map((attachment) => ({
+        mediaId: attachment.mediaId
+      })),
+      inputProps,
+      dropZoneProps,
+      isDragging: dragDepth > 0,
+      onPaste
+    };
+  }, [
+    items,
+    add,
+    remove,
+    retry,
+    clear,
+    inputProps,
+    dropZoneProps,
+    dragDepth,
+    onPaste
+  ]);
+}
+__name(useAttachments, "useAttachments");
+
 // src/catalog/use-agents.ts
-import { useMemo } from "react";
+import { useMemo as useMemo2 } from "react";
 
 // src/catalog/use-resource.ts
-import { useCallback, useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+import { useCallback as useCallback2, useEffect as useEffect3, useRef as useRef3, useState as useState3 } from "react";
 function useResource(load2, key, enabled) {
-  const [data, setData] = useState2(void 0);
-  const [isLoading, setIsLoading] = useState2(enabled);
-  const [error, setError] = useState2(null);
-  const loadRef = useRef2(load2);
+  const [data, setData] = useState3(void 0);
+  const [isLoading, setIsLoading] = useState3(enabled);
+  const [error, setError] = useState3(null);
+  const loadRef = useRef3(load2);
   loadRef.current = load2;
-  const generation = useRef2(0);
-  const refresh = useCallback(async () => {
+  const generation = useRef3(0);
+  const refresh = useCallback2(async () => {
     const mine = ++generation.current;
     setIsLoading(true);
     try {
@@ -1034,7 +1359,7 @@ function useResource(load2, key, enabled) {
       if (mine === generation.current) setIsLoading(false);
     }
   }, []);
-  useEffect2(() => {
+  useEffect3(() => {
     if (!enabled) return;
     void refresh();
   }, [
@@ -1055,7 +1380,7 @@ __name(useResource, "useResource");
 function useAgents(options) {
   const { backend, enabled = true } = options;
   const { data, isLoading, error, refresh } = useResource(() => requireBackendMethod(backend, "listAgents")(), "", enabled);
-  return useMemo(() => {
+  return useMemo2(() => {
     const agents = data ?? [];
     return {
       agents,
@@ -1074,11 +1399,11 @@ function useAgents(options) {
 __name(useAgents, "useAgents");
 
 // src/catalog/use-models.ts
-import { useMemo as useMemo2 } from "react";
+import { useMemo as useMemo3 } from "react";
 function useModels(options) {
   const { backend, agent, enabled = true } = options;
   const { data, isLoading, error, refresh } = useResource(() => requireBackendMethod(backend, "listModels")(agent), `${agent ?? ""}`, enabled);
-  return useMemo2(() => {
+  return useMemo3(() => {
     const providers = data?.providers ?? [];
     const models = providers.flatMap((provider) => provider.models.map((model) => ({
       ...model,
@@ -1108,7 +1433,7 @@ function useModels(options) {
 __name(useModels, "useModels");
 
 // src/quota/use-quota.ts
-import { useEffect as useEffect3, useMemo as useMemo3 } from "react";
+import { useEffect as useEffect4, useMemo as useMemo4 } from "react";
 
 // src/threads/threads-events.ts
 var listeners = /* @__PURE__ */ new WeakMap();
@@ -1135,7 +1460,7 @@ __name(onThreadsEvent, "onThreadsEvent");
 function useQuota(options) {
   const { backend, enabled = true, pollMs } = options;
   const { data, isLoading, error, refresh } = useResource(() => requireBackendMethod(backend, "getQuota")(), "", enabled);
-  useEffect3(() => {
+  useEffect4(() => {
     if (!enabled) return;
     return onThreadsEvent(backend, (event) => {
       if (event.type === "changed") void refresh();
@@ -1145,7 +1470,7 @@ function useQuota(options) {
     enabled,
     refresh
   ]);
-  useEffect3(() => {
+  useEffect4(() => {
     if (!enabled || pollMs === void 0 || pollMs <= 0) return;
     const timer = setInterval(() => void refresh(), pollMs);
     return () => clearInterval(timer);
@@ -1154,7 +1479,7 @@ function useQuota(options) {
     pollMs,
     refresh
   ]);
-  return useMemo3(() => {
+  return useMemo4(() => {
     const windows = data?.windows ?? [];
     return {
       report: data,
@@ -1176,27 +1501,27 @@ function useQuota(options) {
 __name(useQuota, "useQuota");
 
 // src/feedback/use-message-feedback.ts
-import { useCallback as useCallback2, useRef as useRef3, useState as useState3 } from "react";
+import { useCallback as useCallback3, useRef as useRef4, useState as useState4 } from "react";
 function useMessageFeedback(options) {
-  const latest = useRef3(options);
+  const latest = useRef4(options);
   latest.current = options;
-  const [local, setLocal] = useState3(/* @__PURE__ */ new Map());
-  const [pending, setPending] = useState3(/* @__PURE__ */ new Set());
-  const [error, setError] = useState3(null);
-  const localRef = useRef3(local);
+  const [local, setLocal] = useState4(/* @__PURE__ */ new Map());
+  const [pending, setPending] = useState4(/* @__PURE__ */ new Set());
+  const [error, setError] = useState4(null);
+  const localRef = useRef4(local);
   localRef.current = local;
-  const resolved = useRef3(/* @__PURE__ */ new Map());
-  const feedbackOf = useCallback2((message) => {
+  const resolved = useRef4(/* @__PURE__ */ new Map());
+  const feedbackOf = useCallback3((message) => {
     const mine = local.get(message.id);
     if (mine !== void 0) return mine.feedback;
     return metadataOf(message).feedback ?? null;
   }, [
     local
   ]);
-  const isPending = useCallback2((message) => pending.has(message.id), [
+  const isPending = useCallback3((message) => pending.has(message.id), [
     pending
   ]);
-  const storedIdFor = useCallback2(async (message) => {
+  const storedIdFor = useCallback3(async (message) => {
     const runId = metadataOf(message).runId;
     if (runId === void 0) return message.id;
     const known = resolved.current.get(message.id);
@@ -1216,7 +1541,7 @@ function useMessageFeedback(options) {
     resolved.current.set(message.id, row.id);
     return row.id;
   }, []);
-  const rate = useCallback2(async (message, value, comment) => {
+  const rate = useCallback3(async (message, value, comment) => {
     const setFeedback = requireBackendMethod(latest.current.backend, "setMessageFeedback");
     const had = localRef.current.get(message.id);
     const optimistic = value === null ? null : {
@@ -1262,7 +1587,7 @@ function useMessageFeedback(options) {
   }, [
     storedIdFor
   ]);
-  const toggle = useCallback2((message, value) => {
+  const toggle = useCallback3((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);
@@ -1285,16 +1610,16 @@ function metadataOf(message) {
 __name(metadataOf, "metadataOf");
 
 // src/threads/use-threads.ts
-import { useCallback as useCallback3, useEffect as useEffect4, useRef as useRef4, useState as useState4 } from "react";
+import { useCallback as useCallback4, useEffect as useEffect5, useRef as useRef5, useState as useState5 } from "react";
 function useThreads(options) {
   const { backend, enabled = true } = options;
-  const [threads, setThreads] = useState4([]);
-  const [isLoading, setIsLoading] = useState4(enabled);
-  const [error, setError] = useState4(null);
-  const threadsRef = useRef4(threads);
+  const [threads, setThreads] = useState5([]);
+  const [isLoading, setIsLoading] = useState5(enabled);
+  const [error, setError] = useState5(null);
+  const threadsRef = useRef5(threads);
   threadsRef.current = threads;
-  const generation = useRef4(0);
-  const refresh = useCallback3(async () => {
+  const generation = useRef5(0);
+  const refresh = useCallback4(async () => {
     const mine = ++generation.current;
     setIsLoading(true);
     try {
@@ -1311,7 +1636,7 @@ function useThreads(options) {
   }, [
     backend
   ]);
-  useEffect4(() => {
+  useEffect5(() => {
     if (!enabled) return;
     void refresh();
     return onThreadsEvent(backend, (event) => {
@@ -1331,7 +1656,7 @@ function useThreads(options) {
     enabled,
     refresh
   ]);
-  const rename = useCallback3(async (id, title) => {
+  const rename = useCallback4(async (id, title) => {
     const before = threadsRef.current;
     setThreads((current) => current.map((thread) => thread.id === id ? {
       ...thread,
@@ -1353,7 +1678,7 @@ function useThreads(options) {
   }, [
     backend
   ]);
-  const remove = useCallback3(async (id) => {
+  const remove = useCallback4(async (id) => {
     const before = threadsRef.current;
     setThreads((current) => current.filter((thread) => thread.id !== id));
     try {
@@ -1427,11 +1752,29 @@ function backgroundRunsFromThread(messages) {
 }
 __name(backgroundRunsFromThread, "backgroundRunsFromThread");
 
+// src/components/ambient-ui.ts
+import { createContext, useContext } from "react";
+function sharedContext(key) {
+  const symbol = Symbol.for(key);
+  const holder = globalThis;
+  const existing = holder[symbol];
+  if (existing !== void 0) return existing;
+  const created = createContext(null);
+  holder[symbol] = created;
+  return created;
+}
+__name(sharedContext, "sharedContext");
+var AmbientRenderUiContext = sharedContext("@dudousxd/nestjs-agent-react:ambient-render-ui");
+function useAmbientRenderUi() {
+  return useContext(AmbientRenderUiContext);
+}
+__name(useAmbientRenderUi, "useAmbientRenderUi");
+
 // src/components/chat-input.tsx
-import React2, { useEffect as useEffect6, useState as useState6 } from "react";
+import React2, { useEffect as useEffect7, useState as useState7 } from "react";
 
 // src/components/use-speech-recognition.ts
-import { useCallback as useCallback4, useEffect as useEffect5, useMemo as useMemo4, useRef as useRef5, useState as useState5 } from "react";
+import { useCallback as useCallback5, useEffect as useEffect6, useMemo as useMemo5, useRef as useRef6, useState as useState6 } from "react";
 function getRecognitionCtor() {
   if (typeof window === "undefined") return null;
   const scope = window;
@@ -1439,15 +1782,15 @@ function getRecognitionCtor() {
 }
 __name(getRecognitionCtor, "getRecognitionCtor");
 function useSpeechRecognition({ lang = "en-US", onFinalTranscript, onInterimTranscript }) {
-  const recognitionRef = useRef5(null);
-  const [isListening, setIsListening] = useState5(false);
-  const ctor = useMemo4(() => getRecognitionCtor(), []);
+  const recognitionRef = useRef6(null);
+  const [isListening, setIsListening] = useState6(false);
+  const ctor = useMemo5(() => getRecognitionCtor(), []);
   const isSupported = ctor !== null;
-  const finalRef = useRef5(onFinalTranscript);
-  const interimRef = useRef5(onInterimTranscript);
+  const finalRef = useRef6(onFinalTranscript);
+  const interimRef = useRef6(onInterimTranscript);
   finalRef.current = onFinalTranscript;
   interimRef.current = onInterimTranscript;
-  useEffect5(() => {
+  useEffect6(() => {
     if (!ctor) return;
     const recognition = new ctor();
     recognition.lang = lang;
@@ -1486,7 +1829,7 @@ function useSpeechRecognition({ lang = "en-US", onFinalTranscript, onInterimTran
     ctor,
     lang
   ]);
-  const start = useCallback4(() => {
+  const start = useCallback5(() => {
     const recognition = recognitionRef.current;
     if (!recognition) return;
     try {
@@ -1496,7 +1839,7 @@ function useSpeechRecognition({ lang = "en-US", onFinalTranscript, onInterimTran
       console.warn("SpeechRecognition start failed", error);
     }
   }, []);
-  const stop = useCallback4(() => {
+  const stop = useCallback5(() => {
     const recognition = recognitionRef.current;
     if (!recognition) return;
     try {
@@ -1515,8 +1858,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] = useState6("");
-  const [interim, setInterim] = useState6("");
+  const [value, setValue] = useState7("");
+  const [interim, setInterim] = useState7("");
   const speech = useSpeechRecognition({
     lang: speechLang,
     onFinalTranscript: /* @__PURE__ */ __name((text) => {
@@ -1527,7 +1870,7 @@ function ChatInput({ onSubmit, disabled, placeholder, rows = 2, enableSpeech = t
     }, "onFinalTranscript"),
     onInterimTranscript: /* @__PURE__ */ __name((text) => setInterim(text), "onInterimTranscript")
   });
-  useEffect6(() => {
+  useEffect7(() => {
     if (!speech.isListening) setInterim("");
   }, [
     speech.isListening
@@ -1594,7 +1937,7 @@ __name(ChatInput, "ChatInput");
 import React3 from "react";
 
 // src/transcript/use-chat-transcript.ts
-import { useCallback as useCallback6, useEffect as useEffect8, useRef as useRef7, useState as useState8 } from "react";
+import { useCallback as useCallback7, useEffect as useEffect9, useRef as useRef8, useState as useState9 } from "react";
 
 // src/transcript/model.ts
 import { readElicitationInput, validateElicitationAnswer as validateElicitationAnswer2 } from "@dudousxd/nestjs-agent-core";
@@ -2571,11 +2914,11 @@ function formatCostUsd(cost) {
 __name(formatCostUsd, "formatCostUsd");
 
 // src/transcript/use-stick-to-bottom.ts
-import { useCallback as useCallback5, useEffect as useEffect7, useRef as useRef6, useState as useState7 } from "react";
+import { useCallback as useCallback6, useEffect as useEffect8, useRef as useRef7, useState as useState8 } from "react";
 function useStickToBottom({ contentKey, threshold = 32 }) {
-  const containerRef = useRef6(null);
-  const [isAtBottom, setIsAtBottom] = useState7(true);
-  const measure = useCallback5(() => {
+  const containerRef = useRef7(null);
+  const [isAtBottom, setIsAtBottom] = useState8(true);
+  const measure = useCallback6(() => {
     const element = containerRef.current;
     if (!element) {
       return;
@@ -2585,7 +2928,7 @@ function useStickToBottom({ contentKey, threshold = 32 }) {
   }, [
     threshold
   ]);
-  const scrollToBottom = useCallback5(() => {
+  const scrollToBottom = useCallback6(() => {
     const element = containerRef.current;
     if (!element) {
       return;
@@ -2593,7 +2936,7 @@ function useStickToBottom({ contentKey, threshold = 32 }) {
     element.scrollTop = element.scrollHeight;
     setIsAtBottom(true);
   }, []);
-  const setContainer = useCallback5((element) => {
+  const setContainer = useCallback6((element) => {
     containerRef.current = element;
     if (element) {
       measure();
@@ -2601,7 +2944,7 @@ function useStickToBottom({ contentKey, threshold = 32 }) {
   }, [
     measure
   ]);
-  useEffect7(() => {
+  useEffect8(() => {
     if (isAtBottom) {
       scrollToBottom();
     }
@@ -2610,7 +2953,7 @@ function useStickToBottom({ contentKey, threshold = 32 }) {
     isAtBottom,
     scrollToBottom
   ]);
-  const getContainerProps = useCallback5(() => ({
+  const getContainerProps = useCallback6(() => ({
     ref: setContainer,
     onScroll: measure
   }), [
@@ -2632,14 +2975,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 = useRef7(options);
+  const latest = useRef8(options);
   latest.current = options;
-  const [visibleCount, setVisibleCount] = useState8(initialVisibleCount);
-  const [stopRequested, setStopRequested] = useState8(false);
+  const [visibleCount, setVisibleCount] = useState9(initialVisibleCount);
+  const [stopRequested, setStopRequested] = useState9(false);
   const isStreaming = status === "streaming" || status === "reconnecting";
   const isBusy = status === "submitted" || isStreaming;
   const isEmpty = messages.length === 0;
-  useEffect8(() => {
+  useEffect9(() => {
     if (!isBusy) {
       setStopRequested(false);
     }
@@ -2656,7 +2999,7 @@ function useChatTranscript(options) {
     streamingMessageId,
     options
   });
-  const stop = useCallback6(() => {
+  const stop = useCallback7(() => {
     const current = latest.current;
     if (current.status !== "submitted" && current.status !== "streaming" && current.status !== "reconnecting") {
       return;
@@ -2664,8 +3007,8 @@ function useChatTranscript(options) {
     setStopRequested(true);
     void current.onStop?.();
   }, []);
-  const loadEarlier = useCallback6(() => setVisibleCount((count) => count + (latest.current.loadEarlierStep ?? DEFAULT_LOAD_EARLIER_STEP)), []);
-  const showAll = useCallback6(() => setVisibleCount(latest.current.messages.length), []);
+  const loadEarlier = useCallback7(() => setVisibleCount((count) => count + (latest.current.loadEarlierStep ?? DEFAULT_LOAD_EARLIER_STEP)), []);
+  const showAll = useCallback7(() => setVisibleCount(latest.current.messages.length), []);
   const scroll = useStickToBottom({
     contentKey: contentSignature(messages),
     ...stickToBottomThreshold !== void 0 ? {
@@ -2701,7 +3044,7 @@ function useChatTranscript(options) {
 __name(useChatTranscript, "useChatTranscript");
 function useTranscriptItem(options) {
   const { message, isStreaming = false } = options;
-  const messagesRef = useRef7([
+  const messagesRef = useRef8([
     message
   ]);
   if (messagesRef.current[0] !== message) {
@@ -2719,13 +3062,13 @@ function useTranscriptItem(options) {
 }
 __name(useTranscriptItem, "useTranscriptItem");
 function useTranscriptItems({ messages, visibleStart, streamingMessageId, options }) {
-  const [drafts, setDrafts] = useState8(() => /* @__PURE__ */ new Map());
-  const [copied, setCopied] = useState8(() => /* @__PURE__ */ new Set());
-  const [openReasoning, setOpenReasoning] = useState8(() => /* @__PURE__ */ new Map());
-  const [picks, setPicks] = useState8(() => /* @__PURE__ */ new Map());
-  const [settling, setSettling] = useState8(() => /* @__PURE__ */ new Map());
-  const [settleErrors, setSettleErrors] = useState8(() => /* @__PURE__ */ new Map());
-  const latest = useRef7({
+  const [drafts, setDrafts] = useState9(() => /* @__PURE__ */ new Map());
+  const [copied, setCopied] = useState9(() => /* @__PURE__ */ new Set());
+  const [openReasoning, setOpenReasoning] = useState9(() => /* @__PURE__ */ new Map());
+  const [picks, setPicks] = useState9(() => /* @__PURE__ */ new Map());
+  const [settling, setSettling] = useState9(() => /* @__PURE__ */ new Map());
+  const [settleErrors, setSettleErrors] = useState9(() => /* @__PURE__ */ new Map());
+  const latest = useRef8({
     options,
     drafts,
     picks,
@@ -2737,23 +3080,23 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
     picks,
     messages
   };
-  const copyTimers = useRef7(/* @__PURE__ */ new Map());
-  useEffect8(() => () => {
+  const copyTimers = useRef8(/* @__PURE__ */ new Map());
+  useEffect9(() => () => {
     for (const timer of copyTimers.current.values()) {
       clearTimeout(timer);
     }
     copyTimers.current.clear();
   }, []);
-  const callbackCache = useRef7(/* @__PURE__ */ new Map());
-  const reasoningToggleCache = useRef7(/* @__PURE__ */ new Map());
-  const toggleReasoning = useCallback6((key, open) => {
+  const callbackCache = useRef8(/* @__PURE__ */ new Map());
+  const reasoningToggleCache = useRef8(/* @__PURE__ */ new Map());
+  const toggleReasoning = useCallback7((key, open) => {
     setOpenReasoning((current) => {
       const next = new Map(current);
       next.set(key, open ?? !(current.get(key) ?? false));
       return next;
     });
   }, []);
-  const stableToggle = useCallback6((key) => {
+  const stableToggle = useCallback7((key) => {
     let cached = reasoningToggleCache.current.get(key);
     if (!cached) {
       cached = /* @__PURE__ */ __name((open) => toggleReasoning(key, open), "cached");
@@ -2763,10 +3106,10 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
   }, [
     toggleReasoning
   ]);
-  const pick = useCallback6((toolCallId, questionId, values) => {
+  const pick = useCallback7((toolCallId, questionId, values) => {
     setPicks((current) => new Map(current).set(pickKey(toolCallId, questionId), values));
   }, []);
-  const settle = useCallback6((toolCallId, action, send) => {
+  const settle = useCallback7((toolCallId, action, send) => {
     setSettleErrors((current) => {
       if (!current.has(toolCallId)) {
         return current;
@@ -2790,7 +3133,7 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
       failed(error);
     }
   }, []);
-  const answer = useCallback6((toolCallId) => {
+  const answer = useCallback7((toolCallId) => {
     const current = latest.current;
     const onAnswer = current.options.onAnswer;
     if (!onAnswer) {
@@ -2800,7 +3143,7 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
   }, [
     settle
   ]);
-  const skip = useCallback6((toolCallId) => {
+  const skip = useCallback7((toolCallId) => {
     const onSkip = latest.current.options.onSkip;
     if (onSkip) {
       settle(toolCallId, "skip", () => onSkip(toolCallId));
@@ -2808,7 +3151,7 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
   }, [
     settle
   ]);
-  const approve = useCallback6((toolCallId, options2) => {
+  const approve = useCallback7((toolCallId, options2) => {
     const onApprove = latest.current.options.onApprove;
     if (onApprove) {
       settle(toolCallId, "approve", () => options2 === void 0 ? onApprove(toolCallId) : onApprove(toolCallId, options2));
@@ -2816,7 +3159,7 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
   }, [
     settle
   ]);
-  const reject = useCallback6((toolCallId) => {
+  const reject = useCallback7((toolCallId) => {
     const onReject = latest.current.options.onReject;
     if (onReject) {
       settle(toolCallId, "reject", () => onReject(toolCallId));
@@ -2824,7 +3167,7 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
   }, [
     settle
   ]);
-  const callbacksFor = useCallback6((id) => {
+  const callbacksFor = useCallback7((id) => {
     const cached = callbackCache.current.get(id);
     if (cached) {
       return cached;
@@ -3072,7 +3415,12 @@ function MessageItem({ message, isStreaming = false, editable, onEditSubmit, reg
   });
 }
 __name(MessageItem, "MessageItem");
-function MessageItemView({ item, ...slots }) {
+function MessageItemView({ item, ...given }) {
+  const ambientRenderUi = useAmbientRenderUi();
+  const slots = given.renderUi === void 0 && ambientRenderUi !== null ? {
+    ...given,
+    renderUi: ambientRenderUi
+  } : given;
   const { classNames } = slots;
   const actionRow = /* @__PURE__ */ React3.createElement("div", {
     className: classNames?.actions,
@@ -3481,35 +3829,35 @@ function toItem(entry) {
 __name(toItem, "toItem");
 
 // src/composer/use-composer-autocomplete.ts
-import { useCallback as useCallback7, useEffect as useEffect9, useId, useLayoutEffect, useMemo as useMemo5, useRef as useRef8, useState as useState9 } from "react";
+import { useCallback as useCallback8, useEffect as useEffect10, useId, useLayoutEffect, useMemo as useMemo6, useRef as useRef9, useState as useState10 } from "react";
 function useComposerAutocomplete(options) {
   const { value, sources, acceptOnTab = true } = options;
-  const latest = useRef8(options);
+  const latest = useRef9(options);
   latest.current = options;
-  const inputRef = useRef8(null);
-  const [caret, setCaret] = useState9(value.length);
-  const [items, setItems] = useState9([]);
-  const [isLoading, setLoading] = useState9(false);
-  const [error, setError] = useState9(null);
-  const [activeIndex, setActiveIndex] = useState9(0);
-  const [dismissedIndex, setDismissedIndex] = useState9(null);
+  const inputRef = useRef9(null);
+  const [caret, setCaret] = useState10(value.length);
+  const [items, setItems] = useState10([]);
+  const [isLoading, setLoading] = useState10(false);
+  const [error, setError] = useState10(null);
+  const [activeIndex, setActiveIndex] = useState10(0);
+  const [dismissedIndex, setDismissedIndex] = useState10(null);
   const safeCaret = Math.min(caret, value.length);
-  const match = useMemo5(() => findActiveTrigger(value, safeCaret, sources), [
+  const match = useMemo6(() => findActiveTrigger(value, safeCaret, sources), [
     value,
     safeCaret,
     sources
   ]);
   const isActive = match !== null && dismissedIndex !== match.index;
-  const matchRef = useRef8(match);
+  const matchRef = useRef9(match);
   matchRef.current = match;
-  const caretRef = useRef8(safeCaret);
+  const caretRef = useRef9(safeCaret);
   caretRef.current = safeCaret;
-  const itemsRef = useRef8(items);
+  const itemsRef = useRef9(items);
   itemsRef.current = items;
-  const activeIndexRef = useRef8(activeIndex);
+  const activeIndexRef = useRef9(activeIndex);
   activeIndexRef.current = activeIndex;
   const requestKey = isActive && match ? `${match.source.id}\0${match.query}` : null;
-  useEffect9(() => {
+  useEffect10(() => {
     const current = matchRef.current;
     if (requestKey === null || current === null) {
       setItems([]);
@@ -3559,23 +3907,23 @@ function useComposerAutocomplete(options) {
   const activeItem = isOpen ? items[activeIndex] ?? null : null;
   const reactId = useId();
   const listboxId = options.id ?? `agent-autocomplete-${reactId}`;
-  const optionId = useCallback7((index) => `${listboxId}-option-${index}`, [
+  const optionId = useCallback8((index) => `${listboxId}-option-${index}`, [
     listboxId
   ]);
-  const highlight = useCallback7((index) => {
+  const highlight = useCallback8((index) => {
     const total = itemsRef.current.length;
     if (total === 0) return;
     setActiveIndex((index % total + total) % total);
   }, []);
-  const moveHighlight = useCallback7((delta) => highlight(activeIndexRef.current + delta), [
+  const moveHighlight = useCallback8((delta) => highlight(activeIndexRef.current + delta), [
     highlight
   ]);
-  const dismiss = useCallback7(() => {
+  const dismiss = useCallback8(() => {
     const current = matchRef.current;
     if (current) setDismissedIndex(current.index);
   }, []);
-  const pendingCaret = useRef8(null);
-  const accept = useCallback7((item) => {
+  const pendingCaret = useRef9(null);
+  const accept = useCallback8((item) => {
     const current = matchRef.current;
     if (!current) return;
     const chosen = item ?? itemsRef.current[activeIndexRef.current];
@@ -3592,10 +3940,10 @@ function useComposerAutocomplete(options) {
     pendingCaret.current = null;
     inputRef.current?.setSelectionRange(position, position);
   });
-  const readCaret = useCallback7((element) => {
+  const readCaret = useCallback8((element) => {
     setCaret(element.selectionStart ?? element.value.length);
   }, []);
-  const onKeyDown = useCallback7((event) => {
+  const onKeyDown = useCallback8((event) => {
     if (!isOpen) return;
     const hasItems = itemsRef.current.length > 0;
     switch (event.key) {
@@ -3633,23 +3981,23 @@ function useComposerAutocomplete(options) {
     dismiss,
     moveHighlight
   ]);
-  const onChange = useCallback7((event) => {
+  const onChange = useCallback8((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 = useCallback7((event) => readCaret(event.currentTarget), [
+  const onSelect = useCallback8((event) => readCaret(event.currentTarget), [
     readCaret
   ]);
-  const onClick = useCallback7((event) => readCaret(event.currentTarget), [
+  const onClick = useCallback8((event) => readCaret(event.currentTarget), [
     readCaret
   ]);
-  const setInput = useCallback7((element) => {
+  const setInput = useCallback8((element) => {
     inputRef.current = element;
   }, []);
-  const getInputProps = useCallback7(() => ({
+  const getInputProps = useCallback8(() => ({
     ref: setInput,
     onChange,
     onKeyDown,
@@ -3677,7 +4025,7 @@ function useComposerAutocomplete(options) {
     activeIndex,
     optionId
   ]);
-  const getListboxProps = useCallback7(() => ({
+  const getListboxProps = useCallback8(() => ({
     id: listboxId,
     role: "listbox",
     "aria-label": match?.source.label ?? match?.source.id ?? "Suggestions"
@@ -3685,7 +4033,7 @@ function useComposerAutocomplete(options) {
     listboxId,
     match
   ]);
-  const getOptionProps = useCallback7((index) => ({
+  const getOptionProps = useCallback8((index) => ({
     id: optionId(index),
     role: "option",
     "aria-selected": index === activeIndex
@@ -3719,7 +4067,7 @@ function isPromise(value) {
 __name(isPromise, "isPromise");
 
 // src/presentation/use-tool-catalog.ts
-import { useCallback as useCallback8, useEffect as useEffect10, useMemo as useMemo6, useState as useState10 } from "react";
+import { useCallback as useCallback9, useEffect as useEffect11, useMemo as useMemo7, useState as useState11 } from "react";
 var shared = /* @__PURE__ */ new WeakMap();
 function load(client, agent) {
   let byAgent = shared.get(client);
@@ -3743,11 +4091,11 @@ function load(client, agent) {
 __name(load, "load");
 function useToolCatalog(options) {
   const { client, agent, enabled = true } = options;
-  const [entries, setEntries] = useState10([]);
-  const [isLoading, setLoading] = useState10(enabled);
-  const [error, setError] = useState10(null);
-  const [generation, setGeneration] = useState10(0);
-  useEffect10(() => {
+  const [entries, setEntries] = useState11([]);
+  const [isLoading, setLoading] = useState11(enabled);
+  const [error, setError] = useState11(null);
+  const [generation, setGeneration] = useState11(0);
+  useEffect11(() => {
     if (!enabled) {
       setLoading(false);
       return;
@@ -3773,14 +4121,14 @@ function useToolCatalog(options) {
     enabled,
     generation
   ]);
-  const refresh = useCallback8(() => {
+  const refresh = useCallback9(() => {
     shared.get(client)?.delete(agent ?? "");
     setGeneration((current) => current + 1);
   }, [
     client,
     agent
   ]);
-  const catalog = useMemo6(() => toolCatalogFrom(entries), [
+  const catalog = useMemo7(() => toolCatalogFrom(entries), [
     entries
   ]);
   return {
@@ -3794,7 +4142,7 @@ function useToolCatalog(options) {
 __name(useToolCatalog, "useToolCatalog");
 
 // src/approvals/countdown.ts
-import { useEffect as useEffect11, useRef as useRef9, useState as useState11 } from "react";
+import { useEffect as useEffect12, useRef as useRef10, useState as useState12 } from "react";
 function approvalCountdown(expiresAt, now = Date.now()) {
   const deadline = expiresAt == null ? Number.NaN : Date.parse(expiresAt);
   if (!Number.isFinite(deadline)) {
@@ -3812,10 +4160,10 @@ function approvalCountdown(expiresAt, now = Date.now()) {
 __name(approvalCountdown, "approvalCountdown");
 function useApprovalCountdown(expiresAt, options = {}) {
   const { intervalMs = 1e3 } = options;
-  const nowRef = useRef9(options.now ?? Date.now);
+  const nowRef = useRef10(options.now ?? Date.now);
   nowRef.current = options.now ?? Date.now;
-  const [state, setState] = useState11(() => approvalCountdown(expiresAt, nowRef.current()));
-  useEffect11(() => {
+  const [state, setState] = useState12(() => approvalCountdown(expiresAt, nowRef.current()));
+  useEffect12(() => {
     const read = /* @__PURE__ */ __name(() => approvalCountdown(expiresAt, nowRef.current()), "read");
     const first = read();
     setState(first);
@@ -3878,7 +4226,13 @@ function storedMessageToUiMessage(message) {
       type: "file",
       mediaType: attachment.contentType,
       filename: attachment.name,
-      url: attachment.url
+      url: attachment.url,
+      // The stored id rides along, so a replayed file can be referenced again (`messageFiles`).
+      providerMetadata: {
+        agent: {
+          mediaId: attachment.mediaId
+        }
+      }
     });
   }
   const toolCallIds = new Set((message.toolCalls ?? []).map((call) => call.id));
@@ -4057,20 +4411,20 @@ __name(sumUsage, "sumUsage");
 
 // src/use-agent-chat.ts
 import { useChat } from "@ai-sdk/react";
-import { useCallback as useCallback9, useEffect as useEffect12, useMemo as useMemo7, useRef as useRef10, useState as useState12 } from "react";
+import { useCallback as useCallback10, useEffect as useEffect13, useMemo as useMemo8, useRef as useRef11, useState as useState13 } from "react";
 function useAgentChat(options) {
-  const latest = useRef10(options);
+  const latest = useRef11(options);
   latest.current = options;
-  const [runId, setRunId] = useState12(options.resumeRunId);
-  const runIdRef = useRef10(runId);
+  const [runId, setRunId] = useState13(options.resumeRunId);
+  const runIdRef = useRef11(runId);
   runIdRef.current = runId;
-  const settlingRunIdRef = useRef10(void 0);
-  const autoResumeRunIdRef = useRef10(void 0);
-  const [autoResume, setAutoResume] = useState12(false);
-  const [activeRunId, setActiveRunId] = useState12(null);
-  const regenerateNext = useRef10(false);
-  const createdThreadId = useRef10(void 0);
-  const client = useMemo7(() => {
+  const settlingRunIdRef = useRef11(void 0);
+  const autoResumeRunIdRef = useRef11(void 0);
+  const [autoResume, setAutoResume] = useState13(false);
+  const [activeRunId, setActiveRunId] = useState13(null);
+  const regenerateNext = useRef11(false);
+  const createdThreadId = useRef11(void 0);
+  const client = useMemo8(() => {
     if (options.backend) return options.backend;
     if (options.client) return options.client;
     return new AgentClient({
@@ -4086,11 +4440,11 @@ function useAgentChat(options) {
       getHeaders: /* @__PURE__ */ __name(async () => mergeHeaders(latest.current), "getHeaders")
     });
   }, []);
-  const [connection, setConnection] = useState12({
+  const [connection, setConnection] = useState13({
     status: "live"
   });
-  const resyncAfterSettle = useRef10(false);
-  useEffect12(() => {
+  const resyncAfterSettle = useRef11(false);
+  useEffect13(() => {
     if (!options.resume || options.threadId === void 0) return;
     let cancelled = false;
     const threadId = options.threadId;
@@ -4110,7 +4464,7 @@ function useAgentChat(options) {
     options.resume,
     options.threadId
   ]);
-  const transport = useMemo7(() => {
+  const transport = useMemo8(() => {
     function onMeta(meta) {
       settlingRunIdRef.current = meta.runId;
       setRunId(meta.runId);
@@ -4165,7 +4519,7 @@ function useAgentChat(options) {
       }, "onAttemptStart")
     });
   }, []);
-  const backgroundRef = useRef10(() => Promise.resolve());
+  const backgroundRef = useRef11(() => Promise.resolve());
   const chat = useChat({
     transport,
     resume: options.resumeRunId !== void 0 || autoResume,
@@ -4214,7 +4568,7 @@ function useAgentChat(options) {
       }
     }, "onFinish")
   });
-  const chatRef = useRef10(chat);
+  const chatRef = useRef11(chat);
   chatRef.current = chat;
   async function resyncFromThread() {
     const threadId = latest.current.threadId ?? createdThreadId.current;
@@ -4226,11 +4580,11 @@ function useAgentChat(options) {
     }
   }
   __name(resyncFromThread, "resyncFromThread");
-  const turnInFlight = useRef10(false);
-  const isTurnInFlight = useCallback9(() => turnInFlight.current || transport.isAttemptLive, [
+  const turnInFlight = useRef11(false);
+  const isTurnInFlight = useCallback10(() => turnInFlight.current || transport.isAttemptLive, [
     transport
   ]);
-  const sendMessage = useCallback9(async (...args) => {
+  const sendMessage = useCallback10(async (...args) => {
     const blocked = latest.current.blocked;
     if (blocked != null) throw new QuotaBlockedError(blocked);
     if (isTurnInFlight()) return;
@@ -4243,15 +4597,15 @@ function useAgentChat(options) {
   }, [
     isTurnInFlight
   ]);
-  const addToolResult = useCallback9(({ tool, toolCallId, output }) => chatRef.current.addToolResult({
+  const addToolResult = useCallback10(({ tool, toolCallId, output }) => chatRef.current.addToolResult({
     tool,
     toolCallId,
     output
   }), []);
-  const [threads, setThreads] = useState12([]);
-  const [quota, setQuota] = useState12(null);
-  const [backgroundRuns, setBackgroundRuns] = useState12([]);
-  const refreshBackground = useCallback9(async () => {
+  const [threads, setThreads] = useState13([]);
+  const [quota, setQuota] = useState13(null);
+  const [backgroundRuns, setBackgroundRuns] = useState13([]);
+  const refreshBackground = useCallback10(async () => {
     const threadId = latest.current.threadId ?? createdThreadId.current;
     if (threadId === void 0) {
       return;
@@ -4276,7 +4630,7 @@ function useAgentChat(options) {
   ]);
   backgroundRef.current = refreshBackground;
   const isWorking = backgroundRuns.some((run) => run.status === "running");
-  useEffect12(() => {
+  useEffect13(() => {
     if (options.background !== true || options.threadId === void 0) {
       return;
     }
@@ -4286,7 +4640,7 @@ function useAgentChat(options) {
     options.threadId,
     refreshBackground
   ]);
-  useEffect12(() => {
+  useEffect13(() => {
     const every = latest.current.backgroundPollMs ?? 5e3;
     if (latest.current.background !== true || !isWorking || every <= 0) {
       return;
@@ -4297,26 +4651,26 @@ function useAgentChat(options) {
     isWorking,
     refreshBackground
   ]);
-  const loadThreads = useCallback9(async () => {
+  const loadThreads = useCallback10(async () => {
     const list = await client.listThreads();
     setThreads(list);
     return list;
   }, [
     client
   ]);
-  const loadThread = useCallback9((id) => client.getThread(id), [
+  const loadThread = useCallback10((id) => client.getThread(id), [
     client
   ]);
-  const deleteThread = useCallback9(async (id) => {
+  const deleteThread = useCallback10(async (id) => {
     await client.deleteThread(id);
     setThreads((current) => current.filter((thread) => thread.id !== id));
   }, [
     client
   ]);
-  const forkThread = useCallback9((threadId, messageId) => requireBackendMethod(client, "forkFromMessage")(threadId, messageId), [
+  const forkThread = useCallback10((threadId, messageId) => requireBackendMethod(client, "forkFromMessage")(threadId, messageId), [
     client
   ]);
-  const renameThread = useCallback9(async (id, title) => {
+  const renameThread = useCallback10(async (id, title) => {
     await client.updateThread(id, {
       title
     });
@@ -4327,24 +4681,24 @@ function useAgentChat(options) {
   }, [
     client
   ]);
-  const promoteThread = useCallback9(async (id) => {
+  const promoteThread = useCallback10(async (id) => {
     await requireBackendMethod(client, "promoteThread")(id);
     await loadThreads();
   }, [
     client,
     loadThreads
   ]);
-  const truncateFromMessage = useCallback9((threadId, messageId) => requireBackendMethod(client, "truncateFromMessage")(threadId, messageId).then(() => void 0), [
+  const truncateFromMessage = useCallback10((threadId, messageId) => requireBackendMethod(client, "truncateFromMessage")(threadId, messageId).then(() => void 0), [
     client
   ]);
-  const loadQuota = useCallback9(async () => {
+  const loadQuota = useCallback10(async () => {
     const today = await requireBackendMethod(client, "getQuotaToday")();
     setQuota(today);
     return today;
   }, [
     client
   ]);
-  const cancel = useCallback9(async () => {
+  const cancel = useCallback10(async () => {
     chatRef.current.stop();
     const activeRunId2 = runIdRef.current;
     if (activeRunId2) {
@@ -4356,7 +4710,7 @@ function useAgentChat(options) {
   }, [
     client
   ]);
-  const approve = useCallback9(async ({ toolCallId, remember, via }) => {
+  const approve = useCallback10(async ({ toolCallId, remember, via }) => {
     await requireBackendMethod(client, "approveToolCall")({
       toolCallId,
       ...remember === true ? {
@@ -4369,7 +4723,7 @@ function useAgentChat(options) {
   }, [
     client
   ]);
-  const reject = useCallback9(async ({ toolCallId, reason, via }) => {
+  const reject = useCallback10(async ({ toolCallId, reason, via }) => {
     await requireBackendMethod(client, "rejectToolCall")({
       toolCallId,
       ...reason !== void 0 ? {
@@ -4382,7 +4736,7 @@ function useAgentChat(options) {
   }, [
     client
   ]);
-  const answer = useCallback9(async ({ toolCallId, answers }) => {
+  const answer = useCallback10(async ({ toolCallId, answers }) => {
     await requireBackendMethod(client, "answerToolCall")({
       toolCallId,
       ...answers !== void 0 ? {
@@ -4392,14 +4746,14 @@ function useAgentChat(options) {
   }, [
     client
   ]);
-  const skip = useCallback9(async ({ toolCallId }) => {
+  const skip = useCallback10(async ({ toolCallId }) => {
     await requireBackendMethod(client, "skipToolCall")({
       toolCallId
     });
   }, [
     client
   ]);
-  const regenerate = useCallback9(() => {
+  const regenerate = useCallback10(() => {
     const blocked = latest.current.blocked;
     if (blocked != null) throw new QuotaBlockedError(blocked);
     if (isTurnInFlight()) return;
@@ -4416,7 +4770,7 @@ function useAgentChat(options) {
     isWorking,
     refresh: refreshBackground
   };
-  const setThreadModel = useCallback9(async (model) => {
+  const setThreadModel = useCallback10(async (model) => {
     const threadId = latest.current.threadId ?? createdThreadId.current;
     if (threadId === void 0) {
       throw new Error("setThreadModel: this chat has no thread yet");
@@ -4430,7 +4784,7 @@ function useAgentChat(options) {
   }, [
     client
   ]);
-  const getThreadId = useCallback9(() => latest.current.threadId ?? createdThreadId.current, []);
+  const getThreadId = useCallback10(() => latest.current.threadId ?? createdThreadId.current, []);
   const status = connection.status === "reconnecting" ? "reconnecting" : chat.status;
   return {
     ...chat,
@@ -4496,6 +4850,7 @@ export {
   AgentChatTransport,
   AgentClient,
   AgentHttpError,
+  AmbientRenderUiContext,
   ChatInput,
   DEFAULT_SPEECH_LANG,
   MessageItem,
@@ -4503,6 +4858,7 @@ export {
   MessageList,
   QuotaBlockedError,
   SPEECH_LANGUAGES,
+  acceptsFile,
   applyCompletion,
   approvalCountdown,
   backgroundRunsFromThread,
@@ -4513,7 +4869,10 @@ export {
   describeTimestamp,
   describeToolCall,
   describeUsage,
+  dragHasFiles,
   extractMessageText,
+  fileKind,
+  filesFromClipboard,
   fillTemplate,
   filterAutocompleteItems,
   findActiveTrigger,
@@ -4523,6 +4882,7 @@ export {
   inferResultView,
   isActionCall,
   loadStoredSpeechLang,
+  messageFiles,
   notifyThreads,
   onThreadsEvent,
   persistSpeechLang,
@@ -4537,7 +4897,9 @@ export {
   toolCatalogFrom,
   useAgentChat,
   useAgents,
+  useAmbientRenderUi,
   useApprovalCountdown,
+  useAttachments,
   useChatTranscript,
   useComposerAutocomplete,
   useElapsed,