dev test

modules/chat_functions/buscar_google.py

@@ -2,6 +2,7 @@ import json
 import os
 from googleapiclient.discovery import build
 from .. import log_module
+    
 
 activo = True
 try:
@@ -51,6 +52,7 @@ def ejecutar(busqueda):
         retorno = {}
         retorno["conseguidos"] = []
         for result in results["items"]:
+            if "title" not in result or "snippet" not in result: continue
             retorno["conseguidos"].append({
                 "titulo": result["title"],
                 "link": result["link"],

modules/llm.py

@@ -6,6 +6,7 @@ from openai import OpenAI
 import tiktoken
 
 from . import log_module, error_map, chat_functions as tools, settings
+from .model import Functions
 from typing import TYPE_CHECKING                
 if TYPE_CHECKING:                               
     from . import model
@@ -19,7 +20,7 @@ encoding = tiktoken.encoding_for_model(settings.GPT_MODEL)
 
 
 def ejecutar(body: "model.Chat", session: "model.Session"):
-    temp_messages = [{"role":msg.role, "content":msg.content} for msg in body.messages]
+    temp_messages = [msg.model_dump() for msg in body.messages]
      
     try:
         client = OpenAI(
@@ -43,47 +44,24 @@ def ejecutar(body: "model.Chat", session: "model.Session"):
         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):
-    f_cb = dict(chunk["choices"][0]["delta"]["function_call"])
-    for chunk in response_async:
-        if chunk["choices"][0]["finish_reason"]: 
-            break   
-        for k, v in chunk["choices"][0]["delta"]["function_call"].items():
-            f_cb[k] += v
-    
-    f_cb["arguments"] = json.loads(f_cb["arguments"])
-    log_module.log_write(data["token_data"]["user"], "Funcion ejecutada RQ", json.dumps(f_cb))
-    resultado_funcion = chat_functions.function_callbacks[f_cb["name"]](**f_cb["arguments"])
-    log_module.log_write(data["token_data"]["user"], "Funcion ejecutada RS", json.dumps(resultado_funcion))
-    data["messages"].append({"role": "function",
-                "name": f_cb["name"],
-                "content": resultado_funcion,
-            })
-    return json.dumps(f_cb), ejecutar(data)
-
 async def streamer(chat: "model.Chat", session: "model.Session"):
     response_async = ejecutar(chat, session)
     
-    
-    
     yield json.dumps({"comando": "status", "status":{"mensaje":"Cargando", "modo": "reemplazar"}})
     message = chat.new_msg()
     
-    st = time.time()
-    st_times = 0
-    function_exec = {
-        "name": "",
-        "args": ""
-    }
+    functions_exec = []
+    
+    
     for chunk in response_async:
-        print(chunk.model_dump())
-        choise = chunk.choices[0]
-        delta = choise.delta
+        choice = chunk.choices[0]
+        delta = choice.delta
+        
+        message._tokensOutput += 1
         
-        message.tokensOutput += 1
-        if choise.finish_reason in ["stop", "tool_calls"]:
+        if choice.finish_reason in ["stop", "tool_calls"]:
             break
-
+            
         elif delta.role:
             message.role = delta.role
             continue
@@ -92,12 +70,17 @@ async def streamer(chat: "model.Chat", session: "model.Session"):
             message.content += delta.content
             
         elif delta.tool_calls:
-            if(name := delta.tool_calls[0].function.name):
-                function_exec["name"] = name
-            if(args := delta.tool_calls[0].function.arguments):
-                function_exec["args"] += args
+            tool_call = delta.tool_calls[0]
+            if tool_call.id:
+                functions_exec.append(Functions(tool_call_id=tool_call.id, role=message.role))
+            if(name := tool_call.function.name):
+                functions_exec[-1].name = name
+            if(args := tool_call.function.arguments):
+                functions_exec[-1]._busqueda += args
             
-        
+    
+        st = time.time()
+        st_times = 0
         if time.time() - st > 3:
             if st_times > 2:
                 yield json.dumps({"comando": "status", "status":{"mensaje":"Cargando", "modo": "reemplazar"}})
@@ -106,11 +89,26 @@ async def streamer(chat: "model.Chat", session: "model.Session"):
                 yield json.dumps({"comando": "status", "status":{"mensaje":".", "modo": "enlinea"}})
                 st_times += 1
             st = time.time()
-    message.tokensPrompt = chat.tokens 
-    session.update_usage(message)
+        
+    if functions_exec:
+        for i in functions_exec:
+            i.exec()
+            chat.messages.append(i)
+            
     
+        async for out in streamer(chat, session):
+            yield out
+        
+    
+        
+    message._tokensPrompt = chat.tokens 
+    session.update_usage(message)
     
     
     yield json.dumps({"comando":"challenge", "challenge": session.challenge} )
     yield json.dumps({"comando":"token", "token": session.create_cookie_token() } )
-    yield json.dumps({"comando":"mensaje", "mensaje": message.model_dump()} )
+    yield json.dumps({"comando":"mensaje", "mensaje": message.model_dump()} )
+
+
+
+    

modules/model.py

@@ -2,7 +2,7 @@ import json
 from pymongo.mongo_client import MongoClient
 from pymongo.server_api import ServerApi
 from fastapi import Request, Response
-from . import log_module, security, settings
+from . import log_module, security, settings, chat_functions
 from datetime import timezone, datetime, timedelta
 from pydantic import BaseModel, Field, PrivateAttr
 from typing import List, Self
@@ -33,28 +33,55 @@ class Configs(BaseModel):
     useTool: bool = True
     assistant: str = "clasico" 
 
-
+class Functions(BaseModel):
+    role: str = ""
+    tool_call_id: str = ""
+    name: str = ""
+    content: str = ""
+    _busqueda: str = ""
+    _args: str = ""
+    _tokensPrompt: int = 0
+    _tokensOutput: int = 0
+    
+    def parse(self):
+        self._args = json.loads(self._busqueda)
+    
+    
+    def exec(self):
+        if not self._args:
+            self.parse()
+        self.content = chat_functions.function_callbacks[self.name](self._args)
+        self._tokensPrompt += count_tokens_on_message([self.name, self.content])
+        
+        
+        
+        
+    
 class Message(BaseModel):
     role: str
     content: str
-    tokensPrompt: int = 0
-    tokensOutput: int = 0
+    _tokensPrompt: int = 0
+    _tokensOutput: int = 0
 
     def __init__(self, *args: list, **kwargs: dict):
         super(Message, self).__init__(*args, **kwargs)
-        self.tokensPrompt += count_tokens_on_message(list(kwargs.values()))
+        self._tokensPrompt += count_tokens_on_message(list(kwargs.values()))
+    
+    def get_tokens(self):
+        return self._tokensPrompt, self._tokensOutput
+        
 
 class Chat(BaseModel):
-    messages: List[Message]
+    messages: List[Message|Functions]
     tokens: int = 3
 
     def __init__(self: Self, *args: list, **kwargs: dict):
         super(Chat, self).__init__(*args, **kwargs)
-        self.tokens += sum([x.tokensPrompt+3 for x in self.messages])
+        self.tokens += sum([x._tokensPrompt+3 for x in self.messages])
     
-    def append(self: Self, mesage: Message):
+    def append(self: Self, mesage: Message|Functions):
         self.messages.append(mesage)
-        self.tokens += mesage.tokensPrompt
+        self.tokens += mesage._tokensPrompt
 
     def new_msg(self: Self):
         return Message(role="", content="")
@@ -233,7 +260,7 @@ class User(BaseModel):
 
     @staticmethod
     def update_usage(gid:str, message:Message):
-        count_tokens:int = message.tokensOutput+message.tokensPrompt
+        count_tokens:int = message._tokensOutput+message._tokensPrompt
         inc_field = datetime.now().strftime("tokens.%y.%m.%d")
         DB.user.update_one({"gid": gid}, {"$inc":{inc_field: count_tokens}})
 

static/js/chatHandler.js

@@ -310,7 +310,6 @@ class ChatGPT{
             }).catch(err =>{
                 // Error
                 console.log('algo paso', err)
-                document.location.href = "/";
             }); 
         }