strapi-plugin-ai-sdk 0.6.2 → 0.6.4

package/dist/_chunks/App-CdOD0qmW.js

@@ -0,0 +1,2776 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("react/jsx-runtime");
+const admin = require("@strapi/strapi/admin");
+const reactRouterDom = require("react-router-dom");
+const designSystem = require("@strapi/design-system");
+const react = require("react");
+const styled = require("styled-components");
+const index = require("./index-HDnO9h6E.js");
+const THREE = require("three");
+const OrbitControls_js = require("three/examples/jsm/controls/OrbitControls.js");
+const GLTFLoader_js = require("three/examples/jsm/loaders/GLTFLoader.js");
+const icons = require("@strapi/icons");
+const Markdown = require("react-markdown");
+const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const styled__default = /* @__PURE__ */ _interopDefault(styled);
+const THREE__namespace = /* @__PURE__ */ _interopNamespace(THREE);
+const Markdown__default = /* @__PURE__ */ _interopDefault(Markdown);
+const COOKIE_REGEX = /(?:^|;\s*)jwtToken=([^;]*)/;
+function getCookieValue() {
+  const match = COOKIE_REGEX.exec(document.cookie);
+  return match ? decodeURIComponent(match[1]) : void 0;
+}
+function getToken() {
+  const raw = localStorage.getItem("jwtToken");
+  if (raw) {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  }
+  return getCookieValue() ?? null;
+}
+function getBackendURL() {
+  return globalThis.strapi?.backendURL ?? "";
+}
+function parseSSELine(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("data:")) return null;
+  const payload = trimmed.slice(5).trim();
+  if (payload === "[DONE]") return null;
+  try {
+    const parsed = JSON.parse(payload);
+    switch (parsed.type) {
+      case "text-delta":
+        return { type: "text-delta", delta: parsed.delta };
+      case "tool-input-available":
+        return {
+          type: "tool-input-available",
+          toolCallId: parsed.toolCallId,
+          toolName: parsed.toolName,
+          input: parsed.input
+        };
+      case "tool-output-available":
+        return {
+          type: "tool-output-available",
+          toolCallId: parsed.toolCallId,
+          output: parsed.output
+        };
+      default:
+        return null;
+    }
+  } catch {
+  }
+  return null;
+}
+async function readSSEStream(reader, callbacksOrOnDelta) {
+  const callbacks = typeof callbacksOrOnDelta === "function" ? { onTextDelta: callbacksOrOnDelta } : callbacksOrOnDelta;
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let accumulated = "";
+  const toolNameMap = /* @__PURE__ */ new Map();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const event = parseSSELine(line);
+      if (!event) continue;
+      switch (event.type) {
+        case "text-delta":
+          accumulated += event.delta;
+          callbacks.onTextDelta(accumulated);
+          break;
+        case "tool-input-available":
+          toolNameMap.set(event.toolCallId, event.toolName);
+          callbacks.onToolInput?.(event.toolCallId, event.toolName, event.input);
+          break;
+        case "tool-output-available": {
+          const resolvedName = toolNameMap.get(event.toolCallId) ?? "";
+          callbacks.onToolOutput?.(event.toolCallId, resolvedName, event.output);
+          break;
+        }
+      }
+    }
+  }
+  return accumulated;
+}
+function generateId() {
+  return globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random()}`;
+}
+function toUIMessages(messages) {
+  return messages.map((message) => ({
+    id: message.id,
+    role: message.role,
+    parts: [{ type: "text", text: message.content }]
+  }));
+}
+async function fetchChatStream(messages) {
+  const token = getToken();
+  const response = await fetch(`${getBackendURL()}/${index.PLUGIN_ID}/chat`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...token ? { Authorization: `Bearer ${token}` } : {}
+    },
+    body: JSON.stringify({ messages: toUIMessages(messages) })
+  });
+  if (!response.ok) throw new Error(`Request failed: ${response.status}`);
+  const reader = response.body?.getReader();
+  if (!reader) throw new Error("No response stream");
+  return reader;
+}
+function updateMessage(setMessages, id, updater) {
+  setMessages((prev) => prev.map((message) => message.id === id ? updater(message) : message));
+}
+function removeMessage(setMessages, id) {
+  setMessages((prev) => prev.filter((message) => message.id !== id));
+}
+function addToolCall(setMessages, assistantId, toolCallId, toolName, input) {
+  updateMessage(setMessages, assistantId, (message) => ({
+    ...message,
+    toolCalls: [...message.toolCalls ?? [], { toolCallId, toolName, input }]
+  }));
+}
+function updateToolOutput(setMessages, assistantId, toolCallId, output) {
+  updateMessage(setMessages, assistantId, (message) => ({
+    ...message,
+    toolCalls: message.toolCalls?.map(
+      (tc) => tc.toolCallId === toolCallId ? { ...tc, output } : tc
+    )
+  }));
+}
+function useChat(options) {
+  const [messages, setMessages] = react.useState(options?.initialMessages ?? []);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  react.useEffect(() => {
+    setMessages(options?.initialMessages ?? []);
+    setError(null);
+  }, [options?.conversationId]);
+  const sendMessage = react.useCallback(
+    async (text) => {
+      const trimmed = text.trim();
+      if (!trimmed || isLoading) return;
+      const userMessage = { id: generateId(), role: "user", content: trimmed };
+      const assistantId = generateId();
+      setMessages((prev) => [...prev, userMessage, { id: assistantId, role: "assistant", content: "" }]);
+      setIsLoading(true);
+      setError(null);
+      try {
+        const reader = await fetchChatStream([...messages, userMessage]);
+        let streamStarted = false;
+        const result = await readSSEStream(reader, {
+          onTextDelta: (content) => {
+            if (!streamStarted) {
+              streamStarted = true;
+              options?.onStreamStart?.();
+            }
+            updateMessage(setMessages, assistantId, (message) => ({ ...message, content }));
+          },
+          onToolInput: (toolCallId, toolName, input) => {
+            if (toolName === "triggerAnimation" && input && typeof input === "object" && "animation" in input) {
+              options?.onAnimationTrigger?.(String(input.animation));
+            }
+            addToolCall(setMessages, assistantId, toolCallId, toolName, input);
+          },
+          onToolOutput: (toolCallId, _toolName, output) => {
+            updateToolOutput(setMessages, assistantId, toolCallId, output);
+          }
+        });
+        if (result) {
+          options?.onStreamEnd?.(result);
+        }
+        if (!result) {
+          updateMessage(setMessages, assistantId, (message) => ({ ...message, content: message.content || "No response received." }));
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Something went wrong");
+        removeMessage(setMessages, assistantId);
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [isLoading, messages, options]
+  );
+  const clearMessages = react.useCallback(() => {
+    setMessages([]);
+    setError(null);
+  }, []);
+  return { messages, setMessages, sendMessage, clearMessages, isLoading, error };
+}
+const BASE$2 = () => `${getBackendURL()}/${index.PLUGIN_ID}/conversations`;
+function headers$2() {
+  const token = getToken();
+  return {
+    "Content-Type": "application/json",
+    ...token ? { Authorization: `Bearer ${token}` } : {}
+  };
+}
+async function request$2(url, init) {
+  const res = await fetch(url, { headers: headers$2(), ...init });
+  if (!res.ok) throw new Error(`Request failed: ${res.status}`);
+  const json = await res.json();
+  return json.data;
+}
+function fetchConversations() {
+  return request$2(BASE$2());
+}
+function fetchConversation(documentId) {
+  return request$2(`${BASE$2()}/${documentId}`);
+}
+function createConversation(data) {
+  return request$2(BASE$2(), {
+    method: "POST",
+    body: JSON.stringify(data)
+  });
+}
+function updateConversation(documentId, data) {
+  return request$2(`${BASE$2()}/${documentId}`, {
+    method: "PUT",
+    body: JSON.stringify(data)
+  });
+}
+function deleteConversation(documentId) {
+  return request$2(`${BASE$2()}/${documentId}`, { method: "DELETE" });
+}
+function useConversations() {
+  const [conversations, setConversations] = react.useState([]);
+  const [activeId, setActiveId] = react.useState(null);
+  const [initialMessages, setInitialMessages] = react.useState([]);
+  react.useEffect(() => {
+    fetchConversations().then(async (list) => {
+      setConversations(list);
+      if (list.length > 0) {
+        const most_recent = list[0];
+        const conversation = await fetchConversation(most_recent.documentId);
+        setActiveId(most_recent.documentId);
+        setInitialMessages(conversation.messages || []);
+      }
+    }).catch((err) => console.error("Failed to load conversations:", err));
+  }, []);
+  const selectConversation = react.useCallback(async (documentId) => {
+    try {
+      const conversation = await fetchConversation(documentId);
+      setActiveId(documentId);
+      setInitialMessages(conversation.messages || []);
+    } catch (err) {
+      console.error("Failed to load conversation:", err);
+    }
+  }, []);
+  const startNewConversation = react.useCallback(() => {
+    setActiveId(null);
+    setInitialMessages([]);
+  }, []);
+  const saveMessages = react.useCallback(
+    async (messages) => {
+      if (messages.length === 0) return;
+      const firstUserMsg = messages.find((m) => m.role === "user");
+      const title = firstUserMsg ? firstUserMsg.content.slice(0, 80) + (firstUserMsg.content.length > 80 ? "…" : "") : "New conversation";
+      try {
+        if (activeId) {
+          await updateConversation(activeId, { title, messages });
+          setConversations(
+            (prev) => prev.map(
+              (c) => c.documentId === activeId ? { ...c, title, updatedAt: (/* @__PURE__ */ new Date()).toISOString() } : c
+            )
+          );
+        } else {
+          const created = await createConversation({ title, messages });
+          setInitialMessages(messages);
+          setActiveId(created.documentId);
+          setConversations((prev) => [
+            {
+              documentId: created.documentId,
+              title: created.title,
+              createdAt: created.createdAt,
+              updatedAt: created.updatedAt
+            },
+            ...prev
+          ]);
+        }
+      } catch (err) {
+        console.error("Failed to save conversation:", err);
+      }
+    },
+    [activeId]
+  );
+  const removeConversation = react.useCallback(
+    async (documentId) => {
+      try {
+        await deleteConversation(documentId);
+        setConversations((prev) => prev.filter((c) => c.documentId !== documentId));
+        if (activeId === documentId) {
+          setActiveId(null);
+          setInitialMessages([]);
+        }
+      } catch (err) {
+        console.error("Failed to delete conversation:", err);
+      }
+    },
+    [activeId]
+  );
+  return {
+    conversations,
+    activeId,
+    initialMessages,
+    selectConversation,
+    startNewConversation,
+    saveMessages,
+    removeConversation
+  };
+}
+function stripMarkdown(text) {
+  return text.replace(/```[\s\S]*?```/g, "").replace(/`([^`]+)`/g, "$1").replace(/!\[.*?\]\(.*?\)/g, "").replace(/\[([^\]]+)\]\(.*?\)/g, "$1").replace(/#{1,6}\s*/g, "").replace(/[*_]{1,3}([^*_]+)[*_]{1,3}/g, "$1").replace(/>\s?/g, "").replace(/[-*+]\s/g, "").replace(/\d+\.\s/g, "").replace(/\n{2,}/g, " ").replace(/\s{2,}/g, " ").trim();
+}
+function useAudioPlayer(options) {
+  const [isPlaying, setIsPlaying] = react.useState(false);
+  const audioRef = react.useRef(null);
+  const optionsRef = react.useRef(options);
+  optionsRef.current = options;
+  const stop = react.useCallback(() => {
+    if (audioRef.current) {
+      audioRef.current.pause();
+      audioRef.current = null;
+    }
+    setIsPlaying(false);
+  }, []);
+  const speak2 = react.useCallback(
+    async (text) => {
+      stop();
+      const clean = stripMarkdown(text);
+      if (clean.length < 3) {
+        optionsRef.current?.onPlayStart?.(0);
+        optionsRef.current?.onPlayEnded?.();
+        return;
+      }
+      const token = getToken();
+      try {
+        const response = await fetch(`${getBackendURL()}/${index.PLUGIN_ID}/tts`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...token ? { Authorization: `Bearer ${token}` } : {}
+          },
+          body: JSON.stringify({ text: clean })
+        });
+        if (!response.ok) {
+          optionsRef.current?.onPlayStart?.(0);
+          optionsRef.current?.onPlayEnded?.();
+          return;
+        }
+        const blob = await response.blob();
+        const url = URL.createObjectURL(blob);
+        const audio = new Audio(url);
+        audioRef.current = audio;
+        const duration = await new Promise((resolve) => {
+          audio.onloadedmetadata = () => {
+            resolve(Number.isFinite(audio.duration) ? audio.duration : 0);
+          };
+          audio.onerror = () => resolve(0);
+        });
+        audio.onplay = () => {
+          setIsPlaying(true);
+          optionsRef.current?.onPlayStart?.(duration);
+        };
+        audio.onended = () => {
+          setIsPlaying(false);
+          audioRef.current = null;
+          URL.revokeObjectURL(url);
+          optionsRef.current?.onPlayEnded?.();
+        };
+        audio.onerror = () => {
+          setIsPlaying(false);
+          audioRef.current = null;
+          URL.revokeObjectURL(url);
+          optionsRef.current?.onPlayEnded?.();
+        };
+        await audio.play();
+      } catch {
+        setIsPlaying(false);
+        optionsRef.current?.onPlayStart?.(0);
+        optionsRef.current?.onPlayEnded?.();
+      }
+    },
+    [stop]
+  );
+  return { speak: speak2, stop, isPlaying };
+}
+function useTextReveal() {
+  const [visibleText, setVisibleText] = react.useState("");
+  const [isRevealing, setIsRevealing] = react.useState(false);
+  const rafRef = react.useRef(null);
+  const fullTextRef = react.useRef("");
+  const stopReveal = react.useCallback(() => {
+    if (rafRef.current !== null) {
+      cancelAnimationFrame(rafRef.current);
+      rafRef.current = null;
+    }
+    if (fullTextRef.current) {
+      setVisibleText(fullTextRef.current);
+    }
+    setIsRevealing(false);
+  }, []);
+  const startReveal = react.useCallback(
+    (text, duration) => {
+      stopReveal();
+      fullTextRef.current = text;
+      if (duration <= 0 || !text) {
+        setVisibleText(text);
+        setIsRevealing(false);
+        return;
+      }
+      const totalChars = text.length;
+      const durationMs = duration * 1e3;
+      const startTime = performance.now();
+      setVisibleText("");
+      setIsRevealing(true);
+      const tick = (now) => {
+        const elapsed = now - startTime;
+        const progress = Math.min(elapsed / durationMs, 1);
+        const targetChar = Math.floor(progress * totalChars);
+        let snapTo = targetChar;
+        if (snapTo < totalChars) {
+          const nextSpace = text.indexOf(" ", snapTo);
+          snapTo = nextSpace === -1 ? totalChars : nextSpace;
+        }
+        setVisibleText(text.slice(0, snapTo));
+        if (progress < 1) {
+          rafRef.current = requestAnimationFrame(tick);
+        } else {
+          setVisibleText(text);
+          setIsRevealing(false);
+          rafRef.current = null;
+        }
+      };
+      rafRef.current = requestAnimationFrame(tick);
+    },
+    [stopReveal]
+  );
+  const reset = react.useCallback(() => {
+    stopReveal();
+    fullTextRef.current = "";
+    setVisibleText("");
+    setIsRevealing(false);
+  }, [stopReveal]);
+  return { visibleText, isRevealing, startReveal, stopReveal, reset };
+}
+const AvatarAnimationContext = react.createContext(null);
+function AvatarAnimationProvider({ children }) {
+  const [currentAnimation, setCurrentAnimation] = react.useState("idle");
+  const [requestId, setRequestId] = react.useState(0);
+  const trigger = react.useCallback((animation) => {
+    setCurrentAnimation(animation);
+    setRequestId((prev) => prev + 1);
+  }, []);
+  const clearAnimation = react.useCallback(() => {
+    setCurrentAnimation("idle");
+    setRequestId((prev) => prev + 1);
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsx(AvatarAnimationContext.Provider, { value: { currentAnimation, requestId, trigger, clearAnimation }, children });
+}
+function useAvatarAnimation() {
+  const ctx = react.useContext(AvatarAnimationContext);
+  if (!ctx) throw new Error("useAvatarAnimation must be used within AvatarAnimationProvider");
+  return ctx;
+}
+const BASE$1 = () => `${getBackendURL()}/${index.PLUGIN_ID}/memories`;
+function headers$1() {
+  const token = getToken();
+  return {
+    "Content-Type": "application/json",
+    ...token ? { Authorization: `Bearer ${token}` } : {}
+  };
+}
+async function request$1(url, init) {
+  const res = await fetch(url, { headers: headers$1(), ...init });
+  if (!res.ok) throw new Error(`Request failed: ${res.status}`);
+  const json = await res.json();
+  return json.data;
+}
+function fetchMemories() {
+  return request$1(BASE$1());
+}
+function createMemory(data) {
+  return request$1(BASE$1(), {
+    method: "POST",
+    body: JSON.stringify(data)
+  });
+}
+function updateMemory(documentId, data) {
+  return request$1(`${BASE$1()}/${documentId}`, {
+    method: "PUT",
+    body: JSON.stringify(data)
+  });
+}
+function deleteMemory(documentId) {
+  return request$1(`${BASE$1()}/${documentId}`, { method: "DELETE" });
+}
+function useMemories() {
+  const [memories, setMemories] = react.useState([]);
+  const [loading, setLoading] = react.useState(true);
+  const load = react.useCallback(async () => {
+    try {
+      const data = await fetchMemories();
+      setMemories(data);
+    } catch (err) {
+      console.error("Failed to load memories:", err);
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  react.useEffect(() => {
+    load();
+  }, [load]);
+  const addMemory = react.useCallback(async (data) => {
+    try {
+      const created = await createMemory(data);
+      setMemories((prev) => [created, ...prev]);
+    } catch (err) {
+      console.error("Failed to create memory:", err);
+    }
+  }, []);
+  const editMemory = react.useCallback(async (documentId, data) => {
+    try {
+      const updated = await updateMemory(documentId, data);
+      setMemories(
+        (prev) => prev.map((m) => m.documentId === documentId ? { ...m, ...updated } : m)
+      );
+    } catch (err) {
+      console.error("Failed to update memory:", err);
+    }
+  }, []);
+  const removeMemory = react.useCallback(async (documentId) => {
+    try {
+      await deleteMemory(documentId);
+      setMemories((prev) => prev.filter((m) => m.documentId !== documentId));
+    } catch (err) {
+      console.error("Failed to delete memory:", err);
+    }
+  }, []);
+  return { memories, loading, addMemory, editMemory, removeMemory, refresh: load };
+}
+function captureRestPose(refs) {
+  return {
+    rootY: refs.root.position.y,
+    hips: refs.hips.quaternion.clone(),
+    head: refs.head.quaternion.clone(),
+    leftArm: refs.leftArm.quaternion.clone(),
+    rightArm: refs.rightArm.quaternion.clone()
+  };
+}
+const _euler = new THREE__namespace.Euler();
+const _quat = new THREE__namespace.Quaternion();
+function applyAdditiveRotation(target, restQ, x, y, z) {
+  _euler.set(x, y, z);
+  _quat.setFromEuler(_euler);
+  target.quaternion.copy(restQ).multiply(_quat);
+}
+const idle = (refs, rest) => {
+  let elapsed = 0;
+  return {
+    update(delta) {
+      elapsed += delta;
+      refs.root.position.y = rest.rootY + Math.sin(elapsed * 1.2) * 0.012;
+      applyAdditiveRotation(
+        refs.head,
+        rest.head,
+        Math.sin(elapsed * 0.5) * 0.06,
+        Math.sin(elapsed * 0.3) * 0.05,
+        Math.sin(elapsed * 0.7) * 0.05
+      );
+      applyAdditiveRotation(
+        refs.leftArm,
+        rest.leftArm,
+        Math.sin(elapsed * 0.3) * 0.015,
+        0,
+        Math.sin(elapsed * 0.4) * 0.01
+      );
+      applyAdditiveRotation(
+        refs.rightArm,
+        rest.rightArm,
+        Math.sin(elapsed * 0.35) * 0.015,
+        0,
+        Math.sin(elapsed * 0.35) * -0.01
+      );
+      return false;
+    },
+    reset() {
+      elapsed = 0;
+      refs.root.position.y = rest.rootY;
+      refs.head.quaternion.copy(rest.head);
+      refs.leftArm.quaternion.copy(rest.leftArm);
+      refs.rightArm.quaternion.copy(rest.rightArm);
+    }
+  };
+};
+const speak = (refs, rest) => {
+  let elapsed = 0;
+  return {
+    update(delta) {
+      elapsed += delta;
+      const env = Math.min(elapsed / 0.5, 1);
+      const nod2 = Math.sin(elapsed * 3.5) * 0.12 * env;
+      const turn = Math.sin(elapsed * 1.8) * 0.1 * env;
+      const tilt = Math.sin(elapsed * 2.3) * 0.06 * env;
+      applyAdditiveRotation(refs.head, rest.head, nod2, turn, tilt);
+      const rz = Math.sin(elapsed * 0.8) * 0.06 * env;
+      const rx = Math.sin(elapsed * 0.6) * 0.04 * env;
+      applyAdditiveRotation(refs.rightArm, rest.rightArm, rx, 0, rz);
+      const lz = Math.sin(elapsed * 0.7 + 1) * 0.04 * env;
+      const lx = Math.sin(elapsed * 0.5 + 0.5) * 0.03 * env;
+      applyAdditiveRotation(refs.leftArm, rest.leftArm, lx, 0, -lz);
+      refs.root.position.y = rest.rootY + Math.sin(elapsed * 2.5) * 8e-3 * env;
+      return false;
+    },
+    reset() {
+      elapsed = 0;
+      refs.root.position.y = rest.rootY;
+      refs.head.quaternion.copy(rest.head);
+      refs.leftArm.quaternion.copy(rest.leftArm);
+      refs.rightArm.quaternion.copy(rest.rightArm);
+    }
+  };
+};
+const wave = (refs, rest) => {
+  let elapsed = 0;
+  const duration = 2.5;
+  return {
+    update(delta) {
+      elapsed += delta;
+      const t = Math.min(elapsed / duration, 1);
+      let rx = 0;
+      let ry = 0;
+      let rz = 0;
+      if (t < 0.2) {
+        const f = t / 0.2;
+        rx = -f * 1.4;
+        rz = f * 1.3;
+      } else if (t < 0.8) {
+        const w = (t - 0.2) / 0.6;
+        rx = -1.4;
+        rz = 1.3;
+        ry = Math.sin(w * Math.PI * 6) * 0.5;
+      } else {
+        const f = 1 - (t - 0.8) / 0.2;
+        rx = -1.4 * f;
+        rz = 1.3 * f;
+      }
+      applyAdditiveRotation(refs.rightArm, rest.rightArm, rx, ry, rz);
+      const headTilt = t < 0.8 ? Math.sin(t * Math.PI * 4) * 0.08 : 0;
+      applyAdditiveRotation(refs.head, rest.head, 0, 0, headTilt);
+      return elapsed >= duration;
+    },
+    reset() {
+      elapsed = 0;
+      refs.rightArm.quaternion.copy(rest.rightArm);
+      refs.head.quaternion.copy(rest.head);
+    }
+  };
+};
+const nod = (refs, rest) => {
+  let elapsed = 0;
+  const duration = 2;
+  return {
+    update(delta) {
+      elapsed += delta;
+      const t = Math.min(elapsed / duration, 1);
+      const env = t > 0.85 ? (1 - t) / 0.15 : 1;
+      applyAdditiveRotation(
+        refs.head,
+        rest.head,
+        Math.sin(t * Math.PI * 6) * 0.18 * env,
+        0,
+        0
+      );
+      return elapsed >= duration;
+    },
+    reset() {
+      elapsed = 0;
+      refs.head.quaternion.copy(rest.head);
+    }
+  };
+};
+const think = (refs, rest) => {
+  let elapsed = 0;
+  const duration = 3.5;
+  return {
+    update(delta) {
+      elapsed += delta;
+      const t = Math.min(elapsed / duration, 1);
+      let hx = 0, hz = 0, ax = 0, az = 0;
+      if (t < 0.2) {
+        const f = t / 0.2;
+        hz = f * 0.2;
+        hx = f * 0.12;
+      } else if (t > 0.8) {
+        const f = 1 - (t - 0.8) / 0.2;
+        hz = 0.2 * f;
+        hx = 0.12 * f;
+      } else {
+        hz = 0.2 + Math.sin(elapsed * 0.8) * 0.03;
+        hx = 0.12;
+      }
+      if (t < 0.2) {
+        const f = t / 0.2;
+        az = -f * 0.6;
+        ax = f * 0.35;
+      } else if (t < 0.8) {
+        const hold = (t - 0.2) / 0.6;
+        az = -0.6 + Math.sin(hold * Math.PI * 2) * 0.06;
+        ax = 0.35;
+      } else {
+        const f = 1 - (t - 0.8) / 0.2;
+        az = -0.6 * f;
+        ax = 0.35 * f;
+      }
+      applyAdditiveRotation(refs.head, rest.head, hx, 0, hz);
+      applyAdditiveRotation(refs.rightArm, rest.rightArm, ax, 0, az);
+      return elapsed >= duration;
+    },
+    reset() {
+      elapsed = 0;
+      refs.head.quaternion.copy(rest.head);
+      refs.rightArm.quaternion.copy(rest.rightArm);
+    }
+  };
+};
+const celebrate = (refs, rest) => {
+  let elapsed = 0;
+  const duration = 3;
+  return {
+    update(delta) {
+      elapsed += delta;
+      const t = Math.min(elapsed / duration, 1);
+      const env = t > 0.8 ? (1 - t) / 0.2 : 1;
+      const bounce = Math.abs(Math.sin(t * Math.PI * 6)) * 0.05 * env;
+      refs.root.position.y = rest.rootY + bounce;
+      let lz = 0, rz = 0;
+      if (t < 0.15) {
+        const f = t / 0.15;
+        lz = f * 1.2;
+        rz = -f * 1.2;
+      } else if (t < 0.8) {
+        const w = (t - 0.15) / 0.65;
+        lz = 1.2 + Math.sin(w * Math.PI * 8) * 0.25;
+        rz = -1.2 - Math.sin(w * Math.PI * 8) * 0.25;
+      } else {
+        const f = 1 - (t - 0.8) / 0.2;
+        lz = 1.2 * f;
+        rz = -1.2 * f;
+      }
+      applyAdditiveRotation(refs.leftArm, rest.leftArm, 0, 0, lz);
+      applyAdditiveRotation(refs.rightArm, rest.rightArm, 0, 0, rz);
+      applyAdditiveRotation(
+        refs.head,
+        rest.head,
+        Math.sin(elapsed * 4) * 0.1 * env,
+        0,
+        Math.sin(elapsed * 3) * 0.06 * env
+      );
+      return elapsed >= duration;
+    },
+    reset() {
+      elapsed = 0;
+      refs.root.position.y = rest.rootY;
+      refs.leftArm.quaternion.copy(rest.leftArm);
+      refs.rightArm.quaternion.copy(rest.rightArm);
+      refs.head.quaternion.copy(rest.head);
+    }
+  };
+};
+const shake = (refs, rest) => {
+  let elapsed = 0;
+  const duration = 1.5;
+  return {
+    update(delta) {
+      elapsed += delta;
+      const t = Math.min(elapsed / duration, 1);
+      const env = t > 0.8 ? (1 - t) / 0.2 : 1;
+      applyAdditiveRotation(
+        refs.head,
+        rest.head,
+        0,
+        Math.sin(t * Math.PI * 6) * 0.3 * env,
+        0
+      );
+      return elapsed >= duration;
+    },
+    reset() {
+      elapsed = 0;
+      refs.head.quaternion.copy(rest.head);
+    }
+  };
+};
+const spin = (refs, rest) => {
+  let elapsed = 0;
+  const duration = 2;
+  return {
+    update(delta) {
+      elapsed += delta;
+      const t = Math.min(elapsed / duration, 1);
+      const ease = t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
+      _euler.set(0, ease * Math.PI * 2, 0);
+      _quat.setFromEuler(_euler);
+      refs.hips.quaternion.copy(rest.hips).multiply(_quat);
+      refs.root.position.y = rest.rootY + Math.sin(t * Math.PI) * 0.03;
+      return elapsed >= duration;
+    },
+    reset() {
+      elapsed = 0;
+      refs.hips.quaternion.copy(rest.hips);
+      refs.root.position.y = rest.rootY;
+    }
+  };
+};
+const animationRegistry = {
+  idle,
+  speak,
+  wave,
+  nod,
+  think,
+  celebrate,
+  shake,
+  spin
+};
+const SKIN = 16769228;
+const SKIN_SHADOW = 15780016;
+const HAIR_MAIN = 5978764;
+const HAIR_HIGHLIGHT = 8278709;
+const SHIRT = 4802047;
+const SHIRT_ACCENT = 7105023;
+const EYE_IRIS = 4491519;
+const EYE_IRIS_INNER = 6728447;
+const EYE_PUPIL = 1710638;
+const EYE_WHITE = 16777215;
+const EYE_HIGHLIGHT = 16777215;
+const CHEEK = 16751001;
+const MOUTH = 14708848;
+const EYEBROW = 3809894;
+function toon(color) {
+  const gradientMap = new THREE__namespace.DataTexture(
+    new Uint8Array([80, 160, 255]),
+    3,
+    1,
+    THREE__namespace.RedFormat
+  );
+  gradientMap.needsUpdate = true;
+  return new THREE__namespace.MeshToonMaterial({ color, gradientMap });
+}
+function basic(color, opts) {
+  return new THREE__namespace.MeshBasicMaterial({ color, ...opts });
+}
+function phong(color, opts) {
+  return new THREE__namespace.MeshPhongMaterial({ color, shininess: 20, ...opts });
+}
+function sphere(r, w = 16, h = 16) {
+  return new THREE__namespace.SphereGeometry(r, w, h);
+}
+function add(parent, geo, mat, pos, scale, rot) {
+  const m = new THREE__namespace.Mesh(geo, mat);
+  if (pos) m.position.set(...pos);
+  if (scale) m.scale.set(...scale);
+  if (rot) m.rotation.set(...rot);
+  parent.add(m);
+  return m;
+}
+function buildEye(parent, x) {
+  const eyeGroup = new THREE__namespace.Group();
+  eyeGroup.position.set(x, 0.04, 0.26);
+  parent.add(eyeGroup);
+  add(eyeGroup, sphere(0.065, 16, 16), basic(EYE_WHITE), void 0, [0.8, 1, 0.5]);
+  add(eyeGroup, sphere(0.048, 16, 16), phong(EYE_IRIS, { shininess: 60 }), [0, -5e-3, 0.025], [0.85, 1, 0.6]);
+  add(eyeGroup, sphere(0.032, 12, 12), phong(EYE_IRIS_INNER, { shininess: 80 }), [0, 5e-3, 0.035], [0.85, 0.9, 0.5]);
+  add(eyeGroup, sphere(0.02, 10, 10), basic(EYE_PUPIL), [0, -5e-3, 0.04], [0.8, 1, 0.5]);
+  add(eyeGroup, sphere(0.015, 8, 8), basic(EYE_HIGHLIGHT), [0.015, 0.02, 0.05]);
+  add(eyeGroup, sphere(8e-3, 6, 6), basic(EYE_HIGHLIGHT), [-0.01, -0.015, 0.05]);
+  add(
+    eyeGroup,
+    new THREE__namespace.TorusGeometry(0.055, 8e-3, 8, 16, Math.PI),
+    basic(EYEBROW),
+    [0, 0.04, 0.02],
+    void 0,
+    [Math.PI, 0, 0]
+  );
+  return eyeGroup;
+}
+function buildPlaceholderModel() {
+  const root = new THREE__namespace.Group();
+  add(root, new THREE__namespace.CylinderGeometry(0.28, 0.24, 0.5, 16), toon(SHIRT), [0, -0.5, 0]);
+  add(root, new THREE__namespace.CylinderGeometry(0.14, 0.28, 0.12, 16), toon(SHIRT_ACCENT), [0, -0.22, 0]);
+  add(root, sphere(0.1, 12, 12), toon(SHIRT), [-0.28, -0.28, 0]);
+  add(root, sphere(0.1, 12, 12), toon(SHIRT), [0.28, -0.28, 0]);
+  add(root, new THREE__namespace.CylinderGeometry(0.07, 0.09, 0.12, 8), toon(SKIN), [0, -0.1, 0]);
+  const head = new THREE__namespace.Group();
+  head.position.set(0, 0.28, 0);
+  root.add(head);
+  add(head, sphere(0.34, 32, 32), toon(SKIN), void 0, [1, 1.05, 0.95]);
+  add(
+    head,
+    sphere(0.2, 16, 16),
+    phong(SKIN_SHADOW, { transparent: true, opacity: 0.3 }),
+    [0, -0.18, 0.12],
+    [1.4, 0.5, 1]
+  );
+  buildEye(head, -0.11);
+  buildEye(head, 0.11);
+  add(
+    head,
+    new THREE__namespace.CapsuleGeometry(0.012, 0.06, 4, 8),
+    basic(EYEBROW),
+    [-0.11, 0.12, 0.28],
+    void 0,
+    [0, 0, 0.15]
+  );
+  add(
+    head,
+    new THREE__namespace.CapsuleGeometry(0.012, 0.06, 4, 8),
+    basic(EYEBROW),
+    [0.11, 0.12, 0.28],
+    void 0,
+    [0, 0, -0.15]
+  );
+  add(head, sphere(0.012, 6, 6), phong(SKIN_SHADOW), [0, -0.04, 0.32]);
+  add(
+    head,
+    new THREE__namespace.TorusGeometry(0.025, 6e-3, 8, 12, Math.PI),
+    basic(MOUTH),
+    [0, -0.1, 0.3],
+    void 0,
+    [0.15, 0, 0]
+  );
+  add(
+    head,
+    sphere(0.04, 8, 8),
+    basic(CHEEK, { transparent: true, opacity: 0.35 }),
+    [-0.19, -0.04, 0.22],
+    [1.3, 0.7, 0.5]
+  );
+  add(
+    head,
+    sphere(0.04, 8, 8),
+    basic(CHEEK, { transparent: true, opacity: 0.35 }),
+    [0.19, -0.04, 0.22],
+    [1.3, 0.7, 0.5]
+  );
+  const hairMat = toon(HAIR_MAIN);
+  const hairHiMat = toon(HAIR_HIGHLIGHT);
+  add(head, sphere(0.36, 24, 24), hairMat, [0, 0.08, -0.06], [1.05, 1, 1]);
+  add(head, sphere(0.28, 20, 20), hairHiMat, [0, 0.22, 0], [1.1, 0.7, 0.95]);
+  add(head, sphere(0.1, 12, 12), hairMat, [-0.18, 0.2, 0.2], [0.9, 0.7, 0.7]);
+  add(head, sphere(0.12, 12, 12), hairHiMat, [-0.06, 0.22, 0.22], [0.8, 0.65, 0.7]);
+  add(head, sphere(0.11, 12, 12), hairMat, [0.08, 0.23, 0.2], [0.85, 0.6, 0.7]);
+  add(head, sphere(0.09, 12, 12), hairHiMat, [0.19, 0.19, 0.18], [0.8, 0.65, 0.65]);
+  add(head, sphere(0.09, 12, 12), hairMat, [-0.3, 0, 0.05], [0.5, 1.4, 0.6]);
+  add(head, sphere(0.08, 12, 12), hairHiMat, [-0.28, -0.15, 0.08], [0.45, 1, 0.55]);
+  add(head, sphere(0.09, 12, 12), hairMat, [0.3, 0, 0.05], [0.5, 1.4, 0.6]);
+  add(head, sphere(0.08, 12, 12), hairHiMat, [0.28, -0.15, 0.08], [0.45, 1, 0.55]);
+  const ahoge = new THREE__namespace.Group();
+  ahoge.position.set(0.02, 0.38, 0.1);
+  ahoge.rotation.set(-0.3, 0, 0.2);
+  head.add(ahoge);
+  add(ahoge, new THREE__namespace.ConeGeometry(0.02, 0.15, 6), hairHiMat, [0, 0.07, 0]);
+  const leftArm = new THREE__namespace.Group();
+  leftArm.position.set(-0.35, -0.3, 0);
+  root.add(leftArm);
+  add(leftArm, new THREE__namespace.CapsuleGeometry(0.06, 0.18, 8, 8), toon(SHIRT), [0, -0.12, 0]);
+  add(leftArm, sphere(0.055, 10, 10), toon(SKIN), [0, -0.28, 0]);
+  const rightArm = new THREE__namespace.Group();
+  rightArm.position.set(0.35, -0.3, 0);
+  root.add(rightArm);
+  add(rightArm, new THREE__namespace.CapsuleGeometry(0.06, 0.18, 8, 8), toon(SHIRT), [0, -0.12, 0]);
+  add(rightArm, sphere(0.055, 10, 10), toon(SKIN), [0, -0.28, 0]);
+  return { scene: root, refs: { root, hips: root, head, leftArm, rightArm } };
+}
+const MODEL_PATH = "/models/avatar.glb";
+function collectSkeletonBones(root) {
+  const bones = [];
+  const seen = /* @__PURE__ */ new Set();
+  root.traverse((child) => {
+    if (child.isSkinnedMesh) {
+      const skeleton = child.skeleton;
+      if (skeleton) {
+        for (const bone of skeleton.bones) {
+          if (!seen.has(bone.id)) {
+            seen.add(bone.id);
+            bones.push(bone);
+          }
+        }
+      }
+    }
+  });
+  return bones;
+}
+function findBone(bones, names) {
+  for (const bone of bones) {
+    if (names.includes(bone.name)) return bone;
+  }
+  for (const bone of bones) {
+    for (const name of names) {
+      if (bone.name.startsWith(name)) return bone;
+    }
+  }
+  const lower = names.map((n) => n.toLowerCase());
+  for (const bone of bones) {
+    const boneLower = bone.name.toLowerCase();
+    for (const name of lower) {
+      if (boneLower.startsWith(name)) return bone;
+    }
+  }
+  return null;
+}
+function extractRefsFromGLTF(model) {
+  const bones = collectSkeletonBones(model);
+  const hips = findBone(bones, [
+    "Hips",
+    "hips",
+    "J_Bip_C_Hips",
+    "mixamorigHips",
+    "Pelvis",
+    "pelvis",
+    "Root",
+    "root"
+  ]);
+  const head = findBone(bones, [
+    "Head",
+    "head",
+    "J_Bip_C_Head",
+    "mixamorigHead"
+  ]);
+  const leftArm = findBone(bones, [
+    "Left arm",
+    "Left_arm",
+    "LeftArm",
+    "leftArm",
+    "J_Bip_L_UpperArm",
+    "mixamorigLeftArm",
+    "arm_L",
+    "Arm.L",
+    "Left shoulder",
+    "Left_shoulder"
+  ]);
+  const rightArm = findBone(bones, [
+    "Right arm",
+    "Right_arm",
+    "RightArm",
+    "rightArm",
+    "J_Bip_R_UpperArm",
+    "mixamorigRightArm",
+    "arm_R",
+    "Arm.R",
+    "Right shoulder",
+    "Right_shoulder"
+  ]);
+  return {
+    root: model,
+    hips: hips ?? model,
+    head: head ?? model,
+    leftArm: leftArm ?? model,
+    rightArm: rightArm ?? model
+  };
+}
+function Avatar3D() {
+  const containerRef = react.useRef(null);
+  const { currentAnimation, requestId, clearAnimation } = useAvatarAnimation();
+  const stateRef = react.useRef(null);
+  react.useEffect(() => {
+    const el = containerRef.current;
+    if (!el) return;
+    const width = el.clientWidth;
+    const height = el.clientHeight;
+    const renderer = new THREE__namespace.WebGLRenderer({ antialias: true });
+    renderer.setSize(width, height);
+    renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+    renderer.toneMapping = THREE__namespace.NoToneMapping;
+    renderer.outputColorSpace = THREE__namespace.SRGBColorSpace;
+    el.appendChild(renderer.domElement);
+    const scene = new THREE__namespace.Scene();
+    scene.background = new THREE__namespace.Color(15263472);
+    const camera = new THREE__namespace.PerspectiveCamera(30, width / height, 0.1, 100);
+    camera.position.set(0, 0.85, -1.8);
+    scene.add(new THREE__namespace.AmbientLight(16777215, 0.7));
+    const keyLight = new THREE__namespace.DirectionalLight(16777215, 0.9);
+    keyLight.position.set(1, 2, 3);
+    scene.add(keyLight);
+    const fillLight = new THREE__namespace.DirectionalLight(14544639, 0.3);
+    fillLight.position.set(-2, 1, -1);
+    scene.add(fillLight);
+    const rimLight = new THREE__namespace.DirectionalLight(11193599, 0.4);
+    rimLight.position.set(0, 1, -3);
+    scene.add(rimLight);
+    const controls = new OrbitControls_js.OrbitControls(camera, renderer.domElement);
+    controls.target.set(0, 0.8, 0);
+    controls.enablePan = false;
+    controls.enableZoom = true;
+    controls.minDistance = 1;
+    controls.maxDistance = 3.5;
+    controls.minPolarAngle = Math.PI / 3;
+    controls.maxPolarAngle = Math.PI / 1.8;
+    controls.minAzimuthAngle = -Math.PI / 6;
+    controls.maxAzimuthAngle = Math.PI / 6;
+    const clock = new THREE__namespace.Clock();
+    function setupAnimations(refs) {
+      const rest = captureRestPose(refs);
+      const idleClip = animationRegistry.idle(refs, rest);
+      const state = {
+        renderer,
+        scene,
+        camera,
+        controls,
+        refs,
+        rest,
+        idleClip,
+        activeClip: null,
+        lastRequestId: -1,
+        animationFrameId: 0,
+        clock
+      };
+      stateRef.current = state;
+      function animate() {
+        state.animationFrameId = requestAnimationFrame(animate);
+        const delta = Math.min(state.clock.getDelta(), 0.1);
+        state.idleClip.update(delta);
+        if (state.activeClip) {
+          const done = state.activeClip.update(delta);
+          if (done) {
+            state.activeClip.reset();
+            state.activeClip = null;
+          }
+        }
+        state.controls.update();
+        renderer.render(scene, camera);
+      }
+      animate();
+    }
+    {
+      const savedCreateImageBitmap = window.createImageBitmap;
+      window.createImageBitmap = void 0;
+      const loader = new GLTFLoader_js.GLTFLoader();
+      loader.load(
+        MODEL_PATH,
+        (gltf) => {
+          const model = gltf.scene;
+          const box = new THREE__namespace.Box3().setFromObject(model);
+          const size = box.getSize(new THREE__namespace.Vector3());
+          const maxDim = Math.max(size.x, size.y, size.z);
+          const scale = 1.2 / maxDim;
+          model.scale.setScalar(scale);
+          model.rotation.y = 0.45;
+          const scaledBox = new THREE__namespace.Box3().setFromObject(model);
+          const center = scaledBox.getCenter(new THREE__namespace.Vector3());
+          model.position.x -= center.x;
+          model.position.z -= center.z;
+          window.createImageBitmap = savedCreateImageBitmap;
+          const wrapper = new THREE__namespace.Group();
+          wrapper.add(model);
+          scene.add(wrapper);
+          const finalBox = new THREE__namespace.Box3().setFromObject(wrapper);
+          const min = finalBox.min;
+          const max = finalBox.max;
+          const modelHeight = max.y - min.y;
+          const faceY = min.y + modelHeight * 0.78;
+          camera.position.set(0, faceY, -modelHeight * 0.9);
+          controls.target.set(0, faceY, 0);
+          controls.update();
+          const refs = extractRefsFromGLTF(model);
+          refs.root = wrapper;
+          refs.hips = wrapper;
+          setupAnimations(refs);
+        },
+        void 0,
+        () => {
+          window.createImageBitmap = savedCreateImageBitmap;
+          console.info("[ai-sdk] No custom avatar found at /models/avatar.glb — using built-in avatar. To use a custom model, place a .glb file at <strapi-project>/public/models/avatar.glb");
+          const { scene: model, refs } = buildPlaceholderModel();
+          scene.add(model);
+          setupAnimations(refs);
+        }
+      );
+    }
+    const observer = new ResizeObserver(() => {
+      const w = el.clientWidth;
+      const h = el.clientHeight;
+      camera.aspect = w / h;
+      camera.updateProjectionMatrix();
+      renderer.setSize(w, h);
+    });
+    observer.observe(el);
+    return () => {
+      observer.disconnect();
+      const s = stateRef.current;
+      if (s) cancelAnimationFrame(s.animationFrameId);
+      controls.dispose();
+      renderer.dispose();
+      if (el.contains(renderer.domElement)) el.removeChild(renderer.domElement);
+      stateRef.current = null;
+    };
+  }, []);
+  react.useEffect(() => {
+    const state = stateRef.current;
+    if (!state || requestId === state.lastRequestId) return;
+    state.lastRequestId = requestId;
+    if (state.activeClip) {
+      state.activeClip.reset();
+      state.activeClip = null;
+    }
+    if (currentAnimation !== "idle") {
+      const factory = animationRegistry[currentAnimation];
+      if (factory) {
+        state.activeClip = factory(state.refs, state.rest);
+      }
+    }
+  }, [currentAnimation, requestId]);
+  react.useEffect(() => {
+    if (currentAnimation === "idle") return;
+    const interval = setInterval(() => {
+      const state = stateRef.current;
+      if (state && state.activeClip === null) clearAnimation();
+    }, 100);
+    return () => clearInterval(interval);
+  }, [currentAnimation, clearAnimation]);
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { ref: containerRef, style: { width: "100%", height: "100%" } });
+}
+const Panel = styled__default.default.div`
+  width: 280px;
+  min-width: 280px;
+  border-right: 1px solid #eaeaef;
+  background: linear-gradient(180deg, #f0f0ff 0%, #f6f6f9 100%);
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  padding-top: 24px;
+  gap: 12px;
+`;
+const AvatarContainer = styled__default.default.div`
+  width: 250px;
+  height: 300px;
+  border-radius: 16px;
+  overflow: hidden;
+  background: linear-gradient(180deg, #e8e8ff 0%, #f0f0f8 100%);
+  box-shadow: 0 2px 8px rgba(73, 69, 255, 0.1);
+`;
+const Label = styled__default.default.div`
+  font-size: 13px;
+  font-weight: 600;
+  color: #666687;
+  letter-spacing: 0.5px;
+  text-transform: uppercase;
+`;
+function AvatarPanel() {
+  return /* @__PURE__ */ jsxRuntime.jsxs(Panel, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(AvatarContainer, { children: /* @__PURE__ */ jsxRuntime.jsx(Avatar3D, {}) }),
+    /* @__PURE__ */ jsxRuntime.jsx(Label, { children: "AI Assistant" })
+  ] });
+}
+const SidebarRoot = styled__default.default.div`
+  width: ${({ $open }) => $open ? "260px" : "0px"};
+  min-width: ${({ $open }) => $open ? "260px" : "0px"};
+  display: flex;
+  flex-direction: column;
+  border-right: ${({ $open, theme }) => $open ? `1px solid ${theme.colors.neutral200}` : "none"};
+  background: ${({ theme }) => theme.colors.neutral100};
+  overflow: hidden;
+  transition: width 0.2s ease, min-width 0.2s ease;
+`;
+const NewChatButton = styled__default.default.button`
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  width: 100%;
+  padding: 8px 12px;
+  border: 1px solid ${({ theme }) => theme.colors.neutral200};
+  border-radius: 4px;
+  background: ${({ theme }) => theme.colors.neutral0};
+  color: ${({ theme }) => theme.colors.neutral800};
+  font-size: 14px;
+  font-weight: 500;
+  cursor: pointer;
+
+  &:hover {
+    background: ${({ theme }) => theme.colors.neutral100};
+  }
+
+  svg {
+    width: 16px;
+    height: 16px;
+  }
+`;
+const ConversationList = styled__default.default.div`
+  flex: 1;
+  overflow-y: auto;
+`;
+const ConversationItem = styled__default.default.button`
+  width: 100%;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 10px 12px;
+  border: none;
+  background: ${({ $active, theme }) => $active ? theme.colors.neutral200 : "transparent"};
+  cursor: pointer;
+  text-align: left;
+
+  &:hover {
+    background: ${({ theme }) => theme.colors.neutral200};
+  }
+
+  &:hover .delete-btn {
+    opacity: 1;
+  }
+`;
+const DeleteBtn$1 = styled__default.default.button`
+  opacity: 0;
+  transition: opacity 0.15s;
+  flex-shrink: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 24px;
+  height: 24px;
+  padding: 0;
+  border: none;
+  border-radius: 4px;
+  background: transparent;
+  color: ${({ theme }) => theme.colors.neutral600};
+  cursor: pointer;
+
+  &:hover {
+    background: ${({ theme }) => theme.colors.neutral300};
+    color: ${({ theme }) => theme.colors.danger600};
+  }
+
+  svg {
+    width: 14px;
+    height: 14px;
+  }
+`;
+const TitleText = styled__default.default(designSystem.Typography)`
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  flex: 1;
+  min-width: 0;
+`;
+function ConversationSidebar({
+  conversations,
+  activeId,
+  open,
+  onSelect,
+  onNew,
+  onDelete
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(SidebarRoot, { $open: open, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { padding: 3, children: /* @__PURE__ */ jsxRuntime.jsxs(NewChatButton, { onClick: onNew, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(icons.Plus, {}),
+      "New Chat"
+    ] }) }),
+    /* @__PURE__ */ jsxRuntime.jsxs(ConversationList, { children: [
+      conversations.map((conv) => /* @__PURE__ */ jsxRuntime.jsxs(
+        ConversationItem,
+        {
+          $active: conv.documentId === activeId,
+          onClick: () => onSelect(conv.documentId),
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(TitleText, { variant: "omega", textColor: "neutral800", children: conv.title }),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              DeleteBtn$1,
+              {
+                className: "delete-btn",
+                onClick: (e) => {
+                  e.stopPropagation();
+                  onDelete(conv.documentId);
+                },
+                "aria-label": "Delete conversation",
+                children: /* @__PURE__ */ jsxRuntime.jsx(icons.Trash, {})
+              }
+            )
+          ]
+        },
+        conv.documentId
+      )),
+      conversations.length === 0 && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { padding: 4, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "omega", textColor: "neutral500", children: "No conversations yet" }) })
+    ] })
+  ] });
+}
+const PanelRoot = styled__default.default.div`
+  width: ${({ $open }) => $open ? "280px" : "0px"};
+  min-width: ${({ $open }) => $open ? "280px" : "0px"};
+  display: flex;
+  flex-direction: column;
+  border-left: ${({ $open, theme }) => $open ? `1px solid ${theme.colors.neutral200}` : "none"};
+  background: ${({ theme }) => theme.colors.neutral100};
+  overflow: hidden;
+  transition: width 0.2s ease, min-width 0.2s ease;
+`;
+const PanelHeader = styled__default.default.div`
+  padding: 12px 16px;
+  border-bottom: 1px solid ${({ theme }) => theme.colors.neutral200};
+`;
+const MemoryList = styled__default.default.div`
+  flex: 1;
+  overflow-y: auto;
+  padding: 8px 0;
+`;
+const MemoryItem = styled__default.default.div`
+  display: flex;
+  align-items: flex-start;
+  gap: 8px;
+  padding: 8px 16px;
+
+  &:hover .memory-delete {
+    opacity: 1;
+  }
+`;
+const MemoryContent = styled__default.default.div`
+  flex: 1;
+  min-width: 0;
+`;
+const CategoryBadge = styled__default.default.span`
+  display: inline-block;
+  font-size: 11px;
+  padding: 1px 6px;
+  border-radius: 3px;
+  background: ${({ theme }) => theme.colors.neutral200};
+  color: ${({ theme }) => theme.colors.neutral600};
+  margin-bottom: 2px;
+`;
+const DeleteBtn = styled__default.default.button`
+  opacity: 0;
+  transition: opacity 0.15s;
+  flex-shrink: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 22px;
+  height: 22px;
+  margin-top: 2px;
+  padding: 0;
+  border: none;
+  border-radius: 4px;
+  background: transparent;
+  color: ${({ theme }) => theme.colors.neutral500};
+  cursor: pointer;
+
+  &:hover {
+    background: ${({ theme }) => theme.colors.neutral300};
+    color: ${({ theme }) => theme.colors.danger600};
+  }
+
+  svg {
+    width: 12px;
+    height: 12px;
+  }
+`;
+function MemoryPanel({ memories, open, onDelete }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(PanelRoot, { $open: open, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(PanelHeader, { children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { variant: "sigma", textColor: "neutral600", children: [
+      "MEMORIES (",
+      memories.length,
+      ")"
+    ] }) }),
+    /* @__PURE__ */ jsxRuntime.jsxs(MemoryList, { children: [
+      memories.map((mem) => /* @__PURE__ */ jsxRuntime.jsxs(MemoryItem, { children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(MemoryContent, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(CategoryBadge, { children: mem.category }),
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "omega", textColor: "neutral800", style: { display: "block" }, children: mem.content })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          DeleteBtn,
+          {
+            className: "memory-delete",
+            onClick: () => onDelete(mem.documentId),
+            "aria-label": "Delete memory",
+            children: /* @__PURE__ */ jsxRuntime.jsx(icons.Trash, {})
+          }
+        )
+      ] }, mem.documentId)),
+      memories.length === 0 && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { padding: 4, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "omega", textColor: "neutral500", children: "No memories saved yet. The AI will save facts about you as you chat." }) })
+    ] })
+  ] });
+}
+function buildContentManagerUrl(contentType, documentId) {
+  const base = `/content-manager/collection-types/${contentType}`;
+  return documentId ? `${base}/${documentId}` : base;
+}
+function extractContentLinks(toolCall) {
+  if (toolCall.output === void 0) return [];
+  const input = toolCall.input;
+  const output = toolCall.output;
+  if (!input || !output) return [];
+  const contentType = input.contentType;
+  if (!contentType) return [];
+  if (toolCall.toolName === "searchContent") {
+    const results = output.results;
+    const links = [
+      { label: contentType, to: buildContentManagerUrl(contentType) }
+    ];
+    if (results && results.length > 0) {
+      for (const entry of results.slice(0, 5)) {
+        const docId = entry.documentId;
+        if (!docId) continue;
+        const title = entry.title || entry.name || entry.slug || docId;
+        links.push({
+          label: String(title),
+          to: buildContentManagerUrl(contentType, docId)
+        });
+      }
+    }
+    return links;
+  }
+  if (toolCall.toolName === "writeContent") {
+    const doc = output.document;
+    const docId = doc?.documentId;
+    if (docId) {
+      const title = doc?.title || doc?.name || docId;
+      return [
+        {
+          label: `${input.action === "create" ? "Created" : "Updated"}: ${title}`,
+          to: buildContentManagerUrl(contentType, docId)
+        }
+      ];
+    }
+    return [{ label: contentType, to: buildContentManagerUrl(contentType) }];
+  }
+  return [];
+}
+const ToolCallBox = styled__default.default.div`
+  margin-top: 8px;
+  border: 1px solid #dcdce4;
+  border-radius: 8px;
+  overflow: hidden;
+  font-size: 13px;
+`;
+const ToolCallHeader = styled__default.default.button`
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  width: 100%;
+  padding: 8px 12px;
+  background: #eaeaef;
+  border: none;
+  cursor: pointer;
+  font-size: 12px;
+  font-weight: 600;
+  color: #32324d;
+  text-align: left;
+
+  &:hover {
+    background: #dcdce4;
+  }
+`;
+const ToolCallContent = styled__default.default.pre`
+  margin: 0;
+  padding: 8px 12px;
+  background: #fafafa;
+  font-size: 11px;
+  line-height: 1.4;
+  overflow-x: auto;
+  max-height: 200px;
+  overflow-y: auto;
+  white-space: pre-wrap;
+  word-break: break-word;
+`;
+const ContentLinksRow = styled__default.default.div`
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+  padding: 6px 12px;
+  background: #f6f6f9;
+  border-top: 1px solid #eaeaef;
+`;
+const ContentLinkChip = styled__default.default(reactRouterDom.Link)`
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  padding: 2px 8px;
+  border-radius: 4px;
+  background: #dcdce4;
+  color: #4945ff;
+  font-size: 11px;
+  font-weight: 500;
+  text-decoration: none;
+  white-space: nowrap;
+  max-width: 200px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+
+  &:hover {
+    background: #c0c0cf;
+  }
+`;
+const HIDDEN_TOOLS = /* @__PURE__ */ new Set(["triggerAnimation"]);
+function ToolCallDisplay({ toolCall }) {
+  const [expanded, setExpanded] = react.useState(false);
+  const contentLinks = extractContentLinks(toolCall);
+  return /* @__PURE__ */ jsxRuntime.jsxs(ToolCallBox, { children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(ToolCallHeader, { onClick: () => setExpanded(!expanded), children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { children: expanded ? "▼" : "▶" }),
+      /* @__PURE__ */ jsxRuntime.jsxs("span", { children: [
+        "Tool: ",
+        toolCall.toolName
+      ] }),
+      toolCall.output !== void 0 && /* @__PURE__ */ jsxRuntime.jsx("span", { style: { marginLeft: "auto", fontWeight: 400, opacity: 0.6 }, children: "completed" })
+    ] }),
+    contentLinks.length > 0 && /* @__PURE__ */ jsxRuntime.jsx(ContentLinksRow, { children: contentLinks.map((link) => /* @__PURE__ */ jsxRuntime.jsx(ContentLinkChip, { to: link.to, children: link.label }, link.to)) }),
+    expanded && /* @__PURE__ */ jsxRuntime.jsx(ToolCallContent, { children: toolCall.output === void 0 ? "Waiting for result..." : JSON.stringify(toolCall.output, null, 2) })
+  ] });
+}
+const waifuAvatar = "data:image/png;base64,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";
+const MessagesArea = styled__default.default.div`
+  flex: 1;
+  overflow-y: auto;
+  scroll-behavior: smooth;
+  padding: 24px;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+`;
+const MessageRow = styled__default.default.div`
+  display: flex;
+  align-items: flex-end;
+  gap: 8px;
+  align-self: ${({ $isUser }) => $isUser ? "flex-end" : "flex-start"};
+  max-width: 80%;
+`;
+const Avatar = styled__default.default.img`
+  width: 104px;
+  height: 104px;
+  border-radius: 50%;
+  object-fit: cover;
+  flex-shrink: 0;
+`;
+const MessageBubble = styled__default.default.div`
+  min-width: 0;
+  background-color: ${({ $isUser }) => $isUser ? "#4945ff" : "#f6f6f9"};
+  color: ${({ $isUser }) => $isUser ? "#ffffff" : "#32324d"};
+  border-radius: ${({ $isUser }) => $isUser ? "16px 16px 4px 16px" : "16px 16px 16px 4px"};
+  padding: 12px 16px;
+  font-size: 15px;
+  word-break: break-word;
+  line-height: 1.6;
+`;
+const MarkdownBody = styled__default.default.div`
+  p { margin: 0 0 8px; &:last-child { margin-bottom: 0; } }
+  ul, ol { margin: 4px 0; padding-left: 20px; }
+  li { margin: 2px 0; }
+  code {
+    font-size: 0.85em;
+    padding: 1px 4px;
+    border-radius: 3px;
+    background: ${({ $isUser }) => $isUser ? "rgba(255,255,255,0.15)" : "rgba(0,0,0,0.06)"};
+  }
+  pre {
+    margin: 8px 0;
+    padding: 8px 10px;
+    border-radius: 6px;
+    overflow-x: auto;
+    font-size: 0.85em;
+    background: ${({ $isUser }) => $isUser ? "rgba(255,255,255,0.1)" : "rgba(0,0,0,0.04)"};
+    code { padding: 0; background: none; }
+  }
+  h1, h2, h3, h4 { margin: 12px 0 4px; &:first-child { margin-top: 0; } }
+  h1 { font-size: 1.3em; } h2 { font-size: 1.15em; } h3 { font-size: 1.05em; }
+  blockquote {
+    margin: 8px 0;
+    padding-left: 12px;
+    border-left: 3px solid ${({ $isUser }) => $isUser ? "rgba(255,255,255,0.3)" : "#dcdce4"};
+    opacity: 0.85;
+  }
+  a { color: ${({ $isUser }) => $isUser ? "#c0cfff" : "#4945ff"}; }
+  table { border-collapse: collapse; margin: 8px 0; font-size: 0.9em; }
+  th, td { border: 1px solid ${({ $isUser }) => $isUser ? "rgba(255,255,255,0.2)" : "#dcdce4"}; padding: 4px 8px; }
+`;
+const MessageRole = styled__default.default.div`
+  font-size: 11px;
+  font-weight: 600;
+  margin-bottom: 4px;
+  opacity: 0.7;
+  color: ${({ $isUser }) => $isUser ? "#ffffff" : "#666687"};
+`;
+const TypingDots = styled__default.default.span`
+  display: inline-flex;
+  gap: 4px;
+
+  span {
+    width: 7px;
+    height: 7px;
+    border-radius: 50%;
+    background: #a5a5ba;
+    animation: bounce 1.4s infinite ease-in-out both;
+  }
+  span:nth-child(1) { animation-delay: 0s; }
+  span:nth-child(2) { animation-delay: 0.2s; }
+  span:nth-child(3) { animation-delay: 0.4s; }
+
+  @keyframes bounce {
+    0%, 80%, 100% { transform: scale(0.4); opacity: 0.4; }
+    40% { transform: scale(1); opacity: 1; }
+  }
+`;
+const EmptyState = styled__default.default.div`
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  flex: 1;
+  color: #a5a5ba;
+`;
+const CONTENT_TYPE_UID_RE = /\b(api::\w[\w-]*\.\w[\w-]*)\b/g;
+function autoLinkContentTypeUids(text) {
+  return text.replace(
+    CONTENT_TYPE_UID_RE,
+    (match) => `[${match}](/content-manager/collection-types/${match})`
+  );
+}
+function isInternalPath(href) {
+  return href.startsWith("/content-manager/");
+}
+function MarkdownLink({
+  href,
+  children,
+  ...props
+}) {
+  if (href && isInternalPath(href)) {
+    return /* @__PURE__ */ jsxRuntime.jsx(reactRouterDom.Link, { to: href, ...props, children });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("a", { href, target: "_blank", rel: "noopener noreferrer", ...props, children });
+}
+const markdownComponents = {
+  a: MarkdownLink
+};
+const MessageList = react.forwardRef(
+  function MessageList2({ messages, isLoading, awaitingAudio, voiceEnabled, visibleText }, ref) {
+    return /* @__PURE__ */ jsxRuntime.jsxs(MessagesArea, { children: [
+      messages.length === 0 && /* @__PURE__ */ jsxRuntime.jsxs(EmptyState, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "beta", textColor: "neutral400", children: "AI Chat" }),
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingTop: 2, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "omega", textColor: "neutral500", children: "Send a message to start the conversation" }) })
+      ] }),
+      messages.map((message, index2) => {
+        const isLatestAssistant = message.role === "assistant" && index2 === messages.length - 1;
+        const rawContent = voiceEnabled && isLatestAssistant && (awaitingAudio || visibleText) ? visibleText : message.content;
+        const displayContent = message.role === "assistant" && rawContent ? autoLinkContentTypeUids(rawContent) : rawContent;
+        return /* @__PURE__ */ jsxRuntime.jsxs(MessageRow, { $isUser: message.role === "user", children: [
+          message.role === "assistant" && /* @__PURE__ */ jsxRuntime.jsx(Avatar, { src: waifuAvatar, alt: "Assistant" }),
+          /* @__PURE__ */ jsxRuntime.jsxs(MessageBubble, { $isUser: message.role === "user", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(MessageRole, { $isUser: message.role === "user", children: message.role === "user" ? "You" : "Assistant" }),
+            message.role === "user" && message.content,
+            message.role === "assistant" && displayContent && /* @__PURE__ */ jsxRuntime.jsx(MarkdownBody, { $isUser: false, children: /* @__PURE__ */ jsxRuntime.jsx(Markdown__default.default, { components: markdownComponents, children: displayContent }) }),
+            message.role === "assistant" && !displayContent && (isLoading || awaitingAudio) && /* @__PURE__ */ jsxRuntime.jsxs(TypingDots, { children: [
+              /* @__PURE__ */ jsxRuntime.jsx("span", {}),
+              /* @__PURE__ */ jsxRuntime.jsx("span", {}),
+              /* @__PURE__ */ jsxRuntime.jsx("span", {})
+            ] }),
+            message.toolCalls?.filter((tc) => !HIDDEN_TOOLS.has(tc.toolName)).map((tc) => /* @__PURE__ */ jsxRuntime.jsx(ToolCallDisplay, { toolCall: tc }, tc.toolCallId))
+          ] })
+        ] }, message.id);
+      }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { ref })
+    ] });
+  }
+);
+const InputArea = styled__default.default.div`
+  display: flex;
+  gap: 8px;
+  align-items: flex-end;
+  padding: 16px;
+  border-top: 1px solid #eaeaef;
+`;
+const VoiceToggle = styled__default.default.button`
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 40px;
+  height: 40px;
+  border-radius: 8px;
+  border: 1px solid ${({ $active }) => $active ? "#4945ff" : "#dcdce4"};
+  background: ${({ $active }) => $active ? "#f0f0ff" : "#ffffff"};
+  color: ${({ $active }) => $active ? "#4945ff" : "#a5a5ba"};
+  cursor: pointer;
+  flex-shrink: 0;
+  transition: all 0.15s ease;
+
+  &:hover {
+    border-color: #4945ff;
+    color: #4945ff;
+  }
+
+  svg {
+    width: 18px;
+    height: 18px;
+  }
+`;
+function ChatInput({
+  input,
+  isLoading,
+  voiceEnabled,
+  onInputChange,
+  onSend,
+  onToggleVoice
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "form",
+    {
+      onSubmit: (e) => {
+        e.preventDefault();
+        onSend();
+      },
+      children: /* @__PURE__ */ jsxRuntime.jsxs(InputArea, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { flex: "1", children: /* @__PURE__ */ jsxRuntime.jsx(
+          designSystem.TextInput,
+          {
+            placeholder: "Type your message...",
+            "aria-label": "Chat message",
+            value: input,
+            onChange: (e) => onInputChange(e.target.value)
+          }
+        ) }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          VoiceToggle,
+          {
+            type: "button",
+            onClick: onToggleVoice,
+            title: voiceEnabled ? "Disable voice" : "Enable voice",
+            $active: voiceEnabled,
+            children: voiceEnabled ? /* @__PURE__ */ jsxRuntime.jsx(icons.VolumeUp, {}) : /* @__PURE__ */ jsxRuntime.jsx(icons.VolumeMute, {})
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          designSystem.Button,
+          {
+            type: "submit",
+            disabled: isLoading || !input.trim(),
+            loading: isLoading,
+            size: "L",
+            startIcon: /* @__PURE__ */ jsxRuntime.jsx(icons.Sparkle, {}),
+            children: "Send"
+          }
+        )
+      ] })
+    }
+  );
+}
+const ChatLayout = styled__default.default.div`
+  display: flex;
+  flex-direction: row;
+  height: calc(100vh - 200px);
+  min-height: 400px;
+  border-radius: 4px;
+  overflow: hidden;
+  box-shadow: 0 1px 4px rgba(33, 33, 52, 0.1);
+  background: #ffffff;
+`;
+const ChatWrapper = styled__default.default.div`
+  display: flex;
+  flex-direction: column;
+  flex: 1;
+  min-width: 0;
+`;
+const ToggleSidebarBtn = styled__default.default.button`
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 32px;
+  height: 32px;
+  border: 1px solid #dcdce4;
+  border-radius: 4px;
+  background: #ffffff;
+  color: #666687;
+  cursor: pointer;
+  flex-shrink: 0;
+
+  &:hover {
+    background: #f0f0ff;
+    color: #4945ff;
+    border-color: #4945ff;
+  }
+
+  svg {
+    width: 16px;
+    height: 16px;
+  }
+`;
+const ChatTopBar = styled__default.default.div`
+  display: flex;
+  align-items: center;
+  padding: 8px 16px;
+  border-bottom: 1px solid #eaeaef;
+  gap: 8px;
+`;
+function Chat() {
+  const navigate = reactRouterDom.useNavigate();
+  const [input, setInput] = react.useState("");
+  const [sidebarOpen, setSidebarOpen] = react.useState(false);
+  const [memoryPanelOpen, setMemoryPanelOpen] = react.useState(false);
+  const [voiceEnabled, setVoiceEnabled] = react.useState(false);
+  const [awaitingAudio, setAwaitingAudio] = react.useState(false);
+  const messagesEndRef = react.useRef(null);
+  const fullTextRef = react.useRef("");
+  const voiceRef = react.useRef(voiceEnabled);
+  voiceRef.current = voiceEnabled;
+  const prevIsLoadingRef = react.useRef(false);
+  const { trigger, clearAnimation } = useAvatarAnimation();
+  const { visibleText, startReveal, reset: resetReveal } = useTextReveal();
+  const { speak: speak2, stop: stopAudio } = useAudioPlayer({
+    onPlayStart: (duration) => {
+      trigger("speak");
+      startReveal(fullTextRef.current, duration);
+      setAwaitingAudio(false);
+    },
+    onPlayEnded: () => clearAnimation()
+  });
+  const {
+    conversations,
+    activeId,
+    initialMessages,
+    selectConversation,
+    startNewConversation,
+    saveMessages,
+    removeConversation
+  } = useConversations();
+  const { memories, removeMemory, refresh: refreshMemories } = useMemories();
+  const { messages, sendMessage, isLoading, error } = useChat({
+    initialMessages,
+    conversationId: activeId,
+    onAnimationTrigger: trigger,
+    onStreamEnd: (fullText) => {
+      if (!voiceRef.current) return;
+      fullTextRef.current = fullText;
+      if (!fullText) {
+        setAwaitingAudio(false);
+        clearAnimation();
+      } else {
+        speak2(fullText);
+      }
+    }
+  });
+  react.useEffect(() => {
+    if (prevIsLoadingRef.current && !isLoading && messages.length > 0) {
+      saveMessages(messages);
+      refreshMemories();
+    }
+    prevIsLoadingRef.current = isLoading;
+  }, [isLoading, messages, saveMessages, refreshMemories]);
+  const handleSend = () => {
+    if (!input.trim() || isLoading) return;
+    if (voiceEnabled) {
+      fullTextRef.current = "";
+      resetReveal();
+      setAwaitingAudio(true);
+    }
+    sendMessage(input);
+    setInput("");
+  };
+  const handleToggleVoice = () => {
+    const next = !voiceEnabled;
+    setVoiceEnabled(next);
+    if (!next) {
+      stopAudio();
+      resetReveal();
+      setAwaitingAudio(false);
+      clearAnimation();
+    }
+  };
+  react.useEffect(() => {
+    messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
+  }, [messages, visibleText]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(ChatLayout, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      ConversationSidebar,
+      {
+        conversations,
+        activeId,
+        open: sidebarOpen,
+        onSelect: selectConversation,
+        onNew: startNewConversation,
+        onDelete: removeConversation
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(AvatarPanel, {}),
+    /* @__PURE__ */ jsxRuntime.jsxs(ChatWrapper, { children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(ChatTopBar, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          ToggleSidebarBtn,
+          {
+            onClick: () => setSidebarOpen((prev) => !prev),
+            "aria-label": sidebarOpen ? "Hide conversations" : "Show conversations",
+            children: /* @__PURE__ */ jsxRuntime.jsxs("svg", { viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", children: [
+              /* @__PURE__ */ jsxRuntime.jsx("rect", { x: "1", y: "2", width: "14", height: "12", rx: "1.5" }),
+              /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "5.5", y1: "2", x2: "5.5", y2: "14" })
+            ] })
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          ToggleSidebarBtn,
+          {
+            onClick: () => navigate(`/plugins/${index.PLUGIN_ID}/memory-store`),
+            "aria-label": "Memory Store",
+            children: /* @__PURE__ */ jsxRuntime.jsx("svg", { viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M2 4h12M2 8h12M2 12h8" }) })
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          ToggleSidebarBtn,
+          {
+            onClick: () => navigate(`/plugins/${index.PLUGIN_ID}/public-memory-store`),
+            "aria-label": "Public Memory Store",
+            children: /* @__PURE__ */ jsxRuntime.jsxs("svg", { viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", children: [
+              /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "8", cy: "8", r: "6" }),
+              /* @__PURE__ */ jsxRuntime.jsx("ellipse", { cx: "8", cy: "8", rx: "2.5", ry: "6" }),
+              /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M2 8h12" })
+            ] })
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          ToggleSidebarBtn,
+          {
+            onClick: () => navigate(`/plugins/${index.PLUGIN_ID}/widget-preview`),
+            "aria-label": "Widget Preview",
+            children: /* @__PURE__ */ jsxRuntime.jsxs("svg", { viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", children: [
+              /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "4 4 8 2 12 4" }),
+              /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "4 4 4 10 8 12 12 10 12 4" }),
+              /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "8", y1: "2", x2: "8", y2: "12" })
+            ] })
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { style: { flex: 1 } }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          ToggleSidebarBtn,
+          {
+            onClick: () => setMemoryPanelOpen((prev) => !prev),
+            "aria-label": memoryPanelOpen ? "Hide memories" : "Show memories",
+            children: /* @__PURE__ */ jsxRuntime.jsxs("svg", { viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", children: [
+              /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "8", cy: "6", r: "4" }),
+              /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M4 10.5C4 10.5 5 14 8 14s4-3.5 4-3.5" })
+            ] })
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        MessageList,
+        {
+          ref: messagesEndRef,
+          messages,
+          isLoading,
+          awaitingAudio,
+          voiceEnabled,
+          visibleText
+        }
+      ),
+      error && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { padding: 3, background: "danger100", marginLeft: 4, marginRight: 4, children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { textColor: "danger600", children: [
+        "Error: ",
+        error
+      ] }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        ChatInput,
+        {
+          input,
+          isLoading,
+          voiceEnabled,
+          onInputChange: setInput,
+          onSend: handleSend,
+          onToggleVoice: handleToggleVoice
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      MemoryPanel,
+      {
+        memories,
+        open: memoryPanelOpen,
+        onDelete: removeMemory
+      }
+    )
+  ] });
+}
+const HomePage = () => {
+  return /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Main, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      admin.Layouts.Header,
+      {
+        title: "AI Chat",
+        subtitle: "Chat with AI powered by Vercel AI SDK"
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(admin.Layouts.Content, { children: /* @__PURE__ */ jsxRuntime.jsx(AvatarAnimationProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(Chat, {}) }) })
+  ] });
+};
+const PAGE_SIZE$1 = 10;
+const ActionBtn$1 = styled__default.default.button`
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 32px;
+  height: 32px;
+  padding: 0;
+  border: none;
+  border-radius: 4px;
+  background: transparent;
+  color: ${({ theme }) => theme.colors.neutral600};
+  cursor: pointer;
+
+  &:hover {
+    background: ${({ theme }) => theme.colors.neutral200};
+    color: ${({ theme }) => theme.colors.primary600};
+  }
+
+  svg {
+    width: 16px;
+    height: 16px;
+  }
+`;
+const DeleteActionBtn$1 = styled__default.default(ActionBtn$1)`
+  &:hover {
+    color: ${({ theme }) => theme.colors.danger600};
+  }
+`;
+const WideModalContent$1 = styled__default.default(designSystem.Modal.Content)`
+  max-width: 680px;
+  width: 100%;
+`;
+function formatDate$1(iso) {
+  return new Date(iso).toLocaleDateString(void 0, {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+function MemoryModal({ memory, open, onClose, onSave }) {
+  const [content, setContent] = react.useState("");
+  const [category, setCategory] = react.useState("general");
+  const isEdit = memory !== null;
+  react.useEffect(() => {
+    if (open && memory) {
+      setContent(memory.content);
+      setCategory(memory.category);
+    } else if (open) {
+      setContent("");
+      setCategory("general");
+    }
+  }, [open, memory]);
+  const handleClose = () => {
+    setContent("");
+    setCategory("general");
+    onClose();
+  };
+  const handleSave = () => {
+    if (!content.trim()) return;
+    onSave({ content, category }, memory?.documentId);
+    handleClose();
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Root, { open, onOpenChange: (isOpen) => !isOpen && handleClose(), children: /* @__PURE__ */ jsxRuntime.jsxs(WideModalContent$1, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Header, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Title, { children: isEdit ? "Edit Memory" : "Add Memory" }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Body, { children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { direction: "column", gap: 5, width: "100%", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Field.Root, { width: "100%", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Label, { children: "Content" }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          designSystem.Textarea,
+          {
+            placeholder: "A fact or preference to remember (e.g. 'User prefers dark mode')",
+            value: content,
+            onChange: (e) => setContent(e.target.value),
+            style: { width: "100%", minHeight: "120px" }
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Field.Root, { width: "100%", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Label, { children: "Category" }),
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          designSystem.SingleSelect,
+          {
+            value: category,
+            onChange: (value) => setCategory(value),
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(designSystem.SingleSelectOption, { value: "general", children: "General" }),
+              /* @__PURE__ */ jsxRuntime.jsx(designSystem.SingleSelectOption, { value: "preference", children: "Preference" }),
+              /* @__PURE__ */ jsxRuntime.jsx(designSystem.SingleSelectOption, { value: "personal", children: "Personal" }),
+              /* @__PURE__ */ jsxRuntime.jsx(designSystem.SingleSelectOption, { value: "project", children: "Project" })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Hint, { children: "Used to organize memories by topic" })
+      ] })
+    ] }) }),
+    /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Modal.Footer, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Close, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { variant: "tertiary", children: "Cancel" }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { onClick: handleSave, disabled: !content.trim(), children: isEdit ? "Save changes" : "Add memory" })
+    ] })
+  ] }) });
+}
+const MemoryStorePage = () => {
+  const navigate = reactRouterDom.useNavigate();
+  const { memories, loading, addMemory, editMemory, removeMemory } = useMemories();
+  const [search, setSearch] = react.useState("");
+  const [page, setPage] = react.useState(1);
+  const [modalOpen, setModalOpen] = react.useState(false);
+  const [editingMemory, setEditingMemory] = react.useState(null);
+  const filtered = react.useMemo(() => {
+    if (!search.trim()) return memories;
+    const q = search.toLowerCase();
+    return memories.filter(
+      (m) => m.content.toLowerCase().includes(q) || m.category.toLowerCase().includes(q)
+    );
+  }, [memories, search]);
+  const pageCount = Math.max(1, Math.ceil(filtered.length / PAGE_SIZE$1));
+  const paginated = filtered.slice((page - 1) * PAGE_SIZE$1, page * PAGE_SIZE$1);
+  const handleOpenCreate = () => {
+    setEditingMemory(null);
+    setModalOpen(true);
+  };
+  const handleOpenEdit = (mem) => {
+    setEditingMemory(mem);
+    setModalOpen(true);
+  };
+  const handleCloseModal = () => {
+    setModalOpen(false);
+    setEditingMemory(null);
+  };
+  const handleSave = (data, documentId) => {
+    if (documentId) {
+      editMemory(documentId, data);
+    } else {
+      addMemory(data);
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Main, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      admin.Layouts.Header,
+      {
+        title: "Memory Store",
+        subtitle: `${memories.length} memories saved`,
+        primaryAction: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { startIcon: /* @__PURE__ */ jsxRuntime.jsx(icons.Plus, {}), onClick: handleOpenCreate, children: "Add memory" }),
+        navigationAction: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { variant: "ghost", startIcon: /* @__PURE__ */ jsxRuntime.jsx(icons.ArrowLeft, {}), onClick: () => navigate(`/plugins/${index.PLUGIN_ID}`), children: "Back to Chat" })
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsxs(admin.Layouts.Content, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingBottom: 4, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.SearchForm, { children: /* @__PURE__ */ jsxRuntime.jsx(
+        designSystem.Searchbar,
+        {
+          name: "search",
+          value: search,
+          onChange: (e) => {
+            setSearch(e.target.value);
+            setPage(1);
+          },
+          onClear: () => {
+            setSearch("");
+            setPage(1);
+          },
+          placeholder: "Search memories...",
+          children: "Search"
+        }
+      ) }) }),
+      /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Table, { colCount: 4, rowCount: paginated.length + 1, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Thead, { children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Tr, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Th, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "sigma", children: "Content" }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Th, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "sigma", children: "Category" }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Th, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "sigma", children: "Created" }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Th, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "sigma", children: "Actions" }) })
+        ] }) }),
+        /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Tbody, { children: [
+          loading && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Tr, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Td, { colSpan: 4, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { padding: 4, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { textColor: "neutral600", children: "Loading..." }) }) }) }),
+          !loading && paginated.length === 0 && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Tr, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Td, { colSpan: 4, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { padding: 4, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { textColor: "neutral500", children: search ? "No memories match your search" : "No memories saved yet" }) }) }) }),
+          paginated.map((mem) => /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Tr, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(designSystem.Td, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { textColor: "neutral800", children: mem.content }) }),
+            /* @__PURE__ */ jsxRuntime.jsx(designSystem.Td, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { textColor: "neutral600", children: mem.category }) }),
+            /* @__PURE__ */ jsxRuntime.jsx(designSystem.Td, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { textColor: "neutral600", children: formatDate$1(mem.createdAt) }) }),
+            /* @__PURE__ */ jsxRuntime.jsx(designSystem.Td, { children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 1, children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                ActionBtn$1,
+                {
+                  onClick: () => handleOpenEdit(mem),
+                  "aria-label": "Edit memory",
+                  children: /* @__PURE__ */ jsxRuntime.jsx(icons.Pencil, {})
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                DeleteActionBtn$1,
+                {
+                  onClick: () => removeMemory(mem.documentId),
+                  "aria-label": "Delete memory",
+                  children: /* @__PURE__ */ jsxRuntime.jsx(icons.Trash, {})
+                }
+              )
+            ] }) })
+          ] }, mem.documentId))
+        ] })
+      ] }),
+      pageCount > 1 && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingTop: 4, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Flex, { justifyContent: "center", children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Pagination.Root, { pageCount, activePage: page, onPageChange: setPage, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Pagination.Links, {}) }) }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        MemoryModal,
+        {
+          memory: editingMemory,
+          open: modalOpen,
+          onClose: handleCloseModal,
+          onSave: handleSave
+        }
+      )
+    ] })
+  ] });
+};
+const BASE = () => `${getBackendURL()}/${index.PLUGIN_ID}/public-memories`;
+function headers() {
+  const token = getToken();
+  return {
+    "Content-Type": "application/json",
+    ...token ? { Authorization: `Bearer ${token}` } : {}
+  };
+}
+async function request(url, init) {
+  const res = await fetch(url, { headers: headers(), ...init });
+  if (!res.ok) throw new Error(`Request failed: ${res.status}`);
+  const json = await res.json();
+  return json.data;
+}
+function fetchPublicMemories() {
+  return request(BASE());
+}
+function createPublicMemory(data) {
+  return request(BASE(), {
+    method: "POST",
+    body: JSON.stringify(data)
+  });
+}
+function updatePublicMemory(documentId, data) {
+  return request(`${BASE()}/${documentId}`, {
+    method: "PUT",
+    body: JSON.stringify(data)
+  });
+}
+function deletePublicMemory(documentId) {
+  return request(`${BASE()}/${documentId}`, { method: "DELETE" });
+}
+function usePublicMemories() {
+  const [memories, setMemories] = react.useState([]);
+  const [loading, setLoading] = react.useState(true);
+  const load = react.useCallback(async () => {
+    try {
+      const data = await fetchPublicMemories();
+      setMemories(data);
+    } catch (err) {
+      console.error("Failed to load public memories:", err);
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  react.useEffect(() => {
+    load();
+  }, [load]);
+  const addMemory = react.useCallback(async (data) => {
+    try {
+      const created = await createPublicMemory(data);
+      setMemories((prev) => [created, ...prev]);
+    } catch (err) {
+      console.error("Failed to create public memory:", err);
+    }
+  }, []);
+  const editMemory = react.useCallback(async (documentId, data) => {
+    try {
+      const updated = await updatePublicMemory(documentId, data);
+      setMemories(
+        (prev) => prev.map((m) => m.documentId === documentId ? { ...m, ...updated } : m)
+      );
+    } catch (err) {
+      console.error("Failed to update public memory:", err);
+    }
+  }, []);
+  const removeMemory = react.useCallback(async (documentId) => {
+    try {
+      await deletePublicMemory(documentId);
+      setMemories((prev) => prev.filter((m) => m.documentId !== documentId));
+    } catch (err) {
+      console.error("Failed to delete public memory:", err);
+    }
+  }, []);
+  return { memories, loading, addMemory, editMemory, removeMemory, refresh: load };
+}
+const PAGE_SIZE = 10;
+const ActionBtn = styled__default.default.button`
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 32px;
+  height: 32px;
+  padding: 0;
+  border: none;
+  border-radius: 4px;
+  background: transparent;
+  color: ${({ theme }) => theme.colors.neutral600};
+  cursor: pointer;
+
+  &:hover {
+    background: ${({ theme }) => theme.colors.neutral200};
+    color: ${({ theme }) => theme.colors.primary600};
+  }
+
+  svg {
+    width: 16px;
+    height: 16px;
+  }
+`;
+const DeleteActionBtn = styled__default.default(ActionBtn)`
+  &:hover {
+    color: ${({ theme }) => theme.colors.danger600};
+  }
+`;
+const WideModalContent = styled__default.default(designSystem.Modal.Content)`
+  max-width: 680px;
+  width: 100%;
+`;
+function formatDate(iso) {
+  return new Date(iso).toLocaleDateString(void 0, {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+function PublicMemoryModal({ memory, open, onClose, onSave }) {
+  const [content, setContent] = react.useState("");
+  const [category, setCategory] = react.useState("general");
+  const isEdit = memory !== null;
+  react.useEffect(() => {
+    if (open && memory) {
+      setContent(memory.content);
+      setCategory(memory.category);
+    } else if (open) {
+      setContent("");
+      setCategory("general");
+    }
+  }, [open, memory]);
+  const handleClose = () => {
+    setContent("");
+    setCategory("general");
+    onClose();
+  };
+  const handleSave = () => {
+    if (!content.trim()) return;
+    onSave({ content, category }, memory?.documentId);
+    handleClose();
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Root, { open, onOpenChange: (isOpen) => !isOpen && handleClose(), children: /* @__PURE__ */ jsxRuntime.jsxs(WideModalContent, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Header, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Title, { children: isEdit ? "Edit Public Memory" : "Add Public Memory" }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Body, { children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { direction: "column", gap: 5, width: "100%", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Field.Root, { width: "100%", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Label, { children: "Content" }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          designSystem.Textarea,
+          {
+            placeholder: "Public knowledge for the chatbot (e.g. 'Our return policy is 30 days')",
+            value: content,
+            onChange: (e) => setContent(e.target.value),
+            style: { width: "100%", minHeight: "120px" }
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Field.Root, { width: "100%", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Label, { children: "Category" }),
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          designSystem.SingleSelect,
+          {
+            value: category,
+            onChange: (value) => setCategory(value),
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(designSystem.SingleSelectOption, { value: "general", children: "General" }),
+              /* @__PURE__ */ jsxRuntime.jsx(designSystem.SingleSelectOption, { value: "faq", children: "FAQ" }),
+              /* @__PURE__ */ jsxRuntime.jsx(designSystem.SingleSelectOption, { value: "product", children: "Product" }),
+              /* @__PURE__ */ jsxRuntime.jsx(designSystem.SingleSelectOption, { value: "policy", children: "Policy" })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Hint, { children: "Used to organize public memories by topic" })
+      ] })
+    ] }) }),
+    /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Modal.Footer, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Close, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { variant: "tertiary", children: "Cancel" }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { onClick: handleSave, disabled: !content.trim(), children: isEdit ? "Save changes" : "Add memory" })
+    ] })
+  ] }) });
+}
+const PublicMemoryStorePage = () => {
+  const navigate = reactRouterDom.useNavigate();
+  const { memories, loading, addMemory, editMemory, removeMemory } = usePublicMemories();
+  const [search, setSearch] = react.useState("");
+  const [page, setPage] = react.useState(1);
+  const [modalOpen, setModalOpen] = react.useState(false);
+  const [editingMemory, setEditingMemory] = react.useState(null);
+  const filtered = react.useMemo(() => {
+    if (!search.trim()) return memories;
+    const q = search.toLowerCase();
+    return memories.filter(
+      (m) => m.content.toLowerCase().includes(q) || m.category.toLowerCase().includes(q)
+    );
+  }, [memories, search]);
+  const pageCount = Math.max(1, Math.ceil(filtered.length / PAGE_SIZE));
+  const paginated = filtered.slice((page - 1) * PAGE_SIZE, page * PAGE_SIZE);
+  const handleOpenCreate = () => {
+    setEditingMemory(null);
+    setModalOpen(true);
+  };
+  const handleOpenEdit = (mem) => {
+    setEditingMemory(mem);
+    setModalOpen(true);
+  };
+  const handleCloseModal = () => {
+    setModalOpen(false);
+    setEditingMemory(null);
+  };
+  const handleSave = (data, documentId) => {
+    if (documentId) {
+      editMemory(documentId, data);
+    } else {
+      addMemory(data);
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Main, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      admin.Layouts.Header,
+      {
+        title: "Public Memory Store",
+        subtitle: `${memories.length} public memories — available to all visitors via the public chat`,
+        primaryAction: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { startIcon: /* @__PURE__ */ jsxRuntime.jsx(icons.Plus, {}), onClick: handleOpenCreate, children: "Add memory" }),
+        navigationAction: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { variant: "ghost", startIcon: /* @__PURE__ */ jsxRuntime.jsx(icons.ArrowLeft, {}), onClick: () => navigate(`/plugins/${index.PLUGIN_ID}`), children: "Back to Chat" })
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsxs(admin.Layouts.Content, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingBottom: 4, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.SearchForm, { children: /* @__PURE__ */ jsxRuntime.jsx(
+        designSystem.Searchbar,
+        {
+          name: "search",
+          value: search,
+          onChange: (e) => {
+            setSearch(e.target.value);
+            setPage(1);
+          },
+          onClear: () => {
+            setSearch("");
+            setPage(1);
+          },
+          placeholder: "Search public memories...",
+          children: "Search"
+        }
+      ) }) }),
+      /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Table, { colCount: 4, rowCount: paginated.length + 1, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Thead, { children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Tr, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Th, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "sigma", children: "Content" }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Th, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "sigma", children: "Category" }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Th, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "sigma", children: "Created" }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Th, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "sigma", children: "Actions" }) })
+        ] }) }),
+        /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Tbody, { children: [
+          loading && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Tr, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Td, { colSpan: 4, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { padding: 4, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { textColor: "neutral600", children: "Loading..." }) }) }) }),
+          !loading && paginated.length === 0 && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Tr, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Td, { colSpan: 4, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { padding: 4, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { textColor: "neutral500", children: search ? "No public memories match your search" : "No public memories yet — add knowledge for your public chatbot" }) }) }) }),
+          paginated.map((mem) => /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Tr, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(designSystem.Td, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { textColor: "neutral800", children: mem.content }) }),
+            /* @__PURE__ */ jsxRuntime.jsx(designSystem.Td, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { textColor: "neutral600", children: mem.category }) }),
+            /* @__PURE__ */ jsxRuntime.jsx(designSystem.Td, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { textColor: "neutral600", children: formatDate(mem.createdAt) }) }),
+            /* @__PURE__ */ jsxRuntime.jsx(designSystem.Td, { children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 1, children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                ActionBtn,
+                {
+                  onClick: () => handleOpenEdit(mem),
+                  "aria-label": "Edit memory",
+                  children: /* @__PURE__ */ jsxRuntime.jsx(icons.Pencil, {})
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                DeleteActionBtn,
+                {
+                  onClick: () => removeMemory(mem.documentId),
+                  "aria-label": "Delete memory",
+                  children: /* @__PURE__ */ jsxRuntime.jsx(icons.Trash, {})
+                }
+              )
+            ] }) })
+          ] }, mem.documentId))
+        ] })
+      ] }),
+      pageCount > 1 && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingTop: 4, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Flex, { justifyContent: "center", children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Pagination.Root, { pageCount, activePage: page, onPageChange: setPage, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Pagination.Links, {}) }) }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        PublicMemoryModal,
+        {
+          memory: editingMemory,
+          open: modalOpen,
+          onClose: handleCloseModal,
+          onSave: handleSave
+        }
+      )
+    ] })
+  ] });
+};
+function getStrapiOrigin() {
+  return globalThis.location.origin;
+}
+function getEmbedSnippet(origin) {
+  return `<script src="${origin}/api/ai-sdk/widget.js"><\/script>`;
+}
+function getIframeHtml(origin) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <style>
+    body { margin: 0; font-family: sans-serif; background: #f5f5f5; min-height: 100vh; }
+  </style>
+</head>
+<body>
+  <script src="${origin}/api/ai-sdk/widget.js"><\/script>
+</body>
+</html>`;
+}
+function WidgetPreviewPage() {
+  const navigate = reactRouterDom.useNavigate();
+  const [copied, setCopied] = react.useState(false);
+  const origin = getStrapiOrigin();
+  const embedSnippet = getEmbedSnippet(origin);
+  const handleCopy = async () => {
+    await navigator.clipboard.writeText(embedSnippet);
+    setCopied(true);
+    setTimeout(() => setCopied(false), 2e3);
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Main, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      admin.Layouts.Header,
+      {
+        title: "Widget Preview",
+        subtitle: "Preview the embeddable chat widget as visitors will see it",
+        navigationAction: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { variant: "ghost", startIcon: /* @__PURE__ */ jsxRuntime.jsx(icons.ArrowLeft, {}), onClick: () => navigate(`/plugins/${index.PLUGIN_ID}`), children: "Back to Chat" })
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsxs(admin.Layouts.Content, { children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Box, { padding: 6, background: "neutral0", shadow: "filterShadow", hasRadius: true, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "beta", tag: "h2", children: "Live Preview" }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          designSystem.Box,
+          {
+            marginTop: 4,
+            style: {
+              border: "1px solid #dcdce4",
+              borderRadius: "4px",
+              overflow: "hidden",
+              height: "500px"
+            },
+            children: /* @__PURE__ */ jsxRuntime.jsx(
+              "iframe",
+              {
+                title: "Widget Preview",
+                srcDoc: getIframeHtml(origin),
+                style: { width: "100%", height: "100%", border: "none" }
+              }
+            )
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Box, { marginTop: 6, padding: 6, background: "neutral0", shadow: "filterShadow", hasRadius: true, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "beta", tag: "h2", children: "Embed Code" }),
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "omega", textColor: "neutral600", tag: "p", style: { marginTop: "8px" }, children: "Add this snippet to any HTML page to embed the chat widget:" }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          designSystem.Box,
+          {
+            marginTop: 4,
+            padding: 4,
+            background: "neutral100",
+            hasRadius: true,
+            style: { fontFamily: "monospace", fontSize: "14px", wordBreak: "break-all" },
+            children: embedSnippet
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Flex, { marginTop: 4, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { variant: "secondary", onClick: handleCopy, children: copied ? "Copied!" : "Copy Snippet" }) })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Box, { marginTop: 6, padding: 6, background: "neutral0", shadow: "filterShadow", hasRadius: true, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "beta", tag: "h2", children: "Production Setup" }),
+        /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { variant: "omega", textColor: "neutral600", tag: "p", style: { marginTop: "8px" }, children: [
+          "If the widget is embedded on a different domain, update your Strapi project's",
+          " ",
+          /* @__PURE__ */ jsxRuntime.jsx("strong", { children: "config/middlewares.ts" }),
+          " to allow cross-origin access:"
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          designSystem.Box,
+          {
+            marginTop: 4,
+            padding: 4,
+            background: "neutral100",
+            hasRadius: true,
+            style: { fontFamily: "monospace", fontSize: "13px", whiteSpace: "pre", overflowX: "auto", lineHeight: "1.5" },
+            children: `// config/middlewares.ts
+{
+  name: 'strapi::security',
+  config: {
+    contentSecurityPolicy: {
+      useDefaults: true,
+      directives: {
+        'connect-src': ["'self'", "https:", "blob:"],
+        'img-src': ["'self'", "data:", "blob:", "market-assets.strapi.io"],
+        'script-src': ["'self'", "'unsafe-inline'"],
+        'frame-ancestors': ["'self'", "https://your-frontend.com"],
+      },
+    },
+  },
+},
+{
+  name: 'strapi::cors',
+  config: {
+    origin: ['https://your-frontend.com'],
+  },
+},`
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { variant: "pi", textColor: "neutral500", tag: "p", style: { marginTop: "8px" }, children: [
+          "Replace ",
+          /* @__PURE__ */ jsxRuntime.jsx("strong", { children: "https://your-frontend.com" }),
+          " with the domain(s) where the widget will be embedded."
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Box, { marginTop: 6, padding: 6, background: "neutral0", shadow: "filterShadow", hasRadius: true, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "beta", tag: "h2", children: "Development" }),
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "omega", textColor: "neutral600", tag: "p", style: { marginTop: "8px" }, children: "To live-reload the widget during development, run:" }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          designSystem.Box,
+          {
+            marginTop: 4,
+            padding: 4,
+            background: "neutral100",
+            hasRadius: true,
+            style: { fontFamily: "monospace", fontSize: "14px" },
+            children: "npm run dev:widget"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "pi", textColor: "neutral500", tag: "p", style: { marginTop: "8px" }, children: "This watches the widget source and rebuilds on changes. Refresh the iframe to see updates." })
+      ] })
+    ] })
+  ] });
+}
+const App = () => {
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactRouterDom.Routes, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(reactRouterDom.Route, { index: true, element: /* @__PURE__ */ jsxRuntime.jsx(HomePage, {}) }),
+    /* @__PURE__ */ jsxRuntime.jsx(reactRouterDom.Route, { path: "memory-store", element: /* @__PURE__ */ jsxRuntime.jsx(MemoryStorePage, {}) }),
+    /* @__PURE__ */ jsxRuntime.jsx(reactRouterDom.Route, { path: "public-memory-store", element: /* @__PURE__ */ jsxRuntime.jsx(PublicMemoryStorePage, {}) }),
+    /* @__PURE__ */ jsxRuntime.jsx(reactRouterDom.Route, { path: "widget-preview", element: /* @__PURE__ */ jsxRuntime.jsx(WidgetPreviewPage, {}) }),
+    /* @__PURE__ */ jsxRuntime.jsx(reactRouterDom.Route, { path: "*", element: /* @__PURE__ */ jsxRuntime.jsx(admin.Page.Error, {}) })
+  ] });
+};
+exports.App = App;