@informedai/react 0.1.0

package/dist/index.mjs

@@ -0,0 +1,963 @@
+// src/components/InformedAssistant.tsx
+import { useState as useState2, useRef as useRef2, useEffect as useEffect2 } from "react";
+
+// src/context/InformedAIContext.tsx
+import { createContext, useContext, useEffect, useState, useCallback, useRef } from "react";
+
+// src/utils/api-client.ts
+var DEFAULT_API_URL = "https://api.informedassistant.ai/api/v1";
+var InformedAIClient = class {
+  constructor(apiKey, apiUrl) {
+    this.apiKey = apiKey;
+    this.apiUrl = apiUrl || DEFAULT_API_URL;
+  }
+  getHeaders() {
+    return {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${this.apiKey}`
+    };
+  }
+  async request(endpoint, options = {}) {
+    const response = await fetch(`${this.apiUrl}${endpoint}`, {
+      ...options,
+      headers: {
+        ...this.getHeaders(),
+        ...options.headers
+      }
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Request failed" }));
+      throw new Error(error.error || `HTTP ${response.status}`);
+    }
+    if (response.status === 204) {
+      return {};
+    }
+    return response.json();
+  }
+  // ========================================================================
+  // Document Operations
+  // ========================================================================
+  async getDocument(id) {
+    return this.request(`/documents/${id}`);
+  }
+  async getDocumentType(id) {
+    return this.request(`/document-types/${id}`);
+  }
+  async updateDocumentField(documentId, field, value) {
+    return this.request(`/documents/${documentId}/field`, {
+      method: "PATCH",
+      body: JSON.stringify({ field, value })
+    });
+  }
+  // ========================================================================
+  // Session Operations
+  // ========================================================================
+  async createSession(documentId) {
+    return this.request("/sessions", {
+      method: "POST",
+      body: JSON.stringify({ documentId })
+    });
+  }
+  async getSession(id) {
+    return this.request(`/sessions/${id}`);
+  }
+  async deleteSession(id) {
+    await this.request(`/sessions/${id}`, { method: "DELETE" });
+  }
+  /**
+   * Send a message to the session with SSE streaming
+   */
+  async sendMessage(sessionId, message, onEvent) {
+    const response = await fetch(`${this.apiUrl}/sessions/${sessionId}/message`, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify({ message })
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Request failed" }));
+      throw new Error(error.error || `HTTP ${response.status}`);
+    }
+    await this.processSSEStream(response, onEvent);
+  }
+  /**
+   * Send a quick action to the session with SSE streaming
+   */
+  async sendQuickAction(sessionId, action, payload, onEvent) {
+    const response = await fetch(`${this.apiUrl}/sessions/${sessionId}/quick-action`, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify({ action, payload })
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Request failed" }));
+      throw new Error(error.error || `HTTP ${response.status}`);
+    }
+    let finalSession = null;
+    await this.processSSEStream(response, (event) => {
+      onEvent?.(event);
+      if (event.session) {
+        finalSession = event.session;
+      }
+    });
+    if (!finalSession) {
+      throw new Error("No session returned from quick action");
+    }
+    return finalSession;
+  }
+  /**
+   * Apply the pending value for the active task
+   */
+  async applyPendingValue(sessionId) {
+    return this.request(`/sessions/${sessionId}/apply`, {
+      method: "POST"
+    });
+  }
+  /**
+   * Skip the active task
+   */
+  async skipTask(sessionId) {
+    return this.request(`/sessions/${sessionId}/skip`, {
+      method: "POST"
+    });
+  }
+  // ========================================================================
+  // SSE Stream Processing
+  // ========================================================================
+  async processSSEStream(response, onEvent) {
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error("No response body");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            try {
+              const data = JSON.parse(line.slice(6));
+              onEvent(data);
+            } catch {
+            }
+          }
+        }
+      }
+      if (buffer.startsWith("data: ")) {
+        try {
+          const data = JSON.parse(buffer.slice(6));
+          onEvent(data);
+        } catch {
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+};
+
+// src/context/InformedAIContext.tsx
+import { jsx } from "react/jsx-runtime";
+var InformedAIContext = createContext(null);
+function useInformedAI() {
+  const context = useContext(InformedAIContext);
+  if (!context) {
+    throw new Error("useInformedAI must be used within an InformedAIProvider");
+  }
+  return context;
+}
+function InformedAIProvider({ config, children }) {
+  const [session, setSession] = useState(null);
+  const [document, setDocument] = useState(null);
+  const [documentType, setDocumentType] = useState(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [isStreaming, setIsStreaming] = useState(false);
+  const [error, setError] = useState(null);
+  const [streamingContent, setStreamingContent] = useState("");
+  const clientRef = useRef(null);
+  useEffect(() => {
+    clientRef.current = new InformedAIClient(config.apiKey, config.apiUrl);
+  }, [config.apiKey, config.apiUrl]);
+  useEffect(() => {
+    async function initialize() {
+      if (!clientRef.current) return;
+      try {
+        setIsLoading(true);
+        setError(null);
+        const doc = await clientRef.current.getDocument(config.documentId);
+        setDocument(doc);
+        const dt = await clientRef.current.getDocumentType(doc.documentTypeId);
+        setDocumentType(dt);
+        let sess;
+        if (config.sessionId) {
+          sess = await clientRef.current.getSession(config.sessionId);
+        } else {
+          sess = await clientRef.current.createSession(config.documentId);
+        }
+        setSession(sess);
+        config.onSessionChange?.(sess);
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error("Initialization failed");
+        setError(error2);
+        config.onError?.(error2);
+      } finally {
+        setIsLoading(false);
+      }
+    }
+    initialize();
+  }, [config.documentId, config.sessionId]);
+  const handleSSEEvent = useCallback((event) => {
+    if (event.type === "content" && event.content) {
+      setStreamingContent((prev) => prev + event.content);
+    }
+    if (event.type === "done" || event.type === "session_update") {
+      if (event.session) {
+        setSession(event.session);
+        config.onSessionChange?.(event.session);
+        if (event.session.activeTask) {
+          const taskState = event.session.taskStates[event.session.activeTask];
+          if (taskState?.pendingValue !== void 0) {
+          }
+        }
+      }
+      setStreamingContent("");
+      setIsStreaming(false);
+    }
+    if (event.type === "error") {
+      const error2 = new Error(event.error || "Stream error");
+      setError(error2);
+      config.onError?.(error2);
+      setIsStreaming(false);
+    }
+  }, [config]);
+  const sendMessage = useCallback(async (message) => {
+    if (!clientRef.current || !session) return;
+    try {
+      setIsStreaming(true);
+      setStreamingContent("");
+      setError(null);
+      await clientRef.current.sendMessage(session.id, message, handleSSEEvent);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to send message");
+      setError(error2);
+      config.onError?.(error2);
+      setIsStreaming(false);
+    }
+  }, [session, handleSSEEvent, config]);
+  const sendQuickAction = useCallback(async (action, payload) => {
+    if (!clientRef.current || !session) return;
+    try {
+      setIsStreaming(true);
+      setStreamingContent("");
+      setError(null);
+      const newSession = await clientRef.current.sendQuickAction(
+        session.id,
+        action,
+        payload,
+        handleSSEEvent
+      );
+      setSession(newSession);
+      config.onSessionChange?.(newSession);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to send quick action");
+      setError(error2);
+      config.onError?.(error2);
+    } finally {
+      setIsStreaming(false);
+    }
+  }, [session, handleSSEEvent, config]);
+  const applyPendingValue = useCallback(async () => {
+    if (!clientRef.current || !session) return;
+    try {
+      setError(null);
+      const activeTask = session.activeTask;
+      const pendingValue = activeTask ? session.taskStates[activeTask]?.pendingValue : void 0;
+      const newSession = await clientRef.current.applyPendingValue(session.id);
+      setSession(newSession);
+      config.onSessionChange?.(newSession);
+      if (activeTask && pendingValue !== void 0) {
+        config.onFieldApply?.(activeTask, pendingValue);
+      }
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to apply value");
+      setError(error2);
+      config.onError?.(error2);
+    }
+  }, [session, config]);
+  const skipTask = useCallback(async () => {
+    if (!clientRef.current || !session) return;
+    try {
+      setError(null);
+      const newSession = await clientRef.current.skipTask(session.id);
+      setSession(newSession);
+      config.onSessionChange?.(newSession);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to skip task");
+      setError(error2);
+      config.onError?.(error2);
+    }
+  }, [session, config]);
+  const clearError = useCallback(() => {
+    setError(null);
+  }, []);
+  const value = {
+    session,
+    document,
+    documentType,
+    isLoading,
+    isStreaming,
+    error,
+    streamingContent,
+    sendMessage,
+    sendQuickAction,
+    applyPendingValue,
+    skipTask,
+    clearError
+  };
+  return /* @__PURE__ */ jsx(InformedAIContext.Provider, { value, children });
+}
+
+// src/components/InformedAssistant.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var defaultTheme = {
+  primaryColor: "#f59e0b",
+  // Amber
+  backgroundColor: "#ffffff",
+  textColor: "#1c1917",
+  borderRadius: "12px",
+  fontFamily: "system-ui, -apple-system, sans-serif"
+};
+function InformedAssistant({ className, ...config }) {
+  return /* @__PURE__ */ jsx2(InformedAIProvider, { config, children: /* @__PURE__ */ jsx2(
+    AssistantWidget,
+    {
+      className,
+      theme: { ...defaultTheme, ...config.theme },
+      position: config.position,
+      defaultCollapsed: config.defaultCollapsed
+    }
+  ) });
+}
+function AssistantWidget({ className, theme, position = "inline", defaultCollapsed = false }) {
+  const {
+    session,
+    documentType,
+    isLoading,
+    isStreaming,
+    error,
+    streamingContent,
+    sendMessage,
+    sendQuickAction,
+    applyPendingValue,
+    skipTask
+  } = useInformedAI();
+  const [isCollapsed, setIsCollapsed] = useState2(defaultCollapsed);
+  const [inputValue, setInputValue] = useState2("");
+  const messagesEndRef = useRef2(null);
+  useEffect2(() => {
+    messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
+  }, [session?.widgetMessages, streamingContent]);
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    if (!inputValue.trim() || isStreaming) return;
+    const message = inputValue.trim();
+    setInputValue("");
+    await sendMessage(message);
+  };
+  const handleQuickAction = async (action) => {
+    await sendQuickAction(action.action, action.payload);
+  };
+  const activeTask = session?.activeTask;
+  const pendingValue = activeTask ? session?.taskStates[activeTask]?.pendingValue : void 0;
+  const hasPendingValue = pendingValue !== void 0 && pendingValue !== null;
+  const cssVars = {
+    "--ia-primary": theme.primaryColor,
+    "--ia-bg": theme.backgroundColor,
+    "--ia-text": theme.textColor,
+    "--ia-radius": theme.borderRadius,
+    "--ia-font": theme.fontFamily
+  };
+  const positionStyles = position === "inline" ? {} : {
+    position: "fixed",
+    [position === "bottom-right" ? "right" : "left"]: "20px",
+    bottom: "20px",
+    zIndex: 9999
+  };
+  if (isLoading) {
+    return /* @__PURE__ */ jsx2(
+      "div",
+      {
+        className,
+        style: {
+          ...cssVars,
+          ...positionStyles,
+          width: position === "inline" ? "100%" : "380px",
+          backgroundColor: "var(--ia-bg)",
+          borderRadius: "var(--ia-radius)",
+          border: "1px solid #e5e5e5",
+          fontFamily: "var(--ia-font)",
+          padding: "24px",
+          textAlign: "center",
+          color: "#737373"
+        },
+        children: /* @__PURE__ */ jsxs("div", { style: { display: "flex", alignItems: "center", justifyContent: "center", gap: "8px" }, children: [
+          /* @__PURE__ */ jsx2(LoadingSpinner, {}),
+          /* @__PURE__ */ jsx2("span", { children: "Loading assistant..." })
+        ] })
+      }
+    );
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx2(
+      "div",
+      {
+        className,
+        style: {
+          ...cssVars,
+          ...positionStyles,
+          width: position === "inline" ? "100%" : "380px",
+          backgroundColor: "var(--ia-bg)",
+          borderRadius: "var(--ia-radius)",
+          border: "1px solid #fecaca",
+          fontFamily: "var(--ia-font)",
+          padding: "24px",
+          textAlign: "center",
+          color: "#dc2626"
+        },
+        children: /* @__PURE__ */ jsx2("p", { style: { margin: 0 }, children: error.message })
+      }
+    );
+  }
+  if (isCollapsed && position !== "inline") {
+    return /* @__PURE__ */ jsx2(
+      "button",
+      {
+        onClick: () => setIsCollapsed(false),
+        style: {
+          ...positionStyles,
+          width: "56px",
+          height: "56px",
+          borderRadius: "50%",
+          backgroundColor: theme.primaryColor,
+          border: "none",
+          cursor: "pointer",
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          boxShadow: "0 4px 12px rgba(0,0,0,0.15)"
+        },
+        children: /* @__PURE__ */ jsx2(ChatIcon, { color: "#fff" })
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className,
+      style: {
+        ...cssVars,
+        ...positionStyles,
+        width: position === "inline" ? "100%" : "380px",
+        height: position === "inline" ? "auto" : "500px",
+        maxHeight: position === "inline" ? "600px" : "500px",
+        backgroundColor: "var(--ia-bg)",
+        borderRadius: "var(--ia-radius)",
+        border: "1px solid #e5e5e5",
+        fontFamily: "var(--ia-font)",
+        display: "flex",
+        flexDirection: "column",
+        overflow: "hidden",
+        boxShadow: position !== "inline" ? "0 4px 24px rgba(0,0,0,0.12)" : void 0
+      },
+      children: [
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            style: {
+              padding: "16px",
+              borderBottom: "1px solid #e5e5e5",
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "space-between"
+            },
+            children: [
+              /* @__PURE__ */ jsxs("div", { style: { display: "flex", alignItems: "center", gap: "8px" }, children: [
+                /* @__PURE__ */ jsx2(SparklesIcon, { color: theme.primaryColor }),
+                /* @__PURE__ */ jsx2("span", { style: { fontWeight: 600, color: "var(--ia-text)" }, children: "InformedAI Assistant" })
+              ] }),
+              position !== "inline" && /* @__PURE__ */ jsx2(
+                "button",
+                {
+                  onClick: () => setIsCollapsed(true),
+                  style: {
+                    background: "none",
+                    border: "none",
+                    cursor: "pointer",
+                    padding: "4px",
+                    color: "#737373"
+                  },
+                  children: /* @__PURE__ */ jsx2(MinimizeIcon, {})
+                }
+              )
+            ]
+          }
+        ),
+        activeTask && documentType && /* @__PURE__ */ jsxs(
+          "div",
+          {
+            style: {
+              padding: "8px 16px",
+              backgroundColor: `${theme.primaryColor}15`,
+              borderBottom: "1px solid #e5e5e5",
+              fontSize: "13px"
+            },
+            children: [
+              /* @__PURE__ */ jsx2("span", { style: { color: "#737373" }, children: "Working on: " }),
+              /* @__PURE__ */ jsx2("span", { style: { fontWeight: 500, color: theme.primaryColor }, children: documentType.schema.fields[activeTask]?.label || activeTask })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            style: {
+              flex: 1,
+              overflowY: "auto",
+              padding: "16px",
+              display: "flex",
+              flexDirection: "column",
+              gap: "12px"
+            },
+            children: [
+              session?.widgetMessages.map((msg) => /* @__PURE__ */ jsx2(
+                MessageBubble,
+                {
+                  message: msg,
+                  theme,
+                  onQuickAction: handleQuickAction
+                },
+                msg.id
+              )),
+              isStreaming && streamingContent && /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  style: {
+                    padding: "12px 16px",
+                    backgroundColor: "#f5f5f5",
+                    borderRadius: "12px",
+                    borderBottomLeftRadius: "4px",
+                    color: "var(--ia-text)",
+                    fontSize: "14px",
+                    lineHeight: 1.5,
+                    whiteSpace: "pre-wrap"
+                  },
+                  children: [
+                    streamingContent,
+                    /* @__PURE__ */ jsx2("span", { style: { opacity: 0.5 }, children: "\u258A" })
+                  ]
+                }
+              ),
+              isStreaming && !streamingContent && /* @__PURE__ */ jsxs("div", { style: { display: "flex", alignItems: "center", gap: "8px", color: "#737373" }, children: [
+                /* @__PURE__ */ jsx2(LoadingSpinner, { size: 16 }),
+                /* @__PURE__ */ jsx2("span", { style: { fontSize: "14px" }, children: "Thinking..." })
+              ] }),
+              /* @__PURE__ */ jsx2("div", { ref: messagesEndRef })
+            ]
+          }
+        ),
+        hasPendingValue && /* @__PURE__ */ jsxs(
+          "div",
+          {
+            style: {
+              padding: "12px 16px",
+              borderTop: "1px solid #e5e5e5",
+              backgroundColor: `${theme.primaryColor}10`,
+              display: "flex",
+              gap: "8px"
+            },
+            children: [
+              /* @__PURE__ */ jsx2(
+                "button",
+                {
+                  onClick: applyPendingValue,
+                  disabled: isStreaming,
+                  style: {
+                    flex: 1,
+                    padding: "10px 16px",
+                    backgroundColor: theme.primaryColor,
+                    color: "#fff",
+                    border: "none",
+                    borderRadius: "8px",
+                    fontWeight: 500,
+                    cursor: "pointer",
+                    fontSize: "14px",
+                    opacity: isStreaming ? 0.5 : 1
+                  },
+                  children: "Apply"
+                }
+              ),
+              /* @__PURE__ */ jsx2(
+                "button",
+                {
+                  onClick: skipTask,
+                  disabled: isStreaming,
+                  style: {
+                    padding: "10px 16px",
+                    backgroundColor: "transparent",
+                    color: "#737373",
+                    border: "1px solid #e5e5e5",
+                    borderRadius: "8px",
+                    fontWeight: 500,
+                    cursor: "pointer",
+                    fontSize: "14px",
+                    opacity: isStreaming ? 0.5 : 1
+                  },
+                  children: "Skip"
+                }
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          "form",
+          {
+            onSubmit: handleSubmit,
+            style: {
+              padding: "12px 16px",
+              borderTop: "1px solid #e5e5e5",
+              display: "flex",
+              gap: "8px"
+            },
+            children: [
+              /* @__PURE__ */ jsx2(
+                "input",
+                {
+                  type: "text",
+                  value: inputValue,
+                  onChange: (e) => setInputValue(e.target.value),
+                  placeholder: "Type a message...",
+                  disabled: isStreaming,
+                  style: {
+                    flex: 1,
+                    padding: "10px 14px",
+                    border: "1px solid #e5e5e5",
+                    borderRadius: "8px",
+                    fontSize: "14px",
+                    outline: "none",
+                    fontFamily: "inherit"
+                  }
+                }
+              ),
+              /* @__PURE__ */ jsx2(
+                "button",
+                {
+                  type: "submit",
+                  disabled: !inputValue.trim() || isStreaming,
+                  style: {
+                    padding: "10px 16px",
+                    backgroundColor: theme.primaryColor,
+                    color: "#fff",
+                    border: "none",
+                    borderRadius: "8px",
+                    fontWeight: 500,
+                    cursor: "pointer",
+                    fontSize: "14px",
+                    opacity: !inputValue.trim() || isStreaming ? 0.5 : 1
+                  },
+                  children: "Send"
+                }
+              )
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+function MessageBubble({ message, theme, onQuickAction }) {
+  const isUser = message.role === "user";
+  if (message.type === "quick_actions" && message.quickActions) {
+    return /* @__PURE__ */ jsx2("div", { style: { display: "flex", flexWrap: "wrap", gap: "8px" }, children: message.quickActions.map((action) => /* @__PURE__ */ jsx2(
+      "button",
+      {
+        onClick: () => onQuickAction(action),
+        style: {
+          padding: "8px 14px",
+          backgroundColor: "#f5f5f5",
+          border: "1px solid #e5e5e5",
+          borderRadius: "20px",
+          fontSize: "13px",
+          cursor: "pointer",
+          color: theme.textColor,
+          transition: "all 0.15s"
+        },
+        onMouseOver: (e) => {
+          e.currentTarget.style.backgroundColor = `${theme.primaryColor}15`;
+          e.currentTarget.style.borderColor = theme.primaryColor;
+        },
+        onMouseOut: (e) => {
+          e.currentTarget.style.backgroundColor = "#f5f5f5";
+          e.currentTarget.style.borderColor = "#e5e5e5";
+        },
+        children: action.label
+      },
+      action.id
+    )) });
+  }
+  return /* @__PURE__ */ jsx2(
+    "div",
+    {
+      style: {
+        display: "flex",
+        justifyContent: isUser ? "flex-end" : "flex-start"
+      },
+      children: /* @__PURE__ */ jsx2(
+        "div",
+        {
+          style: {
+            maxWidth: "85%",
+            padding: "12px 16px",
+            backgroundColor: isUser ? theme.primaryColor : "#f5f5f5",
+            color: isUser ? "#fff" : theme.textColor,
+            borderRadius: "12px",
+            borderBottomRightRadius: isUser ? "4px" : "12px",
+            borderBottomLeftRadius: isUser ? "12px" : "4px",
+            fontSize: "14px",
+            lineHeight: 1.5,
+            whiteSpace: "pre-wrap"
+          },
+          children: message.content
+        }
+      )
+    }
+  );
+}
+function SparklesIcon({ color = "currentColor" }) {
+  return /* @__PURE__ */ jsxs("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", stroke: color, strokeWidth: "2", children: [
+    /* @__PURE__ */ jsx2("path", { d: "M12 3l1.5 4.5L18 9l-4.5 1.5L12 15l-1.5-4.5L6 9l4.5-1.5L12 3z" }),
+    /* @__PURE__ */ jsx2("path", { d: "M19 13l1 3 3 1-3 1-1 3-1-3-3-1 3-1 1-3z" }),
+    /* @__PURE__ */ jsx2("path", { d: "M5 17l1 2 2 1-2 1-1 2-1-2-2-1 2-1 1-2z" })
+  ] });
+}
+function ChatIcon({ color = "currentColor" }) {
+  return /* @__PURE__ */ jsx2("svg", { width: "24", height: "24", viewBox: "0 0 24 24", fill: "none", stroke: color, strokeWidth: "2", children: /* @__PURE__ */ jsx2("path", { d: "M21 15a2 2 0 01-2 2H7l-4 4V5a2 2 0 012-2h14a2 2 0 012 2z" }) });
+}
+function MinimizeIcon() {
+  return /* @__PURE__ */ jsx2("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", children: /* @__PURE__ */ jsx2("path", { d: "M19 9l-7 7-7-7" }) });
+}
+function LoadingSpinner({ size = 20 }) {
+  return /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      width: size,
+      height: size,
+      viewBox: "0 0 24 24",
+      fill: "none",
+      style: { animation: "ia-spin 1s linear infinite" },
+      children: [
+        /* @__PURE__ */ jsx2("style", { children: `@keyframes ia-spin { to { transform: rotate(360deg); } }` }),
+        /* @__PURE__ */ jsx2("circle", { cx: "12", cy: "12", r: "10", stroke: "#e5e5e5", strokeWidth: "3" }),
+        /* @__PURE__ */ jsx2(
+          "path",
+          {
+            d: "M12 2a10 10 0 019.17 6",
+            stroke: "currentColor",
+            strokeWidth: "3",
+            strokeLinecap: "round"
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/hooks/useSession.ts
+import { useState as useState3, useEffect as useEffect3, useCallback as useCallback2, useRef as useRef3 } from "react";
+function useSession(options) {
+  const { apiKey, apiUrl, documentId, sessionId, onSessionChange, onError } = options;
+  const [session, setSession] = useState3(null);
+  const [isLoading, setIsLoading] = useState3(true);
+  const [error, setError] = useState3(null);
+  const clientRef = useRef3(null);
+  const isStreamingRef = useRef3(false);
+  useEffect3(() => {
+    clientRef.current = new InformedAIClient(apiKey, apiUrl);
+  }, [apiKey, apiUrl]);
+  useEffect3(() => {
+    async function initialize() {
+      if (!clientRef.current) return;
+      try {
+        setIsLoading(true);
+        setError(null);
+        let sess;
+        if (sessionId) {
+          sess = await clientRef.current.getSession(sessionId);
+        } else {
+          sess = await clientRef.current.createSession(documentId);
+        }
+        setSession(sess);
+        onSessionChange?.(sess);
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error("Failed to initialize session");
+        setError(error2);
+        onError?.(error2);
+      } finally {
+        setIsLoading(false);
+      }
+    }
+    initialize();
+  }, [documentId, sessionId, onSessionChange, onError]);
+  const handleSSEEvent = useCallback2((event) => {
+    if (event.type === "done" || event.type === "session_update") {
+      if (event.session) {
+        setSession(event.session);
+        onSessionChange?.(event.session);
+      }
+      isStreamingRef.current = false;
+    }
+    if (event.type === "error") {
+      const error2 = new Error(event.error || "Stream error");
+      setError(error2);
+      onError?.(error2);
+      isStreamingRef.current = false;
+    }
+  }, [onSessionChange, onError]);
+  const sendMessage = useCallback2(async (message) => {
+    if (!clientRef.current || !session || isStreamingRef.current) return;
+    try {
+      isStreamingRef.current = true;
+      setError(null);
+      await clientRef.current.sendMessage(session.id, message, handleSSEEvent);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to send message");
+      setError(error2);
+      onError?.(error2);
+      isStreamingRef.current = false;
+    }
+  }, [session, handleSSEEvent, onError]);
+  const sendQuickAction = useCallback2(async (action, payload) => {
+    if (!clientRef.current || !session || isStreamingRef.current) return;
+    try {
+      isStreamingRef.current = true;
+      setError(null);
+      const newSession = await clientRef.current.sendQuickAction(
+        session.id,
+        action,
+        payload,
+        handleSSEEvent
+      );
+      setSession(newSession);
+      onSessionChange?.(newSession);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to send quick action");
+      setError(error2);
+      onError?.(error2);
+    } finally {
+      isStreamingRef.current = false;
+    }
+  }, [session, handleSSEEvent, onSessionChange, onError]);
+  const applyPendingValue = useCallback2(async () => {
+    if (!clientRef.current || !session) return;
+    try {
+      setError(null);
+      const newSession = await clientRef.current.applyPendingValue(session.id);
+      setSession(newSession);
+      onSessionChange?.(newSession);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to apply value");
+      setError(error2);
+      onError?.(error2);
+    }
+  }, [session, onSessionChange, onError]);
+  const skipTask = useCallback2(async () => {
+    if (!clientRef.current || !session) return;
+    try {
+      setError(null);
+      const newSession = await clientRef.current.skipTask(session.id);
+      setSession(newSession);
+      onSessionChange?.(newSession);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to skip task");
+      setError(error2);
+      onError?.(error2);
+    }
+  }, [session, onSessionChange, onError]);
+  return {
+    session,
+    isLoading,
+    error,
+    sendMessage,
+    sendQuickAction,
+    applyPendingValue,
+    skipTask
+  };
+}
+
+// src/hooks/useDocument.ts
+import { useState as useState4, useEffect as useEffect4, useCallback as useCallback3, useRef as useRef4 } from "react";
+function useDocument(options) {
+  const { apiKey, apiUrl, documentId, onError } = options;
+  const [document, setDocument] = useState4(null);
+  const [documentType, setDocumentType] = useState4(null);
+  const [isLoading, setIsLoading] = useState4(true);
+  const [error, setError] = useState4(null);
+  const clientRef = useRef4(null);
+  useEffect4(() => {
+    clientRef.current = new InformedAIClient(apiKey, apiUrl);
+  }, [apiKey, apiUrl]);
+  const fetchDocument = useCallback3(async () => {
+    if (!clientRef.current) return;
+    try {
+      setIsLoading(true);
+      setError(null);
+      const doc = await clientRef.current.getDocument(documentId);
+      setDocument(doc);
+      const dt = await clientRef.current.getDocumentType(doc.documentTypeId);
+      setDocumentType(dt);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to fetch document");
+      setError(error2);
+      onError?.(error2);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [documentId, onError]);
+  useEffect4(() => {
+    fetchDocument();
+  }, [fetchDocument]);
+  const updateField = useCallback3(async (fieldName, value) => {
+    if (!clientRef.current || !document) return;
+    try {
+      setError(null);
+      const updatedDoc = await clientRef.current.updateDocumentField(document.id, fieldName, value);
+      setDocument(updatedDoc);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to update field");
+      setError(error2);
+      onError?.(error2);
+    }
+  }, [document, onError]);
+  const refetch = useCallback3(async () => {
+    await fetchDocument();
+  }, [fetchDocument]);
+  return {
+    document,
+    documentType,
+    isLoading,
+    error,
+    updateField,
+    refetch
+  };
+}
+export {
+  InformedAIClient,
+  InformedAIProvider,
+  InformedAssistant,
+  useDocument,
+  useInformedAI,
+  useSession
+};