@brainfish-ai/components 0.19.3 → 0.19.5

package/dist/convos.d.ts

@@ -95,6 +95,10 @@ declare enum DiscardReason {
     OTHER = "other"
 }
 
+export declare const EmptyConvos: ({ children }: {
+    children: default_2.ReactNode;
+}) => default_2.JSX.Element;
+
 declare interface EvidenceFromContext {
     supporting_quote?: string;
     url?: string;

package/dist/esm/chunks/{ChatSearch.C6nUXNy4.js → ChatSearch.DOH90EUx.js}

@@ -22,11 +22,12 @@ import { useSearchParam, useEffectOnce } from 'react-use';
 import { MemoizedIcon } from '../components/ui/icon.js';
 import { Collapsible, CollapsibleTrigger, CollapsibleContent } from '../components/ui/collapsible.js';
 import { F as Feedback } from './feedback.D139-1Wr.js';
-import { G as GeneratingStar } from './generating-star.CozjECmM.js';
+import { G as GeneratingStar } from './generating-star.BMQgTqs7.js';
 import { getCountry } from 'countries-and-timezones';
 import { Switch } from '../components/ui/switch.js';
 import { C as Combobox } from './combobox.DNYCWyub.js';
 import { T as TwoLevelCombobox } from './two-level-combobox.DsWPDcI6.js';
+import { l as loadConversation, c as createConversationId, a as useAutocomplete, s as sendFeedbackReason, b as sendFeedback, d as searchApi, f as fetchAnswerStream, e as fetchFollowUpQuestions } from './hooks.B9tkXVNJ.js';
 import { ScrollArea } from '../components/ui/scroll-area.js';
 
 import '../ChatSearch.css';function Suggestions({ suggestions, onQuestionClick, title = "Suggested questions" }) {
@@ -4295,242 +4296,6 @@ const useScrollManager = (answerRefs, containerRef, bottomRef) => {
   return { scrollToLastAnswer, scrollToAnswer, scrollToBottom };
 };
 
-const defaultRetryOptions = {
-  maxRetries: 3,
-  baseDelay: 1e3,
-  shouldRetry: (error) => {
-    if (error instanceof TypeError) {
-      return true;
-    }
-    const apiError = error;
-    return apiError.status ? apiError.status >= 500 : false;
-  }
-};
-const defaultFallbackConfig = {
-  emptyResponse: "I apologize, but I couldn't generate an answer at this time. Please try again.",
-  errorResponse: "I encountered an error while processing your request. Please try again."
-};
-let globalRetryOptions = { ...defaultRetryOptions };
-let globalFallbackConfig = { ...defaultFallbackConfig };
-async function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function makeRequest(url, config = {}) {
-  const { retry = {}, headers = {}, body, isStream = false, fallback = {}, ...fetchConfig } = config;
-  const retryOptions = {
-    ...globalRetryOptions,
-    ...retry
-  };
-  const fallbackOptions = {
-    ...globalFallbackConfig,
-    ...fallback
-  };
-  let attempt = 1;
-  while (true) {
-    try {
-      const response = await fetch(url, {
-        ...fetchConfig,
-        headers: {
-          "Content-Type": "application/json",
-          ...headers
-        },
-        body: body ? JSON.stringify(body) : void 0
-      });
-      if (response.ok) {
-        if (isStream) {
-          if (!response.ok) {
-            throw new Error("Failed to fetch answer");
-          }
-          return response;
-        }
-        const data = await response.json();
-        if (!data || typeof data === "object" && Object.keys(data).length === 0) {
-          const emptyError = new Error(fallbackOptions.emptyResponse);
-          emptyError.name = "EmptyResponseError";
-          throw emptyError;
-        }
-        return data;
-      }
-      const error = new Error(fallbackOptions.errorResponse);
-      error.status = response.status;
-      error.data = await response.json().catch(() => void 0);
-      throw error;
-    } catch (error) {
-      const shouldAttemptRetry = await Promise.resolve(retryOptions.shouldRetry(error, attempt));
-      if (attempt >= retryOptions.maxRetries || !shouldAttemptRetry) {
-        if (error instanceof Error && error.name === "EmptyResponseError") {
-          return { message: error.message };
-        }
-        throw error;
-      }
-      console.warn(`Request failed, attempt ${attempt} of ${retryOptions.maxRetries}. Retrying...`);
-      const jitter = Math.random() * 0.3 + 0.85;
-      await delay(retryOptions.baseDelay * Math.pow(2, attempt - 1) * jitter);
-      attempt++;
-    }
-  }
-}
-
-const searchRetryConfig = {
-  maxRetries: 3,
-  baseDelay: 300,
-  // Start with 300ms delay
-  shouldRetry: (error) => {
-    if (error instanceof TypeError) {
-      return true;
-    }
-    const apiError = error;
-    return apiError.status ? apiError.status >= 500 || apiError.status === 429 : false;
-  }
-};
-const answerRetryConfig = {
-  maxRetries: 3,
-  baseDelay: 500,
-  // Start with 500ms delay for streaming responses
-  shouldRetry: (error) => {
-    if (error instanceof TypeError) {
-      return true;
-    }
-    const apiError = error;
-    return apiError.status ? apiError.status >= 500 : false;
-  }
-};
-async function searchApi({
-  endpoint,
-  query,
-  collectionId,
-  headers,
-  conversationId,
-  attributes,
-  secretAttributes,
-  allowedRegions,
-  source
-}) {
-  const payload = await makeRequest(endpoint, {
-    method: "POST",
-    headers,
-    retry: searchRetryConfig,
-    body: {
-      query,
-      limit: 5,
-      ...collectionId && collectionId !== "all" && { collectionId },
-      ...conversationId && { conversationId },
-      ...attributes && { attributes },
-      ...secretAttributes && { secretAttributes },
-      ...allowedRegions && { allowedRegions },
-      ...source && { source }
-    }
-  });
-  return {
-    results: payload?.data,
-    searchQueryId: payload?.searchQuery?.id,
-    isAgenticResponse: payload?.isAgenticResponse
-  };
-}
-async function fetchAnswerStream({
-  endpoint,
-  headers,
-  body
-}) {
-  return makeRequest(endpoint, {
-    method: "POST",
-    headers,
-    retry: answerRetryConfig,
-    isStream: true,
-    fallback: {
-      emptyResponse: "I apologize, but I couldn't generate an answer for your query. Please try rephrasing your question.",
-      errorResponse: "I encountered an issue while generating the answer. Please try again in a moment."
-    },
-    body
-  });
-}
-function createConversationId() {
-  return createId();
-}
-async function sendFeedback({
-  endpoint,
-  searchQueryId,
-  response,
-  headers,
-  conversationId
-}) {
-  await makeRequest(endpoint, {
-    method: "POST",
-    headers,
-    body: {
-      searchQueryId,
-      response,
-      ...conversationId && { conversationId }
-    }
-  });
-}
-async function sendFeedbackReason({
-  endpoint,
-  searchQueryId,
-  reason,
-  headers
-}) {
-  await makeRequest(endpoint, {
-    method: "POST",
-    headers,
-    body: {
-      searchQueryId,
-      reason
-    }
-  });
-}
-async function loadConversation({
-  endpoint,
-  conversationId,
-  headers,
-  signal
-}) {
-  const payload = await makeRequest(endpoint, {
-    method: "POST",
-    headers,
-    body: { conversationId },
-    signal
-  });
-  return { data: payload.data };
-}
-async function fetchFollowUpQuestions({
-  endpoint,
-  searchQueryId,
-  headers,
-  conversationId
-}) {
-  const data = await makeRequest(endpoint, {
-    method: "POST",
-    headers,
-    body: {
-      searchQueryId,
-      ...conversationId
-    }
-  });
-  return data.questions;
-}
-async function fetchAutocomplete({
-  endpoint,
-  query,
-  collectionId,
-  headers,
-  conversationId,
-  allowedRegions
-}) {
-  const data = await makeRequest(endpoint, {
-    method: "POST",
-    headers,
-    retry: searchRetryConfig,
-    body: {
-      query,
-      ...collectionId && collectionId !== "all" && { collectionId },
-      ...conversationId && { conversationId },
-      ...allowedRegions && { allowedRegions }
-    }
-  });
-  return data;
-}
-
 const useConversationLoader = ({ loadConversationEndpoint, headers, mergedTextConfig }) => {
   const {
     setIsLoadingConversation,
@@ -5682,74 +5447,6 @@ const LoadingConversation = () => {
   );
 };
 
-function useDebounce(value, delay) {
-  const [debouncedValue, setDebouncedValue] = useState(value);
-  useEffect(() => {
-    const handler = setTimeout(() => {
-      setDebouncedValue(value);
-    }, delay);
-    return () => {
-      clearTimeout(handler);
-    };
-  }, [value, delay]);
-  return debouncedValue;
-}
-function useAutocomplete({
-  query,
-  endpoint,
-  allowedRegions,
-  collectionId,
-  headers,
-  conversationId,
-  delay = 300
-}) {
-  const [suggestions, setSuggestions] = useState([]);
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState();
-  const debouncedQuery = useDebounce(query, delay);
-  const fetchSuggestions = useCallback(async () => {
-    if (!debouncedQuery.trim()) {
-      setSuggestions([]);
-      return;
-    }
-    setIsLoading(true);
-    setError(void 0);
-    try {
-      const payload = await fetchAutocomplete({
-        endpoint,
-        query: debouncedQuery,
-        collectionId,
-        headers,
-        conversationId,
-        allowedRegions
-      });
-      if (payload?.response?.results) {
-        const lowerCaseQuery = debouncedQuery.toLowerCase();
-        const sortedSuggestions = payload.response.results.sort((a, b) => {
-          const aStartsWithQuery = a.question.toLowerCase().startsWith(lowerCaseQuery);
-          const bStartsWithQuery = b.question.toLowerCase().startsWith(lowerCaseQuery);
-          if (aStartsWithQuery && !bStartsWithQuery) return -1;
-          if (!aStartsWithQuery && bStartsWithQuery) return 1;
-          return 0;
-        });
-        setSuggestions(sortedSuggestions);
-      } else {
-        setSuggestions([]);
-      }
-    } catch (err) {
-      console.error("Error fetching autocomplete suggestions:", err);
-      setError(err instanceof Error ? err.message : "Failed to fetch suggestions");
-      setSuggestions([]);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [debouncedQuery, endpoint, collectionId, headers, conversationId, allowedRegions]);
-  useEffect(() => {
-    void fetchSuggestions();
-  }, [fetchSuggestions]);
-  return { suggestions, isLoading, error };
-}
-
 const markdownRemarkPlugins = [remarkGfm];
 const markdownRehypePlugins = [rehypeRaw];
 const markdownComponents = {
@@ -6644,4 +6341,4 @@ const ChatSearch = forwardRef(({ featureFlags, ...props }, ref) => /* @__PURE__
 ChatSearch.displayName = "ChatSearch";
 
 export { ChatSearch as C, ChatSearchProvider as a, useIsChatSearchDirty as b, useChatSearch as u };
-//# sourceMappingURL=ChatSearch.C6nUXNy4.js.map
+//# sourceMappingURL=ChatSearch.DOH90EUx.js.map