@heroui/agent 0.2.0-beta.1

package/dist/chunk-GDDNN2XY.js

@@ -0,0 +1,954 @@
+import {
+  ComposerControlTooltip,
+  PanelShell,
+  PoweredByHero,
+  clearAgentComposerDraftsForProject,
+  isHeroUIAgentAttachmentContentType,
+  readAgentShellHandoff,
+  readSidebarWidth,
+  resizeComposerTextarea,
+  resolveOptions,
+  scheduleIdleTask,
+  writeAgentShellHandoff
+} from "./chunk-RQCTC4JB.js";
+
+// src/embed/provider.tsx
+import {
+  useCallback,
+  useEffect as useEffect2,
+  useLayoutEffect,
+  useMemo,
+  useRef as useRef2,
+  useState as useState2,
+  useSyncExternalStore
+} from "react";
+import { createRoot } from "react-dom/client";
+
+// src/embed/launcher-spark-icon.tsx
+import { SparklesFill } from "@gravity-ui/icons";
+import { jsx } from "react/jsx-runtime";
+function LauncherSparkIcon(props) {
+  return /* @__PURE__ */ jsx(SparklesFill, { ...props });
+}
+
+// src/embed/launcher-icon.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function isSvgIcon(icon) {
+  return /\.svg(?:[?#]|$)/i.test(icon) || /^data:image\/svg\+xml[;,]/i.test(icon);
+}
+function cssUrl(value) {
+  return `url("${value.replace(/["\\\n\r]/g, encodeURIComponent)}")`;
+}
+function LauncherIcon({ icon }) {
+  if (!icon) return /* @__PURE__ */ jsx2(LauncherSparkIcon, {});
+  if (isSvgIcon(icon)) {
+    return /* @__PURE__ */ jsx2(
+      "span",
+      {
+        "aria-hidden": "true",
+        className: "ha-launcher__icon ha-launcher__icon--tinted",
+        style: { WebkitMaskImage: cssUrl(icon), maskImage: cssUrl(icon) }
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx2("img", { alt: "", className: "ha-launcher__icon", src: icon });
+}
+
+// src/embed/merge-remote-config.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMerge(base, override) {
+  if (override === void 0) return base;
+  if (!isPlainObject(base) || !isPlainObject(override)) return override;
+  const merged = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    if (value === void 0) continue;
+    merged[key] = key in base ? deepMerge(base[key], value) : value;
+  }
+  return merged;
+}
+function mergeRemoteConfig(remote, props) {
+  if (!remote) return props;
+  const groups = {
+    appearance: remote.appearance,
+    capabilities: remote.capabilities,
+    composer: remote.composer,
+    markdown: remote.markdown,
+    permissions: remote.permissions,
+    responseActions: remote.responseActions,
+    startScreen: remote.startScreen
+  };
+  const merged = deepMerge(groups, {
+    appearance: props.appearance,
+    capabilities: props.capabilities,
+    composer: props.composer,
+    // Markdown renderer plugins are functions and never survive a JSON
+    // document, so they are merged back by identity in the provider.
+    markdown: props.markdown ? { ...props.markdown, plugins: void 0 } : void 0,
+    permissions: props.permissions,
+    responseActions: props.responseActions,
+    startScreen: props.startScreen
+  });
+  return { ...props, ...merged };
+}
+function hostSuppliesFont(props) {
+  return Boolean(props.appearance?.theme?.typography?.fontFamily?.trim());
+}
+
+// src/contracts/appearance.ts
+var HEROUI_AGENT_REMOTE_CONFIG_VERSION = 1;
+var INVALID = Symbol("invalid");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function optionalString(value) {
+  if (value === void 0) return void 0;
+  return typeof value === "string" ? value : INVALID;
+}
+function optionalBoolean(value) {
+  if (value === void 0) return void 0;
+  return typeof value === "boolean" ? value : INVALID;
+}
+function optionalNumber(value) {
+  if (value === void 0) return void 0;
+  return typeof value === "number" && Number.isFinite(value) ? value : INVALID;
+}
+function optionalEnum(allowed) {
+  return (value) => {
+    if (value === void 0) return void 0;
+    return typeof value === "string" && allowed.includes(value) ? value : INVALID;
+  };
+}
+function optionalThemeColor(value) {
+  if (value === void 0) return void 0;
+  if (typeof value === "string") return value;
+  if (!isRecord(value)) return INVALID;
+  const dark = optionalString(value["dark"]);
+  const light = optionalString(value["light"]);
+  if (dark === INVALID || light === INVALID) return INVALID;
+  return { ...dark === void 0 ? {} : { dark }, ...light === void 0 ? {} : { light } };
+}
+function optionalStringRecord(value) {
+  if (value === void 0) return void 0;
+  if (!isRecord(value)) return INVALID;
+  const record = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry !== "string") return INVALID;
+    record[key] = entry;
+  }
+  return record;
+}
+function optionalStringArray(value) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) return INVALID;
+  return value;
+}
+function shape(value, validators) {
+  if (value === void 0) return INVALID;
+  if (!isRecord(value)) return INVALID;
+  const result = {};
+  for (const [key, validate] of Object.entries(validators)) {
+    const parsed = validate(value[key]);
+    if (parsed === INVALID) return INVALID;
+    if (parsed !== void 0) result[key] = parsed;
+  }
+  return result;
+}
+function group(parsed) {
+  return parsed === INVALID ? void 0 : parsed;
+}
+var COLOR_KEYS = [
+  "accent",
+  "background",
+  "foreground",
+  "overlay",
+  "surface",
+  "surfaceSecondary",
+  "tooltip"
+];
+function parseAppearance(value) {
+  return shape(value, {
+    launcher: (launcher) => launcher === void 0 ? void 0 : shape(launcher, {
+      background: optionalThemeColor,
+      icon: optionalString,
+      position: optionalEnum(["bottom-left", "bottom-right"]),
+      style: optionalStringRecord
+    }),
+    panel: (panel) => panel === void 0 ? void 0 : shape(panel, {
+      expandable: optionalBoolean,
+      expanded: optionalBoolean,
+      initialHeight: (entry) => entry === void 0 || typeof entry === "string" ? entry : optionalNumber(entry),
+      initialWidth: (entry) => entry === void 0 || typeof entry === "string" ? entry : optionalNumber(entry)
+    }),
+    theme: (theme) => theme === void 0 ? void 0 : shape(theme, {
+      colorScheme: optionalEnum(["dark", "light", "system"]),
+      colors: (colors) => colors === void 0 ? void 0 : shape(
+        colors,
+        Object.fromEntries(COLOR_KEYS.map((key) => [key, optionalThemeColor]))
+      ),
+      designTheme: optionalEnum(["base", "brutalism", "glass", "mouve"]),
+      radius: optionalEnum(["pill", "round", "sharp", "soft"]),
+      typography: (typography) => typography === void 0 ? void 0 : shape(typography, { baseSize: optionalNumber, fontFamily: optionalString })
+    }),
+    viewMode: optionalEnum(["floating", "sidebar"])
+  });
+}
+function parseComposer(value) {
+  return shape(value, {
+    attachments: (attachments) => {
+      if (attachments === void 0 || attachments === false) return attachments;
+      if (!Array.isArray(attachments)) return INVALID;
+      const types = attachments.filter(
+        (entry) => typeof entry === "string" && isHeroUIAgentAttachmentContentType(entry)
+      );
+      return types.length === attachments.length ? types : INVALID;
+    },
+    defaultModel: optionalString,
+    dictation: optionalBoolean,
+    disclaimer: (disclaimer) => disclaimer === false ? false : optionalString(disclaimer),
+    modelPicker: optionalBoolean,
+    placeholder: optionalString
+  });
+}
+function parseMarkdown(value) {
+  return shape(value, {
+    animated: (animated) => {
+      if (animated === void 0 || animated === false) return animated;
+      if (!isRecord(animated)) return INVALID;
+      const animation = optionalEnum(["blurIn", "fadeIn", "slideUp"])(
+        animated["animation"]
+      );
+      if (animation === INVALID || animation === void 0) return INVALID;
+      return { ...animated, animation };
+    },
+    caret: (caret) => caret === false ? false : optionalEnum(["block", "circle"])(caret)
+  });
+}
+function parseResponseActions(value) {
+  if (value === void 0 || value === false) return value;
+  if (!Array.isArray(value)) return INVALID;
+  const allowed = ["copy", "feedback", "retry"];
+  const actions = value.filter(
+    (entry) => typeof entry === "string" && allowed.includes(entry)
+  );
+  return actions.length === value.length ? actions : INVALID;
+}
+function parseAgentRemoteConfig(value) {
+  if (!isRecord(value)) return null;
+  if (value["version"] !== HEROUI_AGENT_REMOTE_CONFIG_VERSION) return null;
+  const revision = value["revision"];
+  if (typeof revision !== "string" || !revision) return null;
+  const appearance = group(parseAppearance(value["appearance"]));
+  const capabilities = group(
+    shape(value["capabilities"], {
+      imageSearch: optionalBoolean,
+      webSearch: optionalBoolean
+    })
+  );
+  const composer = group(parseComposer(value["composer"]));
+  const markdown = group(parseMarkdown(value["markdown"]));
+  const permissions = group(
+    shape(value["permissions"], {
+      defaultMode: optionalEnum(["ask", "auto", "full"]),
+      showPicker: optionalBoolean
+    })
+  );
+  const responseActions = group(parseResponseActions(value["responseActions"]));
+  const startScreen = group(
+    shape(value["startScreen"], {
+      greeting: optionalString,
+      promptShortcuts: optionalBoolean,
+      prompts: optionalStringArray
+    })
+  );
+  const webfont = group(
+    shape(value["webfont"], {
+      familyName: (familyName) => typeof familyName === "string" && familyName ? familyName : INVALID,
+      fontFaceUrl: optionalString,
+      stylesheetUrl: optionalString
+    })
+  );
+  return {
+    ...appearance ? { appearance } : {},
+    ...capabilities ? { capabilities } : {},
+    ...composer ? { composer } : {},
+    ...markdown ? { markdown } : {},
+    ...permissions ? { permissions } : {},
+    ...responseActions === void 0 ? {} : { responseActions },
+    ...startScreen ? { startScreen } : {},
+    ...webfont ? { webfont } : {},
+    revision,
+    version: HEROUI_AGENT_REMOTE_CONFIG_VERSION
+  };
+}
+
+// src/embed/remote-config.ts
+function cacheKey(agentId) {
+  return `heroui-agent:config:${agentId}`;
+}
+function readCachedRemoteConfig(agentId) {
+  try {
+    const raw = window.localStorage.getItem(cacheKey(agentId));
+    return raw ? parseAgentRemoteConfig(JSON.parse(raw)) : null;
+  } catch {
+    return null;
+  }
+}
+function writeCachedRemoteConfig(agentId, config) {
+  try {
+    window.localStorage.setItem(cacheKey(agentId), JSON.stringify(config));
+  } catch {
+  }
+}
+function clearCachedRemoteConfig(agentId) {
+  try {
+    window.localStorage.removeItem(cacheKey(agentId));
+  } catch {
+  }
+}
+async function fetchRemoteConfig(apiBaseUrl, agentId, options = {}) {
+  try {
+    const response = await fetch(
+      `${apiBaseUrl}/v1/agents/${encodeURIComponent(agentId)}/appearance`,
+      {
+        headers: options.revision ? { "If-None-Match": `"${options.revision}"` } : {},
+        ...options.signal ? { signal: options.signal } : {}
+      }
+    );
+    if (response.status === 304) return { status: "not-modified" };
+    if (response.status === 404 || response.status === 410) return { status: "missing" };
+    if (!response.ok) return { status: "unavailable" };
+    const config = parseAgentRemoteConfig(await response.json());
+    return config ? { config, status: "ok" } : { status: "unavailable" };
+  } catch {
+    return { status: "unavailable" };
+  }
+}
+
+// src/embed/shell-conversation.tsx
+import { useEffect, useRef, useState } from "react";
+import { Fragment, jsx as jsx3, jsxs } from "react/jsx-runtime";
+function ShellConversation({
+  agentId,
+  greeting,
+  onIntent,
+  placeholder,
+  suggestedPrompts
+}) {
+  const [input, setInput] = useState(() => readAgentShellHandoff(agentId)?.prompt ?? "");
+  const [submitted, setSubmitted] = useState(false);
+  const textareaRef = useRef(null);
+  useEffect(() => {
+    if (submitted) return;
+    writeAgentShellHandoff(agentId, { prompt: input, submitted: false });
+  }, [input, agentId, submitted]);
+  const submit = (prompt) => {
+    const trimmed = prompt.trim();
+    if (!trimmed) return;
+    setSubmitted(true);
+    setInput(trimmed);
+    writeAgentShellHandoff(agentId, { prompt: trimmed, submitted: true });
+    onIntent();
+  };
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx3("div", { className: "ha-conversation", children: /* @__PURE__ */ jsxs("div", { "aria-live": "polite", className: "ha-messages", role: "log", children: [
+      /* @__PURE__ */ jsxs("div", { className: "ha-empty", children: [
+        /* @__PURE__ */ jsx3("h2", { children: greeting }),
+        /* @__PURE__ */ jsx3("p", { children: "Live answers with charts, metrics, and tables." })
+      ] }),
+      submitted ? /* @__PURE__ */ jsx3("div", { className: "ha-message", "data-role": "user", children: /* @__PURE__ */ jsx3("div", { className: "ha-message-body", children: input }) }) : null
+    ] }) }),
+    /* @__PURE__ */ jsxs(
+      "form",
+      {
+        className: "ha-composer-wrap",
+        onSubmit: (event) => {
+          event.preventDefault();
+          submit(input);
+        },
+        children: [
+          !submitted && suggestedPrompts.length > 0 ? /* @__PURE__ */ jsx3("div", { "aria-label": "Suggested prompts", className: "ha-suggestions", role: "group", children: suggestedPrompts.map((prompt) => /* @__PURE__ */ jsxs(
+            "button",
+            {
+              className: "ha-suggestion",
+              type: "button",
+              onClick: () => submit(prompt),
+              children: [
+                /* @__PURE__ */ jsx3("span", { children: prompt }),
+                /* @__PURE__ */ jsx3(ArrowUpRightGlyph, {})
+              ]
+            },
+            prompt
+          )) }) : null,
+          /* @__PURE__ */ jsxs("div", { className: "@container ha-composer", children: [
+            /* @__PURE__ */ jsx3(
+              "textarea",
+              {
+                ref: textareaRef,
+                "aria-label": "Message the assistant",
+                placeholder,
+                rows: 1,
+                value: input,
+                onFocus: onIntent,
+                onChange: (event) => {
+                  setInput(event.currentTarget.value);
+                  resizeComposerTextarea(event.currentTarget);
+                  onIntent();
+                },
+                onKeyDown: (event) => {
+                  if (event.key !== "Enter" || event.shiftKey) return;
+                  event.preventDefault();
+                  submit(input);
+                }
+              }
+            ),
+            /* @__PURE__ */ jsxs(
+              "button",
+              {
+                "aria-label": "Send message",
+                className: "ha-send",
+                "data-shortcut": "\u21B5",
+                "data-tooltip": "Send message",
+                disabled: !input.trim() || submitted,
+                type: "submit",
+                children: [
+                  /* @__PURE__ */ jsx3(ArrowUpGlyph, {}),
+                  /* @__PURE__ */ jsx3(ComposerControlTooltip, { shortcut: "\u21B5", children: "Send message" })
+                ]
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx3(PoweredByHero, {})
+        ]
+      }
+    )
+  ] });
+}
+function ArrowUpGlyph() {
+  return /* @__PURE__ */ jsx3("svg", { "aria-hidden": "true", fill: "none", height: "18", viewBox: "0 0 18 18", width: "18", children: /* @__PURE__ */ jsx3(
+    "path",
+    {
+      d: "M9 14.5V3.5m0 0L4.5 8M9 3.5 13.5 8",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.6"
+    }
+  ) });
+}
+function ArrowUpRightGlyph() {
+  return /* @__PURE__ */ jsx3("svg", { "aria-hidden": "true", fill: "none", height: "16", viewBox: "0 0 16 16", width: "16", children: /* @__PURE__ */ jsx3(
+    "path",
+    {
+      d: "M5 11 11 5m0 0H6m5 0v5",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  ) });
+}
+
+// src/embed/webfont.ts
+var FONT_FILE_EXTENSIONS = [".woff2", ".woff", ".ttf", ".otf", ".eot"];
+function elementId(font) {
+  return `heroui-agent-font-${font.familyName.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
+}
+function fontFormat(url) {
+  const isVariable = url.includes(":vf@") || url.includes("-wght-") || url.includes("-opsz-");
+  if (url.endsWith(".woff")) return "woff";
+  if (url.endsWith(".ttf")) return "truetype";
+  if (url.endsWith(".otf")) return "opentype";
+  return isVariable ? "woff2-variations" : "woff2";
+}
+function isSafeFontUrl(url, requireFontFile) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "https:") return false;
+    if (!requireFontFile) return true;
+    const pathname = parsed.pathname.toLowerCase();
+    return FONT_FILE_EXTENSIONS.some((extension) => pathname.endsWith(extension));
+  } catch {
+    return false;
+  }
+}
+function loadAgentWebfont(font) {
+  if (!font || typeof document === "undefined") return () => void 0;
+  const id = elementId(font);
+  if (document.getElementById(id)) return () => void 0;
+  if (font.stylesheetUrl && isSafeFontUrl(font.stylesheetUrl, false)) {
+    const link = document.createElement("link");
+    link.id = id;
+    link.rel = "stylesheet";
+    link.href = font.stylesheetUrl;
+    document.head.append(link);
+    return () => link.remove();
+  }
+  if (font.fontFaceUrl && isSafeFontUrl(font.fontFaceUrl, true)) {
+    const style = document.createElement("style");
+    const isVariable = font.fontFaceUrl.includes(":vf@") || font.fontFaceUrl.includes("-wght-") || font.fontFaceUrl.includes("-opsz-");
+    style.id = id;
+    style.textContent = [
+      "@font-face {",
+      `  font-family: '${font.familyName.replaceAll("'", "")}';`,
+      "  font-style: normal;",
+      "  font-display: swap;",
+      `  font-weight: ${isVariable ? "100 900" : "400"};`,
+      `  src: url(${font.fontFaceUrl}) format('${fontFormat(font.fontFaceUrl)}');`,
+      "}"
+    ].join("\n");
+    document.head.append(style);
+    return () => style.remove();
+  }
+  return () => void 0;
+}
+
+// src/embed/provider.tsx
+import { Fragment as Fragment2, jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+var REMOTE_CONFIG_PAINT_BUDGET_MS = 600;
+var RUNTIME_PREFETCH_IDLE_TIMEOUT_MS = 1200;
+var embedRuntimePromise;
+function loadEmbedRuntime() {
+  embedRuntimePromise ??= import(
+    /* webpackPrefetch: true */
+    "./embed-runtime-XOPQY7Z5.js"
+  ).then(
+    (module) => module.default
+  );
+  return embedRuntimePromise;
+}
+var controllers = /* @__PURE__ */ new Map();
+function subscribeToColorScheme(onChange) {
+  const media = window.matchMedia?.("(prefers-color-scheme: dark)");
+  media?.addEventListener?.("change", onChange);
+  return () => media?.removeEventListener?.("change", onChange);
+}
+function prefersDarkColorScheme() {
+  return window.matchMedia?.("(prefers-color-scheme: dark)").matches === true;
+}
+function dispatch(agentId, method) {
+  const controller = agentId ? controllers.get(agentId) : [...controllers.values()][controllers.size - 1];
+  if (!controller) {
+    console.warn("HeroUI Agent is not mounted yet. Add <HeroUIAgent /> to your layout.");
+    return;
+  }
+  controller[method]();
+}
+function useRemoteConfig(agentId, apiBaseUrl, enabled) {
+  const [state, setState] = useState2(() => {
+    if (!enabled || typeof window === "undefined") return { config: null, resolved: false };
+    const cached = readCachedRemoteConfig(agentId);
+    return { config: cached, resolved: Boolean(cached) };
+  });
+  useEffect2(() => {
+    if (!enabled) return;
+    const cached = readCachedRemoteConfig(agentId);
+    const controller = new AbortController();
+    const budget = window.setTimeout(
+      () => setState((current) => ({ ...current, resolved: true })),
+      REMOTE_CONFIG_PAINT_BUDGET_MS
+    );
+    void fetchRemoteConfig(apiBaseUrl, agentId, {
+      ...cached?.revision ? { revision: cached.revision } : {},
+      signal: controller.signal
+    }).then((result) => {
+      if (controller.signal.aborted) return;
+      if (result.status === "ok") {
+        setState({ config: result.config, resolved: true });
+        writeCachedRemoteConfig(agentId, result.config);
+      }
+      if (result.status === "missing") {
+        setState({ config: null, resolved: true });
+        clearCachedRemoteConfig(agentId);
+      }
+    }).finally(() => {
+      if (controller.signal.aborted) return;
+      window.clearTimeout(budget);
+      setState((current) => ({ ...current, resolved: true }));
+    });
+    return () => {
+      controller.abort();
+      window.clearTimeout(budget);
+    };
+  }, [apiBaseUrl, enabled, agentId]);
+  return enabled ? state : { config: null, resolved: true };
+}
+function useAgent(agentId) {
+  return useMemo(
+    () => ({
+      hide: () => dispatch(agentId, "hide"),
+      newConversation: () => dispatch(agentId, "newConversation"),
+      preload: () => dispatch(agentId, "preload"),
+      refreshAuth: () => dispatch(agentId, "refreshAuth"),
+      show: () => dispatch(agentId, "show"),
+      shutdown: () => dispatch(agentId, "shutdown"),
+      toggle: () => dispatch(agentId, "toggle")
+    }),
+    [agentId]
+  );
+}
+function HeroUIAgent(props) {
+  const {
+    _api,
+    agentId,
+    appearance,
+    capabilities,
+    componentExports,
+    composer,
+    context,
+    getAuthToken,
+    markdown,
+    onFeedback,
+    permissions,
+    preload: preloadEnabled,
+    remoteConfig: remoteConfigEnabled = true,
+    responseActions,
+    showLauncher,
+    startScreen,
+    tools
+  } = props;
+  const markdownPlugins = markdown?.plugins;
+  const apiBaseUrl = (_api?.baseUrl ?? "https://api.heroui.com").replace(/\/$/, "");
+  const { config: remoteConfig, resolved: remoteConfigResolved } = useRemoteConfig(
+    agentId,
+    apiBaseUrl,
+    remoteConfigEnabled
+  );
+  const serializedConfig = JSON.stringify({
+    _api,
+    appearance,
+    capabilities,
+    componentExports,
+    composer,
+    markdown: markdown ? { ...markdown, plugins: void 0 } : void 0,
+    permissions,
+    preload: preloadEnabled,
+    remote: remoteConfig,
+    responseActions,
+    showLauncher,
+    startScreen
+  });
+  const options = useMemo(() => {
+    const { remote, ...config } = JSON.parse(serializedConfig);
+    const merged = mergeRemoteConfig(remote, {
+      ...config,
+      agentId,
+      getAuthToken
+    });
+    return resolveOptions({
+      ...merged,
+      context,
+      markdown: merged.markdown ? { ...merged.markdown, plugins: markdownPlugins } : markdownPlugins ? { plugins: markdownPlugins } : void 0,
+      onFeedback,
+      tools
+    });
+  }, [context, getAuthToken, markdownPlugins, onFeedback, agentId, serializedConfig, tools]);
+  const hostFont = hostSuppliesFont(props);
+  const remoteWebfont = remoteConfig?.webfont;
+  useEffect2(() => {
+    if (hostFont) return;
+    return loadAgentWebfont(remoteWebfont);
+  }, [hostFont, remoteWebfont]);
+  const [isOpen, setIsOpen] = useState2(false);
+  const [conversationEpoch, setConversationEpoch] = useState2(1);
+  const [identityEpoch, setIdentityEpoch] = useState2(1);
+  const [identityReset, setIdentityReset] = useState2(false);
+  const [requestedConversationId, setRequestedConversationId] = useState2(
+    void 0
+  );
+  const [portalRoot, setPortalRoot] = useState2(null);
+  const [EmbedRuntime, setEmbedRuntime] = useState2(null);
+  const conversationEpochRef = useRef2(1);
+  const launcherRef = useRef2(null);
+  const portalRootRef = useRef2(null);
+  const readyEpochRef = useRef2(null);
+  const shouldOpenRef = useRef2(false);
+  const hostRef = useRef2(null);
+  const embedReactRootRef = useRef2(null);
+  const rootPropertyNamesRef = useRef2([]);
+  const prefersDark = useSyncExternalStore(
+    subscribeToColorScheme,
+    prefersDarkColorScheme,
+    () => false
+  );
+  const designThemeClass = options.designTheme === "base" ? null : `${options.designTheme}-${options.colorScheme === "system" ? prefersDark ? "dark" : "light" : options.colorScheme}`;
+  const [shouldLoadRuntime, setShouldLoadRuntime] = useState2(false);
+  const requestRuntime = useCallback(() => setShouldLoadRuntime(true), []);
+  const [preloadRequested, setPreloadRequested] = useState2(false);
+  const shouldWarmSession = options.preload || preloadRequested;
+  useEffect2(() => {
+    if (!options.preload || shouldLoadRuntime) return;
+    return scheduleIdleTask(requestRuntime, RUNTIME_PREFETCH_IDLE_TIMEOUT_MS);
+  }, [options.preload, requestRuntime, shouldLoadRuntime]);
+  useEffect2(() => {
+    if (!shouldLoadRuntime) return;
+    let active = true;
+    void loadEmbedRuntime().then((runtime) => {
+      if (active) setEmbedRuntime(() => runtime);
+    }).catch(() => void 0);
+    return () => {
+      active = false;
+    };
+  }, [shouldLoadRuntime]);
+  useEffect2(() => {
+    if (!isOpen || options.viewMode !== "sidebar") return;
+    if (window.innerWidth < 640) return;
+    const target = document.documentElement;
+    const previousMargin = target.style.marginRight;
+    const previousTransition = target.style.transition;
+    const reducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+    const width = Math.min(readSidebarWidth(options.agentId, window.innerWidth), window.innerWidth);
+    if (!reducedMotion) {
+      target.style.transition = [previousTransition, "margin-right .28s cubic-bezier(.2,.8,.2,1)"].filter(Boolean).join(", ");
+    }
+    target.style.marginRight = `${width}px`;
+    return () => {
+      target.style.marginRight = previousMargin;
+      window.setTimeout(() => {
+        target.style.transition = previousTransition;
+      }, 300);
+    };
+  }, [isOpen, options.agentId, options.viewMode]);
+  useEffect2(() => {
+    const host = document.createElement("div");
+    const root = document.createElement("div");
+    host.dataset["herouiAgent"] = options.agentId;
+    root.className = "ha-root";
+    hostRef.current = host;
+    portalRootRef.current = root;
+    embedReactRootRef.current = createRoot(root);
+    host.append(root);
+    document.body.append(host);
+    let active = true;
+    queueMicrotask(() => {
+      if (active) setPortalRoot(root);
+    });
+    return () => {
+      active = false;
+      const reactRoot = embedReactRootRef.current;
+      portalRootRef.current = null;
+      hostRef.current = null;
+      embedReactRootRef.current = null;
+      rootPropertyNamesRef.current = [];
+      queueMicrotask(() => {
+        reactRoot?.unmount();
+        host.remove();
+      });
+    };
+  }, [options.agentId]);
+  useLayoutEffect(() => {
+    const root = portalRootRef.current;
+    const host = hostRef.current;
+    if (!root || !host) return;
+    root.className = designThemeClass ? `ha-root ${designThemeClass}` : "ha-root";
+    root.dataset["theme"] = options.colorScheme;
+    root.dataset["viewMode"] = options.viewMode;
+    root.dataset["position"] = options.launcherPosition;
+    host.dataset["open"] = isOpen ? "true" : "false";
+    host.dataset["viewMode"] = options.viewMode;
+    host.dataset["position"] = options.launcherPosition;
+    if (options.launcherOffset) {
+      host.style.setProperty("--ha-launcher-x", `${options.launcherOffset.x}px`);
+      host.style.setProperty("--ha-launcher-y", `${options.launcherOffset.y}px`);
+    } else {
+      host.style.removeProperty("--ha-launcher-x");
+      host.style.removeProperty("--ha-launcher-y");
+    }
+    if (options.viewMode === "sidebar") {
+      host.style.setProperty(
+        "--ha-sidebar-width",
+        `${readSidebarWidth(options.agentId, window.innerWidth)}px`
+      );
+    }
+    const rootProperties = { ...options.themeStyle, ...options.panelStyle };
+    for (const property of rootPropertyNamesRef.current) {
+      if (!(property in rootProperties)) root.style.removeProperty(property);
+    }
+    for (const [property, value] of Object.entries(rootProperties)) {
+      root.style.setProperty(property, value);
+    }
+    rootPropertyNamesRef.current = Object.keys(rootProperties);
+  }, [
+    designThemeClass,
+    isOpen,
+    options.colorScheme,
+    options.launcherOffset,
+    options.launcherPosition,
+    options.panelStyle,
+    options.themeStyle,
+    options.viewMode,
+    portalRoot
+  ]);
+  const prepareNextConversation = useCallback((conversationId) => {
+    readyEpochRef.current = null;
+    setRequestedConversationId(conversationId);
+    setConversationEpoch((epoch) => {
+      const nextEpoch = epoch + 1;
+      conversationEpochRef.current = nextEpoch;
+      return nextEpoch;
+    });
+  }, []);
+  const handleRuntimeReady = useCallback((readyEpoch) => {
+    if (conversationEpochRef.current !== readyEpoch) return;
+    readyEpochRef.current = readyEpoch;
+    if (shouldOpenRef.current) setIsOpen(true);
+  }, []);
+  const hide = useCallback(() => {
+    shouldOpenRef.current = false;
+    setIsOpen(false);
+    prepareNextConversation();
+    requestAnimationFrame(() => launcherRef.current?.focus());
+  }, [prepareNextConversation]);
+  const show = useCallback(() => {
+    shouldOpenRef.current = true;
+    requestRuntime();
+    setIsOpen(true);
+  }, [requestRuntime]);
+  const preload = useCallback(() => {
+    setPreloadRequested(true);
+    requestRuntime();
+  }, [requestRuntime]);
+  const newConversation = useCallback(() => {
+    shouldOpenRef.current = true;
+    requestRuntime();
+    prepareNextConversation(null);
+  }, [prepareNextConversation, requestRuntime]);
+  const selectConversation = useCallback(
+    (conversationId) => {
+      shouldOpenRef.current = true;
+      requestRuntime();
+      prepareNextConversation(conversationId);
+    },
+    [prepareNextConversation, requestRuntime]
+  );
+  const toggle = useCallback(() => {
+    if (isOpen || shouldOpenRef.current) hide();
+    else show();
+  }, [hide, isOpen, show]);
+  const refreshAuth = useCallback(() => {
+    setIdentityReset(false);
+    setIdentityEpoch((epoch) => epoch + 1);
+  }, []);
+  const shutdown = useCallback(() => {
+    const prefixes = [
+      `heroui-agent:anonymous:${options.agentId}`,
+      `heroui-agent:conversation:${options.agentId}:`,
+      `heroui-agent:history:${options.agentId}:`,
+      `heroui-agent:session:${options.agentId}:`
+    ];
+    for (let index = localStorage.length - 1; index >= 0; index -= 1) {
+      const key = localStorage.key(index);
+      if (key && prefixes.some((prefix) => key.startsWith(prefix))) localStorage.removeItem(key);
+    }
+    shouldOpenRef.current = false;
+    setIsOpen(false);
+    setIdentityReset(true);
+    setIdentityEpoch((epoch) => epoch + 1);
+    prepareNextConversation();
+    window.setTimeout(() => {
+      void clearAgentComposerDraftsForProject(options.agentId);
+    }, 0);
+  }, [options.agentId, prepareNextConversation]);
+  useEffect2(() => {
+    const controller = {
+      hide,
+      newConversation,
+      preload,
+      refreshAuth,
+      show,
+      shutdown,
+      toggle
+    };
+    controllers.set(options.agentId, controller);
+    return () => {
+      if (controllers.get(options.agentId) === controller) {
+        controllers.delete(options.agentId);
+      }
+    };
+  }, [hide, newConversation, options.agentId, preload, refreshAuth, show, shutdown, toggle]);
+  useLayoutEffect(() => {
+    const reactRoot = embedReactRootRef.current;
+    if (!portalRoot || !reactRoot) return;
+    reactRoot.render(
+      /* @__PURE__ */ jsxs2(Fragment2, { children: [
+        options.showLauncher && remoteConfigResolved && !isOpen ? /* @__PURE__ */ jsx4(
+          "button",
+          {
+            ref: launcherRef,
+            "aria-expanded": false,
+            "aria-haspopup": "dialog",
+            "aria-label": "Open data assistant",
+            className: "ha-launcher",
+            style: options.launcherStyle,
+            type: "button",
+            onClick: show,
+            onFocus: options.preload ? requestRuntime : void 0,
+            onPointerEnter: options.preload ? requestRuntime : void 0,
+            children: /* @__PURE__ */ jsx4(LauncherIcon, { icon: options.launcherIcon })
+          }
+        ) : null,
+        EmbedRuntime ? /* @__PURE__ */ jsx4(
+          EmbedRuntime,
+          {
+            conversationEpoch,
+            identityEpoch,
+            identityReset,
+            open: isOpen,
+            options,
+            requestedConversationId,
+            warmSession: shouldWarmSession,
+            onClose: hide,
+            onNewConversation: newConversation,
+            onReady: handleRuntimeReady,
+            onSelectConversation: selectConversation
+          }
+        ) : /* @__PURE__ */ jsx4(
+          PanelShell,
+          {
+            defaultExpanded: options.panelExpanded,
+            expandable: options.panelExpandable,
+            modal: options.viewMode !== "sidebar",
+            name: "Data assistant",
+            open: isOpen,
+            agentId: options.agentId,
+            onClose: hide,
+            children: /* @__PURE__ */ jsx4(
+              ShellConversation,
+              {
+                greeting: options.greeting,
+                placeholder: options.composerPlaceholder,
+                agentId: options.agentId,
+                suggestedPrompts: options.suggestedPrompts ?? [],
+                onIntent: requestRuntime
+              }
+            )
+          }
+        )
+      ] })
+    );
+  }, [
+    EmbedRuntime,
+    conversationEpoch,
+    handleRuntimeReady,
+    hide,
+    identityEpoch,
+    identityReset,
+    isOpen,
+    newConversation,
+    options,
+    portalRoot,
+    remoteConfigResolved,
+    requestRuntime,
+    requestedConversationId,
+    selectConversation,
+    shouldWarmSession,
+    show
+  ]);
+  return null;
+}
+
+export {
+  useAgent,
+  HeroUIAgent
+};