Improvement/OpenAI token after merge (#153)

* Start switch to new openai live API. Implement init_chatbot_session.

* Start test chatbot in frontend

* Use only text chat for now

* Attempt at reducing typing speed answer

* Start removing state machine for chatbot, adapt test/session chat look-n-feel

* Advance on chatbot UI rework

* Advanced

* Start text-based directory for response API

* Use real-time API again, auth tokens don't work with response API

* Add connection status. Use different connection for each conversation.

* Save/reload chat history (not tested yet)

* Use auth token

* Fix errors, chat works

* Remove unused things in the frontend

* Rework chatHistoryContext

* Few fixes

* Fix chat refresh

* Fix first message saving

* Fix connection initialization

* Update session context based on history

* Add autofocus, disable sending message as long as connection is not ready

* Introduced auth token context. Remove idempotency call for openai.

* Show back chat history

* Removed old unused files

* Fix border

* Consume and check for user AI credits

* Removed idempotent proxy: https outcalls support IPv4 (since August 2025)

* Use silent audio track for real-time chat. Fix CSP.

* Fix real-time session not initializing due to token getting invalid or not getting queried.

* Fix messages not being cleared when creating a new chat. Fix default chat name.

* Chatbot improvement in progress

* Fix async loading of history

* Added some cleaning

* Activate voice-to-voice

* Use upsert instead of refs to concatenate AI content

* Restrict voice AI only to premium users

* Allow microphone access in CSP

* Introduced hooks for saving history

* Prevent saving history if too recent

* Fix credits depleted popup. Add voice in welcome ai page.

* Fix chat ordering. redirect new chat to /chat

* Fix user profile that was using previous session info if any

* Introduce new menu when clicking on user link, with new route to subscriptions and logout. Introduced useIntProp that use authenticated actor if any else unauthenticated. Fix free voice AI.

Author: sardariuss

README.md

@@ -5,7 +5,6 @@
 - npm: https://docs.npmjs.com/downloading-and-installing-node-js-and-npm
 - dfx: https://internetcomputer.org/docs/current/developer-docs/getting-started/install/#installing-dfx-via-dfxvm
 - mops: https://docs.mops.one/quick-start
-- cargo: https://doc.rust-lang.org/cargo/
 
 ## Install
 ```bash
@@ -45,11 +44,8 @@ mops test
 - once created, IP shall not be listed on the marketplace yet, but only in the user's owned IP
 
 ## TODOs
-- Verify the idempotent proxy cycles consomption has been reduced by putting the timer every day
-- Inject the chatgpt API key instead of hardcoding it
 - Fix Conversions.intPropToMetadata to be able to use it
 - Harmonize the error messages returned by the backend canister
 - Be able to add a subaccount when creating IPs
 - Code review of implementation of ICRC-7/ICRC-37/ICRC-3, ideally have them audited
-- Have a proper approve flow (comes with NFID)
 - Misc frontend todos, nothing blocking or critical

package-lock.json

@@ -25,7 +25,7 @@
     "@dfinity/utils": "^2.13.2",
     "@napi-rs/lzma": "^1.3.1",
     "@napi-rs/lzma-linux-x64-gnu": "^1.3.1",
-    "@nfid/identitykit": "^1.0.15",
+    "@nfid/identitykit": "^1.0.16",
     "@pdf-lib/fontkit": "^1.1.1",
     "@stripe/react-stripe-js": "^5.3.0",
     "@stripe/stripe-js": "^8.5.1",

package.json

@@ -16,6 +16,7 @@ import SubscriptionManager   "SubscriptionManager";
 module {
 
   let CHAT_INSTRUCTIONS = "You are an assistant designed to help the user answer questions on intellectual property (IP). Your are embedded in the BIPQuantum website, which is a platform that delivers digital certificate that leverages blockchain technology to provide secure and immutable proof of ownership and authenticity for intellectual properties. You will answer technical questions on IP and guide the user through the process of creating a new IP certificate. You won't answer questions that e not related to IP, blockchain, or the BIPQuantum platform.";
+  let AUTH_KEY_TTL_SECONDS = 60;
 
   type Result<Ok, Err> = Result.Result<Ok, Err>;
 
@@ -47,7 +48,7 @@ module {
         "{ " #
           "\"expires_after\": " #
             "{ \"anchor\": \"created_at\", " #
-            "\"seconds\": 60 }, " #
+            "\"seconds\": " # Nat.toText(AUTH_KEY_TTL_SECONDS) # " }, " #
           "\"session\": { " #
             "\"type\": \"realtime\", " #
             "\"model\": \"gpt-realtime\", " #

src/backend/ChatBot.mo

@@ -12,6 +12,7 @@ import CookieBanner, { CookieBannerProvider } from "./common/CookieBanner";
 import TopBar from "./layout/TopBar";
 import { SearchProvider } from "./common/SearchContext";
 import { NotificationProvider } from "./common/NotificationContext";
+import { UserProvider } from "./common/UserContext";
 
 import "@nfid/identitykit/react/styles.css"
 import { IdentityKitProvider } from "@nfid/identitykit/react"
@@ -127,17 +128,19 @@ function App() {
             authType={IdentityKitAuthType.DELEGATION}
           >
             <ActorsProvider>
-              <ChatHistoryProvider>
-                <CookieBannerProvider>
-                  <SearchProvider>
-                    <NotificationProvider>
-                      <FungibleLedgerProvider>
-                        <AppContent />
-                      </FungibleLedgerProvider>
-                    </NotificationProvider>
-                  </SearchProvider>
-                </CookieBannerProvider>
-              </ChatHistoryProvider>
+              <UserProvider>
+                <ChatHistoryProvider>
+                  <CookieBannerProvider>
+                    <SearchProvider>
+                      <NotificationProvider>
+                        <FungibleLedgerProvider>
+                          <AppContent />
+                        </FungibleLedgerProvider>
+                      </NotificationProvider>
+                    </SearchProvider>
+                  </CookieBannerProvider>
+                </ChatHistoryProvider>
+              </UserProvider>
             </ActorsProvider>
           </IdentityKitProvider>
         </BrowserRouter>

src/frontend/components/App.tsx

@@ -20,6 +20,7 @@ const useQueryCall = <T extends BackendMethods>(options: UseQueryCallOptions<T>,
   const [data, setData] = useState<ExtractReturn<Backend[T]> | undefined>(undefined);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<any>(null);
+  const ready = !!actor;
 
   const call = useCallback(
     async (callArgs?: ExtractArgs<Backend[T]>): Promise<ExtractReturn<Backend[T]> | undefined> => {
@@ -67,7 +68,7 @@ const useQueryCall = <T extends BackendMethods>(options: UseQueryCallOptions<T>,
     }
   }, [actor, options.functionName, serializeArgs(options.args)]);
 
-  return { data, loading, error, call };
+  return { data, loading, ready, error, call };
 };
 
 interface UseUpdateCallOptions<T extends BackendMethods> {
@@ -79,6 +80,7 @@ interface UseUpdateCallOptions<T extends BackendMethods> {
 export const useUpdateCall = <T extends BackendMethods>(options: UseUpdateCallOptions<T>, actor: ActorSubclass<Backend> | undefined) => {
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<any>(null);
+  const ready = !!actor;
 
   const call = useCallback(
     async (args: ExtractArgs<Backend[T]> = [] as any): Promise<ExtractReturn<Backend[T]> | undefined> => {
@@ -103,7 +105,7 @@ export const useUpdateCall = <T extends BackendMethods>(options: UseUpdateCallOp
     [actor, options.functionName, options.onSuccess, options.onError]
   );
 
-  return { call, loading, error };
+  return { call, loading, ready, error };
 };
 
 export type { Backend };

src/frontend/components/actors/BackendActor.tsx

@@ -34,23 +34,20 @@ const VERSION_KEY = "miniSearchVersion";
 export const SearchProvider: React.FC<{ children: React.ReactNode }> = ({
   children,
 }) => {
-  const { authenticated, unauthenticated } = useActors();
+  const { unauthenticated } = useActors();
 
   const [documents, setDocuments] = useState<Document[]>(() => {
     try {
       const version = localStorage.getItem(VERSION_KEY);
-      //console.log("[SearchContext] Current storage version:", version, "Expected:", STORAGE_VERSION);
 
       if (version !== String(STORAGE_VERSION)) {
-        //console.log("[SearchContext] Version mismatch - clearing old data and migrating to version", STORAGE_VERSION);
         localStorage.removeItem(STORAGE_KEY);
         localStorage.setItem(VERSION_KEY, String(STORAGE_VERSION));
         return [];
       }
 
       const raw = localStorage.getItem(STORAGE_KEY);
       const docs = raw ? JSON.parse(raw) : [];
-      //console.log("[SearchContext] Loaded", docs.length, "documents from localStorage");
       return docs;
     } catch (err) {
       console.error("[SearchContext] Failed to parse cached documents:", err);
@@ -68,8 +65,6 @@ export const SearchProvider: React.FC<{ children: React.ReactNode }> = ({
       return [];
     }
 
-    //console.log("[SearchContext] Fetching", ids.length, "intProps:", ids);
-
     const results = await Promise.all(
       ids.map(async (id) => {
         try {
@@ -81,7 +76,6 @@ export const SearchProvider: React.FC<{ children: React.ReactNode }> = ({
               description: result.ok.intProp.V1.description,
               author: result.ok.author?.[0] ?? "",
             };
-            console.log(`[SearchContext] Fetched intProp ${id}:`, doc.title, "by", doc.author || "(no author)");
             return doc;
           } else {
             console.warn(`[SearchContext] Failed to fetch intProp ${id}: result not ok`);
@@ -94,21 +88,17 @@ export const SearchProvider: React.FC<{ children: React.ReactNode }> = ({
     );
 
     const validResults = results.filter((r): r is Document => r !== null);
-    //console.log("[SearchContext] Successfully fetched", validResults.length, "out of", ids.length, "intProps");
     return validResults;
   };
 
   const refreshDocuments = useCallback(async () => {
     if (!unauthenticated) {
-      //console.log("[SearchContext] Cannot refresh - unauthenticated actor not available");
       return;
     }
     if (isRefreshing) {
-      //console.log("[SearchContext] Already refreshing, skipping");
       return;
     }
 
-    //console.log("[SearchContext] Starting refresh of intProp IDs");
     setIsRefreshing(true);
     try {
       const result = await unauthenticated.backend.get_listed_int_props({
@@ -119,7 +109,6 @@ export const SearchProvider: React.FC<{ children: React.ReactNode }> = ({
 
       // Ensure result is valid and convert bigints to numbers safely
       if (Array.isArray(result)) {
-        //console.log("[SearchContext] Received", result.length, "intProp IDs from backend");
         setIntPropIds(result);
         setLastRefreshTime(Date.now());
       } else {
@@ -153,13 +142,6 @@ export const SearchProvider: React.FC<{ children: React.ReactNode }> = ({
     );
 
     if (missingIds.length > 0 || removedIds.length > 0) {
-      //console.log("[SearchContext] Document sync needed - Missing:", missingIds.length, "Removed:", removedIds.length);
-      if (missingIds.length > 0) {
-        //console.log("[SearchContext] Missing IDs:", missingIds);
-      }
-      if (removedIds.length > 0) {
-        //console.log("[SearchContext] Removed IDs:", removedIds);
-      }
 
       (async () => {
         const newDocs = await fetchIntProps(missingIds);
@@ -179,19 +161,15 @@ export const SearchProvider: React.FC<{ children: React.ReactNode }> = ({
           });
 
           const finalDocs = Array.from(docMap.values());
-          //console.log("[SearchContext] Documents updated - Total:", finalDocs.length);
           return finalDocs;
         });
       })();
-    } else {
-      //console.log("[SearchContext] Documents in sync - no updates needed");
     }
   }, [intPropIds]);
 
   useEffect(() => {
     try {
       localStorage.setItem(STORAGE_KEY, JSON.stringify(documents));
-      //console.log("[SearchContext] Saved", documents.length, "documents to localStorage");
     } catch (err) {
       console.error("[SearchContext] Failed to cache documents to localStorage:", err);
     }
@@ -204,7 +182,6 @@ export const SearchProvider: React.FC<{ children: React.ReactNode }> = ({
   };
 
   const miniSearch = useMemo(() => {
-    //console.log("[SearchContext] Rebuilding MiniSearch index with", documents.length, "documents");
     const search = new MiniSearch(options);
 
     try {
@@ -220,9 +197,6 @@ export const SearchProvider: React.FC<{ children: React.ReactNode }> = ({
 
       if (uniqueDocuments.length > 0) {
         search.addAll(uniqueDocuments);
-        //console.log("[SearchContext] MiniSearch index built successfully with", uniqueDocuments.length, "documents");
-      } else {
-        //console.log("[SearchContext] MiniSearch index is empty - no documents to index");
       }
     } catch (error) {
       console.error("[SearchContext] Error adding documents to MiniSearch:", error);

src/frontend/components/common/SearchContext.tsx

@@ -0,0 +1,73 @@
+import React, { createContext, useContext, ReactNode, useEffect, useState } from "react";
+import { useAuth } from "@nfid/identitykit/react";
+import { backendActor } from "../actors/BackendActor";
+import { User } from "../../../declarations/backend/backend.did";
+import { fromNullable } from "@dfinity/utils";
+
+interface UserContextType {
+  user: User | null;
+  isLoading: boolean;
+  refetchUser: () => void;
+}
+
+const UserContext = createContext<UserContextType | undefined>(undefined);
+
+export const useUser = () => {
+  const context = useContext(UserContext);
+  if (!context) {
+    throw new Error("useUser must be used within UserProvider");
+  }
+  return context;
+};
+
+interface UserProviderProps {
+  children: ReactNode;
+}
+
+export const UserProvider: React.FC<UserProviderProps> = ({ children }) => {
+  const { user: authUser } = useAuth();
+  const [user, setUser] = useState<User | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+
+  const { data: queriedUser, call: fetchUser } = backendActor.unauthenticated.useQueryCall({
+    functionName: "get_user",
+    args: authUser ? [authUser.principal] : undefined,
+  });
+
+  // Fetch user when authentication state changes
+  useEffect(() => {
+    if (authUser) {
+      setIsLoading(true);
+      fetchUser([authUser.principal]);
+    } else {
+      // Not authenticated - use default user (null)
+      setUser(null);
+      setIsLoading(false);
+    }
+  }, [authUser?.principal.toText()]);
+
+  // Update user state when query completes
+  useEffect(() => {
+    if (queriedUser !== undefined) {
+      const userData = fromNullable(queriedUser);
+      // If get_user returns null, use default user (null)
+      setUser(userData || null);
+    } else {
+      setUser(null);
+    }
+    setIsLoading(false);
+  }, [queriedUser]);
+
+  const refetchUser = () => {
+    if (authUser) {
+      setIsLoading(true);
+      fetchUser([authUser.principal]);
+    }
+  };
+
+  return (
+    <UserContext.Provider value={{ user, isLoading, refetchUser }}>
+      {children}
+    </UserContext.Provider>
+  );
+};