Dev step

main.py

@@ -73,52 +73,67 @@ async def validate_oauth(request: Request):
 
     # Saves the user
     user.update_user()
-
-
     return response
+
 ##########################################################
 
 
-########################## APIs ##########################   
+###################### APIs Configs ######################   
 
+# Get data and structures from its models
 User_find_from_data = Annotated[User, Depends(User.find_from_data)]
 Session_find_from_data = Annotated[Session, Depends(Session.find_from_data)]
 
 @app.post("/getConfigs")
 async def get_configs(response: Response, user: User_find_from_data):  
-    year, month = datetime.now().strftime("%y-%m").split("-")
-    month = sum(user.tokens.get(year, {}).get(month, {"_":0}).values())
+    # Get config from DB to client
+    
+    # Get llm tokens used
+    year_, month_ = datetime.now().strftime("%y-%m").split("-")
+    month = sum(user.tokens.get(year_, {}).get(month_, {"_":0}).values())
     total = sum([z for x in user.tokens.values() for y in x.values() for z in y.values()])
     tokens = {"month": month, "total": total}
+    
+    # Create cookies and answer
     user._session.create_cookie(response)
     return user.configs.model_dump() | {"tokens": tokens, "challenge": user._session.challenge}
 
 @app.post("/setConfigs")
 async def set_configs(response: Response, user: User_find_from_data):
-    user.configs = user._data
+    # Save configs from users to DB
+    
+    # Create config model
+    user.configs = model.Configs(**user._data)
+    user._session.configs = user.configs
     user.update_user()
+    
+    # Create cookies and answer
     user._session.create_cookie(response)
     return {"success":True, "challenge": user._session.challenge}
     
-
 @app.post("/getToken")
 async def get_token(response: Response, session: Session_find_from_data):
+    # Generate api token
     session.create_cookie(response)
+    
+    # Create cookies and answer
     return {"success":True, "challenge": session.challenge}
 
+##########################################################
 
 @app.post("/chat")
-async def chat_async(request: Request, body: model.Chat, user ): # = Depends(model.User.find_from_header)):
+async def chat_async(response:Response, session: Session_find_from_data):
+    body = model.Chat(messages = session.data["messages"])
     if(len(body.messages) < 1 or body.messages[-1].content==""):
-        log_module.logger.warning(user.gid, "Mensaje RQ", "error, mensajes vacios")
+        log_module.logger.warning(session.gid, "Mensaje RQ", "error, mensajes vacios")
         raise HTTPException(
             status_code=status.HTTP_418_IM_A_TEAPOT,
             detail= "Nope"
         )
     
-    response_async = llm.ejecutar(body, user)
-
-    return StreamingResponse(llm.streamer(response_async, body, user), media_type="application/json")
+    response_async = llm.ejecutar(body, session)
+    session.create_cookie(response)
+    return StreamingResponse(llm.streamer(response_async, body, session), media_type="application/json")
 
 
 ########################## Static Pages ##########################    
@@ -126,7 +141,7 @@ async def chat_async(request: Request, body: model.Chat, user ): # = Depends(mod
 async def privacy_policy(request: Request):
     return templates.TemplateResponse("PrivacyPolicy.html", {"request": request})
 
-@app.get("/hold") #, ["GET", "POST"]
+@app.get("/hold")
 async def on_hold(request: Request, user: User = Depends(User.find_from_cookie)):
     redirect_to_login = RedirectResponse(url='/login')
     
@@ -139,7 +154,7 @@ async def on_hold(request: Request, user: User = Depends(User.find_from_cookie))
             "description": bool(user.description)
         })
 
-@app.post("/hold") #, ["GET", "POST"]
+@app.post("/hold")
 async def on_hold(request: Request, user: User = Depends(User.find_from_cookie)):
     if not user.description:
         form = await request.form() 

modules/llm.py

@@ -18,7 +18,7 @@ if TYPE_CHECKING:
 encoding = tiktoken.encoding_for_model(settings.GPT_MODEL)
 
 
-def ejecutar(body: "model.Body", user: "model.User"):
+def ejecutar(body: "model.Chat", session: "model.Session"):
     temp_messages = [{"role":msg.role, "content":msg.content} for msg in body.messages]
      
     try:
@@ -30,16 +30,17 @@ def ejecutar(body: "model.Body", user: "model.User"):
         generated = client.chat.completions.create(
             model=settings.GPT_MODEL,
             messages=temp_messages,
-            temperature=user.configs.temperature,
-            frequency_penalty=user.configs.frequency_penalty,
-            presence_penalty=user.configs.presence_penalty,
-            tools= tools.functions if user.configs.useTool else None,
+            temperature=session.configs.temperature,
+            frequency_penalty=session.configs.frequency_penalty,
+            presence_penalty=session.configs.presence_penalty,
+            tools= tools.functions if session.configs.useTool else None,
             stream=True,
-            user=sha256(user.gid.encode('UTF-8')).hexdigest()
+            user=sha256(session.gid.encode('UTF-8')).hexdigest()
         )
+        
         return generated
     except Exception as error:
-        log_module.logger.error(repr(error) + " - " + user.gid)
+        log_module.logger.error(repr(error) + " - " + session.gid)
         raise HTTPException(  **error_map.error_table.get(type(error), error_map.error_table["undefined"]))
 
 def manejar_funciones(chunk, response_async, data):
@@ -60,7 +61,7 @@ def manejar_funciones(chunk, response_async, data):
             })
     return json.dumps(f_cb), ejecutar(data)
 
-async def streamer(response_async, body, user):
+async def streamer(response_async, body, session):
     yield json.dumps({"comando": "status", "status":{"mensaje":"Cargando", "modo": "reemplazar"}})
     message = body.new_msg()
     
@@ -91,5 +92,7 @@ async def streamer(response_async, body, user):
                 st_times += 1
             st = time.time()
     message.tokensPrompt = body.tokens 
-    user.update(message)
+    session.update_usage(message)
+    
+    yield json.dumps({"comando":"challenge", "challenge": session.challenge} )
     yield json.dumps({"comando":"mensaje", "mensaje": message.model_dump()} )

modules/model.py

@@ -68,6 +68,7 @@ class Session(BaseModel):
     public_key: str = ""
     challenge: str = str(uuid.uuid4())
     data: dict = {}
+    configs: Configs | None = None
 
     def __init__(self, **kwargs):
         kwargs["guid"] = kwargs.get("guid", str(uuid.uuid4())) 
@@ -104,7 +105,8 @@ class Session(BaseModel):
             fprint = data["fingerprint"],
             guid = cookie_data["guid"],
             public_key = public_key,
-            data = data
+            data = data,
+            configs = Configs(**cookie_data["configs"])
         )
 
         if session.hashed != cookie_data["fprint"]:
@@ -122,9 +124,13 @@ class Session(BaseModel):
             "guid": self.guid, 
             "fprint": self.hashed, 
             "public_key": self.public_key,
-            "challenge": self.challenge
+            "challenge": self.challenge,
+            "configs": self.configs.model_dump()
              })
         security.set_cookie(response, "token", jwt, {"hours": 24})
+        
+    def update_usage(self: Self, message:Message):
+        User.update_usage(self.gid, message)
     
 class User(BaseModel):
     name: str
@@ -173,8 +179,11 @@ class User(BaseModel):
         user._session = Session(
             gid = cookie_data["gid"], 
             guid = cookie_data["guid"], 
-            fprint = cookie_data["fprint"]
+            fprint = cookie_data["fprint"],
+            configs = user.configs
         )
+        print("configs user", id(user.configs))
+        print("configs sesison", id(user._session.configs))
         return user
     
     @classmethod
@@ -189,6 +198,7 @@ class User(BaseModel):
 
         user: Self = cls(**found)
         user._session = session
+        user._data = data
         return user
     
     def update_description(self: Self, message: str) -> None:
@@ -216,7 +226,9 @@ class User(BaseModel):
         return security.create_jwt_token({
             "gid":self.gid, 
             "guid": self._session.guid, 
-            "fprint": self._session.hashed})
+            "fprint": self._session.hashed,
+            "configs": self.configs.model_dump()
+            })
     
 
     

static/js/chatHandler.js

@@ -280,7 +280,8 @@ class ChatGPT{
             method: "POST",
             body: JSON.stringify({
                 messages: tempMensajes,
-                config: {"temperature": 1,"frequency_penalty": 0,"presence_penalty": 0}
+                challenge: this.challenge,
+                fingerprint: this.secHand.fingerprint
             }),
             headers: {
                 "Autorization": "Bearer " + this.token,
@@ -295,6 +296,8 @@ class ChatGPT{
                 return
             }
             return consume(response.body.getReader());
+        }).then(data => {
+            console.log("esto", data)
         })
         .catch(err =>{
             // Error