@meetsmore-oss/use-ai-client 1.2.1

package/dist/index.js

@@ -0,0 +1,4502 @@
+import {
+  generateChatId,
+  generateMessageId
+} from "./chunk-EGKUR4C7.js";
+
+// src/useAI.ts
+import { useState as useState11, useEffect as useEffect10, useRef as useRef11, useCallback as useCallback10, useMemo as useMemo6 } from "react";
+
+// src/providers/useAIProvider.tsx
+import { createContext as createContext4, useContext as useContext4, useState as useState10, useEffect as useEffect9, useCallback as useCallback9, useRef as useRef9 } from "react";
+
+// src/types.ts
+import { EventType, ErrorCode } from "@meetsmore-oss/use-ai-core";
+
+// src/theme/strings.ts
+import { createContext, useContext } from "react";
+var defaultStrings = {
+  // Chat panel header
+  header: {
+    /** Header title when no chat history feature */
+    aiAssistant: "AI Assistant",
+    /** Label for new chat button tooltip */
+    newChat: "New Chat",
+    /** Delete chat confirmation message */
+    deleteConfirm: "Delete this chat from history?",
+    /** Delete button tooltip */
+    deleteChat: "Delete Chat",
+    /** Connection status: online */
+    online: "Online",
+    /** Connection status: offline */
+    offline: "Offline"
+  },
+  // Chat history dropdown
+  chatHistory: {
+    /** Chat history: no chats message */
+    noChatHistory: "No chat history yet",
+    /** Chat history: active chat indicator */
+    active: "Active"
+  },
+  // Empty chat state
+  emptyChat: {
+    /** Empty chat welcome message */
+    startConversation: "Start a conversation with the AI assistant",
+    /** Empty chat help text */
+    askMeToHelp: "Ask me to help with your tasks!"
+  },
+  // Chat input
+  input: {
+    /** Input placeholder when connected */
+    placeholder: "Type a message...",
+    /** Input placeholder when connecting */
+    connectingPlaceholder: "Connecting...",
+    /** Send button text */
+    send: "Send",
+    /** Loading indicator text */
+    thinking: "Thinking"
+  },
+  // File upload
+  fileUpload: {
+    /** Attach files button tooltip */
+    attachFiles: "Attach Files",
+    /** Drop zone text when dragging files */
+    dropFilesHere: "Drop files here",
+    /** File size error (use {filename} and {maxSize} placeholders) */
+    fileSizeError: 'File "{filename}" exceeds {maxSize}MB limit',
+    /** File type error (use {type} placeholder) */
+    fileTypeError: 'File type "{type}" is not accepted'
+  },
+  // Floating button
+  floatingButton: {
+    /** Floating button title when connected */
+    openAssistant: "Open AI Assistant",
+    /** Floating button title when connecting */
+    connectingToAssistant: "Connecting to AI..."
+  },
+  // Slash commands
+  commands: {
+    /** No saved commands empty state */
+    noSavedCommands: "No saved commands yet",
+    /** No matching commands message */
+    noMatchingCommands: "No matching commands",
+    /** Delete command button tooltip */
+    deleteCommand: "Delete command",
+    /** Command name input placeholder */
+    commandNamePlaceholder: "command-name",
+    /** Save command button tooltip */
+    saveCommand: "Save command",
+    /** Error when command name already exists */
+    commandNameExists: "Command name already exists",
+    /** Error when rename is not supported */
+    renameNotSupported: "Rename not supported",
+    /** Error when save is not supported */
+    saveNotSupported: "Save not supported",
+    /** Error when rename fails */
+    renameFailed: "Failed to rename",
+    /** Error when save fails */
+    saveFailed: "Failed to save"
+  },
+  // Error messages (from server error codes)
+  errors: {
+    /** Error when AI service is overloaded */
+    API_OVERLOADED: "The AI service is currently experiencing high demand. Please try again in a moment.",
+    /** Error when rate limited */
+    RATE_LIMITED: "Too many requests. Please wait a moment before trying again.",
+    /** Error for unknown/unexpected errors */
+    UNKNOWN_ERROR: "An unexpected error occurred. Please try again."
+  }
+};
+var StringsContext = createContext(defaultStrings);
+function useStrings() {
+  return useContext(StringsContext);
+}
+
+// src/theme/theme.ts
+import { createContext as createContext2, useContext as useContext2 } from "react";
+var defaultTheme = {
+  // Primary colors
+  /** Primary color for buttons, links, active states */
+  primaryColor: "#667eea",
+  /** Primary gradient for user messages and buttons */
+  primaryGradient: "linear-gradient(135deg, #667eea 0%, #764ba2 100%)",
+  /** Translucent primary color for overlays (e.g., drop zone) */
+  primaryColorTranslucent: "rgba(102, 126, 234, 0.15)",
+  // Backgrounds
+  /** Panel background color */
+  backgroundColor: "white",
+  /** Assistant message bubble background */
+  assistantMessageBackground: "#f3f4f6",
+  /** Hover background for buttons and items */
+  hoverBackground: "#f3f4f6",
+  /** Active/selected item background */
+  activeBackground: "#f0f0ff",
+  /** Disabled button background */
+  buttonDisabledBackground: "#e5e7eb",
+  // Text colors
+  /** Primary text color */
+  textColor: "#1f2937",
+  /** Secondary/muted text color */
+  secondaryTextColor: "#6b7280",
+  /** Placeholder text color */
+  placeholderTextColor: "#9ca3af",
+  // Status colors
+  /** Online status indicator color */
+  onlineColor: "#10b981",
+  /** Offline status indicator color */
+  offlineColor: "#6b7280",
+  /** Unread notification indicator color */
+  unreadIndicatorColor: "#ff4444",
+  // Error/danger colors
+  /** Error message background */
+  errorBackground: "#fee2e2",
+  /** Error message text color */
+  errorTextColor: "#dc2626",
+  /** Danger/destructive action color (e.g., delete) */
+  dangerColor: "#ef4444",
+  // Borders and dividers
+  /** Border color for dividers and inputs */
+  borderColor: "#e5e7eb",
+  /** Dashed border color (e.g., file placeholder) */
+  dashedBorderColor: "#d1d5db",
+  // Shadows
+  /** Panel box shadow */
+  panelShadow: "0 8px 32px rgba(0, 0, 0, 0.12)",
+  /** Dropdown box shadow */
+  dropdownShadow: "0 4px 16px rgba(0, 0, 0, 0.15)",
+  /** Button box shadow */
+  buttonShadow: "0 4px 12px rgba(0, 0, 0, 0.15)",
+  /** Button hover box shadow */
+  buttonHoverShadow: "0 6px 16px rgba(0, 0, 0, 0.2)",
+  // Typography
+  /** Font family */
+  fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+  // Backdrop
+  /** Modal backdrop color */
+  backdropColor: "rgba(0, 0, 0, 0.3)"
+};
+var ThemeContext = createContext2(defaultTheme);
+function useTheme() {
+  return useContext2(ThemeContext);
+}
+
+// src/components/UseAIFloatingButton.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function UseAIFloatingButton({
+  onClick,
+  connected,
+  hasUnread = false
+}) {
+  const strings = useStrings();
+  const theme = useTheme();
+  return /* @__PURE__ */ jsxs(
+    "button",
+    {
+      "data-testid": "ai-button",
+      className: "ai-floating-button",
+      onClick,
+      style: {
+        position: "fixed",
+        bottom: "24px",
+        right: "24px",
+        width: "56px",
+        height: "56px",
+        borderRadius: "50%",
+        border: "none",
+        background: connected ? theme.primaryGradient : theme.offlineColor,
+        color: "white",
+        fontSize: "20px",
+        fontWeight: "bold",
+        cursor: connected ? "pointer" : "not-allowed",
+        boxShadow: theme.buttonShadow,
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        transition: "transform 0.2s, box-shadow 0.2s",
+        zIndex: 1e3,
+        fontFamily: theme.fontFamily
+      },
+      onMouseEnter: (e) => {
+        if (connected) {
+          e.currentTarget.style.transform = "scale(1.1)";
+          e.currentTarget.style.boxShadow = theme.buttonHoverShadow;
+        }
+      },
+      onMouseLeave: (e) => {
+        e.currentTarget.style.transform = "scale(1)";
+        e.currentTarget.style.boxShadow = theme.buttonShadow;
+      },
+      disabled: !connected,
+      title: connected ? strings.floatingButton.openAssistant : strings.floatingButton.connectingToAssistant,
+      children: [
+        "AI",
+        hasUnread && /* @__PURE__ */ jsx(
+          "span",
+          {
+            style: {
+              position: "absolute",
+              top: "4px",
+              right: "4px",
+              width: "12px",
+              height: "12px",
+              borderRadius: "50%",
+              background: theme.unreadIndicatorColor,
+              border: "2px solid white"
+            }
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/components/UseAIChatPanel.tsx
+import { useState as useState4, useRef as useRef4, useEffect as useEffect4 } from "react";
+
+// src/components/MarkdownContent.tsx
+import ReactMarkdown from "react-markdown";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function MarkdownContent({ content }) {
+  return /* @__PURE__ */ jsx2(
+    ReactMarkdown,
+    {
+      components: {
+        // Override default element rendering for better chat styling
+        p: ({ children }) => /* @__PURE__ */ jsx2("p", { style: { margin: "0 0 0.5em 0" }, children }),
+        // Ensure last paragraph has no margin
+        h1: ({ children }) => /* @__PURE__ */ jsx2("h1", { style: { margin: "0 0 0.5em 0", fontSize: "1.25em", fontWeight: 600 }, children }),
+        h2: ({ children }) => /* @__PURE__ */ jsx2("h2", { style: { margin: "0 0 0.5em 0", fontSize: "1.15em", fontWeight: 600 }, children }),
+        h3: ({ children }) => /* @__PURE__ */ jsx2("h3", { style: { margin: "0 0 0.5em 0", fontSize: "1.05em", fontWeight: 600 }, children }),
+        ul: ({ children }) => /* @__PURE__ */ jsx2("ul", { style: { margin: "0 0 0.5em 0", paddingLeft: "1.5em" }, children }),
+        ol: ({ children }) => /* @__PURE__ */ jsx2("ol", { style: { margin: "0 0 0.5em 0", paddingLeft: "1.5em" }, children }),
+        li: ({ children }) => /* @__PURE__ */ jsx2("li", { style: { marginBottom: "0.25em" }, children }),
+        code: ({ className, children, ...props }) => {
+          const isInline = !className;
+          if (isInline) {
+            return /* @__PURE__ */ jsx2(
+              "code",
+              {
+                style: {
+                  backgroundColor: "rgba(0, 0, 0, 0.1)",
+                  padding: "0.1em 0.3em",
+                  borderRadius: "3px",
+                  fontSize: "0.9em",
+                  fontFamily: 'ui-monospace, SFMono-Regular, "SF Mono", Consolas, monospace'
+                },
+                ...props,
+                children
+              }
+            );
+          }
+          return /* @__PURE__ */ jsx2("code", { className, ...props, children });
+        },
+        pre: ({ children }) => /* @__PURE__ */ jsx2(
+          "pre",
+          {
+            style: {
+              margin: "0.5em 0",
+              padding: "0.75em",
+              backgroundColor: "rgba(0, 0, 0, 0.1)",
+              borderRadius: "6px",
+              overflow: "auto",
+              fontSize: "0.85em",
+              fontFamily: 'ui-monospace, SFMono-Regular, "SF Mono", Consolas, monospace'
+            },
+            children
+          }
+        ),
+        blockquote: ({ children }) => /* @__PURE__ */ jsx2(
+          "blockquote",
+          {
+            style: {
+              margin: "0.5em 0",
+              paddingLeft: "1em",
+              borderLeft: "3px solid rgba(0, 0, 0, 0.2)",
+              color: "inherit",
+              opacity: 0.9
+            },
+            children
+          }
+        ),
+        a: ({ children, href }) => /* @__PURE__ */ jsx2(
+          "a",
+          {
+            href,
+            target: "_blank",
+            rel: "noopener noreferrer",
+            style: {
+              color: "inherit",
+              textDecoration: "underline",
+              textUnderlineOffset: "2px"
+            },
+            children
+          }
+        ),
+        hr: () => /* @__PURE__ */ jsx2(
+          "hr",
+          {
+            style: {
+              margin: "0.75em 0",
+              border: "none",
+              borderTop: "1px solid rgba(0, 0, 0, 0.2)"
+            }
+          }
+        ),
+        table: ({ children }) => /* @__PURE__ */ jsx2("div", { style: { overflowX: "auto", margin: "0.5em 0" }, children: /* @__PURE__ */ jsx2(
+          "table",
+          {
+            style: {
+              borderCollapse: "collapse",
+              fontSize: "0.9em",
+              width: "100%"
+            },
+            children
+          }
+        ) }),
+        th: ({ children }) => /* @__PURE__ */ jsx2(
+          "th",
+          {
+            style: {
+              padding: "0.4em 0.6em",
+              borderBottom: "2px solid rgba(0, 0, 0, 0.2)",
+              textAlign: "left",
+              fontWeight: 600
+            },
+            children
+          }
+        ),
+        td: ({ children }) => /* @__PURE__ */ jsx2(
+          "td",
+          {
+            style: {
+              padding: "0.4em 0.6em",
+              borderBottom: "1px solid rgba(0, 0, 0, 0.1)"
+            },
+            children
+          }
+        )
+      },
+      children: content
+    }
+  );
+}
+
+// src/components/FileChip.tsx
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function formatFileSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function truncateFilename(name, maxLength = 20) {
+  if (name.length <= maxLength) return name;
+  const lastDot = name.lastIndexOf(".");
+  const ext = lastDot > 0 ? name.substring(lastDot) : "";
+  const baseName = lastDot > 0 ? name.substring(0, lastDot) : name;
+  const maxBaseLength = maxLength - ext.length - 3;
+  if (maxBaseLength < 5) return name.substring(0, maxLength - 3) + "...";
+  return baseName.substring(0, maxBaseLength) + "..." + ext;
+}
+function FileChip({ attachment, onRemove, disabled }) {
+  const theme = useTheme();
+  const { file, preview } = attachment;
+  const isImage = file.type.startsWith("image/");
+  return /* @__PURE__ */ jsxs2(
+    "div",
+    {
+      "data-testid": "file-chip",
+      style: {
+        display: "inline-flex",
+        alignItems: "center",
+        gap: "8px",
+        padding: "6px 10px",
+        background: theme.hoverBackground,
+        borderRadius: "8px",
+        fontSize: "13px",
+        color: theme.textColor,
+        maxWidth: "200px"
+      },
+      children: [
+        isImage && preview ? /* @__PURE__ */ jsx3(
+          "img",
+          {
+            src: preview,
+            alt: file.name,
+            style: {
+              width: "24px",
+              height: "24px",
+              borderRadius: "4px",
+              objectFit: "cover"
+            }
+          }
+        ) : /* @__PURE__ */ jsx3(
+          "div",
+          {
+            style: {
+              width: "24px",
+              height: "24px",
+              borderRadius: "4px",
+              background: theme.borderColor,
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center",
+              fontSize: "12px"
+            },
+            children: "\u{1F4CE}"
+          }
+        ),
+        /* @__PURE__ */ jsxs2("div", { style: { flex: 1, minWidth: 0, overflow: "hidden" }, children: [
+          /* @__PURE__ */ jsx3(
+            "div",
+            {
+              style: {
+                fontWeight: 500,
+                overflow: "hidden",
+                textOverflow: "ellipsis",
+                whiteSpace: "nowrap"
+              },
+              title: file.name,
+              children: truncateFilename(file.name)
+            }
+          ),
+          /* @__PURE__ */ jsx3("div", { style: { fontSize: "11px", color: theme.secondaryTextColor }, children: formatFileSize(file.size) })
+        ] }),
+        /* @__PURE__ */ jsx3(
+          "button",
+          {
+            "data-testid": "file-chip-remove",
+            onClick: onRemove,
+            disabled,
+            style: {
+              background: "transparent",
+              border: "none",
+              padding: "2px 4px",
+              cursor: disabled ? "not-allowed" : "pointer",
+              color: theme.placeholderTextColor,
+              fontSize: "16px",
+              lineHeight: 1,
+              borderRadius: "4px",
+              transition: "all 0.15s",
+              opacity: disabled ? 0.5 : 1
+            },
+            onMouseEnter: (e) => {
+              if (!disabled) {
+                e.currentTarget.style.background = theme.borderColor;
+                e.currentTarget.style.color = theme.textColor;
+              }
+            },
+            onMouseLeave: (e) => {
+              e.currentTarget.style.background = "transparent";
+              e.currentTarget.style.color = theme.placeholderTextColor;
+            },
+            children: "\xD7"
+          }
+        )
+      ]
+    }
+  );
+}
+function FilePlaceholder({ name, size }) {
+  const theme = useTheme();
+  return /* @__PURE__ */ jsxs2(
+    "div",
+    {
+      "data-testid": "file-placeholder",
+      style: {
+        display: "inline-flex",
+        alignItems: "center",
+        gap: "8px",
+        padding: "6px 10px",
+        background: theme.backgroundColor,
+        border: `1px dashed ${theme.dashedBorderColor}`,
+        borderRadius: "8px",
+        fontSize: "13px",
+        color: theme.placeholderTextColor,
+        maxWidth: "200px"
+      },
+      children: [
+        /* @__PURE__ */ jsx3("span", { children: "\u{1F4CE}" }),
+        /* @__PURE__ */ jsxs2("div", { style: { flex: 1, minWidth: 0, overflow: "hidden" }, children: [
+          /* @__PURE__ */ jsx3(
+            "div",
+            {
+              style: {
+                overflow: "hidden",
+                textOverflow: "ellipsis",
+                whiteSpace: "nowrap"
+              },
+              title: name,
+              children: truncateFilename(name)
+            }
+          ),
+          /* @__PURE__ */ jsx3("div", { style: { fontSize: "11px" }, children: formatFileSize(size) })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/hooks/useSlashCommands.tsx
+import { useState, useRef as useRef2, useEffect as useEffect2, useCallback } from "react";
+
+// src/commands/types.ts
+function generateCommandId() {
+  return `cmd_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+function validateCommandName(name) {
+  if (!name.trim()) {
+    return "Command name is required";
+  }
+  if (!/^[a-z0-9-]+$/.test(name)) {
+    return "Only lowercase letters, numbers, and hyphens allowed (kebab-case)";
+  }
+  if (name.length > 50) {
+    return "Command name must be 50 characters or less";
+  }
+  return null;
+}
+
+// src/components/CommandAutocomplete.tsx
+import { useEffect, useRef } from "react";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var MAX_VISIBLE_ITEMS = 8;
+function CommandAutocomplete({
+  commands,
+  searchPrefix,
+  highlightedIndex,
+  onSelect,
+  onDelete,
+  onHighlightChange,
+  onClose
+}) {
+  const strings = useStrings();
+  const theme = useTheme();
+  const listRef = useRef(null);
+  const itemRefs = useRef([]);
+  const filteredCommands = commands.filter(
+    (c) => c.name.toLowerCase().startsWith(searchPrefix.toLowerCase())
+  ).slice(0, MAX_VISIBLE_ITEMS);
+  useEffect(() => {
+    const item = itemRefs.current[highlightedIndex];
+    if (item && listRef.current) {
+      const listRect = listRef.current.getBoundingClientRect();
+      const itemRect = item.getBoundingClientRect();
+      if (itemRect.bottom > listRect.bottom) {
+        item.scrollIntoView({ block: "end" });
+      } else if (itemRect.top < listRect.top) {
+        item.scrollIntoView({ block: "start" });
+      }
+    }
+  }, [highlightedIndex]);
+  if (filteredCommands.length === 0) {
+    return /* @__PURE__ */ jsx4(
+      "div",
+      {
+        "data-testid": "command-autocomplete",
+        style: {
+          position: "absolute",
+          bottom: "100%",
+          left: 0,
+          right: 0,
+          marginBottom: "8px",
+          background: theme.backgroundColor,
+          borderRadius: "8px",
+          boxShadow: theme.dropdownShadow,
+          overflow: "hidden",
+          zIndex: 1005
+        },
+        children: /* @__PURE__ */ jsx4(
+          "div",
+          {
+            style: {
+              padding: "12px 16px",
+              color: theme.secondaryTextColor,
+              fontSize: "13px",
+              textAlign: "center"
+            },
+            children: commands.length === 0 ? strings.commands.noSavedCommands : strings.commands.noMatchingCommands
+          }
+        )
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx4(
+    "div",
+    {
+      "data-testid": "command-autocomplete",
+      ref: listRef,
+      style: {
+        position: "absolute",
+        bottom: "100%",
+        left: 0,
+        right: 0,
+        marginBottom: "8px",
+        background: theme.backgroundColor,
+        borderRadius: "8px",
+        boxShadow: theme.dropdownShadow,
+        overflow: "hidden",
+        maxHeight: "320px",
+        overflowY: "auto",
+        zIndex: 1005
+      },
+      children: filteredCommands.map((cmd, index) => /* @__PURE__ */ jsxs3(
+        "div",
+        {
+          ref: (el) => {
+            itemRefs.current[index] = el;
+          },
+          "data-testid": "command-autocomplete-item",
+          onClick: () => onSelect(cmd),
+          onMouseEnter: () => onHighlightChange(index),
+          style: {
+            padding: "10px 14px",
+            background: index === highlightedIndex ? theme.hoverBackground : "transparent",
+            cursor: "pointer",
+            borderBottom: index < filteredCommands.length - 1 ? `1px solid ${theme.hoverBackground}` : "none",
+            transition: "background 0.1s",
+            display: "flex",
+            alignItems: "flex-start",
+            gap: "8px"
+          },
+          children: [
+            /* @__PURE__ */ jsxs3("div", { style: { flex: 1, minWidth: 0 }, children: [
+              /* @__PURE__ */ jsxs3(
+                "div",
+                {
+                  style: {
+                    fontWeight: 600,
+                    fontSize: "14px",
+                    color: theme.primaryColor
+                  },
+                  children: [
+                    "/",
+                    cmd.name
+                  ]
+                }
+              ),
+              /* @__PURE__ */ jsx4(
+                "div",
+                {
+                  style: {
+                    marginTop: "4px",
+                    fontSize: "13px",
+                    color: theme.secondaryTextColor,
+                    overflow: "hidden",
+                    textOverflow: "ellipsis",
+                    whiteSpace: "nowrap"
+                  },
+                  children: cmd.text.length > 60 ? cmd.text.substring(0, 60) + "..." : cmd.text
+                }
+              )
+            ] }),
+            onDelete && /* @__PURE__ */ jsx4(
+              "button",
+              {
+                "data-testid": "command-delete-button",
+                onClick: (e) => {
+                  e.stopPropagation();
+                  onDelete(cmd);
+                },
+                style: {
+                  padding: "4px",
+                  background: "transparent",
+                  border: "none",
+                  borderRadius: "4px",
+                  cursor: "pointer",
+                  color: theme.placeholderTextColor,
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  flexShrink: 0,
+                  marginTop: "2px",
+                  transition: "all 0.15s"
+                },
+                onMouseEnter: (e) => {
+                  e.currentTarget.style.color = theme.dangerColor;
+                  e.currentTarget.style.background = theme.errorBackground;
+                },
+                onMouseLeave: (e) => {
+                  e.currentTarget.style.color = theme.placeholderTextColor;
+                  e.currentTarget.style.background = "transparent";
+                },
+                title: strings.commands.deleteCommand,
+                children: /* @__PURE__ */ jsx4("svg", { width: "14", height: "14", viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round", children: /* @__PURE__ */ jsx4("path", { d: "M2 4H14M6.5 7V11M9.5 7V11M3 4L4 13C4 13.5304 4.21071 14.0391 4.58579 14.4142C4.96086 14.7893 5.46957 15 6 15H10C10.5304 15 11.0391 14.7893 11.4142 14.4142C11.7893 14.0391 12 13.5304 12 13L13 4M5.5 4V2.5C5.5 2.23478 5.60536 1.98043 5.79289 1.79289C5.98043 1.60536 6.23478 1.5 6.5 1.5H9.5C9.76522 1.5 10.0196 1.60536 10.2071 1.79289C10.3946 1.98043 10.5 2.23478 10.5 2.5V4" }) })
+              }
+            )
+          ]
+        },
+        cmd.id
+      ))
+    }
+  );
+}
+function getFilteredCommandsCount(commands, searchPrefix) {
+  return Math.min(
+    commands.filter((c) => c.name.toLowerCase().startsWith(searchPrefix.toLowerCase())).length,
+    MAX_VISIBLE_ITEMS
+  );
+}
+
+// src/hooks/useSlashCommands.tsx
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var MAX_VISIBLE_ITEMS2 = 8;
+function useSlashCommands({
+  commands,
+  onCommandSelect,
+  onSaveCommand,
+  onRenameCommand,
+  onDeleteCommand
+}) {
+  const strings = useStrings();
+  const theme = useTheme();
+  const [showAutocomplete, setShowAutocomplete] = useState(false);
+  const [searchPrefix, setSearchPrefix] = useState("");
+  const [highlightedIndex, setHighlightedIndex] = useState(0);
+  const [savingMessageId, setSavingMessageId] = useState(null);
+  const [savingMessageText, setSavingMessageText] = useState("");
+  const [commandNameInput, setCommandNameInput] = useState("");
+  const [commandSaveError, setCommandSaveError] = useState(null);
+  const commandNameInputRef = useRef2(null);
+  useEffect2(() => {
+    if (savingMessageId) {
+      setTimeout(() => commandNameInputRef.current?.focus(), 0);
+    }
+  }, [savingMessageId]);
+  const selectCommand = useCallback((command) => {
+    setShowAutocomplete(false);
+    onCommandSelect?.(command.text);
+  }, [onCommandSelect]);
+  const handleInputChange = useCallback((value) => {
+    if (value.startsWith("/") && commands.length > 0) {
+      setSearchPrefix(value.slice(1));
+      setShowAutocomplete(true);
+      setHighlightedIndex(0);
+      return true;
+    } else {
+      setShowAutocomplete(false);
+      return false;
+    }
+  }, [commands.length]);
+  const handleKeyDown = useCallback((e) => {
+    if (!showAutocomplete) {
+      return false;
+    }
+    const filteredCount = getFilteredCommandsCount(commands, searchPrefix);
+    if (e.key === "ArrowDown") {
+      e.preventDefault();
+      setHighlightedIndex((i) => Math.min(i + 1, filteredCount - 1));
+      return true;
+    } else if (e.key === "ArrowUp") {
+      e.preventDefault();
+      setHighlightedIndex((i) => Math.max(i - 1, 0));
+      return true;
+    } else if (e.key === "Enter" && !e.shiftKey) {
+      e.preventDefault();
+      const filteredCommands = commands.filter((c) => c.name.toLowerCase().startsWith(searchPrefix.toLowerCase())).slice(0, MAX_VISIBLE_ITEMS2);
+      if (filteredCommands[highlightedIndex]) {
+        selectCommand(filteredCommands[highlightedIndex]);
+      }
+      return true;
+    } else if (e.key === "Escape") {
+      e.preventDefault();
+      setShowAutocomplete(false);
+      return true;
+    }
+    return false;
+  }, [showAutocomplete, commands, searchPrefix, highlightedIndex, selectCommand]);
+  const closeAutocomplete = useCallback(() => {
+    setShowAutocomplete(false);
+  }, []);
+  const handleDeleteCommand = useCallback((command) => {
+    if (onDeleteCommand) {
+      onDeleteCommand(command.id);
+    }
+  }, [onDeleteCommand]);
+  const startSavingCommand = useCallback((messageId, messageText) => {
+    const existingCommand = commands.find((c) => c.text === messageText);
+    setSavingMessageId(messageId);
+    setSavingMessageText(messageText);
+    setCommandNameInput(existingCommand?.name || "");
+    setCommandSaveError(null);
+  }, [commands]);
+  const isSavingCommand = useCallback((messageId) => {
+    return savingMessageId === messageId;
+  }, [savingMessageId]);
+  const cancelInlineSave = useCallback(() => {
+    setSavingMessageId(null);
+    setSavingMessageText("");
+    setCommandNameInput("");
+    setCommandSaveError(null);
+  }, []);
+  const handleInlineSaveCommand = useCallback(async () => {
+    if (!savingMessageId || !savingMessageText.trim()) return;
+    const name = commandNameInput.trim();
+    const validationError = validateCommandName(name);
+    if (validationError) {
+      setCommandSaveError(validationError);
+      return;
+    }
+    const existingCommand = commands.find((c) => c.text === savingMessageText);
+    if (existingCommand) {
+      if (existingCommand.name === name) {
+        cancelInlineSave();
+        return;
+      }
+      if (commands.some((c) => c.name === name && c.id !== existingCommand.id)) {
+        setCommandSaveError(strings.commands.commandNameExists);
+        return;
+      }
+      if (!onRenameCommand) {
+        setCommandSaveError(strings.commands.renameNotSupported);
+        return;
+      }
+      try {
+        await onRenameCommand(existingCommand.id, name);
+        cancelInlineSave();
+      } catch (err) {
+        setCommandSaveError(err instanceof Error ? err.message : strings.commands.renameFailed);
+      }
+    } else {
+      if (commands.some((c) => c.name === name)) {
+        setCommandSaveError(strings.commands.commandNameExists);
+        return;
+      }
+      if (!onSaveCommand) {
+        setCommandSaveError(strings.commands.saveNotSupported);
+        return;
+      }
+      try {
+        await onSaveCommand(name, savingMessageText);
+        cancelInlineSave();
+      } catch (err) {
+        setCommandSaveError(err instanceof Error ? err.message : strings.commands.saveFailed);
+      }
+    }
+  }, [savingMessageId, savingMessageText, commandNameInput, commands, onRenameCommand, onSaveCommand, cancelInlineSave, strings]);
+  const AutocompleteComponent = showAutocomplete && commands.length > 0 ? /* @__PURE__ */ jsx5(
+    CommandAutocomplete,
+    {
+      commands,
+      searchPrefix,
+      highlightedIndex,
+      onSelect: selectCommand,
+      onDelete: onDeleteCommand ? handleDeleteCommand : void 0,
+      onHighlightChange: setHighlightedIndex,
+      onClose: closeAutocomplete
+    }
+  ) : null;
+  const renderInlineSaveUI = useCallback(({ messageId, messageText }) => {
+    if (savingMessageId !== messageId) {
+      return null;
+    }
+    return /* @__PURE__ */ jsxs4(
+      "div",
+      {
+        "data-testid": "inline-save-command",
+        onClick: (e) => e.stopPropagation(),
+        style: {
+          padding: "6px 10px",
+          background: theme.hoverBackground,
+          borderRadius: "0 0 12px 12px",
+          display: "flex",
+          flexDirection: "column",
+          gap: "4px"
+        },
+        children: [
+          /* @__PURE__ */ jsxs4("div", { style: { display: "flex", alignItems: "center", gap: "6px" }, children: [
+            /* @__PURE__ */ jsx5("span", { style: { color: theme.primaryColor, fontSize: "13px", fontWeight: 500 }, children: "/" }),
+            /* @__PURE__ */ jsx5(
+              "input",
+              {
+                ref: commandNameInputRef,
+                "data-testid": "command-name-input",
+                type: "text",
+                value: commandNameInput,
+                onChange: (e) => {
+                  setCommandNameInput(e.target.value);
+                  setCommandSaveError(null);
+                },
+                onKeyDown: (e) => {
+                  if (e.key === "Enter") {
+                    e.preventDefault();
+                    handleInlineSaveCommand();
+                  } else if (e.key === "Escape") {
+                    cancelInlineSave();
+                  }
+                },
+                placeholder: strings.commands.commandNamePlaceholder,
+                style: {
+                  flex: 1,
+                  border: commandSaveError ? `1px solid ${theme.dangerColor}` : `1px solid ${theme.borderColor}`,
+                  borderRadius: "6px",
+                  padding: "5px 8px",
+                  fontSize: "13px",
+                  outline: "none",
+                  background: theme.backgroundColor,
+                  minWidth: 0
+                }
+              }
+            ),
+            /* @__PURE__ */ jsx5(
+              "button",
+              {
+                "data-testid": "save-command-confirm",
+                onClick: handleInlineSaveCommand,
+                disabled: !commandNameInput.trim(),
+                style: {
+                  padding: "5px",
+                  border: "none",
+                  borderRadius: "6px",
+                  background: "transparent",
+                  color: commandNameInput.trim() ? theme.primaryColor : theme.dashedBorderColor,
+                  cursor: commandNameInput.trim() ? "pointer" : "not-allowed",
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center"
+                },
+                title: strings.commands.saveCommand,
+                children: /* @__PURE__ */ jsxs4("svg", { width: "16", height: "16", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+                  /* @__PURE__ */ jsx5("path", { d: "M19 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h11l5 5v11a2 2 0 0 1-2 2z" }),
+                  /* @__PURE__ */ jsx5("polyline", { points: "17 21 17 13 7 13 7 21" }),
+                  /* @__PURE__ */ jsx5("polyline", { points: "7 3 7 8 15 8" })
+                ] })
+              }
+            )
+          ] }),
+          commandSaveError && /* @__PURE__ */ jsx5(
+            "div",
+            {
+              "data-testid": "command-save-error",
+              style: {
+                fontSize: "11px",
+                color: theme.dangerColor,
+                paddingLeft: "2px"
+              },
+              children: commandSaveError
+            }
+          )
+        ]
+      }
+    );
+  }, [savingMessageId, commandNameInput, commandSaveError, handleInlineSaveCommand, cancelInlineSave, theme, strings]);
+  return {
+    isAutocompleteVisible: showAutocomplete,
+    handleInputChange,
+    handleKeyDown,
+    closeAutocomplete,
+    AutocompleteComponent,
+    startSavingCommand,
+    isSavingCommand,
+    cancelInlineSave,
+    renderInlineSaveUI
+  };
+}
+
+// src/hooks/useFileUpload.tsx
+import { useState as useState2, useRef as useRef3, useCallback as useCallback2, useEffect as useEffect3, useMemo } from "react";
+
+// src/fileUpload/types.ts
+var DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024;
+
+// src/hooks/useFileUpload.tsx
+import { v4 as uuidv4 } from "uuid";
+import { jsx as jsx6 } from "react/jsx-runtime";
+async function generateImagePreview(file) {
+  if (!file.type.startsWith("image/")) {
+    return void 0;
+  }
+  return new Promise((resolve) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      if (typeof reader.result === "string") {
+        resolve(reader.result);
+      } else {
+        resolve(void 0);
+      }
+    };
+    reader.onerror = () => resolve(void 0);
+    reader.readAsDataURL(file);
+  });
+}
+function isTypeAccepted(mimeType, acceptedTypes) {
+  if (!acceptedTypes || acceptedTypes.length === 0) {
+    return true;
+  }
+  return acceptedTypes.some((pattern) => {
+    if (pattern.endsWith("/*")) {
+      const prefix = pattern.slice(0, -1);
+      return mimeType.startsWith(prefix);
+    }
+    return mimeType === pattern;
+  });
+}
+function useFileUpload({
+  config,
+  disabled = false,
+  resetDependency
+}) {
+  const strings = useStrings();
+  const theme = useTheme();
+  const [attachments, setAttachments] = useState2([]);
+  const [isDragging, setIsDragging] = useState2(false);
+  const [fileError, setFileError] = useState2(null);
+  const fileInputRef = useRef3(null);
+  const dragCounterRef = useRef3(0);
+  const enabled = config !== void 0;
+  const maxFileSize = config?.maxFileSize ?? DEFAULT_MAX_FILE_SIZE;
+  const acceptedTypes = config?.acceptedTypes;
+  useEffect3(() => {
+    if (fileError) {
+      const timer = setTimeout(() => setFileError(null), 3e3);
+      return () => clearTimeout(timer);
+    }
+  }, [fileError]);
+  useEffect3(() => {
+    setAttachments([]);
+    setFileError(null);
+  }, [resetDependency]);
+  const handleFiles = useCallback2(async (files) => {
+    const fileArray = Array.from(files);
+    for (const file of fileArray) {
+      if (file.size > maxFileSize) {
+        const errorMsg = strings.fileUpload.fileSizeError.replace("{filename}", file.name).replace("{maxSize}", String(Math.round(maxFileSize / (1024 * 1024))));
+        setFileError(errorMsg);
+        continue;
+      }
+      if (!isTypeAccepted(file.type, acceptedTypes)) {
+        const errorMsg = strings.fileUpload.fileTypeError.replace("{type}", file.type);
+        setFileError(errorMsg);
+        continue;
+      }
+      const preview = await generateImagePreview(file);
+      setAttachments((prev) => [
+        ...prev,
+        {
+          id: uuidv4(),
+          file,
+          preview
+        }
+      ]);
+    }
+  }, [maxFileSize, acceptedTypes, strings]);
+  const removeAttachment = useCallback2((id) => {
+    setAttachments((prev) => prev.filter((a) => a.id !== id));
+  }, []);
+  const clearAttachments = useCallback2(() => {
+    setAttachments([]);
+  }, []);
+  const openFilePicker = useCallback2(() => {
+    fileInputRef.current?.click();
+  }, []);
+  const handleFileInputChange = useCallback2((e) => {
+    const files = e.target.files;
+    if (files && files.length > 0) {
+      handleFiles(files);
+    }
+    e.target.value = "";
+  }, [handleFiles]);
+  const handleDragEnter = useCallback2((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    if (enabled && !disabled) {
+      dragCounterRef.current++;
+      if (dragCounterRef.current === 1) {
+        setIsDragging(true);
+      }
+    }
+  }, [enabled, disabled]);
+  const handleDragOver = useCallback2((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+  }, []);
+  const handleDragLeave = useCallback2((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    dragCounterRef.current--;
+    if (dragCounterRef.current === 0) {
+      setIsDragging(false);
+    }
+  }, []);
+  const handleDrop = useCallback2((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    dragCounterRef.current = 0;
+    setIsDragging(false);
+    if (!enabled || disabled) return;
+    const files = e.dataTransfer.files;
+    if (files.length > 0) {
+      handleFiles(files);
+    }
+  }, [enabled, disabled, handleFiles]);
+  const getDropZoneProps = useCallback2(() => ({
+    onDragEnter: handleDragEnter,
+    onDragOver: handleDragOver,
+    onDragLeave: handleDragLeave,
+    onDrop: handleDrop
+  }), [handleDragEnter, handleDragOver, handleDragLeave, handleDrop]);
+  const DropZoneOverlay = useMemo(() => {
+    if (!isDragging || !enabled) return null;
+    return /* @__PURE__ */ jsx6(
+      "div",
+      {
+        style: {
+          position: "absolute",
+          inset: 0,
+          background: theme.primaryColorTranslucent,
+          border: `3px dashed ${theme.primaryColor}`,
+          borderRadius: "inherit",
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          zIndex: 1010,
+          pointerEvents: "none"
+        },
+        children: /* @__PURE__ */ jsx6(
+          "div",
+          {
+            style: {
+              background: theme.backgroundColor,
+              padding: "16px 24px",
+              borderRadius: "12px",
+              boxShadow: theme.buttonShadow
+            },
+            children: /* @__PURE__ */ jsx6("span", { style: { color: theme.primaryColor, fontWeight: 600, fontSize: "16px" }, children: strings.fileUpload.dropFilesHere })
+          }
+        )
+      }
+    );
+  }, [isDragging, enabled, theme, strings]);
+  return {
+    attachments,
+    isDragging,
+    fileError,
+    enabled,
+    maxFileSize,
+    acceptedTypes,
+    fileInputRef,
+    handleFiles,
+    removeAttachment,
+    clearAttachments,
+    openFilePicker,
+    handleFileInputChange,
+    handleDragEnter,
+    handleDragOver,
+    handleDragLeave,
+    handleDrop,
+    getDropZoneProps,
+    DropZoneOverlay
+  };
+}
+
+// src/hooks/useDropdownState.tsx
+import { useState as useState3, useCallback as useCallback3, useMemo as useMemo2 } from "react";
+import { jsx as jsx7 } from "react/jsx-runtime";
+function useDropdownState(options = {}) {
+  const { backdropZIndex = 1002, initialOpen = false } = options;
+  const [isOpen, setIsOpen] = useState3(initialOpen);
+  const open = useCallback3(() => {
+    setIsOpen(true);
+  }, []);
+  const close = useCallback3(() => {
+    setIsOpen(false);
+  }, []);
+  const toggle = useCallback3(() => {
+    setIsOpen((prev) => !prev);
+  }, []);
+  const Backdrop = useMemo2(() => {
+    if (!isOpen) return null;
+    return /* @__PURE__ */ jsx7(
+      "div",
+      {
+        onClick: close,
+        style: {
+          position: "fixed",
+          top: 0,
+          left: 0,
+          right: 0,
+          bottom: 0,
+          zIndex: backdropZIndex
+        }
+      }
+    );
+  }, [isOpen, close, backdropZIndex]);
+  return {
+    isOpen,
+    open,
+    close,
+    toggle,
+    Backdrop
+  };
+}
+
+// src/components/UseAIChatPanel.tsx
+import { Fragment, jsx as jsx8, jsxs as jsxs5 } from "react/jsx-runtime";
+function getTextContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+}
+function hasFileContent(content) {
+  return Array.isArray(content) && content.some((part) => part.type === "file");
+}
+function UseAIChatPanel({
+  onSendMessage,
+  messages,
+  loading,
+  connected,
+  streamingText = "",
+  currentChatId,
+  onNewChat,
+  onLoadChat,
+  onDeleteChat,
+  onListChats,
+  suggestions,
+  availableAgents,
+  defaultAgent,
+  selectedAgent,
+  onAgentChange,
+  fileUploadConfig,
+  commands = [],
+  onSaveCommand,
+  onRenameCommand,
+  onDeleteCommand,
+  closeButton
+}) {
+  const strings = useStrings();
+  const theme = useTheme();
+  const [input, setInput] = useState4("");
+  const chatHistoryDropdown = useDropdownState();
+  const agentDropdown = useDropdownState();
+  const [chatHistory, setChatHistory] = useState4([]);
+  const messagesEndRef = useRef4(null);
+  const [displayedSuggestions, setDisplayedSuggestions] = useState4([]);
+  const [hoveredMessageId, setHoveredMessageId] = useState4(null);
+  const {
+    attachments,
+    fileError,
+    enabled: fileUploadEnabled,
+    acceptedTypes,
+    fileInputRef,
+    removeAttachment,
+    clearAttachments,
+    openFilePicker,
+    handleFileInputChange,
+    getDropZoneProps,
+    DropZoneOverlay
+  } = useFileUpload({
+    config: fileUploadConfig,
+    disabled: loading,
+    resetDependency: currentChatId
+  });
+  const slashCommands = useSlashCommands({
+    commands,
+    onCommandSelect: (text) => setInput(text),
+    onSaveCommand,
+    onRenameCommand,
+    onDeleteCommand
+  });
+  useEffect4(() => {
+    messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
+  }, [messages]);
+  useEffect4(() => {
+    if (!suggestions || suggestions.length === 0) {
+      setDisplayedSuggestions([]);
+      return;
+    }
+    const shuffled = [...suggestions].sort(() => Math.random() - 0.5);
+    setDisplayedSuggestions(shuffled.slice(0, 4));
+  }, [messages.length, suggestions]);
+  const handleSend = () => {
+    const hasContent = input.trim() || attachments.length > 0;
+    if (!hasContent || !connected || loading) return;
+    onSendMessage(input, attachments.length > 0 ? attachments : void 0);
+    setInput("");
+    clearAttachments();
+    slashCommands.closeAutocomplete();
+  };
+  const handleInputChange = (e) => {
+    const value = e.target.value;
+    setInput(value);
+    slashCommands.handleInputChange(value);
+  };
+  const handleKeyDown = (e) => {
+    if (slashCommands.handleKeyDown(e)) {
+      return;
+    }
+    if (e.key === "Enter" && !e.shiftKey && !e.nativeEvent.isComposing && !(e.keyCode === 229)) {
+      e.preventDefault();
+      handleSend();
+    }
+  };
+  const handleNewChat = async () => {
+    if (onNewChat) {
+      await onNewChat();
+    }
+  };
+  const handleDeleteChat = async () => {
+    if (onDeleteChat && currentChatId && confirm(strings.header.deleteConfirm)) {
+      await onDeleteChat(currentChatId);
+      if (onNewChat) {
+        await onNewChat();
+      }
+    }
+  };
+  const handleLoadChat = async (chatId) => {
+    if (onLoadChat) {
+      await onLoadChat(chatId);
+      chatHistoryDropdown.close();
+    }
+  };
+  return /* @__PURE__ */ jsxs5(
+    "div",
+    {
+      onClick: () => {
+        slashCommands.cancelInlineSave();
+      },
+      ...getDropZoneProps(),
+      style: {
+        width: "100%",
+        height: "100%",
+        background: theme.backgroundColor,
+        display: "flex",
+        flexDirection: "column",
+        fontFamily: theme.fontFamily,
+        position: "relative"
+      },
+      children: [
+        DropZoneOverlay,
+        /* @__PURE__ */ jsxs5(
+          "div",
+          {
+            style: {
+              padding: "12px 16px",
+              borderBottom: `1px solid ${theme.borderColor}`,
+              background: theme.backgroundColor,
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "space-between",
+              gap: "12px"
+            },
+            children: [
+              /* @__PURE__ */ jsx8("div", { style: { flex: 1, minWidth: 0, position: "relative" }, children: onListChats ? /* @__PURE__ */ jsxs5(
+                "button",
+                {
+                  "data-testid": "chat-history-dropdown-button",
+                  onClick: async () => {
+                    const chats = await onListChats();
+                    setChatHistory(chats);
+                    chatHistoryDropdown.toggle();
+                  },
+                  style: {
+                    background: "transparent",
+                    border: "none",
+                    padding: "6px 8px",
+                    cursor: "pointer",
+                    display: "flex",
+                    alignItems: "center",
+                    gap: "8px",
+                    fontSize: "14px",
+                    fontWeight: "600",
+                    color: theme.textColor,
+                    borderRadius: "6px",
+                    transition: "background 0.2s",
+                    width: "100%",
+                    textAlign: "left",
+                    overflow: "hidden"
+                  },
+                  onMouseEnter: (e) => {
+                    e.currentTarget.style.background = theme.hoverBackground;
+                  },
+                  onMouseLeave: (e) => {
+                    e.currentTarget.style.background = "transparent";
+                  },
+                  children: [
+                    /* @__PURE__ */ jsx8("span", { style: {
+                      overflow: "hidden",
+                      textOverflow: "ellipsis",
+                      whiteSpace: "nowrap",
+                      flex: 1,
+                      minWidth: 0
+                    }, children: (() => {
+                      if (messages.length > 0) {
+                        const firstUserMsg = messages.find((m) => m.role === "user");
+                        if (firstUserMsg) {
+                          const textContent = getTextContent(firstUserMsg.content);
+                          const maxLength = 30;
+                          return textContent.length > maxLength ? textContent.substring(0, maxLength) + "..." : textContent || strings.header.newChat;
+                        }
+                      }
+                      return strings.header.newChat;
+                    })() }),
+                    /* @__PURE__ */ jsx8("svg", { width: "12", height: "12", viewBox: "0 0 12 12", fill: "none", style: { flexShrink: 0 }, children: /* @__PURE__ */ jsx8("path", { d: "M3 4.5L6 7.5L9 4.5", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round" }) })
+                  ]
+                }
+              ) : /* @__PURE__ */ jsx8("div", { style: { fontSize: "14px", fontWeight: "600", color: theme.textColor, padding: "6px 8px" }, children: strings.header.aiAssistant }) }),
+              /* @__PURE__ */ jsxs5("div", { style: { display: "flex", alignItems: "center", gap: "4px" }, children: [
+                availableAgents && availableAgents.length > 1 && onAgentChange && /* @__PURE__ */ jsxs5("div", { style: { position: "relative" }, children: [
+                  /* @__PURE__ */ jsxs5(
+                    "button",
+                    {
+                      "data-testid": "agent-selector",
+                      onClick: agentDropdown.toggle,
+                      style: {
+                        background: "transparent",
+                        border: "none",
+                        padding: "6px 8px",
+                        cursor: "pointer",
+                        display: "flex",
+                        alignItems: "center",
+                        gap: "4px",
+                        fontSize: "13px",
+                        fontWeight: "500",
+                        color: theme.secondaryTextColor,
+                        borderRadius: "6px",
+                        transition: "all 0.2s"
+                      },
+                      onMouseEnter: (e) => {
+                        e.currentTarget.style.background = theme.hoverBackground;
+                        e.currentTarget.style.color = theme.textColor;
+                      },
+                      onMouseLeave: (e) => {
+                        e.currentTarget.style.background = "transparent";
+                        e.currentTarget.style.color = theme.secondaryTextColor;
+                      },
+                      title: "Select AI model",
+                      children: [
+                        /* @__PURE__ */ jsx8("span", { style: {
+                          overflow: "hidden",
+                          textOverflow: "ellipsis",
+                          whiteSpace: "nowrap",
+                          maxWidth: "120px"
+                        }, children: (() => {
+                          const agent = availableAgents.find((a) => a.id === (selectedAgent ?? defaultAgent));
+                          return agent?.name || "AI";
+                        })() }),
+                        /* @__PURE__ */ jsx8("svg", { width: "10", height: "10", viewBox: "0 0 12 12", fill: "none", style: { flexShrink: 0 }, children: /* @__PURE__ */ jsx8("path", { d: "M3 4.5L6 7.5L9 4.5", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round" }) })
+                      ]
+                    }
+                  ),
+                  agentDropdown.isOpen && /* @__PURE__ */ jsx8(
+                    "div",
+                    {
+                      style: {
+                        position: "absolute",
+                        top: "100%",
+                        left: "50%",
+                        transform: "translateX(-50%)",
+                        marginTop: "4px",
+                        minWidth: "180px",
+                        maxWidth: "280px",
+                        background: theme.backgroundColor,
+                        borderRadius: "8px",
+                        boxShadow: "0 4px 16px rgba(0, 0, 0, 0.15)",
+                        zIndex: 1003,
+                        overflow: "hidden",
+                        padding: "4px"
+                      },
+                      children: availableAgents.map((agent) => {
+                        const isSelected = agent.id === (selectedAgent ?? defaultAgent);
+                        return /* @__PURE__ */ jsxs5(
+                          "div",
+                          {
+                            "data-testid": "agent-option",
+                            onClick: () => {
+                              onAgentChange(agent.id === defaultAgent ? null : agent.id);
+                              agentDropdown.close();
+                            },
+                            style: {
+                              padding: "8px 12px",
+                              background: isSelected ? theme.activeBackground : "transparent",
+                              borderRadius: "6px",
+                              cursor: "pointer",
+                              transition: "background 0.15s",
+                              display: "flex",
+                              alignItems: "center",
+                              justifyContent: "space-between",
+                              gap: "8px"
+                            },
+                            onMouseEnter: (e) => {
+                              if (!isSelected) {
+                                e.currentTarget.style.background = theme.hoverBackground;
+                              }
+                            },
+                            onMouseLeave: (e) => {
+                              if (!isSelected) {
+                                e.currentTarget.style.background = "transparent";
+                              }
+                            },
+                            children: [
+                              /* @__PURE__ */ jsxs5("div", { style: { flex: 1, minWidth: 0 }, children: [
+                                /* @__PURE__ */ jsx8("div", { style: {
+                                  fontSize: "13px",
+                                  fontWeight: isSelected ? "600" : "500",
+                                  color: isSelected ? theme.primaryColor : theme.textColor
+                                }, children: agent.name }),
+                                agent.annotation && /* @__PURE__ */ jsx8("div", { style: {
+                                  fontSize: "11px",
+                                  color: theme.secondaryTextColor,
+                                  marginTop: "2px",
+                                  overflow: "hidden",
+                                  textOverflow: "ellipsis",
+                                  whiteSpace: "nowrap"
+                                }, children: agent.annotation })
+                              ] }),
+                              isSelected && /* @__PURE__ */ jsx8("svg", { width: "14", height: "14", viewBox: "0 0 14 14", fill: "none", style: { flexShrink: 0 }, children: /* @__PURE__ */ jsx8("path", { d: "M2 7L5.5 10.5L12 4", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" }) })
+                            ]
+                          },
+                          agent.id
+                        );
+                      })
+                    }
+                  )
+                ] }),
+                onNewChat && /* @__PURE__ */ jsx8(
+                  "button",
+                  {
+                    "data-testid": "new-chat-button",
+                    onClick: handleNewChat,
+                    style: {
+                      background: "transparent",
+                      border: "none",
+                      borderRadius: "6px",
+                      padding: "6px 8px",
+                      color: theme.secondaryTextColor,
+                      fontSize: "13px",
+                      cursor: "pointer",
+                      transition: "all 0.2s",
+                      display: "flex",
+                      alignItems: "center",
+                      gap: "4px"
+                    },
+                    onMouseEnter: (e) => {
+                      e.currentTarget.style.background = theme.hoverBackground;
+                      e.currentTarget.style.color = theme.textColor;
+                    },
+                    onMouseLeave: (e) => {
+                      e.currentTarget.style.background = "transparent";
+                      e.currentTarget.style.color = theme.secondaryTextColor;
+                    },
+                    title: strings.header.newChat,
+                    children: /* @__PURE__ */ jsx8("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", children: /* @__PURE__ */ jsx8("path", { d: "M8 3.5V12.5M3.5 8H12.5", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round" }) })
+                  }
+                ),
+                onDeleteChat && messages.length > 0 && /* @__PURE__ */ jsx8(
+                  "button",
+                  {
+                    "data-testid": "delete-chat-button",
+                    onClick: handleDeleteChat,
+                    style: {
+                      background: "transparent",
+                      border: "none",
+                      borderRadius: "6px",
+                      padding: "6px 8px",
+                      color: theme.secondaryTextColor,
+                      fontSize: "13px",
+                      cursor: "pointer",
+                      transition: "all 0.2s"
+                    },
+                    onMouseEnter: (e) => {
+                      e.currentTarget.style.background = theme.hoverBackground;
+                      e.currentTarget.style.color = theme.textColor;
+                    },
+                    onMouseLeave: (e) => {
+                      e.currentTarget.style.background = "transparent";
+                      e.currentTarget.style.color = theme.secondaryTextColor;
+                    },
+                    title: strings.header.deleteChat,
+                    children: /* @__PURE__ */ jsx8("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", children: /* @__PURE__ */ jsx8("path", { d: "M2 4H14M6.5 7V11M9.5 7V11M3 4L4 13C4 13.5304 4.21071 14.0391 4.58579 14.4142C4.96086 14.7893 5.46957 15 6 15H10C10.5304 15 11.0391 14.7893 11.4142 14.4142C11.7893 14.0391 12 13.5304 12 13L13 4M5.5 4V2.5C5.5 2.23478 5.60536 1.98043 5.79289 1.79289C5.98043 1.60536 6.23478 1.5 6.5 1.5H9.5C9.76522 1.5 10.0196 1.60536 10.2071 1.79289C10.3946 1.98043 10.5 2.23478 10.5 2.5V4", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round" }) })
+                  }
+                ),
+                closeButton
+              ] })
+            ]
+          }
+        ),
+        chatHistoryDropdown.isOpen && onListChats && /* @__PURE__ */ jsx8(
+          "div",
+          {
+            style: {
+              position: "absolute",
+              top: "60px",
+              left: "16px",
+              width: "320px",
+              maxHeight: "400px",
+              background: theme.backgroundColor,
+              borderRadius: "8px",
+              boxShadow: theme.panelShadow,
+              zIndex: 1003,
+              display: "flex",
+              flexDirection: "column",
+              overflow: "hidden"
+            },
+            children: /* @__PURE__ */ jsx8(
+              "div",
+              {
+                style: {
+                  flex: 1,
+                  overflowY: "auto",
+                  padding: "8px"
+                },
+                children: chatHistory.length === 0 ? /* @__PURE__ */ jsx8(
+                  "div",
+                  {
+                    style: {
+                      textAlign: "center",
+                      color: theme.secondaryTextColor,
+                      padding: "32px 16px",
+                      fontSize: "13px"
+                    },
+                    children: /* @__PURE__ */ jsx8("p", { style: { margin: 0 }, children: strings.chatHistory.noChatHistory })
+                  }
+                ) : chatHistory.map((chat) => /* @__PURE__ */ jsxs5(
+                  "div",
+                  {
+                    "data-testid": "chat-history-item",
+                    onClick: () => handleLoadChat(chat.id),
+                    style: {
+                      padding: "10px 12px",
+                      marginBottom: "4px",
+                      background: currentChatId === chat.id ? theme.activeBackground : "transparent",
+                      borderRadius: "6px",
+                      cursor: "pointer",
+                      transition: "background 0.15s"
+                    },
+                    onMouseEnter: (e) => {
+                      if (currentChatId !== chat.id) {
+                        e.currentTarget.style.background = theme.hoverBackground;
+                      }
+                    },
+                    onMouseLeave: (e) => {
+                      if (currentChatId !== chat.id) {
+                        e.currentTarget.style.background = "transparent";
+                      }
+                    },
+                    children: [
+                      /* @__PURE__ */ jsx8("div", { style: { fontSize: "13px", fontWeight: "500", color: theme.textColor, marginBottom: "4px", overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }, children: chat.title || strings.header.newChat }),
+                      /* @__PURE__ */ jsxs5("div", { style: { fontSize: "11px", color: theme.secondaryTextColor }, children: [
+                        new Date(chat.updatedAt).toLocaleDateString([], { month: "short", day: "numeric" }),
+                        currentChatId === chat.id && /* @__PURE__ */ jsxs5("span", { style: {
+                          marginLeft: "8px",
+                          color: theme.primaryColor,
+                          fontWeight: "600"
+                        }, children: [
+                          "\u2022 ",
+                          strings.chatHistory.active
+                        ] })
+                      ] })
+                    ]
+                  },
+                  chat.id
+                ))
+              }
+            )
+          }
+        ),
+        chatHistoryDropdown.Backdrop,
+        agentDropdown.Backdrop,
+        /* @__PURE__ */ jsxs5(
+          "div",
+          {
+            style: {
+              flex: 1,
+              overflowY: "auto",
+              padding: "16px",
+              display: "flex",
+              flexDirection: "column",
+              gap: "12px"
+            },
+            children: [
+              messages.length === 0 && /* @__PURE__ */ jsxs5(
+                "div",
+                {
+                  style: {
+                    display: "flex",
+                    flexDirection: "column",
+                    alignItems: "center",
+                    padding: "40px 20px",
+                    gap: "20px"
+                  },
+                  children: [
+                    /* @__PURE__ */ jsxs5("div", { style: { textAlign: "center", color: theme.secondaryTextColor, fontSize: "14px" }, children: [
+                      /* @__PURE__ */ jsx8("p", { style: { margin: 0, fontSize: "32px", marginBottom: "12px" }, children: "\u{1F4AC}" }),
+                      /* @__PURE__ */ jsx8("p", { style: { margin: 0 }, children: strings.emptyChat.startConversation }),
+                      /* @__PURE__ */ jsx8("p", { style: { margin: "8px 0 0", fontSize: "12px" }, children: strings.emptyChat.askMeToHelp })
+                    ] }),
+                    displayedSuggestions.length > 0 && /* @__PURE__ */ jsx8(
+                      "div",
+                      {
+                        style: {
+                          display: "grid",
+                          gridTemplateColumns: "repeat(2, 1fr)",
+                          gap: "8px",
+                          width: "100%",
+                          maxWidth: "320px"
+                        },
+                        children: displayedSuggestions.map((suggestion, index) => /* @__PURE__ */ jsx8(
+                          "button",
+                          {
+                            "data-testid": "chat-suggestion-button",
+                            onClick: () => {
+                              if (connected && !loading) {
+                                onSendMessage(suggestion);
+                              }
+                            },
+                            disabled: !connected || loading,
+                            style: {
+                              padding: "10px 14px",
+                              background: theme.backgroundColor,
+                              border: `1px solid ${theme.borderColor}`,
+                              borderRadius: "8px",
+                              fontSize: "13px",
+                              color: theme.textColor,
+                              cursor: connected && !loading ? "pointer" : "not-allowed",
+                              textAlign: "left",
+                              transition: "all 0.2s",
+                              lineHeight: "1.4",
+                              opacity: connected && !loading ? 1 : 0.5
+                            },
+                            onMouseEnter: (e) => {
+                              if (connected && !loading) {
+                                e.currentTarget.style.background = theme.hoverBackground;
+                                e.currentTarget.style.transform = "translateY(-1px)";
+                                e.currentTarget.style.boxShadow = "0 2px 8px rgba(0, 0, 0, 0.08)";
+                              }
+                            },
+                            onMouseLeave: (e) => {
+                              e.currentTarget.style.background = theme.backgroundColor;
+                              e.currentTarget.style.transform = "translateY(0)";
+                              e.currentTarget.style.boxShadow = "none";
+                            },
+                            children: suggestion
+                          },
+                          index
+                        ))
+                      }
+                    )
+                  ]
+                }
+              ),
+              messages.map((message) => /* @__PURE__ */ jsxs5(
+                "div",
+                {
+                  "data-testid": `chat-message-${message.role}`,
+                  className: `chat-message chat-message-${message.role}`,
+                  style: {
+                    display: "flex",
+                    flexDirection: "column",
+                    alignItems: message.role === "user" ? "flex-end" : "flex-start"
+                  },
+                  onMouseEnter: () => message.role === "user" && setHoveredMessageId(message.id),
+                  onMouseLeave: () => setHoveredMessageId(null),
+                  children: [
+                    /* @__PURE__ */ jsxs5(
+                      "div",
+                      {
+                        style: {
+                          position: "relative",
+                          maxWidth: "80%"
+                        },
+                        children: [
+                          message.role === "user" && hoveredMessageId === message.id && onSaveCommand && !slashCommands.isSavingCommand(message.id) && /* @__PURE__ */ jsx8(
+                            "button",
+                            {
+                              "data-testid": "save-command-button",
+                              onClick: (e) => {
+                                e.stopPropagation();
+                                const messageText = getTextContent(message.content);
+                                slashCommands.startSavingCommand(message.id, messageText);
+                              },
+                              title: "Save as slash command",
+                              style: {
+                                position: "absolute",
+                                top: "-8px",
+                                right: "-8px",
+                                width: "24px",
+                                height: "24px",
+                                borderRadius: "50%",
+                                border: "none",
+                                background: theme.backgroundColor,
+                                boxShadow: "0 2px 6px rgba(0, 0, 0, 0.15)",
+                                cursor: "pointer",
+                                display: "flex",
+                                alignItems: "center",
+                                justifyContent: "center",
+                                color: theme.primaryColor,
+                                transition: "all 0.15s",
+                                zIndex: 10
+                              },
+                              onMouseEnter: (e) => {
+                                e.currentTarget.style.transform = "scale(1.1)";
+                                e.currentTarget.style.boxShadow = "0 3px 8px rgba(0, 0, 0, 0.2)";
+                              },
+                              onMouseLeave: (e) => {
+                                e.currentTarget.style.transform = "scale(1)";
+                                e.currentTarget.style.boxShadow = "0 2px 6px rgba(0, 0, 0, 0.15)";
+                              },
+                              children: /* @__PURE__ */ jsxs5("svg", { width: "14", height: "14", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+                                /* @__PURE__ */ jsx8("path", { d: "M19 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h11l5 5v11a2 2 0 0 1-2 2z" }),
+                                /* @__PURE__ */ jsx8("polyline", { points: "17 21 17 13 7 13 7 21" }),
+                                /* @__PURE__ */ jsx8("polyline", { points: "7 3 7 8 15 8" })
+                              ] })
+                            }
+                          ),
+                          /* @__PURE__ */ jsxs5(
+                            "div",
+                            {
+                              "data-testid": "chat-message-content",
+                              className: `chat-message-content${message.role === "assistant" ? " markdown-content" : ""}`,
+                              style: {
+                                padding: "10px 14px",
+                                borderRadius: slashCommands.isSavingCommand(message.id) ? "12px 12px 0 0" : "12px",
+                                background: message.displayMode === "error" ? theme.errorBackground : message.role === "user" ? theme.primaryGradient : theme.assistantMessageBackground,
+                                color: message.displayMode === "error" ? theme.errorTextColor : message.role === "user" ? "white" : theme.textColor,
+                                fontSize: "14px",
+                                lineHeight: "1.5",
+                                wordWrap: "break-word"
+                              },
+                              children: [
+                                message.role === "user" && hasFileContent(message.content) && /* @__PURE__ */ jsx8("div", { style: { display: "flex", flexWrap: "wrap", gap: "6px", marginBottom: "8px" }, children: message.content.filter((part) => part.type === "file").map((part, idx) => /* @__PURE__ */ jsx8(
+                                  FilePlaceholder,
+                                  {
+                                    name: part.file.name,
+                                    size: part.file.size
+                                  },
+                                  idx
+                                )) }),
+                                message.role === "assistant" ? /* @__PURE__ */ jsx8(MarkdownContent, { content: getTextContent(message.content) }) : getTextContent(message.content)
+                              ]
+                            }
+                          ),
+                          slashCommands.renderInlineSaveUI({
+                            messageId: message.id,
+                            messageText: getTextContent(message.content)
+                          })
+                        ]
+                      }
+                    ),
+                    /* @__PURE__ */ jsx8(
+                      "div",
+                      {
+                        style: {
+                          fontSize: "11px",
+                          color: theme.secondaryTextColor,
+                          marginTop: "4px",
+                          padding: "0 4px"
+                        },
+                        children: message.timestamp.toLocaleTimeString([], {
+                          hour: "2-digit",
+                          minute: "2-digit"
+                        })
+                      }
+                    )
+                  ]
+                },
+                message.id
+              )),
+              loading && /* @__PURE__ */ jsx8(
+                "div",
+                {
+                  style: {
+                    display: "flex",
+                    alignItems: "flex-start"
+                  },
+                  children: /* @__PURE__ */ jsx8(
+                    "div",
+                    {
+                      className: "markdown-content",
+                      style: {
+                        padding: "10px 14px",
+                        borderRadius: "12px",
+                        background: theme.assistantMessageBackground,
+                        fontSize: "14px",
+                        lineHeight: "1.5",
+                        color: theme.textColor,
+                        maxWidth: "80%"
+                      },
+                      children: streamingText ? /* @__PURE__ */ jsx8(MarkdownContent, { content: streamingText }) : /* @__PURE__ */ jsxs5(Fragment, { children: [
+                        /* @__PURE__ */ jsx8("span", { style: { opacity: 0.6 }, children: strings.input.thinking }),
+                        /* @__PURE__ */ jsx8("span", { className: "dots", style: { marginLeft: "4px" }, children: "..." })
+                      ] })
+                    }
+                  )
+                }
+              ),
+              /* @__PURE__ */ jsx8("div", { ref: messagesEndRef })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs5(
+          "div",
+          {
+            style: {
+              padding: "16px",
+              borderTop: `1px solid ${theme.borderColor}`
+            },
+            children: [
+              fileError && /* @__PURE__ */ jsx8(
+                "div",
+                {
+                  "data-testid": "file-error",
+                  style: {
+                    marginBottom: "8px",
+                    padding: "8px 12px",
+                    background: theme.errorBackground,
+                    color: theme.errorTextColor,
+                    borderRadius: "6px",
+                    fontSize: "13px"
+                  },
+                  children: fileError
+                }
+              ),
+              attachments.length > 0 && /* @__PURE__ */ jsx8(
+                "div",
+                {
+                  "data-testid": "file-attachments",
+                  style: {
+                    display: "flex",
+                    flexWrap: "wrap",
+                    gap: "8px",
+                    marginBottom: "8px"
+                  },
+                  children: attachments.map((attachment) => /* @__PURE__ */ jsx8(
+                    FileChip,
+                    {
+                      attachment,
+                      onRemove: () => removeAttachment(attachment.id),
+                      disabled: loading
+                    },
+                    attachment.id
+                  ))
+                }
+              ),
+              /* @__PURE__ */ jsxs5(
+                "div",
+                {
+                  style: {
+                    display: "flex",
+                    gap: "8px",
+                    position: "relative"
+                  },
+                  children: [
+                    slashCommands.AutocompleteComponent,
+                    /* @__PURE__ */ jsx8(
+                      "input",
+                      {
+                        ref: fileInputRef,
+                        type: "file",
+                        multiple: true,
+                        style: { display: "none" },
+                        onChange: handleFileInputChange,
+                        accept: acceptedTypes?.join(",")
+                      }
+                    ),
+                    /* @__PURE__ */ jsxs5(
+                      "div",
+                      {
+                        style: {
+                          flex: 1,
+                          display: "flex",
+                          alignItems: "center",
+                          border: `1px solid ${theme.borderColor}`,
+                          borderRadius: "8px",
+                          background: theme.backgroundColor,
+                          overflow: "hidden"
+                        },
+                        children: [
+                          /* @__PURE__ */ jsx8(
+                            "textarea",
+                            {
+                              "data-testid": "chat-input",
+                              className: "chat-input",
+                              value: input,
+                              onChange: handleInputChange,
+                              onKeyDown: handleKeyDown,
+                              placeholder: connected ? strings.input.placeholder : strings.input.connectingPlaceholder,
+                              disabled: !connected || loading,
+                              style: {
+                                flex: 1,
+                                padding: "10px 12px",
+                                border: "none",
+                                fontSize: "14px",
+                                resize: "none",
+                                minHeight: "44px",
+                                maxHeight: "120px",
+                                fontFamily: "inherit",
+                                outline: "none",
+                                background: "transparent"
+                              },
+                              rows: 1
+                            }
+                          ),
+                          fileUploadEnabled && /* @__PURE__ */ jsx8(
+                            "button",
+                            {
+                              "data-testid": "file-picker-button",
+                              onClick: openFilePicker,
+                              disabled: !connected || loading,
+                              style: {
+                                padding: "6px",
+                                marginRight: "6px",
+                                background: "transparent",
+                                border: "none",
+                                borderRadius: "6px",
+                                cursor: connected && !loading ? "pointer" : "not-allowed",
+                                color: theme.secondaryTextColor,
+                                display: "flex",
+                                alignItems: "center",
+                                justifyContent: "center",
+                                transition: "all 0.15s",
+                                opacity: connected && !loading ? 1 : 0.5
+                              },
+                              onMouseEnter: (e) => {
+                                if (connected && !loading) {
+                                  e.currentTarget.style.color = theme.primaryColor;
+                                  e.currentTarget.style.background = theme.activeBackground;
+                                }
+                              },
+                              onMouseLeave: (e) => {
+                                e.currentTarget.style.color = theme.secondaryTextColor;
+                                e.currentTarget.style.background = "transparent";
+                              },
+                              title: strings.fileUpload.attachFiles,
+                              children: /* @__PURE__ */ jsxs5("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+                                /* @__PURE__ */ jsx8("circle", { cx: "12", cy: "12", r: "10" }),
+                                /* @__PURE__ */ jsx8("line", { x1: "12", y1: "8", x2: "12", y2: "16" }),
+                                /* @__PURE__ */ jsx8("line", { x1: "8", y1: "12", x2: "16", y2: "12" })
+                              ] })
+                            }
+                          )
+                        ]
+                      }
+                    ),
+                    /* @__PURE__ */ jsx8(
+                      "button",
+                      {
+                        "data-testid": "chat-send-button",
+                        className: "chat-send-button",
+                        onClick: handleSend,
+                        disabled: !connected || loading || !input.trim() && attachments.length === 0,
+                        style: {
+                          padding: "10px 16px",
+                          background: connected && !loading && (input.trim() || attachments.length > 0) ? theme.primaryGradient : theme.buttonDisabledBackground,
+                          color: connected && !loading && (input.trim() || attachments.length > 0) ? "white" : theme.secondaryTextColor,
+                          border: "none",
+                          borderRadius: "8px",
+                          cursor: connected && !loading && (input.trim() || attachments.length > 0) ? "pointer" : "not-allowed",
+                          fontSize: "14px",
+                          fontWeight: "600",
+                          minWidth: "60px",
+                          transition: "all 0.2s"
+                        },
+                        children: strings.input.send
+                      }
+                    )
+                  ]
+                }
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx8("style", { children: `
+        /* Markdown content styles */
+        .markdown-content > :first-child {
+          margin-top: 0 !important;
+        }
+        .markdown-content > :last-child {
+          margin-bottom: 0 !important;
+        }
+        .markdown-content p:last-child {
+          margin-bottom: 0 !important;
+        }
+        .markdown-content ul:last-child,
+        .markdown-content ol:last-child {
+          margin-bottom: 0 !important;
+        }
+        .markdown-content pre:last-child {
+          margin-bottom: 0 !important;
+        }
+      ` })
+      ]
+    }
+  );
+}
+
+// src/components/UseAIFloatingChatWrapper.tsx
+import { Fragment as Fragment2, jsx as jsx9, jsxs as jsxs6 } from "react/jsx-runtime";
+function UseAIFloatingChatWrapper({
+  isOpen,
+  onClose,
+  children
+}) {
+  const theme = useTheme();
+  if (!isOpen) return null;
+  return /* @__PURE__ */ jsxs6(Fragment2, { children: [
+    /* @__PURE__ */ jsx9(
+      "div",
+      {
+        style: {
+          position: "fixed",
+          top: 0,
+          left: 0,
+          right: 0,
+          bottom: 0,
+          background: theme.backdropColor,
+          zIndex: 999,
+          animation: "fadeIn 0.2s"
+        },
+        onClick: onClose
+      }
+    ),
+    /* @__PURE__ */ jsx9(
+      "div",
+      {
+        style: {
+          position: "fixed",
+          bottom: "24px",
+          right: "24px",
+          width: "380px",
+          height: "600px",
+          maxHeight: "calc(100vh - 48px)",
+          borderRadius: "16px",
+          boxShadow: theme.panelShadow,
+          zIndex: 1001,
+          animation: "slideIn 0.3s ease-out",
+          overflow: "hidden"
+        },
+        children
+      }
+    ),
+    /* @__PURE__ */ jsx9("style", { children: `
+        @keyframes fadeIn {
+          from { opacity: 0; }
+          to { opacity: 1; }
+        }
+        @keyframes slideIn {
+          from {
+            transform: translateY(20px);
+            opacity: 0;
+          }
+          to {
+            transform: translateY(0);
+            opacity: 1;
+          }
+        }
+      ` })
+  ] });
+}
+function CloseButton({ onClick }) {
+  const theme = useTheme();
+  return /* @__PURE__ */ jsx9(
+    "button",
+    {
+      "data-testid": "chat-close-button",
+      className: "chat-close-button",
+      onClick,
+      style: {
+        background: "transparent",
+        border: "none",
+        borderRadius: "6px",
+        padding: "6px 8px",
+        cursor: "pointer",
+        color: theme.secondaryTextColor,
+        fontSize: "20px",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        transition: "all 0.2s",
+        lineHeight: 1
+      },
+      onMouseEnter: (e) => {
+        e.currentTarget.style.background = theme.hoverBackground;
+        e.currentTarget.style.color = theme.textColor;
+      },
+      onMouseLeave: (e) => {
+        e.currentTarget.style.background = "transparent";
+        e.currentTarget.style.color = theme.secondaryTextColor;
+      },
+      children: "\xD7"
+    }
+  );
+}
+
+// src/components/UseAIChat.tsx
+import { createContext as createContext3, useContext as useContext3 } from "react";
+import { jsx as jsx10 } from "react/jsx-runtime";
+var __UseAIChatContext = createContext3(null);
+function useChatUIContext() {
+  const context = useContext3(__UseAIChatContext);
+  if (!context) {
+    throw new Error(
+      "UseAIChat must be used within a UseAIProvider. Make sure UseAIChat is a descendant of UseAIProvider."
+    );
+  }
+  return context;
+}
+function UseAIChat({ floating = false }) {
+  const ctx = useChatUIContext();
+  const chatPanelProps = {
+    onSendMessage: ctx.sendMessage,
+    messages: ctx.messages,
+    loading: ctx.loading,
+    connected: ctx.connected,
+    streamingText: ctx.streamingText,
+    currentChatId: ctx.history.currentId,
+    onNewChat: ctx.history.create,
+    onLoadChat: ctx.history.load,
+    onDeleteChat: ctx.history.delete,
+    onListChats: ctx.history.list,
+    suggestions: ctx.suggestions,
+    availableAgents: ctx.agents.available,
+    defaultAgent: ctx.agents.default,
+    selectedAgent: ctx.agents.selected,
+    onAgentChange: ctx.agents.set,
+    fileUploadConfig: ctx.fileUploadConfig,
+    commands: ctx.commands.list,
+    onSaveCommand: ctx.commands.save,
+    onRenameCommand: ctx.commands.rename,
+    onDeleteCommand: ctx.commands.delete
+  };
+  if (floating) {
+    return /* @__PURE__ */ jsx10(
+      UseAIFloatingChatWrapper,
+      {
+        isOpen: ctx.ui.isOpen,
+        onClose: () => ctx.ui.setOpen(false),
+        children: /* @__PURE__ */ jsx10(
+          UseAIChatPanel,
+          {
+            ...chatPanelProps,
+            closeButton: /* @__PURE__ */ jsx10(CloseButton, { onClick: () => ctx.ui.setOpen(false) })
+          }
+        )
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx10(UseAIChatPanel, { ...chatPanelProps });
+}
+
+// src/client.ts
+import { io } from "socket.io-client";
+import { EventType as EventType2 } from "@meetsmore-oss/use-ai-core";
+import { v4 as uuidv42 } from "uuid";
+var UseAIClient = class {
+  /**
+   * Creates a new UseAI client instance.
+   *
+   * @param serverUrl - The WebSocket URL of the UseAI server
+   */
+  constructor(serverUrl) {
+    this.serverUrl = serverUrl;
+  }
+  socket = null;
+  eventHandlers = /* @__PURE__ */ new Map();
+  reconnectAttempts = 0;
+  maxReconnectAttempts = 5;
+  reconnectDelay = 1e3;
+  // Session state
+  _threadId = null;
+  _tools = [];
+  _messages = [];
+  _state = null;
+  // MCP headers provider
+  mcpHeadersProvider;
+  // Agent selection
+  _availableAgents = [];
+  _defaultAgent = null;
+  _selectedAgent = null;
+  agentsChangeHandlers = /* @__PURE__ */ new Set();
+  // Connection state handlers
+  connectionStateHandlers = /* @__PURE__ */ new Set();
+  // Text message assembly
+  _currentMessageId = null;
+  _currentMessageContent = "";
+  // Assistant message assembly (for tracking full conversation history)
+  _currentAssistantMessage = null;
+  _currentAssistantToolCalls = [];
+  // Tool call assembly
+  currentToolCalls = /* @__PURE__ */ new Map();
+  /**
+   * Establishes a Socket.IO connection to the server.
+   * Connection state changes are notified via onConnectionStateChange().
+   * Socket.IO handles reconnection automatically.
+   */
+  connect() {
+    this.socket = io(this.serverUrl, {
+      transports: ["polling", "websocket"],
+      reconnection: true,
+      reconnectionAttempts: this.maxReconnectAttempts,
+      reconnectionDelay: this.reconnectDelay,
+      withCredentials: true
+    });
+    this.socket.on("connect", () => {
+      console.log("[UseAI] Connected to server");
+      console.log("[UseAI] Transport:", this.socket?.io?.engine?.transport?.name);
+      this.reconnectAttempts = 0;
+      const engine = this.socket?.io?.engine;
+      if (engine) {
+        engine.on("upgrade", (transport) => {
+          console.log("[UseAI] Upgraded to transport:", transport.name);
+        });
+        engine.on("upgradeError", (err) => {
+          console.warn("[UseAI] Upgrade error:", err.message);
+        });
+      }
+      this.connectionStateHandlers.forEach((handler) => handler(true));
+    });
+    this.socket.on("event", (aguiEvent) => {
+      try {
+        console.log("[Client] Received event:", aguiEvent.type);
+        this.handleEvent(aguiEvent);
+      } catch (error) {
+        console.error("[UseAI] Error handling event:", error);
+      }
+    });
+    this.socket.on("agents", (data) => {
+      console.log("[Client] Received available agents:", data);
+      this._availableAgents = data.agents;
+      this._defaultAgent = data.defaultAgent;
+      this.agentsChangeHandlers.forEach((handler) => handler(data.agents, data.defaultAgent));
+    });
+    this.socket.on("connect_error", (error) => {
+      console.warn("[UseAI] Connection error:", error.message);
+    });
+    this.socket.on("disconnect", (reason) => {
+      console.log("[UseAI] Disconnected:", reason);
+      this.connectionStateHandlers.forEach((handler) => handler(false));
+    });
+  }
+  handleEvent(event) {
+    if (event.type === EventType2.RUN_STARTED) {
+      this._currentAssistantMessage = {
+        id: uuidv42(),
+        role: "assistant",
+        content: ""
+      };
+      this._currentAssistantToolCalls = [];
+    }
+    if (event.type === EventType2.TEXT_MESSAGE_START) {
+      const e = event;
+      this._currentMessageId = e.messageId;
+      this._currentMessageContent = "";
+    } else if (event.type === EventType2.TEXT_MESSAGE_CONTENT) {
+      const e = event;
+      this._currentMessageContent += e.delta;
+    } else if (event.type === EventType2.TEXT_MESSAGE_END) {
+      if (this._currentAssistantMessage) {
+        this._currentAssistantMessage.content = this._currentMessageContent;
+      }
+      this._currentMessageId = null;
+    } else if (event.type === EventType2.TOOL_CALL_START) {
+      const e = event;
+      this.currentToolCalls.set(e.toolCallId, {
+        name: e.toolCallName,
+        args: ""
+      });
+    } else if (event.type === EventType2.TOOL_CALL_ARGS) {
+      const e = event;
+      const toolCall = this.currentToolCalls.get(e.toolCallId);
+      if (toolCall) {
+        toolCall.args += e.delta;
+      }
+    } else if (event.type === EventType2.TOOL_CALL_END) {
+      const e = event;
+      const toolCall = this.currentToolCalls.get(e.toolCallId);
+      if (toolCall) {
+        this._currentAssistantToolCalls.push({
+          id: e.toolCallId,
+          type: "function",
+          function: {
+            name: toolCall.name,
+            arguments: toolCall.args
+          }
+        });
+      }
+    } else if (event.type === EventType2.RUN_FINISHED) {
+      if (this._currentAssistantMessage) {
+        const assistantMessage = {
+          id: this._currentAssistantMessage.id,
+          role: "assistant",
+          content: this._currentAssistantMessage.content || ""
+        };
+        if (this._currentAssistantToolCalls.length > 0) {
+          assistantMessage.toolCalls = this._currentAssistantToolCalls;
+        }
+        this._messages.push(assistantMessage);
+        this._currentAssistantMessage = null;
+        this._currentAssistantToolCalls = [];
+      }
+    }
+    this.eventHandlers.forEach((handler) => handler(event));
+  }
+  /**
+   * Registers available tools and optional state with the server.
+   * This updates the session state for future agent runs.
+   *
+   * @param tools - Array of tool definitions to register
+   * @param state - Optional state object to provide to the AI.
+   */
+  registerTools(tools, state) {
+    this._tools = tools;
+    if (state !== void 0) {
+      this._state = state;
+    }
+  }
+  /**
+   * Updates the state without re-registering tools.
+   * Call this before sendPrompt to ensure the AI sees the latest UI state.
+   *
+   * @param state - The current state object to provide to the AI
+   */
+  updateState(state) {
+    this._state = state;
+  }
+  /**
+   * Sets the MCP headers provider.
+   * The provider will be called each time a message is sent to get fresh headers.
+   *
+   * @param provider - Function that returns MCP headers configuration
+   */
+  setMcpHeadersProvider(provider) {
+    this.mcpHeadersProvider = provider;
+  }
+  /**
+   * Sends a user prompt to the AI.
+   *
+   * @param prompt - The user's prompt/question (text part)
+   * @param multimodalContent - Optional multimodal content (text, images, files)
+   */
+  async sendPrompt(prompt, multimodalContent) {
+    let messageContent = prompt;
+    if (multimodalContent && multimodalContent.length > 0) {
+      messageContent = multimodalContent.map((part) => {
+        if (part.type === "text") {
+          return { type: "text", text: part.text };
+        } else if (part.type === "image") {
+          return { type: "image", url: part.url };
+        } else {
+          return {
+            type: "file",
+            url: part.url,
+            mimeType: part.mimeType
+          };
+        }
+      });
+    }
+    const userMessage = {
+      id: uuidv42(),
+      role: "user",
+      content: messageContent
+      // Type cast needed for Message type compatibility
+    };
+    this._messages.push(userMessage);
+    let mcpHeaders;
+    if (this.mcpHeadersProvider) {
+      try {
+        mcpHeaders = await this.mcpHeadersProvider();
+      } catch (error) {
+        console.error("[UseAIClient] Failed to get MCP headers:", error);
+      }
+    }
+    const runInput = {
+      threadId: this.threadId,
+      // Use getter to ensure non-null
+      runId: uuidv42(),
+      messages: this._messages,
+      tools: this._tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters
+      })),
+      state: this._state,
+      context: [],
+      forwardedProps: {
+        ...mcpHeaders ? { mcpHeaders } : {},
+        ...this._selectedAgent ? { agent: this._selectedAgent } : {}
+      }
+    };
+    this.send({
+      type: "run_agent",
+      data: runInput
+    });
+  }
+  /**
+   * Sends the result of a tool execution back to the server.
+   *
+   * @param toolCallId - The ID of the tool call being responded to
+   * @param result - The result returned by the tool execution
+   * @param state - Optional updated state to send back to the AI
+   */
+  sendToolResponse(toolCallId, result, state) {
+    if (state !== void 0) {
+      this._state = state;
+    }
+    const toolResultMessage = {
+      type: "tool_result",
+      data: {
+        messageId: uuidv42(),
+        toolCallId,
+        content: JSON.stringify(result),
+        role: "tool"
+      }
+    };
+    const toolResultMsg = {
+      id: toolResultMessage.data.messageId,
+      role: "tool",
+      content: toolResultMessage.data.content,
+      toolCallId
+    };
+    this._messages.push(toolResultMsg);
+    this.send(toolResultMessage);
+  }
+  /**
+   * Retrieves accumulated tool call data for a specific tool call ID.
+   * Used to get the complete tool name and arguments after they've been streamed
+   * across multiple TOOL_CALL_ARGS events.
+   *
+   * @param toolCallId - The ID of the tool call
+   * @returns Object with tool name and accumulated arguments, or undefined if not found
+   */
+  getToolCallData(toolCallId) {
+    return this.currentToolCalls.get(toolCallId);
+  }
+  /**
+   * Registers an AG-UI event handler for receiving server events.
+   *
+   * @param id - Unique identifier for this handler
+   * @param handler - Callback function to handle incoming AG-UI events
+   * @returns Cleanup function to unregister the handler
+   */
+  onEvent(id, handler) {
+    this.eventHandlers.set(id, handler);
+    return () => {
+      this.eventHandlers.delete(id);
+    };
+  }
+  /**
+   * Helper method to listen for text message content.
+   * Aggregates TEXT_MESSAGE_CONTENT events and calls handler with complete messages.
+   *
+   * @param handler - Callback function to handle complete text messages
+   * @returns Cleanup function
+   */
+  onTextMessage(handler) {
+    return this.onEvent("text-message-handler", (event) => {
+      if (event.type === EventType2.TEXT_MESSAGE_END && this._currentMessageContent) {
+        handler(this._currentMessageContent);
+      }
+    });
+  }
+  /**
+   * Helper method to listen for tool call requests.
+   * Aggregates TOOL_CALL_* events and calls handler with complete tool calls.
+   *
+   * @param handler - Callback function to handle tool calls
+   * @returns Cleanup function
+   */
+  onToolCall(handler) {
+    return this.onEvent("tool-call-handler", (event) => {
+      if (event.type === EventType2.TOOL_CALL_END) {
+        const e = event;
+        const toolCall = this.currentToolCalls.get(e.toolCallId);
+        if (toolCall) {
+          try {
+            const args = JSON.parse(toolCall.args);
+            handler(e.toolCallId, toolCall.name, args);
+            this.currentToolCalls.delete(e.toolCallId);
+          } catch (error) {
+            console.error("Error parsing tool call args:", error);
+          }
+        }
+      }
+    });
+  }
+  /**
+   * Gets the current accumulated message content (useful during streaming).
+   */
+  get currentMessageContent() {
+    return this._currentMessageContent;
+  }
+  /**
+   * Gets the current thread ID for this session.
+   * Generates a new one if not set.
+   */
+  get threadId() {
+    if (!this._threadId) {
+      this._threadId = uuidv42();
+    }
+    return this._threadId;
+  }
+  /**
+   * Gets the current conversation messages.
+   */
+  get messages() {
+    return this._messages;
+  }
+  /**
+   * Gets the current state.
+   */
+  get state() {
+    return this._state;
+  }
+  /**
+   * Gets the list of available agents from the server.
+   */
+  get availableAgents() {
+    return this._availableAgents;
+  }
+  /**
+   * Gets the default agent ID from the server.
+   */
+  get defaultAgent() {
+    return this._defaultAgent;
+  }
+  /**
+   * Gets the currently selected agent ID.
+   * Returns null if using server default.
+   */
+  get selectedAgent() {
+    return this._selectedAgent;
+  }
+  /**
+   * Gets the effective agent ID (selected or default).
+   */
+  get currentAgent() {
+    return this._selectedAgent ?? this._defaultAgent;
+  }
+  /**
+   * Sets the agent to use for requests.
+   * Pass null to use the server default.
+   *
+   * @param agentId - The agent ID to use, or null for server default
+   */
+  setAgent(agentId) {
+    this._selectedAgent = agentId;
+    console.log("[Client] Agent set to:", agentId ?? "server default");
+  }
+  /**
+   * Subscribes to agent changes (when server sends available agents).
+   *
+   * @param handler - Callback function receiving agents list and default agent
+   * @returns Cleanup function to unsubscribe
+   */
+  onAgentsChange(handler) {
+    this.agentsChangeHandlers.add(handler);
+    if (this._availableAgents.length > 0) {
+      handler(this._availableAgents, this._defaultAgent);
+    }
+    return () => {
+      this.agentsChangeHandlers.delete(handler);
+    };
+  }
+  /**
+   * Subscribes to connection state changes.
+   * This is called on both initial connection and reconnection.
+   *
+   * @param handler - Callback function receiving connection state (true = connected, false = disconnected)
+   * @returns Cleanup function to unsubscribe
+   */
+  onConnectionStateChange(handler) {
+    this.connectionStateHandlers.add(handler);
+    handler(this.isConnected());
+    return () => {
+      this.connectionStateHandlers.delete(handler);
+    };
+  }
+  /**
+   * Sets the thread ID for this session.
+   * When the thread ID changes, conversation state is cleared to prevent history bleeding.
+   * Use this when switching between different chat conversations.
+   *
+   * @param threadId - The thread/chat ID to use (typically the chatId)
+   */
+  setThreadId(threadId) {
+    if (this._threadId !== threadId) {
+      console.log("[Client] ThreadId changed, clearing conversation state", {
+        oldThreadId: this._threadId,
+        newThreadId: threadId
+      });
+      this._messages = [];
+      this._currentMessageContent = "";
+      this._currentMessageId = null;
+      this.currentToolCalls.clear();
+      this._currentAssistantMessage = null;
+      this._currentAssistantToolCalls = [];
+    }
+    this._threadId = threadId;
+  }
+  /**
+   * Loads messages into the conversation history (for resuming from storage).
+   * @param messages - Array of messages to load
+   */
+  loadMessages(messages) {
+    this._messages = messages;
+  }
+  /**
+   * Clears the conversation history and resets the thread.
+   */
+  clearConversation() {
+    this._messages = [];
+    this._threadId = null;
+    this._currentMessageContent = "";
+    this._currentMessageId = null;
+    this.currentToolCalls.clear();
+    this._currentAssistantMessage = null;
+    this._currentAssistantToolCalls = [];
+  }
+  send(message) {
+    if (this.socket && this.socket.connected) {
+      this.socket.emit("message", message);
+    } else {
+      console.error("Socket.IO is not connected");
+    }
+  }
+  /**
+   * Closes the Socket.IO connection to the server.
+   */
+  disconnect() {
+    if (this.socket) {
+      this.socket.disconnect();
+      this.socket = null;
+    }
+  }
+  /**
+   * Checks if the client is currently connected to the server.
+   *
+   * @returns true if connected, false otherwise
+   */
+  isConnected() {
+    return this.socket !== null && this.socket.connected;
+  }
+};
+
+// src/defineTool.ts
+import { z } from "zod";
+function defineTool(description, schemaOrFn, fnOrOptions, options) {
+  const isNoParamFunction = typeof schemaOrFn === "function";
+  const schema = isNoParamFunction ? z.object({}) : schemaOrFn;
+  let actualFn;
+  let actualOptions;
+  if (isNoParamFunction) {
+    actualFn = schemaOrFn;
+    actualOptions = fnOrOptions || {};
+  } else {
+    actualFn = fnOrOptions;
+    actualOptions = options || {};
+  }
+  const jsonSchema = z.toJSONSchema(schema);
+  return {
+    description,
+    _jsonSchema: jsonSchema,
+    _zodSchema: schema,
+    fn: actualFn,
+    _options: actualOptions,
+    _toToolDefinition(name) {
+      const parameters = {
+        type: "object",
+        properties: this._jsonSchema.properties || {}
+      };
+      if (this._jsonSchema.required && this._jsonSchema.required.length > 0) {
+        parameters.required = this._jsonSchema.required;
+      }
+      if (this._jsonSchema.additionalProperties !== void 0) {
+        parameters.additionalProperties = this._jsonSchema.additionalProperties;
+      }
+      const toolDef = {
+        name,
+        description,
+        parameters
+      };
+      if (this._options.confirmationRequired) {
+        toolDef.confirmationRequired = true;
+      }
+      return toolDef;
+    },
+    async _execute(input) {
+      const validated = this._zodSchema.parse(input);
+      return await actualFn(validated);
+    }
+  };
+}
+function convertToolsToDefinitions(tools) {
+  return Object.entries(tools).map(([name, tool]) => tool._toToolDefinition(name));
+}
+async function executeDefinedTool(tools, toolName, input) {
+  const tool = tools[toolName];
+  if (!tool) {
+    throw new Error(`Tool "${toolName}" not found`);
+  }
+  return await tool._execute(input);
+}
+
+// src/providers/chatRepository/LocalStorageChatRepository.ts
+var STORAGE_KEY_PREFIX = "use-ai:chat:";
+var STORAGE_INDEX_KEY = "use-ai:chat-index";
+var MAX_CHATS = 20;
+var LocalStorageChatRepository = class {
+  storage;
+  maxChats;
+  /**
+   * Creates a new LocalStorageChatRepository.
+   *
+   * @param storage - Storage implementation to use (defaults to browser `localStorage`)
+   * @param maxChats - Maximum number of chats to keep (defaults to 20). Oldest chats are automatically deleted when this limit is exceeded.
+   */
+  constructor(storage = localStorage, maxChats = MAX_CHATS) {
+    this.storage = storage;
+    this.maxChats = maxChats;
+  }
+  async createChat(options) {
+    const id = generateChatId();
+    const now = /* @__PURE__ */ new Date();
+    const chat = {
+      id,
+      title: options?.title,
+      messages: [],
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.enforceMaxChatsLimit();
+    await this.saveChat(chat);
+    await this.addToIndex(id);
+    return id;
+  }
+  async loadChat(id) {
+    try {
+      const key = this.getChatKey(id);
+      const data = this.storage.getItem(key);
+      if (!data) {
+        return null;
+      }
+      const chat = JSON.parse(data);
+      chat.createdAt = new Date(chat.createdAt);
+      chat.updatedAt = new Date(chat.updatedAt);
+      chat.messages = chat.messages.map((msg) => ({
+        ...msg,
+        createdAt: new Date(msg.createdAt)
+      }));
+      return chat;
+    } catch (error) {
+      console.error(`Failed to load chat ${id}:`, error);
+      return null;
+    }
+  }
+  async saveChat(chat) {
+    try {
+      const key = this.getChatKey(chat.id);
+      const data = JSON.stringify({
+        ...chat,
+        updatedAt: /* @__PURE__ */ new Date()
+      });
+      this.storage.setItem(key, data);
+    } catch (error) {
+      console.error(`Failed to save chat ${chat.id}:`, error);
+      throw new Error(`Failed to save chat: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  async deleteChat(id) {
+    try {
+      const key = this.getChatKey(id);
+      this.storage.removeItem(key);
+      await this.removeFromIndex(id);
+    } catch (error) {
+      console.error(`Failed to delete chat ${id}:`, error);
+      throw new Error(`Failed to delete chat: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  async listChats(options) {
+    try {
+      const ids = await this.getIndex();
+      const chats = [];
+      for (const id of ids) {
+        const chat = await this.loadChat(id);
+        if (chat) {
+          const { messages, ...metadata } = chat;
+          chats.push(metadata);
+        }
+      }
+      chats.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+      const { limit, offset = 0 } = options ?? {};
+      const start = offset;
+      const end = limit ? offset + limit : void 0;
+      return chats.slice(start, end);
+    } catch (error) {
+      console.error("Failed to list chats:", error);
+      return [];
+    }
+  }
+  async deleteAll() {
+    try {
+      const ids = await this.getIndex();
+      for (const id of ids) {
+        const key = this.getChatKey(id);
+        this.storage.removeItem(key);
+      }
+      this.storage.removeItem(STORAGE_INDEX_KEY);
+    } catch (error) {
+      console.error("Failed to clear all chats:", error);
+      throw new Error(`Failed to clear all chats: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  getChatKey(id) {
+    return `${STORAGE_KEY_PREFIX}${id}`;
+  }
+  async getIndex() {
+    try {
+      const data = this.storage.getItem(STORAGE_INDEX_KEY);
+      return data ? JSON.parse(data) : [];
+    } catch (error) {
+      console.error("Failed to load chat index:", error);
+      return [];
+    }
+  }
+  async addToIndex(id) {
+    const index = await this.getIndex();
+    if (!index.includes(id)) {
+      index.push(id);
+      this.storage.setItem(STORAGE_INDEX_KEY, JSON.stringify(index));
+    }
+  }
+  async removeFromIndex(id) {
+    const index = await this.getIndex();
+    const filtered = index.filter((chatId) => chatId !== id);
+    this.storage.setItem(STORAGE_INDEX_KEY, JSON.stringify(filtered));
+  }
+  async enforceMaxChatsLimit() {
+    const chats = await this.listChats();
+    if (chats.length >= this.maxChats) {
+      const sortedChats = [...chats].sort(
+        (a, b) => a.updatedAt.getTime() - b.updatedAt.getTime()
+      );
+      const numToDelete = chats.length - this.maxChats + 1;
+      for (let i = 0; i < numToDelete; i++) {
+        await this.deleteChat(sortedChats[i].id);
+      }
+    }
+  }
+};
+
+// src/fileUpload/EmbedFileUploadBackend.ts
+var EmbedFileUploadBackend = class {
+  /**
+   * Converts a File to a base64 data URL.
+   *
+   * @param file - The File object to convert
+   * @returns Promise resolving to a base64 data URL (e.g., "data:image/png;base64,...")
+   * @throws Error if file reading fails
+   */
+  async prepareForSend(file) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => {
+        if (typeof reader.result === "string") {
+          resolve(reader.result);
+        } else {
+          reject(new Error("Failed to read file as data URL"));
+        }
+      };
+      reader.onerror = () => {
+        reject(new Error(`Failed to read file: ${file.name}`));
+      };
+      reader.readAsDataURL(file);
+    });
+  }
+};
+
+// src/hooks/useChatManagement.ts
+import { useState as useState5, useCallback as useCallback4, useRef as useRef5, useEffect as useEffect5 } from "react";
+var CHAT_TITLE_MAX_LENGTH = 50;
+function generateChatTitle(message) {
+  return message.length > CHAT_TITLE_MAX_LENGTH ? message.substring(0, CHAT_TITLE_MAX_LENGTH) + "..." : message;
+}
+function getTextFromContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+}
+function transformMessagesToUI(storageMessages) {
+  return storageMessages.map((msg) => ({
+    id: msg.id,
+    role: msg.role,
+    content: msg.content,
+    timestamp: msg.createdAt,
+    displayMode: msg.displayMode
+  }));
+}
+function transformMessagesToClientFormat(uiMessages) {
+  return uiMessages.map((msg) => {
+    const textContent = getTextFromContent(msg.content);
+    return {
+      id: msg.id,
+      role: msg.role,
+      content: textContent
+    };
+  });
+}
+function useChatManagement({
+  repository,
+  clientRef
+}) {
+  const [currentChatId, setCurrentChatId] = useState5(null);
+  const [pendingChatId, setPendingChatId] = useState5(null);
+  const [messages, setMessages] = useState5([]);
+  const currentChatIdSnapshot = useRef5(null);
+  const pendingChatIdSnapshot = useRef5(null);
+  useEffect5(() => {
+    currentChatIdSnapshot.current = currentChatId;
+  }, [currentChatId]);
+  useEffect5(() => {
+    pendingChatIdSnapshot.current = pendingChatId;
+  }, [pendingChatId]);
+  const loadChatMessages = useCallback4(async (chatId) => {
+    try {
+      const chat = await repository.loadChat(chatId);
+      if (chat) {
+        const loadedMessages = transformMessagesToUI(chat.messages);
+        console.log("[ChatManagement] Loaded", loadedMessages.length, "messages from storage for chat:", chatId);
+        return loadedMessages;
+      } else {
+        console.log("[ChatManagement] Chat not found in storage:", chatId);
+        return [];
+      }
+    } catch (error) {
+      console.error("[ChatManagement] Failed to load chat messages:", error);
+      return [];
+    }
+  }, [repository]);
+  const reloadMessages = useCallback4(async (chatId) => {
+    const loadedMessages = await loadChatMessages(chatId);
+    setMessages(loadedMessages);
+  }, [loadChatMessages]);
+  const createNewChat = useCallback4(async () => {
+    console.log("[ChatManagement] createNewChat called - currentChatId:", currentChatId, "pendingChatId:", pendingChatId, "messages.length:", messages.length);
+    if (pendingChatId && messages.length === 0) {
+      console.log("[ChatManagement] Pending chat is already blank, not creating new chat");
+      return pendingChatId;
+    }
+    if (currentChatId && !pendingChatId && messages.length === 0) {
+      console.log("[ChatManagement] Current chat is already blank, not creating new chat");
+      return currentChatId;
+    }
+    console.log("[ChatManagement] Creating new chat...");
+    const chatId = await repository.createChat();
+    setPendingChatId(chatId);
+    setMessages([]);
+    if (clientRef.current) {
+      clientRef.current.setThreadId(chatId);
+      console.log("[ChatManagement] Set threadId to new chatId:", chatId);
+    }
+    console.log("[ChatManagement] Created pending chat:", chatId, "(will activate on first message)");
+    return chatId;
+  }, [currentChatId, pendingChatId, messages, repository, clientRef]);
+  const loadChat = useCallback4(async (chatId) => {
+    setPendingChatId(chatId);
+    await reloadMessages(chatId);
+    if (clientRef.current) {
+      clientRef.current.setThreadId(chatId);
+      console.log("[ChatManagement] Set threadId to chatId:", chatId);
+    }
+    console.log("[ChatManagement] Loaded pending chat:", chatId, "(will activate on first message)");
+  }, [reloadMessages, clientRef]);
+  const deleteChat = useCallback4(async (chatId) => {
+    await repository.deleteChat(chatId);
+    if (currentChatId === chatId) {
+      setCurrentChatId(null);
+      setMessages([]);
+    }
+    if (pendingChatId === chatId) {
+      setPendingChatId(null);
+      setMessages([]);
+    }
+    console.log("[ChatManagement] Deleted chat:", chatId);
+  }, [currentChatId, pendingChatId, repository]);
+  const listChats = useCallback4(async () => {
+    return await repository.listChats();
+  }, [repository]);
+  const clearCurrentChat = useCallback4(async () => {
+    setMessages([]);
+    if (currentChatId) {
+      const chat = await repository.loadChat(currentChatId);
+      if (chat) {
+        chat.messages = [];
+        await repository.saveChat(chat);
+        console.log("[ChatManagement] Cleared current chat:", currentChatId);
+      }
+    }
+  }, [currentChatId, repository]);
+  const activatePendingChat = useCallback4(() => {
+    if (!pendingChatId) return null;
+    console.log("[ChatManagement] Activating pending chat:", pendingChatId);
+    if (clientRef.current && messages.length > 0) {
+      clientRef.current.loadMessages(transformMessagesToClientFormat(messages));
+      console.log("[ChatManagement] Loaded", messages.length, "existing messages into client");
+    }
+    setCurrentChatId(pendingChatId);
+    setPendingChatId(null);
+    return pendingChatId;
+  }, [pendingChatId, messages, clientRef]);
+  const saveUserMessage = useCallback4(async (chatId, content) => {
+    try {
+      const chat = await repository.loadChat(chatId);
+      if (!chat) {
+        console.error("[ChatManagement] Chat not found:", chatId);
+        return false;
+      }
+      const { generateMessageId: generateMessageId2 } = await import("./types-TVUXB3NB.js");
+      chat.messages.push({
+        id: generateMessageId2(),
+        role: "user",
+        content,
+        createdAt: /* @__PURE__ */ new Date()
+      });
+      if (!chat.title) {
+        const text = getTextFromContent(content);
+        if (text) {
+          chat.title = generateChatTitle(text);
+        }
+      }
+      await repository.saveChat(chat);
+      console.log("[ChatManagement] Saved user message to storage");
+      await reloadMessages(chatId);
+      return true;
+    } catch (error) {
+      console.error("[ChatManagement] Failed to save user message:", error);
+      return false;
+    }
+  }, [repository, reloadMessages]);
+  const saveAIResponse = useCallback4(async (content, displayMode) => {
+    const currentChatIdValue = currentChatIdSnapshot.current;
+    const pendingChatIdValue = pendingChatIdSnapshot.current;
+    const displayedChatId2 = pendingChatIdValue || currentChatIdValue;
+    if (!currentChatIdValue) {
+      console.warn("[ChatManagement] No current chat ID, cannot save AI response");
+      return;
+    }
+    try {
+      const chat = await repository.loadChat(currentChatIdValue);
+      if (!chat) {
+        console.error("[ChatManagement] Chat not found:", currentChatIdValue);
+        return;
+      }
+      const { generateMessageId: generateMessageId2 } = await import("./types-TVUXB3NB.js");
+      chat.messages.push({
+        id: generateMessageId2(),
+        role: "assistant",
+        content,
+        createdAt: /* @__PURE__ */ new Date(),
+        displayMode
+      });
+      if (!chat.title) {
+        const firstUserMessage = chat.messages.find((msg) => msg.role === "user");
+        if (firstUserMessage) {
+          const textContent = getTextFromContent(firstUserMessage.content);
+          if (textContent) {
+            chat.title = generateChatTitle(textContent);
+          }
+        }
+      }
+      await repository.saveChat(chat);
+      console.log("[ChatManagement] Saved AI response to storage for chatId:", currentChatIdValue);
+      if (displayedChatId2 === currentChatIdValue) {
+        await reloadMessages(currentChatIdValue);
+      }
+    } catch (error) {
+      console.error("[ChatManagement] Failed to save AI response:", error);
+    }
+  }, [repository, reloadMessages]);
+  const initializedRef = useRef5(false);
+  useEffect5(() => {
+    if (currentChatId === null && pendingChatId === null && !initializedRef.current) {
+      initializedRef.current = true;
+      (async () => {
+        try {
+          const chats = await repository.listChats({ limit: 1 });
+          if (chats.length > 0) {
+            const mostRecentChatId = chats[0].id;
+            console.log("[ChatManagement] Loading most recent chat on mount:", mostRecentChatId);
+            const loadedMessages = await loadChatMessages(mostRecentChatId);
+            setCurrentChatId(mostRecentChatId);
+            setMessages(loadedMessages);
+            if (clientRef.current) {
+              clientRef.current.setThreadId(mostRecentChatId);
+              clientRef.current.loadMessages(transformMessagesToClientFormat(loadedMessages));
+              console.log("[ChatManagement] Set threadId and loaded messages for chat:", mostRecentChatId);
+            }
+            console.log("[ChatManagement] Loaded and activated chat on mount:", mostRecentChatId);
+          } else {
+            console.log("[ChatManagement] No existing chats, creating new one");
+            await createNewChat();
+          }
+        } catch (err) {
+          console.error("[ChatManagement] Failed to initialize chat:", err);
+          initializedRef.current = false;
+        }
+      })();
+    }
+  }, [currentChatId, pendingChatId, createNewChat, repository, loadChatMessages, clientRef]);
+  const displayedChatId = pendingChatId || currentChatId;
+  return {
+    currentChatId,
+    pendingChatId,
+    messages,
+    displayedChatId,
+    createNewChat,
+    loadChat,
+    deleteChat,
+    listChats,
+    clearCurrentChat,
+    activatePendingChat,
+    saveUserMessage,
+    saveAIResponse,
+    reloadMessages,
+    currentChatIdSnapshot,
+    pendingChatIdSnapshot
+  };
+}
+
+// src/hooks/useAgentSelection.ts
+import { useState as useState6, useCallback as useCallback5, useEffect as useEffect6, useMemo as useMemo3 } from "react";
+function filterAgents(serverAgents, defaultAgentId, visibleAgentIds) {
+  const getDefaultAgentFallback = () => {
+    const defaultAgentInfo = serverAgents.find((a) => a.id === defaultAgentId);
+    return defaultAgentInfo ? [defaultAgentInfo] : serverAgents;
+  };
+  if (visibleAgentIds === void 0) {
+    return serverAgents;
+  }
+  if (visibleAgentIds.length === 0) {
+    console.warn("[AgentSelection] visibleAgentIds is empty array, falling back to default agent");
+    return getDefaultAgentFallback();
+  }
+  const serverAgentMap = new Map(serverAgents.map((a) => [a.id, a]));
+  const matchedAgents = visibleAgentIds.filter((id) => serverAgentMap.has(id)).map((id) => serverAgentMap.get(id));
+  if (matchedAgents.length === 0) {
+    console.warn("[AgentSelection] No agents in visibleAgentIds match server agents, falling back to default agent");
+    return getDefaultAgentFallback();
+  }
+  return matchedAgents;
+}
+function useAgentSelection({
+  clientRef,
+  connected,
+  visibleAgentIds
+}) {
+  const [serverAgents, setServerAgents] = useState6([]);
+  const [defaultAgent, setDefaultAgent] = useState6(null);
+  const [selectedAgent, setSelectedAgent] = useState6(null);
+  const availableAgents = useMemo3(
+    () => filterAgents(serverAgents, defaultAgent, visibleAgentIds),
+    [serverAgents, defaultAgent, visibleAgentIds]
+  );
+  const setAgent = useCallback5((agentId) => {
+    setSelectedAgent(agentId);
+    if (clientRef.current) {
+      clientRef.current.setAgent(agentId);
+    }
+    console.log("[AgentSelection] Agent set to:", agentId ?? "server default");
+  }, [clientRef]);
+  useEffect6(() => {
+    const client = clientRef.current;
+    if (!client || !connected) return;
+    const unsubscribe = client.onAgentsChange((agents, defaultAgentId) => {
+      console.log("[AgentSelection] Received agents:", agents, "default:", defaultAgentId);
+      setServerAgents(agents);
+      setDefaultAgent(defaultAgentId);
+    });
+    return unsubscribe;
+  }, [clientRef, connected]);
+  useEffect6(() => {
+    if (selectedAgent === null && availableAgents.length > 0 && !availableAgents.some((a) => a.id === defaultAgent)) {
+      const firstAgentId = availableAgents[0].id;
+      setAgent(firstAgentId);
+    }
+  }, [availableAgents, selectedAgent, defaultAgent, setAgent]);
+  return {
+    availableAgents,
+    defaultAgent,
+    selectedAgent,
+    setAgent
+  };
+}
+
+// src/hooks/useCommandManagement.ts
+import { useState as useState7, useCallback as useCallback6, useRef as useRef6, useEffect as useEffect7 } from "react";
+
+// src/commands/LocalStorageCommandRepository.ts
+var STORAGE_KEY_PREFIX2 = "use-ai:command:";
+var STORAGE_INDEX_KEY2 = "use-ai:command-index";
+var DEFAULT_MAX_COMMANDS = 50;
+var LocalStorageCommandRepository = class {
+  storage;
+  maxCommands;
+  constructor(storage = localStorage, maxCommands = DEFAULT_MAX_COMMANDS) {
+    this.storage = storage;
+    this.maxCommands = maxCommands;
+  }
+  async createCommand(options) {
+    const name = options.name.trim();
+    const existing = await this.loadCommandByName(name);
+    if (existing) {
+      throw new Error(`Command "${name}" already exists`);
+    }
+    const id = generateCommandId();
+    const command = {
+      id,
+      name,
+      text: options.text,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    await this.enforceMaxCommandsLimit();
+    this.saveCommandToStorage(command);
+    await this.addToIndex(id);
+    return id;
+  }
+  async loadCommand(id) {
+    try {
+      const data = this.storage.getItem(`${STORAGE_KEY_PREFIX2}${id}`);
+      if (!data) return null;
+      return this.deserializeCommand(data);
+    } catch {
+      return null;
+    }
+  }
+  async loadCommandByName(name) {
+    const trimmedName = name.trim();
+    const commands = await this.listCommands();
+    return commands.find((c) => c.name === trimmedName) || null;
+  }
+  async updateCommand(command) {
+    this.saveCommandToStorage(command);
+  }
+  async deleteCommand(id) {
+    this.storage.removeItem(`${STORAGE_KEY_PREFIX2}${id}`);
+    await this.removeFromIndex(id);
+  }
+  async listCommands(options) {
+    const ids = this.getIndex();
+    const commands = [];
+    for (const id of ids) {
+      const cmd = await this.loadCommand(id);
+      if (cmd) {
+        if (!options?.namePrefix || cmd.name.startsWith(options.namePrefix.toLowerCase())) {
+          commands.push(cmd);
+        }
+      }
+    }
+    commands.sort((a, b) => {
+      if (a.lastUsedAt && b.lastUsedAt) {
+        return b.lastUsedAt.getTime() - a.lastUsedAt.getTime();
+      }
+      if (a.lastUsedAt) return -1;
+      if (b.lastUsedAt) return 1;
+      return a.name.localeCompare(b.name);
+    });
+    return options?.limit ? commands.slice(0, options.limit) : commands;
+  }
+  async deleteAll() {
+    const ids = this.getIndex();
+    for (const id of ids) {
+      this.storage.removeItem(`${STORAGE_KEY_PREFIX2}${id}`);
+    }
+    this.storage.removeItem(STORAGE_INDEX_KEY2);
+  }
+  saveCommandToStorage(command) {
+    this.storage.setItem(
+      `${STORAGE_KEY_PREFIX2}${command.id}`,
+      JSON.stringify(command)
+    );
+  }
+  deserializeCommand(data) {
+    const parsed = JSON.parse(data);
+    parsed.createdAt = new Date(parsed.createdAt);
+    if (parsed.lastUsedAt) {
+      parsed.lastUsedAt = new Date(parsed.lastUsedAt);
+    }
+    return parsed;
+  }
+  getIndex() {
+    const data = this.storage.getItem(STORAGE_INDEX_KEY2);
+    return data ? JSON.parse(data) : [];
+  }
+  async addToIndex(id) {
+    const index = this.getIndex();
+    if (!index.includes(id)) {
+      index.push(id);
+      this.storage.setItem(STORAGE_INDEX_KEY2, JSON.stringify(index));
+    }
+  }
+  async removeFromIndex(id) {
+    const index = this.getIndex();
+    this.storage.setItem(
+      STORAGE_INDEX_KEY2,
+      JSON.stringify(index.filter((i) => i !== id))
+    );
+  }
+  async enforceMaxCommandsLimit() {
+    const commands = await this.listCommands();
+    if (commands.length >= this.maxCommands) {
+      const sorted = [...commands].sort(
+        (a, b) => a.createdAt.getTime() - b.createdAt.getTime()
+      );
+      const numToDelete = commands.length - this.maxCommands + 1;
+      for (let i = 0; i < numToDelete; i++) {
+        await this.deleteCommand(sorted[i].id);
+      }
+    }
+  }
+};
+
+// src/hooks/useCommandManagement.ts
+function useCommandManagement({
+  repository
+} = {}) {
+  const repositoryRef = useRef6(
+    repository || new LocalStorageCommandRepository()
+  );
+  const [commands, setCommands] = useState7([]);
+  const refreshCommands = useCallback6(async () => {
+    try {
+      const cmdList = await repositoryRef.current.listCommands();
+      setCommands(cmdList);
+      console.log("[CommandManagement] Loaded", cmdList.length, "commands");
+    } catch (err) {
+      console.error("[CommandManagement] Failed to load commands:", err);
+    }
+  }, []);
+  const saveCommand = useCallback6(async (name, text) => {
+    const id = await repositoryRef.current.createCommand({ name, text });
+    await refreshCommands();
+    console.log("[CommandManagement] Saved command:", name);
+    return id;
+  }, [refreshCommands]);
+  const renameCommand = useCallback6(async (id, newName) => {
+    const command = await repositoryRef.current.loadCommand(id);
+    if (!command) throw new Error(`Command ${id} not found`);
+    command.name = newName.trim();
+    await repositoryRef.current.updateCommand(command);
+    await refreshCommands();
+    console.log("[CommandManagement] Renamed command:", id, "to", newName);
+  }, [refreshCommands]);
+  const deleteCommand = useCallback6(async (id) => {
+    await repositoryRef.current.deleteCommand(id);
+    await refreshCommands();
+    console.log("[CommandManagement] Deleted command:", id);
+  }, [refreshCommands]);
+  useEffect7(() => {
+    refreshCommands();
+  }, [refreshCommands]);
+  return {
+    commands,
+    refreshCommands,
+    saveCommand,
+    renameCommand,
+    deleteCommand
+  };
+}
+
+// src/hooks/useToolRegistry.ts
+import { useState as useState8, useCallback as useCallback7, useRef as useRef7, useMemo as useMemo4 } from "react";
+function useToolRegistry() {
+  const toolRegistryRef = useRef7(/* @__PURE__ */ new Map());
+  const [toolRegistryVersion, setToolRegistryVersion] = useState8(0);
+  const toolOwnershipRef = useRef7(/* @__PURE__ */ new Map());
+  const invisibleRef = useRef7(/* @__PURE__ */ new Set());
+  const registerTools = useCallback7((id, tools, options) => {
+    const existingTools = toolRegistryRef.current.get(id);
+    toolRegistryRef.current.set(id, tools);
+    if (existingTools) {
+      const existingKeys = Object.keys(existingTools).sort().join(",");
+      const newKeys = Object.keys(tools).sort().join(",");
+      if (existingKeys !== newKeys) {
+        setToolRegistryVersion((v) => v + 1);
+      }
+    } else {
+      setToolRegistryVersion((v) => v + 1);
+    }
+    Object.keys(tools).forEach((toolName) => {
+      toolOwnershipRef.current.set(toolName, id);
+    });
+    if (options?.invisible) {
+      invisibleRef.current.add(id);
+    } else {
+      invisibleRef.current.delete(id);
+    }
+  }, []);
+  const unregisterTools = useCallback7((id) => {
+    const tools = toolRegistryRef.current.get(id);
+    if (tools) {
+      Object.keys(tools).forEach((toolName) => {
+        toolOwnershipRef.current.delete(toolName);
+      });
+    }
+    toolRegistryRef.current.delete(id);
+    setToolRegistryVersion((v) => v + 1);
+    invisibleRef.current.delete(id);
+  }, []);
+  const isInvisible = useCallback7((id) => {
+    return invisibleRef.current.has(id);
+  }, []);
+  const aggregatedTools = useMemo4(() => {
+    const tools = {};
+    toolRegistryRef.current.forEach((toolSet) => {
+      Object.assign(tools, toolSet);
+    });
+    return tools;
+  }, [toolRegistryVersion]);
+  const hasTools = toolRegistryRef.current.size > 0;
+  const aggregatedToolsRef = useRef7(aggregatedTools);
+  aggregatedToolsRef.current = aggregatedTools;
+  return {
+    registerTools,
+    unregisterTools,
+    isInvisible,
+    aggregatedTools,
+    hasTools,
+    aggregatedToolsRef,
+    toolOwnershipRef
+  };
+}
+
+// src/hooks/usePromptState.ts
+import { useState as useState9, useCallback as useCallback8, useRef as useRef8, useMemo as useMemo5, useEffect as useEffect8 } from "react";
+function usePromptState({
+  systemPrompt,
+  clientRef,
+  connected
+}) {
+  const promptsRef = useRef8(/* @__PURE__ */ new Map());
+  const suggestionsRef = useRef8(/* @__PURE__ */ new Map());
+  const waitersRef = useRef8(/* @__PURE__ */ new Map());
+  const [suggestionsVersion, setSuggestionsVersion] = useState9(0);
+  const buildStateFromPrompts = useCallback8(() => {
+    const promptParts = [];
+    if (systemPrompt) {
+      promptParts.push(systemPrompt);
+    }
+    for (const [, prompt] of promptsRef.current.entries()) {
+      if (prompt) {
+        promptParts.push(prompt);
+      }
+    }
+    return promptParts.length > 0 ? { context: promptParts.join("\n\n---\n\n") } : null;
+  }, [systemPrompt]);
+  useEffect8(() => {
+    if (connected && clientRef.current && systemPrompt) {
+      clientRef.current.updateState(buildStateFromPrompts());
+    }
+  }, [connected, clientRef, systemPrompt, buildStateFromPrompts]);
+  const updatePrompt = useCallback8((id, prompt, suggestions) => {
+    if (prompt) {
+      promptsRef.current.set(id, prompt);
+    } else {
+      promptsRef.current.delete(id);
+    }
+    const hadSuggestions = suggestionsRef.current.has(id);
+    if (suggestions && suggestions.length > 0) {
+      suggestionsRef.current.set(id, suggestions);
+      if (!hadSuggestions) setSuggestionsVersion((v) => v + 1);
+    } else {
+      suggestionsRef.current.delete(id);
+      if (hadSuggestions) setSuggestionsVersion((v) => v + 1);
+    }
+    if (clientRef.current) {
+      clientRef.current.updateState(buildStateFromPrompts());
+    }
+  }, [buildStateFromPrompts, clientRef, connected]);
+  const registerWaiter = useCallback8((id, waiter) => {
+    waitersRef.current.set(id, waiter);
+  }, []);
+  const unregisterWaiter = useCallback8((id) => {
+    waitersRef.current.delete(id);
+  }, []);
+  const getWaiter = useCallback8((id) => {
+    return waitersRef.current.get(id);
+  }, []);
+  const aggregatedSuggestions = useMemo5(() => {
+    const allSuggestions = [];
+    suggestionsRef.current.forEach((suggestions) => {
+      allSuggestions.push(...suggestions);
+    });
+    return allSuggestions;
+  }, [suggestionsVersion]);
+  return {
+    updatePrompt,
+    registerWaiter,
+    unregisterWaiter,
+    getWaiter,
+    aggregatedSuggestions,
+    promptsRef
+  };
+}
+
+// src/providers/useAIProvider.tsx
+import { Fragment as Fragment3, jsx as jsx11, jsxs as jsxs7 } from "react/jsx-runtime";
+var __UseAIContext = createContext4(null);
+var hasWarnedAboutMissingProvider = false;
+var noOpContextValue = {
+  serverUrl: "",
+  connected: false,
+  client: null,
+  tools: {
+    register: () => {
+    },
+    unregister: () => {
+    }
+  },
+  prompts: {
+    update: () => {
+    },
+    registerWaiter: () => {
+    },
+    unregisterWaiter: () => {
+    }
+  },
+  chat: {
+    currentId: null,
+    create: async () => "",
+    load: async () => {
+    },
+    delete: async () => {
+    },
+    list: async () => [],
+    clear: async () => {
+    }
+  },
+  agents: {
+    available: [],
+    default: null,
+    selected: null,
+    set: () => {
+    }
+  },
+  commands: {
+    list: [],
+    refresh: async () => {
+    },
+    save: async () => "",
+    rename: async () => {
+    },
+    delete: async () => {
+    }
+  }
+};
+var DEFAULT_FILE_UPLOAD_CONFIG = {
+  backend: new EmbedFileUploadBackend(),
+  maxFileSize: 10 * 1024 * 1024,
+  // 10MB
+  acceptedTypes: ["image/*", "application/pdf"]
+};
+function UseAIProvider({
+  serverUrl,
+  children,
+  systemPrompt,
+  CustomButton,
+  CustomChat,
+  chatRepository,
+  mcpHeadersProvider,
+  fileUploadConfig: fileUploadConfigProp,
+  commandRepository,
+  renderChat = true,
+  theme: customTheme,
+  strings: customStrings,
+  visibleAgentIds
+}) {
+  const fileUploadConfig = fileUploadConfigProp === false ? void 0 : fileUploadConfigProp ?? DEFAULT_FILE_UPLOAD_CONFIG;
+  const theme = { ...defaultTheme, ...customTheme };
+  const strings = { ...defaultStrings, ...customStrings };
+  const [connected, setConnected] = useState10(false);
+  const [isChatOpen, setIsChatOpen] = useState10(false);
+  const [loading, setLoading] = useState10(false);
+  const [streamingText, setStreamingText] = useState10("");
+  const streamingChatIdRef = useRef9(null);
+  const clientRef = useRef9(null);
+  const repositoryRef = useRef9(
+    chatRepository || new LocalStorageChatRepository()
+  );
+  const {
+    registerTools,
+    unregisterTools,
+    isInvisible,
+    aggregatedTools,
+    hasTools,
+    aggregatedToolsRef,
+    toolOwnershipRef
+  } = useToolRegistry();
+  const {
+    updatePrompt,
+    registerWaiter,
+    unregisterWaiter,
+    getWaiter,
+    aggregatedSuggestions,
+    promptsRef
+  } = usePromptState({
+    systemPrompt,
+    clientRef,
+    connected
+  });
+  const chatManagement = useChatManagement({
+    repository: repositoryRef.current,
+    clientRef
+  });
+  const {
+    currentChatId,
+    pendingChatId,
+    messages,
+    displayedChatId,
+    createNewChat,
+    loadChat,
+    deleteChat,
+    listChats,
+    clearCurrentChat,
+    activatePendingChat,
+    saveUserMessage,
+    saveAIResponse
+  } = chatManagement;
+  const {
+    availableAgents,
+    defaultAgent,
+    selectedAgent,
+    setAgent
+  } = useAgentSelection({ clientRef, connected, visibleAgentIds });
+  const {
+    commands,
+    refreshCommands,
+    saveCommand,
+    renameCommand,
+    deleteCommand
+  } = useCommandManagement({ repository: commandRepository });
+  useEffect9(() => {
+    console.log("[UseAIProvider] Initializing client with serverUrl:", serverUrl);
+    const client = new UseAIClient(serverUrl);
+    if (mcpHeadersProvider) {
+      client.setMcpHeadersProvider(mcpHeadersProvider);
+    }
+    const unsubscribeConnection = client.onConnectionStateChange((isConnected) => {
+      console.log("[UseAIProvider] Connection state changed:", isConnected);
+      setConnected(isConnected);
+    });
+    console.log("[UseAIProvider] Connecting...");
+    client.connect();
+    const unsubscribe = client.onEvent("globalChat", async (event) => {
+      if (event.type === EventType.TOOL_CALL_END) {
+        const toolCallEnd = event;
+        const toolCallId = toolCallEnd.toolCallId;
+        const toolCallData = client["currentToolCalls"].get(toolCallId);
+        if (!toolCallData) {
+          console.error(`[Provider] Tool call ${toolCallId} not found`);
+          return;
+        }
+        const name = toolCallData.name;
+        const input = JSON.parse(toolCallData.args);
+        if (!aggregatedToolsRef.current[name]) {
+          console.log(`[Provider] Tool "${name}" not found in useAI tools, skipping (likely a workflow tool)`);
+          return;
+        }
+        try {
+          const ownerId = toolOwnershipRef.current.get(name);
+          console.log(`[useAI] Tool "${name}" owned by component:`, ownerId);
+          console.log("[useAI] Executing tool...");
+          const result = await executeDefinedTool(aggregatedToolsRef.current, name, input);
+          const isErrorResult = result && typeof result === "object" && ("error" in result || result.success === false);
+          const ownerIsInvisible = ownerId ? isInvisible(ownerId) : false;
+          if (ownerId && !isErrorResult && !ownerIsInvisible) {
+            const waiter = getWaiter(ownerId);
+            if (waiter) {
+              console.log(`[useAI] Waiting for prompt change from ${ownerId}...`);
+              await waiter();
+              console.log("[useAI] Prompt change wait complete");
+            }
+          } else if (isErrorResult) {
+            console.log("[useAI] Tool returned error, skipping prompt wait");
+          } else if (ownerIsInvisible) {
+            console.log("[useAI] Component is invisible, skipping prompt wait");
+          }
+          let updatedState = null;
+          if (ownerId) {
+            const prompt = promptsRef.current.get(ownerId);
+            if (prompt) {
+              updatedState = { context: prompt };
+              console.log(`[useAI] Updated state from ${ownerId}`);
+            }
+          }
+          client.sendToolResponse(toolCallId, result, updatedState);
+        } catch (err) {
+          console.error("Tool execution error:", err);
+          client.sendToolResponse(toolCallId, {
+            error: err instanceof Error ? err.message : "Unknown error"
+          });
+        }
+      } else if (event.type === EventType.TEXT_MESSAGE_CONTENT) {
+        const contentEvent = event;
+        setStreamingText((prev) => prev + contentEvent.delta);
+      } else if (event.type === EventType.TEXT_MESSAGE_END) {
+        const content = client.currentMessageContent;
+        if (content) {
+          console.log("[Provider] Received text message:", content.substring(0, 100));
+          saveAIResponse(content);
+          setStreamingText("");
+          streamingChatIdRef.current = null;
+          setLoading(false);
+        }
+      } else if (event.type === EventType.RUN_ERROR) {
+        const errorEvent = event;
+        const errorCode = errorEvent.message;
+        console.error("[Provider] Run error:", errorCode);
+        const userMessage = strings.errors[errorCode] || strings.errors[ErrorCode.UNKNOWN_ERROR];
+        saveAIResponse(userMessage, "error");
+        setStreamingText("");
+        streamingChatIdRef.current = null;
+        setLoading(false);
+      }
+    });
+    clientRef.current = client;
+    return () => {
+      unsubscribeConnection();
+      unsubscribe();
+      client.disconnect();
+    };
+  }, [serverUrl]);
+  useEffect9(() => {
+    const client = clientRef.current;
+    if (!client) return;
+    if (mcpHeadersProvider) {
+      client.setMcpHeadersProvider(mcpHeadersProvider);
+    }
+  }, [mcpHeadersProvider]);
+  const lastRegisteredToolsRef = useRef9("");
+  useEffect9(() => {
+    const client = clientRef.current;
+    if (!client || !client.isConnected() || !hasTools) return;
+    const toolKeys = Object.keys(aggregatedTools).sort().join(",");
+    if (toolKeys === lastRegisteredToolsRef.current) {
+      console.log("[Provider] Skipping re-registration, tools unchanged");
+      return;
+    }
+    lastRegisteredToolsRef.current = toolKeys;
+    console.log("[Provider] Registering tools:", toolKeys);
+    try {
+      const toolDefinitions = convertToolsToDefinitions(aggregatedTools);
+      console.log(`[Provider] Registering ${toolDefinitions.length} tools`);
+      client.registerTools(toolDefinitions);
+    } catch (err) {
+      console.error("Failed to register tools:", err);
+    }
+  }, [hasTools, aggregatedTools, connected]);
+  const handleSendMessage = useCallback9(async (message, attachments) => {
+    if (!clientRef.current) return;
+    setStreamingText("");
+    const activatedChatId = activatePendingChat();
+    const activeChatId = activatedChatId || currentChatId;
+    streamingChatIdRef.current = activeChatId;
+    let persistedContent = message;
+    let multimodalContent;
+    if (attachments && attachments.length > 0) {
+      const backend = fileUploadConfig?.backend ?? new EmbedFileUploadBackend();
+      const persistedParts = [];
+      if (message.trim()) {
+        persistedParts.push({ type: "text", text: message });
+      }
+      for (const attachment of attachments) {
+        persistedParts.push({
+          type: "file",
+          file: {
+            name: attachment.file.name,
+            size: attachment.file.size,
+            mimeType: attachment.file.type
+          }
+        });
+      }
+      persistedContent = persistedParts;
+      const contentParts = [];
+      if (message.trim()) {
+        contentParts.push({ type: "text", text: message });
+      }
+      for (const attachment of attachments) {
+        try {
+          const url = await backend.prepareForSend(attachment.file);
+          if (attachment.file.type.startsWith("image/")) {
+            contentParts.push({ type: "image", url });
+          } else {
+            contentParts.push({
+              type: "file",
+              url,
+              mimeType: attachment.file.type,
+              name: attachment.file.name
+            });
+          }
+        } catch (error) {
+          console.error("[Provider] Failed to prepare file for send:", error);
+        }
+      }
+      multimodalContent = contentParts;
+    }
+    if (activeChatId) {
+      await saveUserMessage(activeChatId, persistedContent);
+    }
+    setLoading(true);
+    await clientRef.current.sendPrompt(message, multimodalContent);
+  }, [activatePendingChat, currentChatId, saveUserMessage, fileUploadConfig]);
+  const value = {
+    serverUrl,
+    connected,
+    client: clientRef.current,
+    tools: {
+      register: registerTools,
+      unregister: unregisterTools
+    },
+    prompts: {
+      update: updatePrompt,
+      registerWaiter,
+      unregisterWaiter
+    },
+    chat: {
+      currentId: currentChatId,
+      create: createNewChat,
+      load: loadChat,
+      delete: deleteChat,
+      list: listChats,
+      clear: clearCurrentChat
+    },
+    agents: {
+      available: availableAgents,
+      default: defaultAgent,
+      selected: selectedAgent,
+      set: setAgent
+    },
+    commands: {
+      list: commands,
+      refresh: refreshCommands,
+      save: saveCommand,
+      rename: renameCommand,
+      delete: deleteCommand
+    }
+  };
+  const effectiveStreamingText = streamingChatIdRef.current === displayedChatId ? streamingText : "";
+  const chatUIContextValue = {
+    connected,
+    loading,
+    sendMessage: handleSendMessage,
+    messages,
+    streamingText: effectiveStreamingText,
+    suggestions: aggregatedSuggestions,
+    fileUploadConfig,
+    history: {
+      currentId: displayedChatId,
+      create: createNewChat,
+      load: loadChat,
+      delete: deleteChat,
+      list: listChats
+    },
+    agents: {
+      available: availableAgents,
+      default: defaultAgent,
+      selected: selectedAgent,
+      set: setAgent
+    },
+    commands: {
+      list: commands,
+      save: saveCommand,
+      rename: renameCommand,
+      delete: deleteCommand
+    },
+    ui: {
+      isOpen: isChatOpen,
+      setOpen: setIsChatOpen
+    }
+  };
+  const isUIDisabled = CustomButton === null || CustomChat === null;
+  const ButtonComponent = isUIDisabled ? null : CustomButton || UseAIFloatingButton;
+  const hasCustomChat = CustomChat !== void 0 && CustomChat !== null;
+  const chatPanelProps = {
+    onSendMessage: handleSendMessage,
+    messages,
+    loading,
+    connected,
+    streamingText: effectiveStreamingText,
+    currentChatId: displayedChatId,
+    onNewChat: createNewChat,
+    onLoadChat: loadChat,
+    onDeleteChat: deleteChat,
+    onListChats: listChats,
+    suggestions: aggregatedSuggestions,
+    availableAgents,
+    defaultAgent,
+    selectedAgent,
+    onAgentChange: setAgent,
+    fileUploadConfig,
+    commands,
+    onSaveCommand: saveCommand,
+    onRenameCommand: renameCommand,
+    onDeleteCommand: deleteCommand
+  };
+  const renderDefaultChat = () => {
+    if (isUIDisabled) return null;
+    return /* @__PURE__ */ jsx11(UseAIFloatingChatWrapper, { isOpen: isChatOpen, onClose: () => setIsChatOpen(false), children: /* @__PURE__ */ jsx11(
+      UseAIChatPanel,
+      {
+        ...chatPanelProps,
+        closeButton: /* @__PURE__ */ jsx11(CloseButton, { onClick: () => setIsChatOpen(false) })
+      }
+    ) });
+  };
+  const renderCustomChat = () => {
+    if (!CustomChat) return null;
+    return /* @__PURE__ */ jsx11(
+      CustomChat,
+      {
+        isOpen: isChatOpen,
+        onClose: () => setIsChatOpen(false),
+        onSendMessage: handleSendMessage,
+        messages,
+        loading,
+        connected,
+        suggestions: aggregatedSuggestions,
+        availableAgents,
+        defaultAgent,
+        selectedAgent,
+        onAgentChange: setAgent
+      }
+    );
+  };
+  const renderBuiltInChat = () => {
+    if (!renderChat) return null;
+    return /* @__PURE__ */ jsxs7(Fragment3, { children: [
+      ButtonComponent && /* @__PURE__ */ jsx11(
+        ButtonComponent,
+        {
+          onClick: () => setIsChatOpen(true),
+          connected
+        }
+      ),
+      hasCustomChat ? renderCustomChat() : renderDefaultChat()
+    ] });
+  };
+  return /* @__PURE__ */ jsx11(ThemeContext.Provider, { value: theme, children: /* @__PURE__ */ jsx11(StringsContext.Provider, { value: strings, children: /* @__PURE__ */ jsx11(__UseAIContext.Provider, { value, children: /* @__PURE__ */ jsxs7(__UseAIChatContext.Provider, { value: chatUIContextValue, children: [
+    children,
+    renderBuiltInChat()
+  ] }) }) }) });
+}
+function useAIContext() {
+  const context = useContext4(__UseAIContext);
+  if (!context) {
+    if (!hasWarnedAboutMissingProvider) {
+      console.warn(
+        "[use-ai] useAI hook used without UseAIProvider. AI features will be disabled. Wrap your app in <UseAIProvider> to enable AI features."
+      );
+      hasWarnedAboutMissingProvider = true;
+    }
+    return noOpContextValue;
+  }
+  return context;
+}
+
+// src/hooks/useStableTools.ts
+import { useRef as useRef10 } from "react";
+function useStableTools(tools) {
+  const latestToolsRef = useRef10({});
+  const stableToolsRef = useRef10({});
+  const prevToolNamesRef = useRef10("");
+  if (!tools) {
+    latestToolsRef.current = {};
+    return void 0;
+  }
+  latestToolsRef.current = tools;
+  const currentToolNames = Object.keys(tools).sort().join(",");
+  if (currentToolNames !== prevToolNamesRef.current) {
+    prevToolNamesRef.current = currentToolNames;
+    stableToolsRef.current = {};
+    for (const [name, tool] of Object.entries(tools)) {
+      stableToolsRef.current[name] = createStableToolWrapper(
+        name,
+        tool,
+        latestToolsRef
+      );
+    }
+  } else {
+    for (const [name, tool] of Object.entries(tools)) {
+      const stable = stableToolsRef.current[name];
+      if (stable) {
+        stable.description = tool.description;
+        stable._jsonSchema = tool._jsonSchema;
+        stable._zodSchema = tool._zodSchema;
+        stable._options = tool._options;
+      }
+    }
+  }
+  return stableToolsRef.current;
+}
+function createStableToolWrapper(name, tool, latestToolsRef) {
+  const stableHandler = (input) => {
+    const currentTool = latestToolsRef.current[name];
+    if (!currentTool) {
+      throw new Error(`Tool "${name}" no longer exists`);
+    }
+    return currentTool.fn(input);
+  };
+  const stableExecute = async (input) => {
+    const currentTool = latestToolsRef.current[name];
+    if (!currentTool) {
+      throw new Error(`Tool "${name}" no longer exists`);
+    }
+    return await currentTool._execute(input);
+  };
+  return {
+    description: tool.description,
+    _jsonSchema: tool._jsonSchema,
+    _zodSchema: tool._zodSchema,
+    fn: stableHandler,
+    _options: tool._options,
+    _toToolDefinition: tool._toToolDefinition.bind(tool),
+    _execute: stableExecute
+  };
+}
+
+// src/useAI.ts
+function namespaceTools(tools, namespace) {
+  const namespacedTools = {};
+  for (const [toolName, tool] of Object.entries(tools)) {
+    const namespacedName = `${namespace}_${toolName}`;
+    namespacedTools[namespacedName] = tool;
+  }
+  return namespacedTools;
+}
+function useAI(options = {}) {
+  const { enabled = true } = options;
+  const { connected, tools, client, prompts } = useAIContext();
+  const { register: registerTools, unregister: unregisterTools } = tools;
+  const { update: updatePrompt, registerWaiter, unregisterWaiter } = prompts;
+  const [response, setResponse] = useState11(null);
+  const [loading, setLoading] = useState11(false);
+  const [error, setError] = useState11(null);
+  const hookId = useRef11(`useAI-${Math.random().toString(36).substr(2, 9)}`);
+  const toolsRef = useRef11({});
+  const componentRef = useRef11(null);
+  const promptChangeResolvers = useRef11([]);
+  const stableTools = useStableTools(options.tools);
+  const toolsKey = useMemo6(() => {
+    if (!options.tools) return "";
+    return Object.keys(options.tools).sort().join(",");
+  }, [options.tools]);
+  const memoizedSuggestions = useMemo6(() => options.suggestions, [options.suggestions]);
+  useEffect10(() => {
+    if (componentRef.current) {
+      componentRef.current.setAttribute("data-useai-context", "true");
+    }
+  }, []);
+  const waitForPromptChange = useCallback10(() => {
+    return new Promise((resolve) => {
+      const timeoutMs = 100;
+      const timeoutId = setTimeout(() => {
+        const index = promptChangeResolvers.current.indexOf(resolveAndCleanup);
+        if (index !== -1) {
+          promptChangeResolvers.current.splice(index, 1);
+        }
+        resolve();
+      }, timeoutMs);
+      const resolveAndCleanup = () => {
+        clearTimeout(timeoutId);
+        resolve();
+      };
+      promptChangeResolvers.current.push(resolveAndCleanup);
+    });
+  }, []);
+  useEffect10(() => {
+    if (!enabled || options.invisible) return;
+    registerWaiter(hookId.current, waitForPromptChange);
+    return () => {
+      unregisterWaiter(hookId.current);
+    };
+  }, [enabled, options.invisible, registerWaiter, unregisterWaiter, waitForPromptChange]);
+  useEffect10(() => {
+    if (!enabled) return;
+    updatePrompt(hookId.current, options.prompt, memoizedSuggestions);
+    if (promptChangeResolvers.current.length > 0) {
+      promptChangeResolvers.current.forEach((resolve) => resolve());
+      promptChangeResolvers.current = [];
+    }
+  }, [enabled, options.prompt, memoizedSuggestions, updatePrompt]);
+  const updatePromptRef = useRef11(updatePrompt);
+  updatePromptRef.current = updatePrompt;
+  useEffect10(() => {
+    const id = hookId.current;
+    return () => {
+      updatePromptRef.current(id, void 0, void 0);
+    };
+  }, []);
+  useEffect10(() => {
+    if (!enabled) return;
+    if (stableTools) {
+      const componentId = options.id || componentRef.current?.id;
+      const toolsToRegister = componentId ? namespaceTools(stableTools, componentId) : stableTools;
+      registerTools(hookId.current, toolsToRegister, { invisible: options.invisible });
+      toolsRef.current = toolsToRegister;
+    }
+    return () => {
+      if (stableTools) {
+        unregisterTools(hookId.current);
+      }
+    };
+  }, [enabled, toolsKey, stableTools, options.id, options.invisible, registerTools, unregisterTools]);
+  useEffect10(() => {
+    if (!enabled || !client) return;
+    const unsubscribe = client.onEvent(hookId.current, (event) => {
+      handleAGUIEvent(event);
+    });
+    return () => {
+      unsubscribe();
+    };
+  }, [enabled, client]);
+  const handleAGUIEvent = useCallback10(async (event) => {
+    switch (event.type) {
+      case EventType.TEXT_MESSAGE_END: {
+        const content = client?.currentMessageContent;
+        if (content) {
+          setResponse(content);
+          setLoading(false);
+        }
+        break;
+      }
+      case EventType.RUN_ERROR: {
+        const errorEvent = event;
+        const error2 = new Error(errorEvent.message);
+        setError(error2);
+        setLoading(false);
+        options.onError?.(error2);
+        break;
+      }
+    }
+  }, [client, options.onError]);
+  const generate = useCallback10(async (prompt) => {
+    if (!enabled) {
+      const error2 = new Error("AI features are disabled");
+      setError(error2);
+      options.onError?.(error2);
+      return;
+    }
+    if (!client?.isConnected()) {
+      const error2 = new Error("Not connected to server");
+      setError(error2);
+      options.onError?.(error2);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    setResponse(null);
+    try {
+      client.sendPrompt(prompt);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Unknown error");
+      setError(error2);
+      setLoading(false);
+      options.onError?.(error2);
+    }
+  }, [enabled, client, options.onError]);
+  return {
+    response,
+    loading,
+    error,
+    generate,
+    connected: enabled && connected,
+    ref: componentRef
+  };
+}
+
+// src/useAIWorkflow.ts
+import { useState as useState12, useCallback as useCallback11, useRef as useRef12, useEffect as useEffect11 } from "react";
+import { EventType as EventType3 } from "@meetsmore-oss/use-ai-core";
+import { v4 as uuidv43 } from "uuid";
+function useAIWorkflow(runner, workflowId) {
+  const { connected, client } = useAIContext();
+  const [status, setStatus] = useState12("idle");
+  const [text, setText] = useState12(null);
+  const [error, setError] = useState12(null);
+  const currentWorkflowRef = useRef12(null);
+  const eventListenerIdRef = useRef12(`useAIWorkflow-${Math.random().toString(36).substr(2, 9)}`);
+  const handleWorkflowEvent = useCallback11(async (event) => {
+    const currentWorkflow = currentWorkflowRef.current;
+    if (!currentWorkflow) return;
+    if (event.type === EventType3.RUN_STARTED) {
+      const runEvent = event;
+      if (runEvent.runId !== currentWorkflow.runId) return;
+    }
+    switch (event.type) {
+      case EventType3.TEXT_MESSAGE_CONTENT: {
+        const textEvent = event;
+        currentWorkflow.accumulatedText += textEvent.delta;
+        setText(currentWorkflow.accumulatedText);
+        currentWorkflow.onProgress?.({
+          status: "running",
+          text: currentWorkflow.accumulatedText,
+          toolCalls: currentWorkflow.toolCalls
+        });
+        break;
+      }
+      case EventType3.TOOL_CALL_END: {
+        if (!client) break;
+        const toolCallEvent = event;
+        const toolCallId = toolCallEvent.toolCallId;
+        const toolCallData = client.getToolCallData(toolCallId);
+        if (!toolCallData) {
+          console.error(`[useAIWorkflow] Tool call ${toolCallId} not found`);
+          break;
+        }
+        const toolName = toolCallData.name;
+        const toolArgs = JSON.parse(toolCallData.args);
+        console.log(`[useAIWorkflow] Executing tool: ${toolName}`, toolArgs);
+        console.log(`[useAIWorkflow] Available tools:`, Object.keys(currentWorkflow.tools));
+        try {
+          const result = await executeDefinedTool(currentWorkflow.tools, toolName, toolArgs);
+          currentWorkflow.toolCalls.push({
+            toolName,
+            args: toolArgs,
+            result
+          });
+          currentWorkflow.onProgress?.({
+            status: "running",
+            text: currentWorkflow.accumulatedText,
+            toolCalls: currentWorkflow.toolCalls
+          });
+          client.sendToolResponse(toolCallId, result);
+        } catch (err) {
+          console.error("[useAIWorkflow] Tool execution error:", err);
+          client.sendToolResponse(toolCallId, {
+            error: err instanceof Error ? err.message : "Unknown error"
+          });
+        }
+        break;
+      }
+      case EventType3.RUN_FINISHED: {
+        setStatus("completed");
+        const result = {
+          text: currentWorkflow.accumulatedText,
+          toolCalls: currentWorkflow.toolCalls
+        };
+        currentWorkflow.onProgress?.({
+          status: "completed",
+          text: currentWorkflow.accumulatedText,
+          toolCalls: currentWorkflow.toolCalls
+        });
+        currentWorkflow.onComplete?.(result);
+        currentWorkflowRef.current = null;
+        break;
+      }
+      case EventType3.RUN_ERROR: {
+        const errorEvent = event;
+        const err = new Error(errorEvent.message);
+        setError(err);
+        setStatus("error");
+        currentWorkflow.onProgress?.({
+          status: "error",
+          error: errorEvent.message,
+          text: currentWorkflow.accumulatedText,
+          toolCalls: currentWorkflow.toolCalls
+        });
+        currentWorkflow.onError?.(err);
+        currentWorkflowRef.current = null;
+        break;
+      }
+    }
+  }, [client]);
+  useEffect11(() => {
+    if (!client) return;
+    const unsubscribe = client.onEvent(eventListenerIdRef.current, handleWorkflowEvent);
+    return () => {
+      unsubscribe();
+    };
+  }, [client, handleWorkflowEvent]);
+  const trigger = useCallback11(async (options) => {
+    if (!client?.isConnected()) {
+      const err = new Error("Not connected to server");
+      setError(err);
+      options.onError?.(err);
+      return;
+    }
+    if (currentWorkflowRef.current !== null) {
+      const err = new Error("A workflow is already running. Wait for it to complete before triggering a new one.");
+      setError(err);
+      setStatus("error");
+      options.onError?.(err);
+      return;
+    }
+    setStatus("running");
+    setError(null);
+    setText(null);
+    const runId = uuidv43();
+    const threadId = uuidv43();
+    currentWorkflowRef.current = {
+      runId,
+      threadId,
+      tools: options.tools || {},
+      onProgress: options.onProgress,
+      onComplete: options.onComplete,
+      onError: options.onError,
+      accumulatedText: "",
+      toolCalls: []
+    };
+    const toolDefinitions = options.tools ? convertToolsToDefinitions(options.tools) : [];
+    const message = {
+      type: "run_workflow",
+      data: {
+        runner,
+        workflowId,
+        inputs: options.inputs,
+        tools: toolDefinitions,
+        runId,
+        threadId
+      }
+    };
+    console.log("[useAIWorkflow] Sending run_workflow message:", message);
+    client.send(message);
+    options.onProgress?.({
+      status: "running"
+    });
+  }, [client, handleWorkflowEvent, runner, workflowId]);
+  return {
+    trigger,
+    status,
+    text,
+    error,
+    connected
+  };
+}
+
+// src/index.ts
+import { z as z2 } from "zod";
+export {
+  CloseButton,
+  DEFAULT_MAX_FILE_SIZE,
+  EmbedFileUploadBackend,
+  LocalStorageChatRepository,
+  LocalStorageCommandRepository,
+  UseAIChat,
+  UseAIChatPanel,
+  UseAIClient,
+  UseAIFloatingButton,
+  UseAIFloatingChatWrapper,
+  UseAIProvider,
+  convertToolsToDefinitions,
+  defaultStrings,
+  defaultTheme,
+  defineTool,
+  executeDefinedTool,
+  generateChatId,
+  generateCommandId,
+  generateMessageId,
+  useAI,
+  useAIContext,
+  useAIWorkflow,
+  useAgentSelection,
+  useChatManagement,
+  useCommandManagement,
+  useDropdownState,
+  useFileUpload,
+  usePromptState,
+  useSlashCommands,
+  useStableTools,
+  useStrings,
+  useTheme,
+  useToolRegistry,
+  validateCommandName,
+  z2 as z
+};
+//# sourceMappingURL=index.js.map