@novaqore/ai 0.3.1 → 0.4.0

package/README.md

@@ -239,6 +239,48 @@ Call `stop()` at any time to abort the stream (e.g. wire it to a stop button in
 | `tools` | array | - | Tool definitions |
 | `tool_choice` | string | - | Tool selection mode |
 
+### Encrypted Chat History (localStorage)
+
+Enable `localStorage` to automatically save encrypted chat history in the browser. Messages are stored as encrypted blobs — zero extra crypto work, the SDK just keeps what's already encrypted.
+
+```javascript
+const nq = new NovaQoreAI({
+  uid: process.env.NOVAQORE_UID,
+  quantumKey: process.env.NOVAQORE_QUANTUM_KEY,
+  keyId: process.env.NOVAQORE_KEY_ID,
+  localStorage: true,
+});
+```
+
+Every `chat()` call automatically saves the encrypted request and response. Retrieve and decrypt on demand:
+
+```javascript
+const history = nq.getHistory();
+
+for (const entry of history) {
+  console.log("User:", entry.messages[entry.messages.length - 1].content);
+  console.log("Assistant:", entry.response.content);
+}
+```
+
+Clear all stored history:
+
+```javascript
+nq.clearHistory();
+```
+
+Use a custom storage key to separate conversations:
+
+```javascript
+const nq = new NovaQoreAI({
+  uid, quantumKey, keyId,
+  localStorage: true,
+  storageKey: "my-conversation-123",
+});
+```
+
+Data at rest stays encrypted in the browser — decryption only happens when you call `getHistory()`.
+
 ### Health check
 
 ```javascript

package/index.js

@@ -13,6 +13,8 @@ class NovaQoreAI {
   #authToken;
   #getAuthToken;
   #abort;
+  #useLocalStorage;
+  #storageKey;
 
   constructor(config) {
     if (config === undefined) {
@@ -50,6 +52,11 @@ class NovaQoreAI {
     this.#keyId = config.keyId;
     this.#authToken = config.authToken || config.bearerToken || null;
     this.#getAuthToken = config.getAuthToken || null;
+    this.#useLocalStorage = config.localStorage || false;
+    this.#storageKey = config.storageKey || `novaqore-ai-history-${this.#uid}`;
+    if (this.#useLocalStorage && typeof localStorage === "undefined") {
+      throw new Error("localStorage is not available in this environment");
+    }
     this.version = version;
     this.description = "NovaQore AI - Quantum-encrypted LLM client by NovaQore";
     this.methods = ["chat", "health"];
@@ -59,6 +66,42 @@ class NovaQoreAI {
     this.#authToken = token;
   }
 
+  #saveToStorage(entry) {
+    if (!this.#useLocalStorage) return;
+    const raw = localStorage.getItem(this.#storageKey);
+    const history = raw ? JSON.parse(raw) : [];
+    history.push(entry);
+    localStorage.setItem(this.#storageKey, JSON.stringify(history));
+  }
+
+  getHistory() {
+    if (!this.#useLocalStorage) return [];
+    const raw = localStorage.getItem(this.#storageKey);
+    if (!raw) return [];
+    const history = JSON.parse(raw);
+    return history.map(entry => {
+      const sharedSecret = Buffer.from(entry.sharedSecret, "base64");
+      const request = this.#decryptResponse(entry.request, sharedSecret);
+      let response = null;
+      if (entry.chunks) {
+        const parts = entry.chunks.map(c => {
+          const chunk = this.#decryptResponse(c, sharedSecret);
+          return chunk.choices[0]?.delta?.content || "";
+        });
+        response = { role: "assistant", content: parts.join("") };
+      } else if (entry.response) {
+        const decrypted = this.#decryptResponse(entry.response, sharedSecret);
+        response = decrypted.choices[0].message;
+      }
+      return { messages: request.messages, response };
+    });
+  }
+
+  clearHistory() {
+    if (!this.#useLocalStorage) return;
+    localStorage.removeItem(this.#storageKey);
+  }
+
   async #encryptPayload(payload) {
     const quantumKey = new Uint8Array(Buffer.from(this.#quantumKey, "base64"));
 
@@ -140,12 +183,14 @@ class NovaQoreAI {
       }
 
       if (options.stream) {
-        const stream = this.#readStream(res, sharedSecret);
+        const entry = { sharedSecret: sharedSecret.toString("base64"), request: encrypted, chunks: [] };
+        const stream = this.#readStream(res, sharedSecret, entry);
         const stop = () => this.#abort.abort();
         return { stream, stop };
       }
 
       const { encrypted: encryptedResponse } = await res.json();
+      this.#saveToStorage({ sharedSecret: sharedSecret.toString("base64"), request: encrypted, response: encryptedResponse });
       const result = this.#decryptResponse(encryptedResponse, sharedSecret);
       return { result, stop: () => {} };
     } catch (err) {
@@ -155,7 +200,7 @@ class NovaQoreAI {
     }
   }
 
-  async *#readStream(res, sharedSecret) {
+  async *#readStream(res, sharedSecret, entry) {
     const decoder = new TextDecoder();
     const reader = res.body.getReader();
     let buffer = "";
@@ -175,9 +220,13 @@ class NovaQoreAI {
           if (!trimmed || !trimmed.startsWith("data: ")) continue;
           const data = trimmed.slice(6);
 
-          if (data === "[DONE]") return;
+          if (data === "[DONE]") {
+            this.#saveToStorage(entry);
+            return;
+          }
 
           const { encrypted } = JSON.parse(data);
+          entry.chunks.push(encrypted);
           const chunk = this.#decryptResponse(encrypted, sharedSecret);
 
           if (chunk.seq !== expectedSeq) {
@@ -188,8 +237,12 @@ class NovaQoreAI {
           yield chunk;
         }
       }
+      this.#saveToStorage(entry);
     } catch (err) {
-      if (err.name === "AbortError") return;
+      if (err.name === "AbortError") {
+        this.#saveToStorage(entry);
+        return;
+      }
       throw err;
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@novaqore/ai",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "The world's first private, quantum-encrypted LLM clients. CRYSTALS-Kyber + AES-256-GCM end-to-end encryption. Zero dependencies.",
   "main": "index.js",
   "files": [