@cubos/agent-sdk-react-dom 0.0.1136563

package/dist/index.js

@@ -0,0 +1,678 @@
+// src/agent-markdown.tsx
+import { memo, useMemo } from "react";
+import Markdown from "react-markdown";
+import rehypeHighlight from "rehype-highlight";
+import rehypeKatex from "rehype-katex";
+import remarkGfm from "remark-gfm";
+import remarkMath from "remark-math";
+
+// src/colors.ts
+function colorStyle(colors) {
+  if (!colors)
+    return;
+  const style = {};
+  for (const [token, value] of Object.entries(colors)) {
+    if (value)
+      style[`--cubos-agent-sdk-react-dom-${token}`] = value;
+  }
+  return style;
+}
+
+// src/currency.ts
+var CURRENCY_PREFIX = /(?:R|US|CA|AU|NZ|HK|NT|SG|Cz|C|A|S|B|J|Z|Mex|Arg|CLP|COP)$/;
+var AMOUNT_AFTER = /^[   ]{0,1}\d/;
+function escapeCurrency(markdown) {
+  let out = "";
+  let i = 0;
+  while (i < markdown.length) {
+    const char = markdown[i];
+    if (char === "`" && markdown.startsWith("```", i)) {
+      const end = markdown.indexOf("```", i + 3);
+      const stop = end === -1 ? markdown.length : end + 3;
+      out += markdown.slice(i, stop);
+      i = stop;
+      continue;
+    }
+    if (char === "`") {
+      let ticks = 0;
+      while (markdown[i + ticks] === "`")
+        ticks += 1;
+      const fence = "`".repeat(ticks);
+      const end = markdown.indexOf(fence, i + ticks);
+      const stop = end === -1 ? markdown.length : end + ticks;
+      out += markdown.slice(i, stop);
+      i = stop;
+      continue;
+    }
+    if (char === "\\" && i + 1 < markdown.length) {
+      out += markdown.slice(i, i + 2);
+      i += 2;
+      continue;
+    }
+    if (char === "$") {
+      if (markdown.startsWith("$$", i)) {
+        const end = markdown.indexOf("$$", i + 2);
+        const stop = end === -1 ? markdown.length : end + 2;
+        out += markdown.slice(i, stop);
+        i = stop;
+        continue;
+      }
+      if (isCurrency(markdown, i, out)) {
+        out += "\\$";
+        i += 1;
+        continue;
+      }
+    }
+    out += char;
+    i += 1;
+  }
+  return out;
+}
+function isCurrency(text, index, emitted) {
+  if (CURRENCY_PREFIX.test(emitted))
+    return true;
+  return AMOUNT_AFTER.test(text.slice(index + 1, index + 3));
+}
+
+// src/agent-markdown.tsx
+import"./styles.css";
+import { jsx } from "react/jsx-runtime";
+var ROOT_CLASS = "cubos-agent-sdk-react-dom cubos-agent-sdk-react-dom--markdown";
+var DEFAULT_COMPONENTS = {
+  a: ({ node: _node, ...props }) => /* @__PURE__ */ jsx("a", {
+    ...props,
+    target: "_blank",
+    rel: "noopener noreferrer"
+  }),
+  table: ({ node: _node, ...props }) => /* @__PURE__ */ jsx("div", {
+    className: "cubos-agent-sdk-react-dom__table",
+    children: /* @__PURE__ */ jsx("table", {
+      ...props
+    })
+  })
+};
+var AgentMarkdown = memo(function AgentMarkdown2({
+  children,
+  gfm = true,
+  math = true,
+  highlight = true,
+  components,
+  colors,
+  className
+}) {
+  const remarkPlugins = useMemo(() => [...gfm ? [remarkGfm] : [], ...math ? [remarkMath] : []], [gfm, math]);
+  const rehypePlugins = useMemo(() => [
+    ...math ? [rehypeKatex] : [],
+    ...highlight ? [[rehypeHighlight, { detect: true, ignoreMissing: true }]] : []
+  ], [math, highlight]);
+  const merged = useMemo(() => ({ ...DEFAULT_COMPONENTS, ...components }), [components]);
+  const source = useMemo(() => math ? escapeCurrency(children) : children, [children, math]);
+  return /* @__PURE__ */ jsx("div", {
+    className: ROOT_CLASS + (className ? ` ${className}` : ""),
+    style: colorStyle(colors),
+    children: /* @__PURE__ */ jsx(Markdown, {
+      remarkPlugins,
+      rehypePlugins,
+      components: merged,
+      children: source
+    })
+  });
+});
+// src/recording-wave.tsx
+import"./styles.css";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function RecordingWave({ levels, silent = false, colors, className }) {
+  return /* @__PURE__ */ jsx2("div", {
+    className: `cubos-agent-sdk-react-dom cubos-agent-sdk-react-dom__meter${silent ? " cubos-agent-sdk-react-dom__meter--silent" : ""}${className ? ` ${className}` : ""}`,
+    style: colorStyle(colors),
+    "data-silent": silent ? "true" : undefined,
+    "aria-hidden": "true",
+    children: levels.map((level, index) => /* @__PURE__ */ jsx2("span", {
+      className: "cubos-agent-sdk-react-dom__meter-bar",
+      style: { height: `${Math.max(6, Math.round(level * 100))}%` }
+    }, index))
+  });
+}
+// src/use-recorder.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+var CANDIDATE_TYPES = [
+  "audio/webm;codecs=opus",
+  "audio/webm",
+  "audio/mp4",
+  "audio/ogg;codecs=opus"
+];
+function pickMimeType() {
+  if (typeof MediaRecorder === "undefined")
+    return;
+  return CANDIDATE_TYPES.find((type) => MediaRecorder.isTypeSupported(type));
+}
+var LEVEL_BARS = 40;
+var LEVEL_INTERVAL_MS = 50;
+var LEVEL_GAIN = 5;
+var SILENCE_FLOOR = 0.012;
+var SILENCE_AFTER_MS = 1500;
+function levelOf(samples) {
+  if (samples.length === 0)
+    return 0;
+  let sum = 0;
+  for (const sample of samples) {
+    const centred = (sample - 128) / 128;
+    sum += centred * centred;
+  }
+  return Math.sqrt(sum / samples.length);
+}
+var NO_LEVELS = Array.from({ length: LEVEL_BARS }, () => 0);
+function isSupported() {
+  return typeof MediaRecorder !== "undefined" && typeof navigator !== "undefined" && navigator.mediaDevices?.getUserMedia !== undefined;
+}
+function useRecorder() {
+  const [state, setState] = useState("idle");
+  const [seconds, setSeconds] = useState(0);
+  const [error, setError] = useState(null);
+  const [levels, setLevels] = useState(NO_LEVELS);
+  const [silent, setSilent] = useState(false);
+  const recorderRef = useRef(null);
+  const chunksRef = useRef([]);
+  const streamRef = useRef(null);
+  const analyserRef = useRef(null);
+  const audioRef = useRef(null);
+  useEffect(() => {
+    setState(isSupported() ? "idle" : "unsupported");
+  }, []);
+  const release = useCallback(() => {
+    for (const track of streamRef.current?.getTracks() ?? [])
+      track.stop();
+    audioRef.current?.close().catch(() => {});
+    audioRef.current = null;
+    analyserRef.current = null;
+    streamRef.current = null;
+    recorderRef.current = null;
+    chunksRef.current = [];
+    setLevels(NO_LEVELS);
+    setSilent(false);
+  }, []);
+  useEffect(() => release, [release]);
+  useEffect(() => {
+    if (state !== "recording")
+      return;
+    const started = Date.now();
+    setSeconds(0);
+    const timer = setInterval(() => setSeconds(Math.floor((Date.now() - started) / 1000)), 500);
+    return () => clearInterval(timer);
+  }, [state]);
+  useEffect(() => {
+    const analyser = analyserRef.current;
+    if (state !== "recording" || analyser === null)
+      return;
+    const samples = new Uint8Array(analyser.fftSize);
+    let lastSound = Date.now();
+    const timer = setInterval(() => {
+      analyser.getByteTimeDomainData(samples);
+      const level = levelOf(samples);
+      if (level > SILENCE_FLOOR)
+        lastSound = Date.now();
+      setLevels((held) => [...held.slice(1), Math.min(1, level * LEVEL_GAIN)]);
+      setSilent(Date.now() - lastSound > SILENCE_AFTER_MS);
+    }, LEVEL_INTERVAL_MS);
+    return () => clearInterval(timer);
+  }, [state]);
+  const start = useCallback(async () => {
+    if (!isSupported()) {
+      setState("unsupported");
+      return;
+    }
+    setError(null);
+    setState("requesting");
+    try {
+      const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+      streamRef.current = stream;
+      const mimeType = pickMimeType();
+      const recorder = new MediaRecorder(stream, mimeType ? { mimeType } : undefined);
+      chunksRef.current = [];
+      recorder.ondataavailable = (event) => {
+        if (event.data.size > 0)
+          chunksRef.current.push(event.data);
+      };
+      recorderRef.current = recorder;
+      try {
+        const Ctx = window.AudioContext ?? window.webkitAudioContext;
+        if (Ctx) {
+          const audio = new Ctx;
+          const analyser = audio.createAnalyser();
+          analyser.fftSize = 1024;
+          analyser.smoothingTimeConstant = 0;
+          audio.createMediaStreamSource(stream).connect(analyser);
+          audioRef.current = audio;
+          analyserRef.current = analyser;
+        }
+      } catch {
+        analyserRef.current = null;
+      }
+      setLevels(NO_LEVELS);
+      setSilent(false);
+      recorder.start();
+      setState("recording");
+    } catch (err) {
+      release();
+      setState("idle");
+      setError(err instanceof Error ? err : new Error(String(err)));
+    }
+  }, [release]);
+  const stop = useCallback(async () => {
+    const recorder = recorderRef.current;
+    if (!recorder || recorder.state === "inactive") {
+      release();
+      setState("idle");
+      return null;
+    }
+    const clip = await new Promise((resolve) => {
+      recorder.onstop = () => {
+        const chunks = chunksRef.current;
+        resolve(chunks.length ? new Blob(chunks, { type: recorder.mimeType }) : null);
+      };
+      recorder.stop();
+    });
+    release();
+    setState("idle");
+    setSeconds(0);
+    return clip;
+  }, [release]);
+  const cancel = useCallback(() => {
+    const recorder = recorderRef.current;
+    if (recorder && recorder.state !== "inactive") {
+      recorder.onstop = null;
+      recorder.stop();
+    }
+    release();
+    setState("idle");
+    setSeconds(0);
+  }, [release]);
+  return { state, seconds, levels, silent, error, start, stop, cancel };
+}
+// src/use-transcript-anchor.ts
+import { useCallback as useCallback2, useEffect as useEffect2, useLayoutEffect, useRef as useRef2, useState as useState2 } from "react";
+function useTranscriptAnchor(options) {
+  const { tailKey, hasOlder = false, loadOlder, atBottomPx = 24, loadOlderPx = 200 } = options;
+  const scrollRef = useRef2(null);
+  const following = useRef2(true);
+  const [isAtBottom, setIsAtBottom] = useState2(true);
+  const heightBeforePrepend = useRef2(null);
+  const loadingOlder = useRef2(false);
+  const toEnd = useCallback2(() => {
+    const box = scrollRef.current;
+    if (box)
+      box.scrollTop = box.scrollHeight;
+  }, []);
+  const scrollToEnd = useCallback2(() => {
+    following.current = true;
+    setIsAtBottom(true);
+    toEnd();
+  }, [toEnd]);
+  const paging = useRef2({ hasOlder, loadOlder });
+  paging.current = { hasOlder, loadOlder };
+  const requestOlder = useCallback2(() => {
+    const box = scrollRef.current;
+    const { hasOlder: more, loadOlder: fetchOlder } = paging.current;
+    if (!box || !more || !fetchOlder || loadingOlder.current)
+      return;
+    loadingOlder.current = true;
+    heightBeforePrepend.current = box.scrollHeight;
+    fetchOlder().then((added) => {
+      if (added === 0)
+        heightBeforePrepend.current = null;
+    }).catch(() => {
+      heightBeforePrepend.current = null;
+    }).finally(() => {
+      loadingOlder.current = false;
+    });
+  }, []);
+  const onScroll = useCallback2(() => {
+    const box = scrollRef.current;
+    if (!box)
+      return;
+    const atBottom = box.scrollHeight - box.scrollTop - box.clientHeight < atBottomPx;
+    following.current = atBottom;
+    setIsAtBottom((held) => held === atBottom ? held : atBottom);
+    if (box.scrollTop < loadOlderPx)
+      requestOlder();
+  }, [atBottomPx, loadOlderPx, requestOlder]);
+  useLayoutEffect(() => {
+    const box = scrollRef.current;
+    const before = heightBeforePrepend.current;
+    if (!box || before === null)
+      return;
+    const added = box.scrollHeight - before;
+    if (added <= 0)
+      return;
+    heightBeforePrepend.current = null;
+    box.scrollTop += added;
+  });
+  useLayoutEffect(() => {
+    if (heightBeforePrepend.current !== null)
+      return;
+    if (following.current)
+      toEnd();
+  }, [tailKey, toEnd]);
+  const pullWhileShort = useCallback2(() => {
+    const box = scrollRef.current;
+    if (!box || !paging.current.hasOlder)
+      return;
+    if (box.scrollHeight <= box.clientHeight)
+      requestOlder();
+  }, [requestOlder]);
+  const observer = useRef2(null);
+  const contentRef = useCallback2((node) => {
+    observer.current?.disconnect();
+    observer.current = null;
+    if (node === null)
+      return;
+    let previous = node.scrollHeight;
+    const watch = new ResizeObserver(() => {
+      const height = node.scrollHeight;
+      if (height === previous)
+        return;
+      previous = height;
+      if (heightBeforePrepend.current !== null)
+        return;
+      if (following.current)
+        toEnd();
+      pullWhileShort();
+    });
+    watch.observe(node);
+    observer.current = watch;
+  }, [toEnd, pullWhileShort]);
+  useEffect2(() => {
+    pullWhileShort();
+  }, [pullWhileShort, hasOlder]);
+  useEffect2(() => () => observer.current?.disconnect(), []);
+  return { scrollRef, contentRef, onScroll, isAtBottom, scrollToEnd };
+}
+// src/voice-message.tsx
+import { ChevronDown, ChevronRight, Pause, Play } from "lucide-react";
+import { useEffect as useEffect3, useRef as useRef3, useState as useState3 } from "react";
+import"./styles.css";
+import { jsx as jsx3, jsxs, Fragment } from "react/jsx-runtime";
+var DEFAULT_LABELS = {
+  play: "Play voice message",
+  pause: "Pause voice message",
+  transcript: "Transcript",
+  transcribing: "Transcribing…",
+  noSpeech: "No speech in this recording.",
+  loadFailed: "Could not load the recording."
+};
+var ROOT_CLASS2 = "cubos-agent-sdk-react-dom cubos-agent-sdk-react-dom--voice";
+var PEAK_COUNT = 40;
+var MAX_DECODE_BYTES = 8 * 1024 * 1024;
+async function extractPeaks(blob) {
+  if (blob.size > MAX_DECODE_BYTES)
+    return null;
+  const Ctx = window.OfflineAudioContext ?? window.webkitOfflineAudioContext;
+  if (!Ctx)
+    return null;
+  try {
+    const bytes = await blob.arrayBuffer();
+    const decoded = await new Ctx(1, 1, 8000).decodeAudioData(bytes);
+    const samples = decoded.getChannelData(0);
+    const bucket = Math.floor(samples.length / PEAK_COUNT) || 1;
+    const peaks = [];
+    let loudest = 0;
+    for (let i = 0;i < PEAK_COUNT; i++) {
+      let peak = 0;
+      for (let j = i * bucket;j < (i + 1) * bucket && j < samples.length; j++) {
+        const value = Math.abs(samples[j]);
+        if (value > peak)
+          peak = value;
+      }
+      peaks.push(peak);
+      if (peak > loudest)
+        loudest = peak;
+    }
+    if (loudest === 0)
+      return null;
+    return peaks.map((peak) => Math.max(0.12, peak / loudest));
+  } catch {
+    return null;
+  }
+}
+function VoiceMessage({
+  loadBytes,
+  transcript,
+  bytes,
+  defaultTranscriptOpen = false,
+  labels,
+  colors,
+  className
+}) {
+  const text = { ...DEFAULT_LABELS, ...labels };
+  const rootRef = useRef3(null);
+  const audioRef = useRef3(null);
+  const objectUrlRef = useRef3(null);
+  const abortRef = useRef3(null);
+  const inflightRef = useRef3(null);
+  const [isPlaying, setIsPlaying] = useState3(false);
+  const [isLoading, setIsLoading] = useState3(false);
+  const [failed, setFailed] = useState3(false);
+  const [position, setPosition] = useState3(0);
+  const [duration, setDuration] = useState3(0);
+  const [peaks, setPeaks] = useState3(null);
+  const [open, setOpen] = useState3(defaultTranscriptOpen);
+  useEffect3(() => () => {
+    abortRef.current?.abort();
+    audioRef.current?.pause();
+    if (objectUrlRef.current)
+      URL.revokeObjectURL(objectUrlRef.current);
+  }, []);
+  const ensureLoadedRef = useRef3(() => {});
+  ensureLoadedRef.current = () => void ensureLoaded();
+  useEffect3(() => {
+    const node = rootRef.current;
+    if (node === null || typeof IntersectionObserver === "undefined")
+      return;
+    const observer = new IntersectionObserver((entries) => {
+      if (!entries.some((entry) => entry.isIntersecting))
+        return;
+      observer.disconnect();
+      ensureLoadedRef.current();
+    }, { rootMargin: "600px" });
+    observer.observe(node);
+    return () => observer.disconnect();
+  }, []);
+  function ensureLoaded() {
+    if (audioRef.current)
+      return Promise.resolve(audioRef.current);
+    inflightRef.current ??= load();
+    return inflightRef.current;
+  }
+  async function load() {
+    const controller = new AbortController;
+    abortRef.current = controller;
+    setFailed(false);
+    try {
+      const blob = await loadBytes(controller.signal);
+      if (controller.signal.aborted)
+        return null;
+      const url = URL.createObjectURL(blob);
+      objectUrlRef.current = url;
+      const element = new Audio(url);
+      element.preload = "metadata";
+      element.onended = () => {
+        setIsPlaying(false);
+        setPosition(0);
+      };
+      element.ontimeupdate = () => setPosition(element.currentTime);
+      element.ondurationchange = () => {
+        if (Number.isFinite(element.duration))
+          setDuration(element.duration);
+      };
+      element.onloadedmetadata = () => {
+        if (Number.isFinite(element.duration)) {
+          setDuration(element.duration);
+          return;
+        }
+        element.currentTime = 100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000;
+        element.addEventListener("durationchange", () => {
+          element.currentTime = 0;
+          setPosition(0);
+        }, { once: true });
+      };
+      audioRef.current = element;
+      extractPeaks(blob).then((found) => {
+        if (!controller.signal.aborted && found)
+          setPeaks(found);
+      });
+      return element;
+    } catch {
+      if (!controller.signal.aborted)
+        setFailed(true);
+      return null;
+    }
+  }
+  async function toggle() {
+    setIsLoading(audioRef.current === null);
+    const element = await ensureLoaded().finally(() => setIsLoading(false));
+    if (!element)
+      return;
+    if (element.paused) {
+      try {
+        await element.play();
+        setIsPlaying(true);
+      } catch {
+        setFailed(true);
+        setIsPlaying(false);
+      }
+    } else {
+      element.pause();
+      setIsPlaying(false);
+    }
+  }
+  function seek(to) {
+    setPosition(to);
+    if (audioRef.current)
+      audioRef.current.currentTime = to;
+  }
+  const progress = duration > 0 ? Math.min(1, position / duration) : 0;
+  const clock = duration > 0 ? formatClock(position > 0 ? position : duration) : formatSize(bytes);
+  return /* @__PURE__ */ jsxs("div", {
+    ref: rootRef,
+    className: className ? `${ROOT_CLASS2} ${className}` : ROOT_CLASS2,
+    style: colorStyle(colors),
+    children: [
+      /* @__PURE__ */ jsxs("div", {
+        className: "cubos-agent-sdk-react-dom__voice-row",
+        children: [
+          /* @__PURE__ */ jsx3("button", {
+            type: "button",
+            className: "cubos-agent-sdk-react-dom__voice-play",
+            onClick: () => void toggle(),
+            disabled: isLoading,
+            "aria-label": isPlaying ? text.pause : text.play,
+            children: /* @__PURE__ */ jsx3("span", {
+              className: "cubos-agent-sdk-react-dom__voice-face",
+              children: isPlaying ? /* @__PURE__ */ jsx3(Pause, {
+                size: 13,
+                fill: "currentColor",
+                "aria-hidden": "true"
+              }) : /* @__PURE__ */ jsx3(Play, {
+                size: 13,
+                fill: "currentColor",
+                style: { marginLeft: 1 },
+                "aria-hidden": "true"
+              })
+            })
+          }),
+          /* @__PURE__ */ jsxs("div", {
+            className: "cubos-agent-sdk-react-dom__voice-track",
+            children: [
+              peaks ? /* @__PURE__ */ jsx3("div", {
+                className: "cubos-agent-sdk-react-dom__voice-wave",
+                "aria-hidden": "true",
+                children: peaks.map((height, index) => /* @__PURE__ */ jsx3("span", {
+                  className: index / peaks.length <= progress ? "cubos-agent-sdk-react-dom__voice-bar cubos-agent-sdk-react-dom__voice-bar--played" : "cubos-agent-sdk-react-dom__voice-bar",
+                  style: { height: `${Math.round(height * 100)}%` }
+                }, index))
+              }) : /* @__PURE__ */ jsx3("div", {
+                className: "cubos-agent-sdk-react-dom__voice-line",
+                "aria-hidden": "true",
+                children: /* @__PURE__ */ jsx3("span", {
+                  className: "cubos-agent-sdk-react-dom__voice-line-fill",
+                  style: { width: `${progress * 100}%` }
+                })
+              }),
+              duration > 0 && /* @__PURE__ */ jsx3("span", {
+                className: "cubos-agent-sdk-react-dom__voice-head",
+                style: { left: `${progress * 100}%` },
+                "aria-hidden": "true"
+              }),
+              /* @__PURE__ */ jsx3("input", {
+                type: "range",
+                className: "cubos-agent-sdk-react-dom__voice-seek",
+                min: 0,
+                max: duration || 0,
+                step: "any",
+                value: position,
+                disabled: duration === 0,
+                "aria-label": text.play,
+                "aria-valuetext": formatClock(position),
+                onChange: (event) => seek(Number(event.target.value))
+              })
+            ]
+          }),
+          /* @__PURE__ */ jsx3("span", {
+            className: "cubos-agent-sdk-react-dom__voice-time",
+            children: clock
+          })
+        ]
+      }),
+      failed && /* @__PURE__ */ jsx3("p", {
+        className: "cubos-agent-sdk-react-dom__voice-error",
+        children: text.loadFailed
+      }),
+      transcript !== undefined && transcript !== "" ? /* @__PURE__ */ jsxs(Fragment, {
+        children: [
+          /* @__PURE__ */ jsxs("button", {
+            type: "button",
+            className: "cubos-agent-sdk-react-dom__voice-disclosure",
+            onClick: () => setOpen((was) => !was),
+            "aria-expanded": open,
+            children: [
+              open ? /* @__PURE__ */ jsx3(ChevronDown, {
+                size: 12,
+                "aria-hidden": "true"
+              }) : /* @__PURE__ */ jsx3(ChevronRight, {
+                size: 12,
+                "aria-hidden": "true"
+              }),
+              text.transcript
+            ]
+          }),
+          open && /* @__PURE__ */ jsx3("p", {
+            className: "cubos-agent-sdk-react-dom__voice-transcript",
+            children: transcript
+          })
+        ]
+      }) : /* @__PURE__ */ jsx3("p", {
+        className: "cubos-agent-sdk-react-dom__voice-pending",
+        children: transcript === undefined ? text.transcribing : text.noSpeech
+      })
+    ]
+  });
+}
+function formatClock(seconds) {
+  const total = Math.max(0, Math.round(seconds));
+  return `${Math.floor(total / 60)}:${String(total % 60).padStart(2, "0")}`;
+}
+function formatSize(bytes) {
+  if (bytes === undefined)
+    return "--:--";
+  return bytes >= 1024 * 1024 ? `${(bytes / (1024 * 1024)).toFixed(1)} MB` : `${Math.max(1, Math.round(bytes / 1024))} KB`;
+}
+export {
+  useTranscriptAnchor,
+  useRecorder,
+  VoiceMessage,
+  RecordingWave,
+  AgentMarkdown
+};
+
+//# debugId=D616CDC56985922A64756E2164756E21
+//# sourceMappingURL=index.js.map