@dudousxd/nestjs-agent-react 0.1.0

package/dist/index.js

@@ -0,0 +1,1121 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/agent-chat-transport.ts
+var HEADER_RUN_ID = "x-agent-run-id";
+var HEADER_THREAD_ID = "x-agent-thread-id";
+var AgentChatTransport = class {
+  static {
+    __name(this, "AgentChatTransport");
+  }
+  options;
+  currentRunId;
+  currentThreadId;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /** Run id of the most recent stream — HITL approve/reject target this. */
+  get runId() {
+    return this.currentRunId;
+  }
+  /** Thread id of the most recent stream. */
+  get threadId() {
+    return this.currentThreadId;
+  }
+  async sendMessages(options) {
+    const lastMessage = options.messages.at(-1);
+    const message = lastMessage ? extractText(lastMessage) : "";
+    const body = {
+      ...this.options.agent !== void 0 ? {
+        agent: this.options.agent
+      } : {},
+      ...this.options.getBody?.() ?? {},
+      ...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
+      } : {},
+      ...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);
+  }
+  async reconnectToStream(options) {
+    const runId = this.options.getResumeRunId?.();
+    if (runId === void 0) return null;
+    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
+      } : {}
+    });
+    if (response.status === 404) 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);
+  }
+  fetchImpl() {
+    return this.options.fetch ?? globalThis.fetch;
+  }
+  baseUrl() {
+    return (this.options.baseUrl ?? "").replace(/\/$/, "");
+  }
+  async resolveHeaders(perRequest) {
+    const dynamic = await this.options.getHeaders?.() ?? {};
+    const extra = perRequest instanceof Headers ? Object.fromEntries(perRequest.entries()) : perRequest ?? {};
+    return {
+      ...this.options.headers,
+      ...dynamic,
+      ...extra
+    };
+  }
+  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;
+    this.options.onMeta?.(meta);
+  }
+  /**
+  * Parse the backend's SSE byte stream and synthesize a valid v7
+  * UI-message chunk stream. Recognized backend frames:
+  *  - `event: meta`  `data: {"runId","threadId"}`  → records identity
+  *  - `data: {"delta":"..."}`                       → `text-delta`
+  *  - `event: done`  `data: {}`                     → terminates
+  */
+  toChunkStream(source) {
+    const reader = source.getReader();
+    const decoder = new TextDecoder();
+    const textId = `txt-${Math.random().toString(36).slice(2)}`;
+    let buffer = "";
+    let started = false;
+    const record = /* @__PURE__ */ __name((meta) => this.recordMeta(meta), "record");
+    return new ReadableStream({
+      async pull(controller) {
+        function ensureStarted() {
+          if (started) return;
+          started = true;
+          controller.enqueue({
+            type: "start"
+          });
+          controller.enqueue({
+            type: "start-step"
+          });
+          controller.enqueue({
+            type: "text-start",
+            id: textId
+          });
+        }
+        __name(ensureStarted, "ensureStarted");
+        function finish() {
+          ensureStarted();
+          controller.enqueue({
+            type: "text-end",
+            id: textId
+          });
+          controller.enqueue({
+            type: "finish-step"
+          });
+          controller.enqueue({
+            type: "finish"
+          });
+          controller.close();
+        }
+        __name(finish, "finish");
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              finish();
+              return;
+            }
+            buffer += decoder.decode(value, {
+              stream: true
+            });
+            let separator = buffer.indexOf("\n\n");
+            while (separator !== -1) {
+              const rawEvent = buffer.slice(0, separator);
+              buffer = buffer.slice(separator + 2);
+              const frame = parseSseFrame(rawEvent);
+              if (frame.event === "done") {
+                finish();
+                return;
+              }
+              if (frame.event === "error") {
+                ensureStarted();
+                controller.enqueue({
+                  type: "error",
+                  errorText: parseErrorText(frame.data)
+                });
+                controller.close();
+                return;
+              }
+              if (frame.event === "meta") {
+                const meta = parseMeta(frame.data);
+                if (meta) record(meta);
+              } else if (frame.data) {
+                const delta = parseDelta(frame.data);
+                if (delta) {
+                  ensureStarted();
+                  controller.enqueue({
+                    type: "text-delta",
+                    id: textId,
+                    delta
+                  });
+                }
+              }
+              separator = buffer.indexOf("\n\n");
+            }
+          }
+        } catch (error) {
+          controller.enqueue({
+            type: "error",
+            errorText: error instanceof Error ? error.message : "Agent stream error"
+          });
+          controller.close();
+        }
+      },
+      cancel() {
+        void reader.cancel();
+      }
+    });
+  }
+};
+function parseSseFrame(raw) {
+  let event;
+  const dataLines = [];
+  for (const line of raw.split("\n")) {
+    if (line.startsWith("event:")) {
+      event = line.slice("event:".length).trim();
+    } else if (line.startsWith("data:")) {
+      dataLines.push(line.slice("data:".length).trimStart());
+    }
+  }
+  return {
+    event,
+    data: dataLines.length > 0 ? dataLines.join("\n") : void 0
+  };
+}
+__name(parseSseFrame, "parseSseFrame");
+function parseMeta(data) {
+  if (!data) return null;
+  try {
+    const parsed = JSON.parse(data);
+    if (parsed !== null && typeof parsed === "object" && "runId" in parsed && "threadId" in parsed && typeof parsed.runId === "string" && typeof parsed.threadId === "string") {
+      return {
+        runId: parsed.runId,
+        threadId: parsed.threadId
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+__name(parseMeta, "parseMeta");
+function parseErrorText(data) {
+  if (!data) return "Agent run failed";
+  try {
+    const parsed = JSON.parse(data);
+    if (parsed !== null && typeof parsed === "object" && "message" in parsed && typeof parsed.message === "string") {
+      return parsed.message;
+    }
+  } catch {
+  }
+  return "Agent run failed";
+}
+__name(parseErrorText, "parseErrorText");
+function parseDelta(data) {
+  try {
+    const parsed = JSON.parse(data);
+    if (parsed !== null && typeof parsed === "object" && "delta" in parsed && typeof parsed.delta === "string") {
+      return parsed.delta;
+    }
+  } catch {
+  }
+  return null;
+}
+__name(parseDelta, "parseDelta");
+function extractText(message) {
+  let text = "";
+  for (const part of message.parts ?? []) {
+    if (part.type === "text") text += part.text;
+  }
+  return text;
+}
+__name(extractText, "extractText");
+
+// 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");
+  }
+  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)}`);
+  }
+  getPersonaCatalog() {
+    return this.request("GET", "/agent/threads/personas/catalog");
+  }
+  getQuotaToday() {
+    return this.request("GET", "/agent/quota/today");
+  }
+  cancelStream(runId) {
+    return this.request("POST", `/agent/chat/${encodeURIComponent(runId)}/cancel`);
+  }
+  approveToolCall(input) {
+    return this.request("POST", "/agent/tool-call/approve", input);
+  }
+  rejectToolCall(input) {
+    return this.request("POST", "/agent/tool-call/reject", 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
+      } : {}
+    });
+    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/use-agent-chat.ts
+import { useChat } from "@ai-sdk/react";
+import { useCallback, useMemo, useRef, useState } from "react";
+function useAgentChat(options) {
+  const latest = useRef(options);
+  latest.current = options;
+  const [runId, setRunId] = useState(options.resumeRunId);
+  const runIdRef = useRef(runId);
+  runIdRef.current = runId;
+  const regenerateNext = useRef(false);
+  const client = useMemo(() => {
+    if (options.client) return options.client;
+    return new AgentClient({
+      ...options.baseUrl !== void 0 ? {
+        baseUrl: options.baseUrl
+      } : {},
+      ...options.credentials !== void 0 ? {
+        credentials: options.credentials
+      } : {},
+      ...options.fetch !== void 0 ? {
+        fetch: options.fetch
+      } : {},
+      getHeaders: /* @__PURE__ */ __name(async () => mergeHeaders(latest.current), "getHeaders")
+    });
+  }, []);
+  const transport = useMemo(() => {
+    function onMeta(meta) {
+      setRunId(meta.runId);
+    }
+    __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
+      } : {},
+      ...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;
+        const regenerate2 = regenerateNext.current;
+        regenerateNext.current = false;
+        return {
+          ...current.threadId !== void 0 ? {
+            threadId: current.threadId
+          } : {},
+          ...current.persona !== void 0 ? {
+            persona: current.persona
+          } : {},
+          ...pageContext ? {
+            pageContext
+          } : {},
+          ...regenerate2 ? {
+            regenerate: true
+          } : {}
+        };
+      }, "getBody"),
+      getResumeRunId: /* @__PURE__ */ __name(() => latest.current.resumeRunId, "getResumeRunId"),
+      onMeta
+    });
+  }, []);
+  const chat = useChat({
+    transport,
+    resume: options.resumeRunId !== void 0,
+    ...options.threadId !== void 0 ? {
+      id: options.threadId
+    } : {},
+    ...options.initialMessages !== void 0 ? {
+      messages: options.initialMessages
+    } : {},
+    onFinish: /* @__PURE__ */ __name(() => {
+      latest.current.onFinish?.();
+    }, "onFinish")
+  });
+  const chatRef = useRef(chat);
+  chatRef.current = chat;
+  const addToolResult = useCallback(({ tool, toolCallId, output }) => chatRef.current.addToolResult({
+    tool,
+    toolCallId,
+    output
+  }), []);
+  const [threads, setThreads] = useState([]);
+  const [personaCatalog, setPersonaCatalog] = useState([]);
+  const [quota, setQuota] = useState(null);
+  const loadThreads = useCallback(async () => {
+    const list = await client.listThreads();
+    setThreads(list);
+    return list;
+  }, [
+    client
+  ]);
+  const loadThread = useCallback((id) => client.getThread(id), [
+    client
+  ]);
+  const deleteThread = useCallback(async (id) => {
+    await client.deleteThread(id);
+    setThreads((current) => current.filter((thread) => thread.id !== id));
+  }, [
+    client
+  ]);
+  const forkThread = useCallback((threadId, messageId) => client.forkFromMessage(threadId, messageId), [
+    client
+  ]);
+  const loadPersonaCatalog = useCallback(async () => {
+    const catalog = await client.getPersonaCatalog();
+    setPersonaCatalog(catalog);
+    return catalog;
+  }, [
+    client
+  ]);
+  const loadQuota = useCallback(async () => {
+    const today = await client.getQuotaToday();
+    setQuota(today);
+    return today;
+  }, [
+    client
+  ]);
+  const cancel = useCallback(async () => {
+    chatRef.current.stop();
+    const activeRunId = runIdRef.current;
+    if (activeRunId) {
+      try {
+        await client.cancelStream(activeRunId);
+      } catch {
+      }
+    }
+  }, [
+    client
+  ]);
+  const approve = useCallback(async ({ toolCallId }) => {
+    await client.approveToolCall({
+      toolCallId
+    });
+  }, [
+    client
+  ]);
+  const reject = useCallback(async ({ toolCallId, reason }) => {
+    await client.rejectToolCall({
+      toolCallId,
+      ...reason !== void 0 ? {
+        reason
+      } : {}
+    });
+  }, [
+    client
+  ]);
+  const regenerate = useCallback(() => {
+    regenerateNext.current = true;
+    void chatRef.current.regenerate();
+  }, []);
+  return {
+    ...chat,
+    addToolResult,
+    runId,
+    client,
+    threads,
+    loadThreads,
+    loadThread,
+    deleteThread,
+    forkThread,
+    personaCatalog,
+    loadPersonaCatalog,
+    quota,
+    loadQuota,
+    cancel,
+    approve,
+    reject,
+    regenerate
+  };
+}
+__name(useAgentChat, "useAgentChat");
+async function mergeHeaders(options) {
+  const dynamic = await options.getHeaders?.() ?? {};
+  return {
+    ...options.headers,
+    ...dynamic
+  };
+}
+__name(mergeHeaders, "mergeHeaders");
+
+// src/components/chat-input.tsx
+import React, { useEffect as useEffect2, useState as useState3 } from "react";
+
+// src/components/use-speech-recognition.ts
+import { useCallback as useCallback2, useEffect, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
+function getRecognitionCtor() {
+  if (typeof window === "undefined") return null;
+  const scope = window;
+  return scope.SpeechRecognition ?? scope.webkitSpeechRecognition ?? null;
+}
+__name(getRecognitionCtor, "getRecognitionCtor");
+function useSpeechRecognition({ lang = "en-US", onFinalTranscript, onInterimTranscript }) {
+  const recognitionRef = useRef2(null);
+  const [isListening, setIsListening] = useState2(false);
+  const ctor = useMemo2(() => getRecognitionCtor(), []);
+  const isSupported = ctor !== null;
+  const finalRef = useRef2(onFinalTranscript);
+  const interimRef = useRef2(onInterimTranscript);
+  finalRef.current = onFinalTranscript;
+  interimRef.current = onInterimTranscript;
+  useEffect(() => {
+    if (!ctor) return;
+    const recognition = new ctor();
+    recognition.lang = lang;
+    recognition.continuous = false;
+    recognition.interimResults = true;
+    recognition.onresult = (event) => {
+      let interim = "";
+      for (let i = event.resultIndex; i < event.results.length; i++) {
+        const result = event.results[i];
+        if (!result) continue;
+        const text = result[0]?.transcript ?? "";
+        if (result.isFinal) {
+          finalRef.current(text);
+        } else {
+          interim += text;
+        }
+      }
+      if (interim && interimRef.current) interimRef.current(interim);
+    };
+    recognition.onerror = (event) => {
+      if (event.error !== "no-speech" && event.error !== "aborted") {
+        console.warn("SpeechRecognition error", event.error);
+      }
+      setIsListening(false);
+    };
+    recognition.onend = () => setIsListening(false);
+    recognitionRef.current = recognition;
+    return () => {
+      try {
+        recognition.stop();
+      } catch {
+      }
+      recognitionRef.current = null;
+    };
+  }, [
+    ctor,
+    lang
+  ]);
+  const start = useCallback2(() => {
+    const recognition = recognitionRef.current;
+    if (!recognition) return;
+    try {
+      recognition.start();
+      setIsListening(true);
+    } catch (error) {
+      console.warn("SpeechRecognition start failed", error);
+    }
+  }, []);
+  const stop = useCallback2(() => {
+    const recognition = recognitionRef.current;
+    if (!recognition) return;
+    try {
+      recognition.stop();
+    } catch {
+    }
+  }, []);
+  return {
+    isSupported,
+    isListening,
+    start,
+    stop
+  };
+}
+__name(useSpeechRecognition, "useSpeechRecognition");
+
+// src/components/chat-input.tsx
+function ChatInput({ onSubmit, disabled, placeholder, rows = 2, enableSpeech = true, speechLang = "en-US", sendLabel = "Send", className, textareaClassName, sendButtonClassName, micButtonClassName, renderMic }) {
+  const [value, setValue] = useState3("");
+  const [interim, setInterim] = useState3("");
+  const speech = useSpeechRecognition({
+    lang: speechLang,
+    onFinalTranscript: /* @__PURE__ */ __name((text) => {
+      const trimmed = text.trim();
+      if (!trimmed) return;
+      setValue((prev) => prev.length === 0 ? trimmed : `${prev.trimEnd()} ${trimmed}`);
+      setInterim("");
+    }, "onFinalTranscript"),
+    onInterimTranscript: /* @__PURE__ */ __name((text) => setInterim(text), "onInterimTranscript")
+  });
+  useEffect2(() => {
+    if (!speech.isListening) setInterim("");
+  }, [
+    speech.isListening
+  ]);
+  function submit() {
+    const trimmed = value.trim();
+    if (!trimmed) return;
+    onSubmit(trimmed);
+    setValue("");
+    setInterim("");
+  }
+  __name(submit, "submit");
+  function handleKeyDown(event) {
+    if (event.key === "Enter" && !event.shiftKey) {
+      event.preventDefault();
+      submit();
+    }
+  }
+  __name(handleKeyDown, "handleKeyDown");
+  function toggleMic() {
+    if (speech.isListening) speech.stop();
+    else speech.start();
+  }
+  __name(toggleMic, "toggleMic");
+  const displayValue = speech.isListening && interim ? `${value}${value && !value.endsWith(" ") ? " " : ""}${interim}` : value;
+  const showMic = enableSpeech && speech.isSupported;
+  return /* @__PURE__ */ React.createElement("div", {
+    className
+  }, /* @__PURE__ */ React.createElement("textarea", {
+    className: textareaClassName,
+    rows,
+    value: displayValue,
+    disabled,
+    onChange: /* @__PURE__ */ __name((event) => {
+      if (speech.isListening && interim) return;
+      setValue(event.target.value);
+    }, "onChange"),
+    onKeyDown: handleKeyDown,
+    placeholder: placeholder ?? "Ask something (Enter to send, Shift+Enter for newline)"
+  }), /* @__PURE__ */ React.createElement("button", {
+    type: "button",
+    className: sendButtonClassName,
+    onClick: submit,
+    disabled: disabled || !value.trim()
+  }, sendLabel), showMic ? /* @__PURE__ */ React.createElement("button", {
+    type: "button",
+    className: micButtonClassName,
+    onClick: toggleMic,
+    disabled,
+    "aria-label": speech.isListening ? "Stop dictating" : "Start dictating"
+  }, renderMic ? renderMic({
+    isListening: speech.isListening
+  }) : speech.isListening ? "Stop" : "Speak") : null);
+}
+__name(ChatInput, "ChatInput");
+
+// src/components/message-item.tsx
+import { isTextUIPart, isToolUIPart } from "ai";
+import React2, { useEffect as useEffect3, useRef as useRef3, useState as useState4 } from "react";
+function MessageItem({ message, renderToolPart, renderToolGroup, renderText, classNames, isStreaming = false, editable, onEditSubmit, regeneratable, onRegenerate, onFork, usage, createdAt }) {
+  const isUser = message.role === "user";
+  const parts = message.parts ?? [];
+  const copyableText = extractText2(parts);
+  const actionRow = /* @__PURE__ */ React2.createElement("div", {
+    className: classNames?.actions,
+    "data-actions-for": message.role
+  }, copyableText ? /* @__PURE__ */ React2.createElement(CopyButton, {
+    text: copyableText,
+    className: classNames?.actionButton
+  }) : null, onFork ? /* @__PURE__ */ React2.createElement("button", {
+    type: "button",
+    onClick: /* @__PURE__ */ __name(() => void onFork(message.id), "onClick"),
+    className: classNames?.actionButton,
+    title: "Fork thread from this message"
+  }, "Fork") : null, !isUser && regeneratable && onRegenerate ? /* @__PURE__ */ React2.createElement("button", {
+    type: "button",
+    onClick: /* @__PURE__ */ __name(() => void onRegenerate(), "onClick"),
+    className: classNames?.actionButton,
+    title: "Regenerate response"
+  }, "Regenerate") : null, !isUser && usage ? /* @__PURE__ */ React2.createElement(UsageInline, {
+    usage,
+    className: classNames?.usage
+  }) : null, createdAt ? /* @__PURE__ */ React2.createElement(TimestampInline, {
+    createdAt,
+    className: classNames?.timestamp
+  }) : null);
+  if (isUser && editable && onEditSubmit) {
+    return /* @__PURE__ */ React2.createElement(EditableUserBubble, {
+      message,
+      onSubmit: onEditSubmit,
+      renderText,
+      classNames,
+      actions: actionRow
+    });
+  }
+  const className = [
+    classNames?.root,
+    classNames?.byRole?.[message.role]
+  ].filter((entry) => entry).join(" ");
+  return /* @__PURE__ */ React2.createElement("div", {
+    className: className === "" ? void 0 : className,
+    "data-role": message.role,
+    "data-streaming": isStreaming ? "true" : void 0
+  }, /* @__PURE__ */ React2.createElement("div", null, renderParts(message, parts, {
+    renderText,
+    renderToolPart,
+    renderToolGroup,
+    classNames,
+    isStreaming
+  })), actionRow);
+}
+__name(MessageItem, "MessageItem");
+function renderParts(message, parts, ctx) {
+  const blocks = [];
+  let toolBuffer = [];
+  let toolGroupCounter = 0;
+  let textCounter = 0;
+  function flushTools() {
+    if (toolBuffer.length === 0) {
+      return;
+    }
+    const key = `${message.id}-tools-${toolGroupCounter++}`;
+    if (ctx.renderToolGroup) {
+      blocks.push(/* @__PURE__ */ React2.createElement(React2.Fragment, {
+        key
+      }, ctx.renderToolGroup(toolBuffer, key)));
+    } else if (ctx.renderToolPart) {
+      for (const part of toolBuffer) {
+        const partKey = `${message.id}-${part.toolCallId}`;
+        blocks.push(/* @__PURE__ */ React2.createElement(React2.Fragment, {
+          key: partKey
+        }, ctx.renderToolPart(part, partKey)));
+      }
+    }
+    toolBuffer = [];
+  }
+  __name(flushTools, "flushTools");
+  for (const part of parts) {
+    if (isToolUIPart(part)) {
+      toolBuffer.push(part);
+      continue;
+    }
+    flushTools();
+    if (isTextUIPart(part)) {
+      const key = `${message.id}-text-${textCounter++}`;
+      blocks.push(/* @__PURE__ */ React2.createElement("div", {
+        key,
+        className: ctx.classNames?.text
+      }, ctx.renderText ? ctx.renderText(part.text, {
+        isStreaming: ctx.isStreaming
+      }) : part.text));
+    }
+  }
+  flushTools();
+  return blocks;
+}
+__name(renderParts, "renderParts");
+function EditableUserBubble({ message, onSubmit, renderText, classNames, actions }) {
+  const initialText = extractText2(message.parts ?? []);
+  const [isEditing, setIsEditing] = useState4(false);
+  const [draft, setDraft] = useState4(initialText);
+  const textareaRef = useRef3(null);
+  useEffect3(() => {
+    if (isEditing && textareaRef.current) {
+      const el = textareaRef.current;
+      el.focus();
+      el.setSelectionRange(el.value.length, el.value.length);
+    }
+  }, [
+    isEditing
+  ]);
+  async function handleSave() {
+    const next = draft.trim();
+    if (!next) {
+      return;
+    }
+    setIsEditing(false);
+    await onSubmit(next);
+  }
+  __name(handleSave, "handleSave");
+  if (!isEditing) {
+    const rootClass = [
+      classNames?.root,
+      classNames?.byRole?.user
+    ].filter((entry) => entry).join(" ");
+    return /* @__PURE__ */ React2.createElement("div", {
+      className: rootClass === "" ? void 0 : rootClass,
+      "data-role": "user"
+    }, /* @__PURE__ */ React2.createElement("div", {
+      className: classNames?.text
+    }, renderText ? renderText(initialText, {
+      isStreaming: false
+    }) : initialText), /* @__PURE__ */ React2.createElement("button", {
+      type: "button",
+      onClick: /* @__PURE__ */ __name(() => {
+        setDraft(initialText);
+        setIsEditing(true);
+      }, "onClick"),
+      className: classNames?.actionButton,
+      title: "Edit & resubmit"
+    }, "Edit"), actions);
+  }
+  return /* @__PURE__ */ React2.createElement("div", {
+    "data-editing": "true"
+  }, /* @__PURE__ */ React2.createElement("textarea", {
+    ref: textareaRef,
+    value: draft,
+    onChange: /* @__PURE__ */ __name((event) => setDraft(event.target.value), "onChange"),
+    onKeyDown: /* @__PURE__ */ __name((event) => {
+      if (event.key === "Enter" && !event.shiftKey) {
+        event.preventDefault();
+        void handleSave();
+      }
+      if (event.key === "Escape") {
+        event.preventDefault();
+        setIsEditing(false);
+      }
+    }, "onKeyDown"),
+    rows: Math.min(8, draft.split("\n").length + 1),
+    className: classNames?.editTextarea
+  }), /* @__PURE__ */ React2.createElement("div", {
+    className: classNames?.editActions
+  }, /* @__PURE__ */ React2.createElement("button", {
+    type: "button",
+    onClick: /* @__PURE__ */ __name(() => setIsEditing(false), "onClick")
+  }, "Cancel"), /* @__PURE__ */ React2.createElement("button", {
+    type: "button",
+    onClick: /* @__PURE__ */ __name(() => void handleSave(), "onClick"),
+    disabled: !draft.trim()
+  }, "Resend")));
+}
+__name(EditableUserBubble, "EditableUserBubble");
+function CopyButton({ text, className }) {
+  const [copied, setCopied] = useState4(false);
+  async function handleCopy() {
+    try {
+      await navigator.clipboard.writeText(text);
+      setCopied(true);
+      setTimeout(() => setCopied(false), 1500);
+    } catch {
+    }
+  }
+  __name(handleCopy, "handleCopy");
+  return /* @__PURE__ */ React2.createElement("button", {
+    type: "button",
+    onClick: /* @__PURE__ */ __name(() => void handleCopy(), "onClick"),
+    className,
+    title: copied ? "Copied!" : "Copy message text"
+  }, copied ? "Copied" : "Copy");
+}
+__name(CopyButton, "CopyButton");
+function UsageInline({ usage, className }) {
+  const total = usage.inputTokens + usage.outputTokens;
+  return /* @__PURE__ */ React2.createElement("span", {
+    className,
+    title: `Input ${usage.inputTokens.toLocaleString()} \xB7 Output ${usage.outputTokens.toLocaleString()} tokens`
+  }, formatCostUsd(usage.costUsd), " \xB7 ", formatTokensShort(total));
+}
+__name(UsageInline, "UsageInline");
+function TimestampInline({ createdAt, className }) {
+  const parsed = new Date(createdAt);
+  if (Number.isNaN(parsed.getTime())) {
+    return null;
+  }
+  const absolute = parsed.toLocaleString(void 0, {
+    dateStyle: "medium",
+    timeStyle: "short"
+  });
+  return /* @__PURE__ */ React2.createElement("span", {
+    className,
+    title: absolute
+  }, formatRelativeTime(parsed));
+}
+__name(TimestampInline, "TimestampInline");
+var RELATIVE_TIME = new Intl.RelativeTimeFormat(void 0, {
+  numeric: "auto",
+  style: "narrow"
+});
+var ONE_WEEK_MS = 7 * 24 * 60 * 60 * 1e3;
+function formatRelativeTime(date) {
+  const diffMs = Date.now() - date.getTime();
+  if (Math.abs(diffMs) < 1e4) {
+    return "just now";
+  }
+  if (diffMs > ONE_WEEK_MS) {
+    return date.toLocaleDateString(void 0, {
+      month: "short",
+      day: "numeric"
+    });
+  }
+  const minutes = Math.round(-diffMs / 6e4);
+  if (Math.abs(minutes) < 60) {
+    return RELATIVE_TIME.format(minutes, "minute");
+  }
+  const hours = Math.round(-diffMs / 36e5);
+  if (Math.abs(hours) < 24) {
+    return RELATIVE_TIME.format(hours, "hour");
+  }
+  return RELATIVE_TIME.format(Math.round(-diffMs / 864e5), "day");
+}
+__name(formatRelativeTime, "formatRelativeTime");
+function formatTokensShort(n) {
+  if (n < 1e3) {
+    return `${n} tokens`;
+  }
+  if (n < 1e4) {
+    return `${(n / 1e3).toFixed(1)}k tokens`;
+  }
+  return `${Math.round(n / 1e3)}k tokens`;
+}
+__name(formatTokensShort, "formatTokensShort");
+function formatCostUsd(cost) {
+  if (cost === 0) {
+    return "$0";
+  }
+  if (cost < 0.01) {
+    return `$${cost.toFixed(4)}`;
+  }
+  if (cost < 1) {
+    return `$${cost.toFixed(3)}`;
+  }
+  return `$${cost.toFixed(2)}`;
+}
+__name(formatCostUsd, "formatCostUsd");
+function extractText2(parts) {
+  const out = [];
+  for (const part of parts) {
+    if (isTextUIPart(part)) {
+      out.push(part.text);
+    }
+  }
+  return out.join("\n\n").trim();
+}
+__name(extractText2, "extractText");
+
+// src/components/message-list.tsx
+import React3, { useState as useState5 } from "react";
+var DEFAULT_VISIBLE_COUNT = 50;
+var LOAD_EARLIER_STEP = 50;
+function MessageList({ messages, status, renderToolPart, renderToolGroup, renderText, onFork, editable, onEditSubmit, regeneratable, onRegenerate, getUsage, getCreatedAt, emptyState, typingIndicator, followUps, onFollowUpClick, error, onRetry, classNames }) {
+  const [visibleCount, setVisibleCount] = useState5(DEFAULT_VISIBLE_COUNT);
+  if (messages.length === 0 && status === "ready") {
+    return /* @__PURE__ */ React3.createElement("div", {
+      className: classNames?.empty
+    }, emptyState);
+  }
+  const lastMessage = messages.at(-1);
+  const showTypingBubble = (status === "submitted" || status === "streaming") && lastMessage?.role !== "assistant";
+  const showFollowUps = status === "ready" && !showTypingBubble && lastMessage?.role === "assistant" && onFollowUpClick !== void 0 && !!followUps && followUps.length > 0;
+  const visibleStart = Math.max(0, messages.length - visibleCount);
+  const visibleMessages = messages.slice(visibleStart);
+  const hiddenCount = visibleStart;
+  let lastAssistantIndex = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i]?.role === "assistant") {
+      lastAssistantIndex = i;
+      break;
+    }
+  }
+  return /* @__PURE__ */ React3.createElement("div", {
+    className: classNames?.root
+  }, hiddenCount > 0 ? /* @__PURE__ */ React3.createElement("button", {
+    type: "button",
+    className: classNames?.loadEarlier,
+    onClick: /* @__PURE__ */ __name(() => setVisibleCount((count) => count + LOAD_EARLIER_STEP), "onClick")
+  }, "Load earlier (", hiddenCount, " more)") : null, visibleMessages.map((message, index) => {
+    const absoluteIndex = visibleStart + index;
+    const isLastAssistant = absoluteIndex === lastAssistantIndex;
+    const usage = getUsage?.(message) ?? null;
+    const createdAt = getCreatedAt?.(message) ?? null;
+    return /* @__PURE__ */ React3.createElement(MessageItem, {
+      key: message.id,
+      message,
+      ...renderToolPart ? {
+        renderToolPart
+      } : {},
+      ...renderToolGroup ? {
+        renderToolGroup
+      } : {},
+      ...renderText ? {
+        renderText
+      } : {},
+      ...classNames?.message ? {
+        classNames: classNames.message
+      } : {},
+      ...onFork ? {
+        onFork
+      } : {},
+      ...editable ? {
+        editable
+      } : {},
+      ...onEditSubmit ? {
+        onEditSubmit: /* @__PURE__ */ __name((text) => onEditSubmit(message.id, text), "onEditSubmit")
+      } : {},
+      ...regeneratable && isLastAssistant ? {
+        regeneratable
+      } : {},
+      ...onRegenerate ? {
+        onRegenerate: /* @__PURE__ */ __name(() => onRegenerate(message.id), "onRegenerate")
+      } : {},
+      ...usage !== null ? {
+        usage
+      } : {},
+      ...createdAt !== null ? {
+        createdAt
+      } : {},
+      isStreaming: status === "streaming" && isLastAssistant
+    });
+  }), showTypingBubble ? /* @__PURE__ */ React3.createElement("div", {
+    className: classNames?.typing
+  }, typingIndicator ?? "Thinking\u2026") : null, error && onRetry ? /* @__PURE__ */ React3.createElement("div", {
+    className: classNames?.error
+  }, /* @__PURE__ */ React3.createElement("span", null, error.message || "The assistant didn't respond."), /* @__PURE__ */ React3.createElement("button", {
+    type: "button",
+    className: classNames?.errorRetry,
+    onClick: /* @__PURE__ */ __name(() => void onRetry(), "onClick")
+  }, "Retry")) : null, showFollowUps ? /* @__PURE__ */ React3.createElement("div", {
+    className: classNames?.followUps
+  }, followUps.map((text) => /* @__PURE__ */ React3.createElement("button", {
+    key: text,
+    type: "button",
+    className: classNames?.followUpChip,
+    onClick: /* @__PURE__ */ __name(() => onFollowUpClick(text), "onClick")
+  }, text))) : null);
+}
+__name(MessageList, "MessageList");
+
+// src/components/speech-languages.ts
+var DEFAULT_SPEECH_LANG = "en-US";
+var SPEECH_LANGUAGES = [
+  {
+    tag: "en-US",
+    label: "English (US)"
+  },
+  {
+    tag: "en-GB",
+    label: "English (UK)"
+  },
+  {
+    tag: "pt-BR",
+    label: "Portuguese (Brazil)"
+  },
+  {
+    tag: "es-ES",
+    label: "Spanish (Spain)"
+  }
+];
+var STORAGE_KEY = "nestjs-agent-chat-speech-lang";
+function loadStoredSpeechLang() {
+  if (typeof window === "undefined") return DEFAULT_SPEECH_LANG;
+  try {
+    const raw = window.localStorage.getItem(STORAGE_KEY);
+    if (raw && SPEECH_LANGUAGES.some((language) => language.tag === raw)) {
+      return raw;
+    }
+  } catch {
+  }
+  return DEFAULT_SPEECH_LANG;
+}
+__name(loadStoredSpeechLang, "loadStoredSpeechLang");
+function persistSpeechLang(tag) {
+  if (typeof window === "undefined") return;
+  try {
+    window.localStorage.setItem(STORAGE_KEY, tag);
+  } catch {
+  }
+}
+__name(persistSpeechLang, "persistSpeechLang");
+export {
+  AgentChatTransport,
+  AgentClient,
+  AgentHttpError,
+  ChatInput,
+  DEFAULT_SPEECH_LANG,
+  MessageItem,
+  MessageList,
+  SPEECH_LANGUAGES,
+  formatRelativeTime,
+  loadStoredSpeechLang,
+  persistSpeechLang,
+  useAgentChat,
+  useSpeechRecognition
+};
+//# sourceMappingURL=index.js.map