chat-nest-sdk 1.0.1 → 1.1.1

package/README.md

@@ -1,26 +1,29 @@
 # chat-nest-sdk
 
-> Frontend SDK for Chat Nest providing a simple React hook to consume streaming AI APIs safely.
+> Frontend SDK for Chat Nest providing a simple React hook to consume streaming AI APIs safely using Server-Side Events (SSE).
 
 This package handles:
-- Streaming response handling
+- Server-Side Events (SSE) streaming response handling
+- Real-time token streaming via SSE protocol
 - Cancellation propagation
 - Intelligent retry behavior
 - Error normalization
 - Message state management
 
-Designed for production usage in React applications.
+Designed for production usage in React applications. Uses SSE for efficient, bidirectional communication with the backend.
 
 ---
 
 ## ✨ Features
 
-- Streaming token handling
+- Server-Side Events (SSE) streaming protocol
+- Real-time token streaming via SSE events
 - Abort-safe cancellation
 - Retry only on network / server failures
 - No retries on client or policy errors
 - Message state management
 - Lightweight and framework-friendly
+- Efficient SSE event parsing (`token`, `done`, `error`, `ping`, `start` events)
 
 ---
 
@@ -96,6 +99,8 @@ Cancel immediately stops streaming and billing.
 
 Network failures retry automatically.
 
+**Server-Side Events (SSE)**: The SDK communicates with the backend using the SSE protocol. The backend must send events in SSE format (`event: <type>\ndata: <data>\n\n`). Supported event types: `start`, `token`, `done`, `error`, `ping`.
+
 ---
 
 ## 📄 License

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-import { UseAIChatOptions, UseAIChatReturn, AIClient, AiClientConfig, Message, StreamCallbacks } from 'chat-nest-core';
+import { UseAIChatOptions, UseAIChatReturn, AIClient, AiClientConfig, Message, StreamCallbacks, AiUsageProfile, ChatRequestOptions } from 'chat-nest-core';
+export { AiUsageProfile } from 'chat-nest-core';
 
 declare function useAiChat(options: UseAIChatOptions): UseAIChatReturn;
 
@@ -6,7 +7,7 @@ declare class FetchAiClient implements AIClient {
     private abortController?;
     private config;
     constructor(config: AiClientConfig);
-    streamChat(messages: Message[], callbacks: StreamCallbacks): Promise<void>;
+    streamChat(messages: Message[], callbacks: StreamCallbacks, profile: AiUsageProfile, options?: ChatRequestOptions): Promise<void>;
     cancel(): void;
     private executeStream;
     private normalizeError;

package/dist/index.js

@@ -4,6 +4,16 @@ import {
   MessageRole
 } from "chat-nest-core";
 
+// src/core/promptPresets.ts
+var PROFILE_SYSTEM_PROMPTS = {
+  constrained: "You are a concise assistant. Answer in the fewest words possible. No explanations or preamble. Direct answers only. No examples needed",
+  balanced: "You are a helpful assistant. Be clear and concise. Give brief explanations when they add value, but keep responses focused.",
+  expanded: "You are a thorough assistant. Explain your reasoning step by step when useful. Include relevant examples and detail. Prioritize clarity and completeness."
+};
+function getSystemPromptForProfile(profile) {
+  return PROFILE_SYSTEM_PROMPTS[profile];
+}
+
 // src/core/aiClient.ts
 var DEFAULT_TIMEOUT = 3e4;
 var DEFAULT_RETRIES = 2;
@@ -22,11 +32,11 @@ var FetchAiClient = class {
       maxRetries: config.maxRetries ?? DEFAULT_RETRIES
     };
   }
-  async streamChat(messages, callbacks) {
+  async streamChat(messages, callbacks, profile, options) {
     let attempt = 0;
     while (attempt <= this.config.maxRetries) {
       try {
-        await this.executeStream(messages, callbacks);
+        await this.executeStream(messages, callbacks, profile, options);
         return;
       } catch (error) {
         if (error?.name === "AbortError") {
@@ -48,12 +58,13 @@ var FetchAiClient = class {
   cancel() {
     this.abortController?.abort();
   }
-  async executeStream(messages, callbacks) {
+  async executeStream(messages, callbacks, profile, options) {
     this.abortController = new AbortController();
     const timeoutId = setTimeout(
       () => this.abortController?.abort(),
       this.config.timeoutMs
     );
+    let completed = false;
     try {
       const response = await fetch(this.config.endpoint, {
         method: "POST",
@@ -62,7 +73,17 @@ var FetchAiClient = class {
           ...this.config.headers
         },
         signal: this.abortController.signal,
-        body: JSON.stringify({ messages })
+        body: JSON.stringify({
+          messages,
+          profile,
+          systemPrompt: getSystemPromptForProfile(profile),
+          ...options?.dailyTokenLimit != null && {
+            dailyTokenLimit: options.dailyTokenLimit
+          },
+          ...options?.maxTokensPerRequest != null && {
+            maxTokensPerRequest: options.maxTokensPerRequest
+          }
+        })
       });
       if (!response.ok) {
         if (response.status >= 400 && response.status < 500) {
@@ -75,13 +96,64 @@ var FetchAiClient = class {
       }
       const reader = response.body.getReader();
       const decoder = new TextDecoder();
+      let buffer = "";
       while (true) {
+        if (this.abortController.signal.aborted) {
+          throw new DOMException("Aborted", "AbortError");
+        }
         const { value, done } = await reader.read();
+        if (value) {
+          buffer += decoder.decode(value, { stream: true });
+        }
+        const events = buffer.split("\n\n");
+        buffer = events.pop() || "";
+        for (const eventText of events) {
+          if (!eventText.trim()) continue;
+          let eventType = "";
+          let eventDataParts = [];
+          for (const line of eventText.split("\n")) {
+            if (line.startsWith("event:")) {
+              eventType = line.substring(6).trim();
+            } else if (line.startsWith("data:")) {
+              eventDataParts.push(line.substring(5).trim());
+            }
+          }
+          const eventData = eventDataParts.join("\n");
+          switch (eventType) {
+            case "token": {
+              try {
+                const token = JSON.parse(eventData);
+                callbacks.onToken(token);
+              } catch {
+                callbacks.onToken(eventData);
+              }
+              break;
+            }
+            case "done":
+              completed = true;
+              callbacks.onComplete();
+              return;
+            case "error":
+              completed = true;
+              try {
+                const errorObj = JSON.parse(eventData);
+                callbacks.onError(
+                  new Error(errorObj.message || "Stream error")
+                );
+              } catch {
+                callbacks.onError(new Error(eventData || "Stream error"));
+              }
+              return;
+            case "ping":
+            case "start":
+              break;
+          }
+        }
         if (done) break;
-        const chunk = decoder.decode(value, { stream: true });
-        callbacks.onToken(chunk);
       }
-      callbacks.onComplete();
+      if (!completed) {
+        callbacks.onComplete();
+      }
     } finally {
       clearTimeout(timeoutId);
     }
@@ -107,15 +179,42 @@ function generateId() {
 }
 
 // src/react/useAiChat.ts
+var STORAGE_KEY = "aiUsageProfile";
+var VALID_PROFILES = ["constrained", "balanced", "expanded"];
+var DEFAULT_PROFILE = "balanced";
+function readStoredProfile() {
+  if (typeof window === "undefined") return DEFAULT_PROFILE;
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (raw && VALID_PROFILES.includes(raw)) {
+      return raw;
+    }
+  } catch {
+  }
+  return DEFAULT_PROFILE;
+}
 function useAiChat(options) {
   const {
     endpoint,
     initialMessages = [],
-    maxMessages = 10
+    maxMessages = 10,
+    initialProfile,
+    dailyTokenLimit,
+    maxTokensPerRequest
   } = options;
-  const [messages, setMessages] = useState(
-    initialMessages
+  const [profile, setProfileState] = useState(
+    () => initialProfile ?? readStoredProfile()
   );
+  const setProfile = useCallback((next) => {
+    setProfileState(next);
+    try {
+      if (typeof window !== "undefined") {
+        localStorage.setItem(STORAGE_KEY, next);
+      }
+    } catch {
+    }
+  }, []);
+  const [messages, setMessages] = useState(initialMessages);
   const [isStreaming, setIsStreaming] = useState(false);
   const [error, setError] = useState();
   const clientRef = useRef(null);
@@ -144,30 +243,43 @@ function useAiChat(options) {
     setIsStreaming(true);
     const history = [...messages, userMessage];
     try {
-      await clientRef.current.streamChat(history, {
-        onToken(token) {
-          setMessages(
-            (prev) => prev.map(
-              (msg) => msg.id === assistantMessage.id ? {
-                ...msg,
-                content: msg.content + token
-              } : msg
-            )
-          );
+      await clientRef.current.streamChat(
+        history,
+        {
+          onToken(token) {
+            setMessages(
+              (prev) => prev.map(
+                (msg) => msg.id === assistantMessage.id ? {
+                  ...msg,
+                  content: msg.content + token
+                } : msg
+              )
+            );
+          },
+          onComplete() {
+            setIsStreaming(false);
+          },
+          onError(err) {
+            setError(err.message);
+            setIsStreaming(false);
+          }
         },
-        onComplete() {
-          setIsStreaming(false);
-        },
-        onError(err) {
-          setError(err.message);
-          setIsStreaming(false);
-        }
-      });
+        profile,
+        dailyTokenLimit != null || maxTokensPerRequest != null ? { dailyTokenLimit: dailyTokenLimit ?? void 0, maxTokensPerRequest: maxTokensPerRequest ?? void 0 } : void 0
+      );
     } catch (err) {
       setError(err.message);
       setIsStreaming(false);
     }
-  }, [endpoint, isStreaming, maxMessages, messages]);
+  }, [
+    endpoint,
+    isStreaming,
+    maxMessages,
+    messages,
+    profile,
+    dailyTokenLimit,
+    maxTokensPerRequest
+  ]);
   const cancel = useCallback(() => {
     clientRef.current?.cancel();
     setIsStreaming(false);
@@ -184,9 +296,11 @@ function useAiChat(options) {
       cancel,
       reset,
       isStreaming,
-      error
+      error,
+      profile,
+      setProfile
     }),
-    [messages, sendMessage, cancel, reset, isStreaming, error]
+    [messages, sendMessage, cancel, reset, isStreaming, error, profile, setProfile]
   );
 }
 export {

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "chat-nest-sdk",
 	"description": "Frontend React SDK for consuming streaming AI APIs with cancellation and retry safety.",
-	"version": "1.0.1",
+	"version": "1.1.1",
 	"type": "module",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",