@plasius/chatbot 1.0.0 → 1.0.1

package/CHANGELOG.md

@@ -20,6 +20,23 @@ The format is based on **[Keep a Changelog](https://keepachangelog.com/en/1.1.0/
 - **Security**
   - (placeholder)
 
+## [1.0.1] - 2026-02-21
+
+- **Added**
+  - Add chatbot API client helpers (`getChatbotUsage`, `sendChatbotMessage`) and typed `ChatbotClientError`.
+  - Add signed-in gating UX and demo usage-limit messaging in the `ChatBot` component.
+  - Add usage/auth/client tests for chatbot API integration behavior.
+
+- **Changed**
+  - Refactor `ChatBot` to call backend `/ai/chatbot` instead of browser-side OpenAI keys.
+  - Simplify package peer requirements by removing direct `openai` dependency from `@plasius/chatbot`.
+
+- **Fixed**
+  - (placeholder)
+
+- **Security**
+  - (placeholder)
+
 ## [1.0.0] - 2026-02-12
 
 - **Added**
@@ -48,7 +65,7 @@ The format is based on **[Keep a Changelog](https://keepachangelog.com/en/1.1.0/
 
 ---
 
-[Unreleased]: https://github.com/Plasius-LTD/chatbot/compare/v1.0.0...HEAD
+[Unreleased]: https://github.com/Plasius-LTD/chatbot/compare/v1.0.1...HEAD
 
 ## [1.0.0] - 2026-02-11
 
@@ -64,3 +81,4 @@ The format is based on **[Keep a Changelog](https://keepachangelog.com/en/1.1.0/
 - **Security**
   - (placeholder)
 [1.0.0]: https://github.com/Plasius-LTD/chatbot/releases/tag/v1.0.0
+[1.0.1]: https://github.com/Plasius-LTD/chatbot/releases/tag/v1.0.1

package/dist/chatbot.d.ts

@@ -1,9 +1,12 @@
 import React from "react";
-interface ChatBotProps {
-    openaiOrgID: string;
-    openaiProjectKey: string;
-    openaiAPIKey: string;
+import { type ChatMessage, type ChatbotClientOptions, type ChatbotUsage } from "./client.js";
+export interface ChatBotProps extends ChatbotClientOptions {
+    initialMessages?: ChatMessage[];
+    systemPrompt?: string;
+    placeholder?: string;
+    title?: string;
+    onUsageChange?: (usage: ChatbotUsage) => void;
+    onAuthRequired?: () => void;
 }
 export default function ChatBot(props: React.PropsWithChildren<ChatBotProps>): React.ReactElement;
-export {};
 //# sourceMappingURL=chatbot.d.ts.map

package/dist/chatbot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chatbot.d.ts","sourceRoot":"","sources":["../src/chatbot.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA8C,MAAM,OAAO,CAAC;AAiBnE,UAAU,YAAY;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,CAAC,OAAO,UAAU,OAAO,CAC7B,KAAK,EAAE,KAAK,CAAC,iBAAiB,CAAC,YAAY,CAAC,GAC3C,KAAK,CAAC,YAAY,CAyNpB"}
+{"version":3,"file":"chatbot.d.ts","sourceRoot":"","sources":["../src/chatbot.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAoE,MAAM,OAAO,CAAC;AAIzF,OAAO,EAIL,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,YAAY,EAClB,MAAM,aAAa,CAAC;AAUrB,MAAM,WAAW,YAAa,SAAQ,oBAAoB;IACxD,eAAe,CAAC,EAAE,WAAW,EAAE,CAAC;IAChC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;IAC9C,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC;CAC7B;AAoBD,MAAM,CAAC,OAAO,UAAU,OAAO,CAC7B,KAAK,EAAE,KAAK,CAAC,iBAAiB,CAAC,YAAY,CAAC,GAC3C,KAAK,CAAC,YAAY,CA2NpB"}

package/dist/chatbot.js

@@ -1,180 +1,160 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { lazy, Suspense, useState, useEffect } from "react";
+import { lazy, Suspense, useCallback, useEffect, useMemo, useState } from "react";
+import { FaPaperPlane, FaSmile } from "react-icons/fa";
+import styles from "./styles/chatbot.module.css";
+import { ChatbotClientError, getChatbotUsage, sendChatbotMessage, } from "./client.js";
 const EmojiPicker = lazy(() => import("emoji-picker-react/dist/emoji-picker-react.esm.js").then((module) => ({
-    default: module.EmojiPicker, // <--- force the correct component export
+    default: module.EmojiPicker,
 })));
-import { FaPaperPlane, FaSmile } from "react-icons/fa";
-import OpenAI from "openai";
-import styles from "./styles/chatbot.module.css"; // Import a CSS file for styling
+const DEFAULT_TITLE = "Plasius Chatbot";
+const DEFAULT_PLACEHOLDER = "Ask Plasius something...";
+const DEFAULT_SYSTEM_PROMPT = "You are the Plasius assistant. Keep responses concise, practical, and factual.";
+function statusMessage(state, usage) {
+    if (state === "loading")
+        return "Checking access...";
+    if (state === "signed_out")
+        return "Sign in to use chatbot.";
+    if (state === "limit_reached") {
+        if (usage) {
+            return `Demo limit reached (${usage.used}/${usage.limit} messages).`;
+        }
+        return "Demo limit reached.";
+    }
+    if (state === "error")
+        return "Chatbot is currently unavailable.";
+    return "";
+}
 export default function ChatBot(props) {
-    const [messages, setMessages] = useState([]);
+    const [messages, setMessages] = useState(props.initialMessages ?? []);
     const [input, setInput] = useState("");
     const [showEmojiPicker, setShowEmojiPicker] = useState(false);
-    const openai = new OpenAI({
-        apiKey: props.openaiAPIKey,
-        project: props.openaiProjectKey,
-        organization: props.openaiOrgID,
-        dangerouslyAllowBrowser: true,
-    });
-    const chat = async (msgs, callback) => {
-        try {
-            const value = await openai.chat.completions.create({
-                model: "gpt-o1",
-                messages: msgs,
-            });
-            value.choices.forEach((choice) => {
-                callback({ content: choice.message.content ?? "", role: "system" });
-            });
-        }
-        catch (err) {
-            console.error("chat() failed", err);
-        }
-    };
-    const objects = window.location.origin + "/api/objects/list";
-    const decorations = window.location.origin + "/api/decorations/list";
-    const locations = window.location.origin + "/api/locations/list";
-    const surfaces = window.location.origin + "/api/surfaces/list";
+    const [isSending, setIsSending] = useState(false);
+    const [state, setState] = useState("loading");
+    const [usage, setUsage] = useState(null);
+    const [errorMessage, setErrorMessage] = useState(null);
+    const clientOptions = useMemo(() => ({
+        endpoint: props.endpoint,
+        credentials: props.credentials,
+        headers: props.headers,
+        fetchFn: props.fetchFn,
+        csrfCookieName: props.csrfCookieName,
+        csrfHeaderName: props.csrfHeaderName,
+        bootstrapCsrf: props.bootstrapCsrf,
+    }), [
+        props.endpoint,
+        props.credentials,
+        props.headers,
+        props.fetchFn,
+        props.csrfCookieName,
+        props.csrfHeaderName,
+        props.bootstrapCsrf,
+    ]);
+    const applyUsage = useCallback((nextUsage) => {
+        setUsage(nextUsage);
+        props.onUsageChange?.(nextUsage);
+        setState(nextUsage.exhausted ? "limit_reached" : "ready");
+    }, [props.onUsageChange]);
     useEffect(() => {
-        void chat([
-            {
-                role: "system",
-                content: `You are a game designer, you are responsible for helping build the world and game mechanics, adjusting the game to be more fun for the player playing, 
-          using your knowledge of gameplay mechanics and world building you are going to help assign objects to the map.
-          
-          You can find the list of objects from the following url: ${objects}
-          You can find the list of decorations from the following url: ${decorations}
-          You can find the list of surfaces from the following url: ${surfaces}
-
-          Each location is a hexagon with a radius of 10 meters and 10m tall (allowing  for locations to be on top of each other!), and a q and r coordinate system.
-          The q coordinate is the horizontal axis, and the r coordinate is the vertical axis. The center of the hexagon is at (0, 0), 
-          and the corners are at (5, 8.66), (10, 0), (5, -8.66), (-5, -8.66), (-10, 0), and (-5, 8.66).
-          Adjacent hexagons are at (q + 1, r), (q - 1, r), (q, r + 1), (q, r - 1), (q + 1, r - 1), and (q - 1, r + 1) and you should try and 
-          coordinate over the hexagons to make sure the objects are placed in a way that makes sense.
-          
-          Try and align surfaces, decorations, and objects to a 1m size hexagon when placing items so they align to each other in the world, 
-          but avoid overlapping the objects with each other, unless they are meant to overlap (like a chair under a table, or a tree in a bush).
-          Surfaces should not overlap with each other, and should be placed in a way that makes sense for the location, 
-          such as a road should be continuous and have purpose, to or from somewhere, 
-          use the locations map to identify good roads, forests, mountains, lakes and oceans locations.
-          
-          for each prompt the user gives you, will relate to a specific location in the game world, you should take in the location, 
-          some basic information about the users expectations for the location and return a json object with the following fields:
-            {
-              "location": {
-                "r": "number", // 10m hexagon radius
-                "q": "number", // 10m hexagon radius
-                "elevation": "number",
-                "name": "string",
-                "description": "string",
-                "type": "string",
-              
-              "surfaces": [{
-                "location": {
-                  "q": "number", // 1m hexagon radius
-                  "r": "number", // 1m hexagon radius
-                  "elevation": "number"
-                },
-                "name": "string",
-                "type": "string",
-                "description": "string",
-                "url": "string",
-                "image": "string",
-                "rotation": "number",
-                "color": "string"
-              }],
-              "decorations": [
-                {
-                  "name": "string",
-                  "type": "string",
-                  "description": "string",
-                  "url": "string",
-                  "image": "string",
-                  "rotation": "number",
-                  "scale": "number",
-                  "color": "string",
-                  "location": {
-                    "x": "number",
-                    "y": "number",
-                    "z": "number"
-                  }
-                }
-              ],
-              "objects": [
-                {
-                  "name": "string",
-                  "type": "string",
-                  "description": "string",
-                  "url": "string",
-                  "image": "string",
-                  "rotation": "number",
-                  "scale": "number",
-                  "color": "string",
-                  "location": {
-                    "x": "number",
-                    "y": "number",
-                    "z": "number"
-                  }
-                }
-              ]
-            }
-          }
-
-          You can find the list of populated locations from the following url: ${locations} for reference and to allow you to be more creative in your assignments. 
-          If your current location is in the list, then take the current objects and decorations into account when placing the new objects, and remove or replace the old ones.`,
-            },
-        ], (arg) => {
-            setMessages((prev) => [...prev, arg]);
-        });
-    }, []);
-    const handleSend = async () => {
-        if (input.trim()) {
-            setMessages((prev) => [...prev, { content: input, role: "user" }]);
-            setInput("");
-            setShowEmojiPicker(false);
+        let active = true;
+        const loadUsage = async () => {
+            setState("loading");
+            setErrorMessage(null);
             try {
-                const value = await openai.chat.completions.create({
-                    model: "gpt-4o-mini",
-                    messages: [{ content: input, role: "user" }],
-                });
-                value.choices.forEach((choice) => {
-                    setMessages((prev) => [
-                        ...prev,
-                        { content: choice.message.content ?? "", role: "system" },
-                    ]);
-                });
+                const result = await getChatbotUsage(clientOptions);
+                if (!active)
+                    return;
+                applyUsage(result.usage);
             }
-            catch (err) {
-                console.error("handleSend() failed", err);
+            catch (error) {
+                if (!active)
+                    return;
+                if (error instanceof ChatbotClientError && error.status === 401) {
+                    setState("signed_out");
+                    setErrorMessage("Sign in to start chatting.");
+                    props.onAuthRequired?.();
+                    return;
+                }
+                setState("error");
+                setErrorMessage(error instanceof Error ? error.message : "Failed to load chatbot.");
             }
-        }
-    };
+        };
+        void loadUsage();
+        return () => {
+            active = false;
+        };
+    }, [applyUsage, clientOptions, props.onAuthRequired]);
+    const sendDisabled = isSending ||
+        state === "loading" ||
+        state === "signed_out" ||
+        state === "limit_reached" ||
+        !input.trim();
     const handleEmojiClick = (emojiData) => {
         setInput((prev) => prev + (emojiData.emoji ?? ""));
     };
-    const contentToString = (content) => {
-        if (typeof content === "string" || content == null)
-            return content ?? "";
-        if (Array.isArray(content)) {
-            return content
-                .map((part) => {
-                if (typeof part === "string")
-                    return part;
-                if (typeof part === "object" &&
-                    part !== null &&
-                    Object.prototype.hasOwnProperty.call(part, "text")) {
-                    const text = part.text;
-                    return typeof text === "string" ? text : "";
+    const handleSend = useCallback(async () => {
+        const message = input.trim();
+        if (!message || sendDisabled)
+            return;
+        const userMessage = { role: "user", content: message };
+        const nextHistory = [...messages, userMessage].slice(-20);
+        setMessages((prev) => [...prev, userMessage]);
+        setInput("");
+        setShowEmojiPicker(false);
+        setIsSending(true);
+        setErrorMessage(null);
+        try {
+            const response = await sendChatbotMessage({
+                message,
+                history: nextHistory,
+                systemPrompt: props.systemPrompt ?? DEFAULT_SYSTEM_PROMPT,
+            }, clientOptions);
+            setMessages((prev) => [
+                ...prev,
+                { role: "assistant", content: response.reply },
+            ]);
+            applyUsage(response.usage);
+        }
+        catch (error) {
+            if (error instanceof ChatbotClientError) {
+                if (error.status === 401) {
+                    setState("signed_out");
+                    setErrorMessage("You must be signed in to use chatbot.");
+                    props.onAuthRequired?.();
+                    return;
+                }
+                if (error.status === 429) {
+                    if (error.usage) {
+                        applyUsage(error.usage);
+                    }
+                    else {
+                        setState("limit_reached");
+                    }
+                    setErrorMessage("You reached the 10 message demo limit.");
+                    return;
                 }
-                return "";
-            })
-                .join("");
+                setState("error");
+                setErrorMessage(error.message);
+                return;
+            }
+            setState("error");
+            setErrorMessage(error instanceof Error ? error.message : "Message failed.");
         }
-        return "";
-    };
-    return (_jsxs("div", { className: styles.chatbotcontainer, children: [_jsx("div", { className: styles.messagesbox, children: messages.map((msg, index) => (_jsx("div", { className: styles.message + ` ${styles[msg.role]}`, children: _jsx("div", { className: styles.bubble, children: contentToString(msg.content) }) }, index))) }), _jsxs("div", { className: styles.inputbox, children: [_jsx("input", { type: "text", value: input, onChange: (e) => setInput(e.target.value), onKeyUp: async (e) => {
-                            if (e.key === "Enter" && e.shiftKey === false) {
+        finally {
+            setIsSending(false);
+        }
+    }, [
+        applyUsage,
+        clientOptions,
+        input,
+        messages,
+        props.onAuthRequired,
+        props.systemPrompt,
+        sendDisabled,
+    ]);
+    return (_jsxs("div", { className: styles.chatbotcontainer, children: [_jsxs("div", { className: styles.header, children: [_jsx("div", { className: styles.title, children: props.title ?? DEFAULT_TITLE }), _jsx("div", { className: styles.usage, children: usage ? `${usage.used}/${usage.limit} used` : "No usage data" })] }), (state !== "ready" || errorMessage) && (_jsx("div", { className: styles.notice, children: errorMessage ?? statusMessage(state, usage) })), _jsx("div", { className: styles.messagesbox, children: messages.map((msg, index) => (_jsx("div", { className: styles.message, children: _jsx("div", { className: styles[msg.role], children: _jsx("div", { className: styles.bubble, children: msg.content }) }) }, `${msg.role}-${index}`))) }), _jsxs("div", { className: styles.inputbox, children: [_jsx("input", { type: "text", value: input, disabled: sendDisabled, onChange: (event) => setInput(event.target.value), onKeyUp: async (event) => {
+                            if (event.key === "Enter" && !event.shiftKey) {
                                 await handleSend();
-                                e.stopPropagation();
+                                event.stopPropagation();
                             }
-                        }, placeholder: "Type a message..." }), _jsx(FaSmile, { onClick: () => setShowEmojiPicker(!showEmojiPicker), className: styles.emojiicon }), showEmojiPicker && (_jsx(Suspense, { fallback: _jsx("div", { children: "Loading emoji picker..." }), children: _jsx(EmojiPicker, { onEmojiClick: handleEmojiClick }) })), _jsx(FaPaperPlane, { onClick: handleSend, className: styles.sendicon })] })] }));
+                        }, placeholder: props.placeholder ?? DEFAULT_PLACEHOLDER }), _jsx("button", { type: "button", className: styles.iconButton, onClick: () => setShowEmojiPicker((current) => !current), disabled: state === "signed_out" || state === "limit_reached", "aria-label": "Open emoji picker", children: _jsx(FaSmile, { className: styles.emojiicon }) }), showEmojiPicker && (_jsx("div", { className: styles.emojiPicker, children: _jsx(Suspense, { fallback: _jsx("div", { children: "Loading emoji picker..." }), children: _jsx(EmojiPicker, { onEmojiClick: handleEmojiClick }) }) })), _jsx("button", { type: "button", className: styles.iconButton, onClick: () => void handleSend(), disabled: sendDisabled, "aria-label": "Send message", children: _jsx(FaPaperPlane, { className: styles.sendicon }) })] })] }));
 }

package/dist/client.d.ts

@@ -0,0 +1,41 @@
+export type ChatRole = "system" | "user" | "assistant";
+export interface ChatMessage {
+    role: ChatRole;
+    content: string;
+}
+export interface ChatbotUsage {
+    limit: number;
+    used: number;
+    remaining: number;
+    exhausted: boolean;
+}
+export interface ChatbotReply {
+    reply: string;
+    model: string;
+    usage: ChatbotUsage;
+}
+export interface ChatbotUsageResponse {
+    usage: ChatbotUsage;
+}
+export interface ChatbotClientOptions {
+    endpoint?: string;
+    credentials?: RequestCredentials;
+    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+    fetchFn?: typeof fetch;
+    csrfCookieName?: string;
+    csrfHeaderName?: string;
+    bootstrapCsrf?: boolean;
+}
+export declare class ChatbotClientError extends Error {
+    status: number;
+    code?: string;
+    usage?: ChatbotUsage;
+    constructor(status: number, message: string, code?: string, usage?: ChatbotUsage);
+}
+export declare function getChatbotUsage(options?: ChatbotClientOptions): Promise<ChatbotUsageResponse>;
+export declare function sendChatbotMessage(payload: {
+    message: string;
+    history?: ChatMessage[];
+    systemPrompt?: string;
+}, options?: ChatbotClientOptions): Promise<ChatbotReply>;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAC;AAEvD,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,YAAY,CAAC;CACrB;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,YAAY,CAAC;CACrB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,OAAO,CAAC,EAAE,WAAW,GAAG,CAAC,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC;IACnE,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAQD,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,YAAY,CAAC;gBAET,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,YAAY;CAOjF;AAiHD,wBAAsB,eAAe,CACnC,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,oBAAoB,CAAC,CA4B/B;AAED,wBAAsB,kBAAkB,CACtC,OAAO,EAAE;IACP,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,WAAW,EAAE,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,EACD,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,YAAY,CAAC,CAiDvB"}

package/dist/client.js

@@ -0,0 +1,168 @@
+export class ChatbotClientError extends Error {
+    constructor(status, message, code, usage) {
+        super(message);
+        this.name = "ChatbotClientError";
+        this.status = status;
+        this.code = code;
+        this.usage = usage;
+    }
+}
+const DEFAULT_ENDPOINT = "/ai/chatbot";
+const DEFAULT_CSRF_COOKIE_NAME = "csrf-token";
+const DEFAULT_CSRF_HEADER_NAME = "x-csrf-token";
+function resolveFetch(fetchFn) {
+    const resolved = fetchFn ?? (typeof fetch !== "undefined" ? fetch : undefined);
+    if (!resolved) {
+        throw new Error("No fetch implementation is available.");
+    }
+    return resolved;
+}
+async function resolveHeaders(headers) {
+    if (!headers)
+        return undefined;
+    if (typeof headers === "function") {
+        return await headers();
+    }
+    return headers;
+}
+function readCookie(name) {
+    if (typeof document === "undefined" || typeof document.cookie !== "string") {
+        return undefined;
+    }
+    const entry = document.cookie
+        .split(";")
+        .map((part) => part.trim())
+        .find((value) => value.startsWith(`${name}=`));
+    if (!entry)
+        return undefined;
+    const [, rawValue = ""] = entry.split("=");
+    try {
+        return decodeURIComponent(rawValue);
+    }
+    catch {
+        return rawValue;
+    }
+}
+function normalizeUsage(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const usage = value;
+    if (typeof usage.limit !== "number" ||
+        typeof usage.used !== "number" ||
+        typeof usage.remaining !== "number" ||
+        typeof usage.exhausted !== "boolean") {
+        return undefined;
+    }
+    return {
+        limit: usage.limit,
+        used: usage.used,
+        remaining: usage.remaining,
+        exhausted: usage.exhausted,
+    };
+}
+async function parseBody(response) {
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+        return await response.json();
+    }
+    const text = await response.text();
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function normalizeError(status, body) {
+    const payload = body && typeof body === "object" ? body : undefined;
+    const fallbackMessage = status === 401
+        ? "Sign in to use chatbot."
+        : status === 429
+            ? "Chatbot usage limit reached."
+            : "Chatbot request failed.";
+    const message = payload?.message ?? fallbackMessage;
+    return new ChatbotClientError(status, message, payload?.error, payload?.usage);
+}
+async function ensureCsrfToken(fetcher, endpoint, options, baseHeaders) {
+    const cookieName = options.csrfCookieName ?? DEFAULT_CSRF_COOKIE_NAME;
+    const existing = readCookie(cookieName);
+    if (existing || options.bootstrapCsrf === false) {
+        return existing;
+    }
+    await fetcher(endpoint, {
+        method: "GET",
+        credentials: options.credentials ?? "include",
+        headers: baseHeaders,
+    });
+    return readCookie(cookieName);
+}
+export async function getChatbotUsage(options = {}) {
+    const fetcher = resolveFetch(options.fetchFn);
+    const endpoint = options.endpoint ?? DEFAULT_ENDPOINT;
+    const customHeaders = await resolveHeaders(options.headers);
+    const response = await fetcher(endpoint, {
+        method: "GET",
+        credentials: options.credentials ?? "include",
+        headers: {
+            Accept: "application/json",
+            ...(customHeaders ?? {}),
+        },
+    });
+    const body = await parseBody(response);
+    if (!response.ok) {
+        throw normalizeError(response.status, body);
+    }
+    if (!body || typeof body !== "object") {
+        throw new Error("Invalid chatbot usage response.");
+    }
+    const usage = normalizeUsage(body.usage);
+    if (!usage) {
+        throw new Error("Invalid chatbot usage response.");
+    }
+    return { usage };
+}
+export async function sendChatbotMessage(payload, options = {}) {
+    const fetcher = resolveFetch(options.fetchFn);
+    const endpoint = options.endpoint ?? DEFAULT_ENDPOINT;
+    const customHeaders = await resolveHeaders(options.headers);
+    const baseHeaders = {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        ...(customHeaders ?? {}),
+    };
+    const csrfToken = await ensureCsrfToken(fetcher, endpoint, options, baseHeaders);
+    const csrfHeader = options.csrfHeaderName ?? DEFAULT_CSRF_HEADER_NAME;
+    const requestHeaders = csrfToken
+        ? {
+            ...baseHeaders,
+            [csrfHeader]: csrfToken,
+        }
+        : baseHeaders;
+    const response = await fetcher(endpoint, {
+        method: "POST",
+        credentials: options.credentials ?? "include",
+        headers: requestHeaders,
+        body: JSON.stringify({
+            message: payload.message,
+            history: payload.history ?? [],
+            systemPrompt: payload.systemPrompt,
+        }),
+    });
+    const body = await parseBody(response);
+    if (!response.ok) {
+        throw normalizeError(response.status, body);
+    }
+    if (!body || typeof body !== "object") {
+        throw new Error("Invalid chatbot response.");
+    }
+    const content = body;
+    const reply = content.reply;
+    const model = content.model;
+    const usage = normalizeUsage(content.usage);
+    if (typeof reply !== "string" || typeof model !== "string" || !usage) {
+        throw new Error("Invalid chatbot response.");
+    }
+    return { reply, model, usage };
+}

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export { default as ChatBot } from "./chatbot.js";
+export * from "./client.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,cAAc,CAAC;AAClD,cAAc,aAAa,CAAC"}

package/dist/index.js

@@ -1 +1,2 @@
 export { default as ChatBot } from "./chatbot.js";
+export * from "./client.js";