@27works/chat-core 0.1.0

package/dist/components/index.d.ts

@@ -0,0 +1,18 @@
+declare function ChatSessionProvider({ children, ...props }: {
+    [x: string]: any;
+    children: any;
+}): any;
+
+declare function MessageList({ renderMessage, renderThinking, renderStreamingIndicator }: {
+    renderMessage: any;
+    renderThinking: any;
+    renderStreamingIndicator: any;
+}): any;
+
+declare function UserInput({ renderInput }: {
+    renderInput: any;
+}): any;
+
+declare function useChatSession(): any;
+
+export { ChatSessionProvider, MessageList, UserInput, useChatSession };

package/dist/components/index.js

@@ -0,0 +1,609 @@
+// src/components/ChatSessionProvider.js
+import {
+  useState as useState5,
+  useRef as useRef5,
+  useCallback as useCallback3,
+  useEffect as useEffect4,
+  useMemo,
+  Suspense
+} from "react";
+import { useChat } from "@ai-sdk/react";
+import { DefaultChatTransport, isToolUIPart } from "ai";
+import { useSearchParams } from "next/navigation";
+
+// src/components/SessionContext.js
+import { createContext, useContext } from "react";
+var SessionContext = createContext(null);
+function useChatSession() {
+  const ctx = useContext(SessionContext);
+  if (!ctx) {
+    throw new Error("useChatSession must be used within a ChatSessionProvider");
+  }
+  return ctx;
+}
+var SessionContext_default = SessionContext;
+
+// src/contexts/ChatContext.js
+import { createContext as createContext2, useCallback, useContext as useContext2, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+var ChatContext = createContext2({
+  triggerMessage: () => {
+  },
+  registerTriggerMessage: () => {
+  },
+  shareConversation: () => {
+  },
+  shareAnswer: () => {
+  },
+  canShare: false,
+  registerShareHandlers: () => {
+  },
+  chatControls: null,
+  registerChatControls: () => {
+  },
+  hasTransitioned: false,
+  setHasTransitioned: () => {
+  },
+  shareModalOpen: false,
+  openShareModal: () => {
+  },
+  closeShareModal: () => {
+  }
+});
+var useChatContext = () => {
+  const context = useContext2(ChatContext);
+  if (!context) {
+    return {
+      triggerMessage: () => {
+      },
+      registerTriggerMessage: () => {
+      },
+      shareConversation: () => {
+      },
+      shareAnswer: () => {
+      },
+      canShare: false,
+      registerShareHandlers: () => {
+      },
+      chatControls: null,
+      registerChatControls: () => {
+      },
+      hasTransitioned: false,
+      setHasTransitioned: () => {
+      },
+      shareModalOpen: false,
+      openShareModal: () => {
+      },
+      closeShareModal: () => {
+      }
+    };
+  }
+  return context;
+};
+var ChatProvider = ({ children }) => {
+  const triggerMessageRef = useRef(() => {
+  });
+  const shareHandlersRef = useRef({
+    shareConversation: () => {
+    },
+    shareAnswer: () => {
+    }
+  });
+  const [canShare, setCanShare] = useState(false);
+  const [messageCount, setMessageCount] = useState(0);
+  const [chatControls, setChatControls] = useState(null);
+  const [hasTransitioned, setHasTransitioned] = useState(false);
+  const [shareModalOpen, setShareModalOpen] = useState(false);
+  const registerTriggerMessage = (fn) => {
+    triggerMessageRef.current = fn;
+  };
+  const registerShareHandlers = useCallback((handlers) => {
+    shareHandlersRef.current = {
+      shareConversation: handlers.shareConversation,
+      shareAnswer: handlers.shareAnswer
+    };
+    setCanShare((prev) => {
+      const next = handlers.canShare || false;
+      return prev === next ? prev : next;
+    });
+    setMessageCount((prev) => {
+      const next = handlers.messageCount || 0;
+      return prev === next ? prev : next;
+    });
+  }, []);
+  const registerChatControls = useCallback((controls) => {
+    setChatControls((prev) => {
+      if (prev === controls) {
+        return prev;
+      }
+      if (prev === null && controls === null) {
+        return prev;
+      }
+      if (prev && controls && prev.firstQuestionId === controls.firstQuestionId && prev.onMakePublic === controls.onMakePublic) {
+        return prev;
+      }
+      return controls;
+    });
+  }, []);
+  const triggerMessage = (message) => triggerMessageRef.current(message);
+  const shareConversation = () => shareHandlersRef.current.shareConversation();
+  const shareAnswer = () => shareHandlersRef.current.shareAnswer();
+  const openShareModal = useCallback(() => setShareModalOpen(true), []);
+  const closeShareModal = useCallback(() => setShareModalOpen(false), []);
+  const value = {
+    triggerMessage,
+    registerTriggerMessage,
+    shareConversation,
+    shareAnswer,
+    canShare,
+    messageCount,
+    registerShareHandlers,
+    chatControls,
+    registerChatControls,
+    hasTransitioned,
+    setHasTransitioned,
+    shareModalOpen,
+    openShareModal,
+    closeShareModal
+  };
+  return /* @__PURE__ */ jsx(ChatContext.Provider, { value, children });
+};
+
+// src/contexts/ToastContext.js
+import {
+  createContext as createContext3,
+  useContext as useContext3,
+  useState as useState2,
+  useCallback as useCallback2,
+  useRef as useRef2,
+  useEffect
+} from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var ToastContext = createContext3({
+  showToast: () => {
+  },
+  toast: null,
+  hideToast: () => {
+  }
+});
+var useToast = () => useContext3(ToastContext);
+var ToastProvider = ({ children }) => {
+  const [toast, setToast] = useState2(null);
+  const timeoutRef = useRef2(null);
+  useEffect(() => {
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, []);
+  const showToast = useCallback2((message, type = "success") => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+    }
+    setToast({ message, type, id: Date.now() });
+    timeoutRef.current = setTimeout(() => {
+      setToast(null);
+      timeoutRef.current = null;
+    }, 3e3);
+  }, []);
+  const hideToast = useCallback2(() => {
+    setToast(null);
+  }, []);
+  return /* @__PURE__ */ jsx2(ToastContext.Provider, { value: { showToast, toast, hideToast }, children });
+};
+
+// src/hooks/useConversationLoad.js
+import { useState as useState3, useEffect as useEffect2, useRef as useRef3 } from "react";
+import { useRouter } from "next/navigation";
+function useConversationLoad(chatId, options = {}) {
+  const {
+    shouldLoad = true,
+    skipIfLoaded = false,
+    onSuccess,
+    onError
+  } = options;
+  const router = useRouter();
+  const [loading, setLoading] = useState3(false);
+  const hasLoadedRef = useRef3(false);
+  const onSuccessRef = useRef3(onSuccess);
+  const onErrorRef = useRef3(onError);
+  useEffect2(() => {
+    onSuccessRef.current = onSuccess;
+    onErrorRef.current = onError;
+  }, [onSuccess, onError]);
+  useEffect2(() => {
+    hasLoadedRef.current = false;
+  }, [chatId]);
+  useEffect2(() => {
+    if (!shouldLoad || !chatId) {
+      return;
+    }
+    if (skipIfLoaded && hasLoadedRef.current) {
+      setLoading(false);
+      return;
+    }
+    const controller = new AbortController();
+    const { signal } = controller;
+    const loadConversation = async () => {
+      setLoading(true);
+      try {
+        const response = await fetch(`/api/chat/load/${chatId}`, {
+          signal: controller.signal
+        });
+        if (response.status === 403) {
+          const reason = "This conversation is private and you do not have access.";
+          const err = new Error(reason);
+          if (!signal.aborted) {
+            onErrorRef.current?.(err);
+          }
+          router.replace("/?reason=private");
+          return;
+        }
+        if (response.status === 404) {
+          const reason = "Conversation not found.";
+          const err = new Error(reason);
+          if (!signal.aborted) {
+            onErrorRef.current?.(err);
+          }
+          router.replace("/?reason=not_found");
+          return;
+        }
+        if (!response.ok) {
+          const reason = `Failed to load conversation (HTTP ${response.status})`;
+          const err = new Error(reason);
+          if (!signal.aborted) {
+            onErrorRef.current?.(err);
+          }
+          return;
+        }
+        const data = await response.json();
+        if (!data || typeof data !== "object") {
+          const err = new Error("Invalid response format from server");
+          if (!signal.aborted) {
+            onErrorRef.current?.(err);
+          }
+          return;
+        }
+        hasLoadedRef.current = true;
+        if (!signal.aborted && Array.isArray(data.messages)) {
+          onSuccessRef.current?.(data.messages);
+        }
+      } catch (err) {
+        if (err.name === "AbortError") {
+          return;
+        }
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        console.error(`Error loading conversation ${chatId}:`, errorObj);
+        if (!signal.aborted) {
+          onErrorRef.current?.(errorObj);
+        }
+      } finally {
+        if (!signal.aborted) {
+          setLoading(false);
+        }
+      }
+    };
+    loadConversation();
+    return () => {
+      controller.abort();
+    };
+  }, [chatId, shouldLoad, skipIfLoaded, router]);
+  return { loading };
+}
+
+// src/hooks/useCountdown.js
+import { useState as useState4, useEffect as useEffect3, useRef as useRef4 } from "react";
+function useCountdown(initialSeconds = 0, onComplete) {
+  const [seconds, setSeconds] = useState4(initialSeconds);
+  const onCompleteRef = useRef4(onComplete);
+  useEffect3(() => {
+    onCompleteRef.current = onComplete;
+  }, [onComplete]);
+  const isActive = seconds > 0;
+  useEffect3(() => {
+    if (!isActive) {
+      return;
+    }
+    const timer = setInterval(() => {
+      setSeconds((prev) => {
+        const next = prev - 1;
+        if (next <= 0) {
+          onCompleteRef.current?.();
+          return 0;
+        }
+        return next;
+      });
+    }, 1e3);
+    return () => clearInterval(timer);
+  }, [isActive]);
+  return { seconds, setSeconds };
+}
+
+// src/utils/anonymousId.js
+var STORAGE_KEY = "caruuto_anonymous_id";
+function getOrCreateAnonymousId() {
+  try {
+    const existing = window.localStorage.getItem(STORAGE_KEY);
+    if (existing) {
+      return existing;
+    }
+    const id = crypto.randomUUID();
+    window.localStorage.setItem(STORAGE_KEY, id);
+    return id;
+  } catch (err) {
+    console.error("Failed to get or create anonymous ID:", err);
+    return null;
+  }
+}
+
+// src/components/ChatSessionProvider.js
+import { jsx as jsx3 } from "react/jsx-runtime";
+var DEFAULT_THINKING_OPTIONS = [
+  "Thinking...",
+  "Processing your request...",
+  "One moment please...",
+  "Analysing the information..."
+];
+function ChatSessionProviderInner({
+  children,
+  chatId,
+  apiPath = "/api/chat",
+  thinkingOptions = DEFAULT_THINKING_OPTIONS,
+  shouldLoadConversation = true,
+  onFinish,
+  onError: onErrorProp
+}) {
+  const { registerTriggerMessage } = useChatContext();
+  const { showToast } = useToast();
+  const searchParams = useSearchParams();
+  const [loadedMessages, setLoadedMessages] = useState5([]);
+  const [loadFailed, setLoadFailed] = useState5(false);
+  const [lastFailedInput, setLastFailedInput] = useState5(null);
+  const [acquisition, setAcquisition] = useState5(null);
+  const [anonymousUserId, setAnonymousUserId] = useState5(null);
+  const lastInputRef = useRef5("");
+  const onErrorRef = useRef5(onErrorProp);
+  const acquisitionRef = useRef5(null);
+  const anonymousUserIdRef = useRef5(null);
+  acquisitionRef.current = acquisition;
+  anonymousUserIdRef.current = anonymousUserId;
+  useEffect4(() => {
+    onErrorRef.current = onErrorProp;
+  }, [onErrorProp]);
+  const {
+    messages,
+    sendMessage: rawSendMessage,
+    status,
+    addToolResult,
+    setMessages,
+    clearError
+  } = useChat({
+    id: chatId,
+    initialMessages: loadedMessages,
+    transport: new DefaultChatTransport({
+      api: apiPath,
+      body: () => ({
+        ...acquisitionRef.current && { acquisition: acquisitionRef.current },
+        ...anonymousUserIdRef.current && {
+          clientSessionId: anonymousUserIdRef.current
+        }
+      })
+    }),
+    onFinish,
+    onError: (error) => {
+      setMessages((prev) => {
+        if (prev.length > 0 && prev[prev.length - 1].role === "user") {
+          return prev.slice(0, -1);
+        }
+        return prev;
+      });
+      setLastFailedInput(lastInputRef.current);
+      if (error.message?.includes("Too many requests")) {
+        const retryMatch = error.message.match(/(\d+)/i);
+        const retrySeconds = retryMatch ? parseInt(retryMatch[1]) : 60;
+        setRateLimitSeconds(retrySeconds);
+        let waitText;
+        if (retrySeconds < 60) {
+          waitText = `${retrySeconds} seconds`;
+        } else if (retrySeconds < 3600) {
+          const mins = Math.ceil(retrySeconds / 60);
+          waitText = `${mins} minute${mins > 1 ? "s" : ""}`;
+        } else {
+          const hours = Math.ceil(retrySeconds / 3600);
+          waitText = `${hours} hour${hours > 1 ? "s" : ""}`;
+        }
+        showToast(`Too many requests. Please wait ${waitText}.`, "error");
+      } else if (error.message?.includes("Message too long")) {
+        showToast("Your message is too long. Please shorten it.", "error");
+      } else {
+        showToast("Something went wrong. Please try again.", "error");
+      }
+      console.error("Chat error:", error);
+      onErrorRef.current?.(error);
+    }
+  });
+  const { seconds: rateLimitSeconds, setSeconds: setRateLimitSeconds } = useCountdown(0, clearError);
+  const { loading: conversationLoading } = useConversationLoad(chatId, {
+    shouldLoad: shouldLoadConversation && !loadFailed,
+    onSuccess: (msgs) => {
+      setLoadedMessages(msgs);
+      setMessages(msgs);
+    },
+    onError: () => {
+      setLoadFailed(true);
+    }
+  });
+  const streamingWithNoText = useMemo(() => {
+    if (status !== "streaming") {
+      return false;
+    }
+    const lastMsg = messages[messages.length - 1];
+    if (!lastMsg || lastMsg.role !== "assistant") {
+      return true;
+    }
+    return !lastMsg.parts?.some((p) => p.type === "text" && p.text?.length > 0);
+  }, [status, messages]);
+  const pendingToolCallConfirmation = useMemo(
+    () => messages.some(
+      (m) => m.parts?.some(
+        (part) => isToolUIPart(part) && part.state === "input-available"
+      )
+    ),
+    [messages]
+  );
+  const [thinkingMessage, setThinkingMessage] = useState5("Thinking...");
+  useEffect4(() => {
+    setThinkingMessage(
+      thinkingOptions[Math.floor(Math.random() * thinkingOptions.length)]
+    );
+  }, [thinkingOptions]);
+  useEffect4(() => {
+    if (!searchParams) {
+      return;
+    }
+    try {
+      const source = searchParams.get("utm_source");
+      const medium = searchParams.get("utm_medium");
+      const campaign = searchParams.get("utm_campaign");
+      const term = searchParams.get("utm_term");
+      const content = searchParams.get("utm_content");
+      const referrerUrl = document.referrer || null;
+      if (source || medium || campaign || term || content || referrerUrl) {
+        setAcquisition({
+          utm_source: source,
+          utm_medium: medium,
+          utm_campaign: campaign,
+          utm_term: term,
+          utm_content: content,
+          referrer_url: referrerUrl
+        });
+      }
+    } catch (err) {
+      console.error("Failed to capture acquisition data:", err);
+    }
+  }, []);
+  useEffect4(() => {
+    setAnonymousUserId(getOrCreateAnonymousId());
+  }, []);
+  const sendMessage = useCallback3(
+    (payload) => {
+      if (payload?.text) {
+        lastInputRef.current = payload.text;
+      }
+      return rawSendMessage(payload);
+    },
+    [rawSendMessage]
+  );
+  useEffect4(() => {
+    registerTriggerMessage((text) => sendMessage({ text }));
+  }, [registerTriggerMessage, sendMessage]);
+  const value = {
+    messages,
+    sendMessage,
+    status,
+    addToolResult,
+    setMessages,
+    clearError,
+    streamingWithNoText,
+    thinkingMessage,
+    pendingToolCallConfirmation,
+    rateLimitSeconds,
+    conversationLoading,
+    loadFailed,
+    lastFailedInput,
+    acquisition,
+    anonymousUserId
+  };
+  return /* @__PURE__ */ jsx3(SessionContext_default.Provider, { value, children });
+}
+function ChatSessionProvider({ children, ...props }) {
+  return /* @__PURE__ */ jsx3(ToastProvider, { children: /* @__PURE__ */ jsx3(ChatProvider, { children: /* @__PURE__ */ jsx3(Suspense, { children: /* @__PURE__ */ jsx3(ChatSessionProviderInner, { ...props, children }) }) }) });
+}
+
+// src/components/MessageList.js
+import { Fragment, jsxs } from "react/jsx-runtime";
+function MessageList({
+  renderMessage,
+  renderThinking,
+  renderStreamingIndicator
+}) {
+  const {
+    messages,
+    status,
+    addToolResult,
+    streamingWithNoText,
+    thinkingMessage
+  } = useChatSession();
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    messages.map((message, index) => {
+      const isUser = message.role === "user";
+      const isStreaming = !isUser && status === "streaming" && index === messages.length - 1;
+      return renderMessage({
+        key: message.id ?? index,
+        message,
+        parts: message.parts ?? [],
+        isUser,
+        isStreaming,
+        addToolResult
+      });
+    }),
+    status === "submitted" && renderThinking?.({ message: thinkingMessage }),
+    streamingWithNoText && renderStreamingIndicator?.()
+  ] });
+}
+
+// src/components/UserInput.js
+import { useState as useState6, useEffect as useEffect5, useCallback as useCallback4 } from "react";
+function UserInput({ renderInput }) {
+  const {
+    sendMessage,
+    status,
+    rateLimitSeconds,
+    pendingToolCallConfirmation,
+    lastFailedInput
+  } = useChatSession();
+  const [value, setValue] = useState6("");
+  useEffect5(() => {
+    if (lastFailedInput != null) {
+      setValue(lastFailedInput);
+    }
+  }, [lastFailedInput]);
+  const isLoading = status === "submitted" || status === "streaming";
+  const disabled = status !== "ready" || !value.trim() || rateLimitSeconds > 0 || pendingToolCallConfirmation;
+  const onSubmit = useCallback4(() => {
+    if (disabled) {
+      return;
+    }
+    const text = value.trim();
+    setValue("");
+    sendMessage({ text });
+  }, [disabled, value, sendMessage]);
+  const onChange = useCallback4((e) => {
+    setValue(typeof e === "string" ? e : e.target.value);
+  }, []);
+  const onKeyDown = useCallback4(
+    (e) => {
+      if (e.key === "Enter" && !e.shiftKey && !disabled) {
+        e.preventDefault();
+        onSubmit();
+      }
+    },
+    [disabled, onSubmit]
+  );
+  return renderInput({
+    value,
+    onChange,
+    onSubmit,
+    onKeyDown,
+    disabled,
+    isLoading,
+    countdownSeconds: rateLimitSeconds
+  });
+}
+export {
+  ChatSessionProvider,
+  MessageList,
+  UserInput,
+  useChatSession
+};

package/dist/contexts/index.d.ts

@@ -0,0 +1,11 @@
+declare function useChatContext(): any;
+declare function ChatProvider({ children }: {
+    children: any;
+}): any;
+
+declare function useToast(): any;
+declare function ToastProvider({ children }: {
+    children: any;
+}): any;
+
+export { ChatProvider, ToastProvider, useChatContext, useToast };