ws-bom-robot-app 0.0.61__py3-none-any.whl → 0.0.63__py3-none-any.whl

ws_bom_robot_app/config.py

@@ -4,6 +4,7 @@ from pydantic_settings import BaseSettings
 import os
 
 class Settings(BaseSettings):
+    USER_AGENT: str = 'ws-bom-robot'
     robot_env: str = 'local'
     robot_user: str = 'user'
     robot_password: str = 'password'
@@ -28,7 +29,6 @@ class Settings(BaseSettings):
     GOOGLE_API_KEY: str = ''
     NEBULY_API_URL: str =''
     GOOGLE_APPLICATION_CREDENTIALS: str = '' # path to google credentials iam file, e.d. ./.secrets/google-credentials.json
-    TAVILY_API_KEY: str = '' #TODO DELETE
     model_config = ConfigDict(
         env_file='./.env',
         extra='ignore',
@@ -36,6 +36,7 @@ class Settings(BaseSettings):
     )
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
+        os.environ["USER_AGENT"] = self.USER_AGENT
         os.environ["OPENAI_API_KEY"] = self.OPENAI_API_KEY
         os.environ["OLLAMA_API_URL"] = self.OLLAMA_API_URL
         os.environ["ANTHROPIC_API_KEY"] = self.ANTHROPIC_API_KEY
@@ -44,8 +45,6 @@ class Settings(BaseSettings):
         os.environ["GOOGLE_API_KEY"] = self.GOOGLE_API_KEY
         os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = self.GOOGLE_APPLICATION_CREDENTIALS
         os.environ["NEBULY_API_URL"] = self.NEBULY_API_URL
-        # TODO DELETE
-        os.environ["TAVILY_API_KEY"] = self.TAVILY_API_KEY
 
     class RuntimeOptions(BaseModel):
         @staticmethod

ws_bom_robot_app/cron_manager.py

@@ -59,14 +59,14 @@ class CronManager:
             Job('cleanup-task',task_manager.cleanup_task, interval=5 * 60),
             Job('cleanup-data',kb_cleanup_data_file, interval=180 * 60),
         ]
-    def __get_jobstore_strategy() -> JobstoreStrategy:
+    def __get_jobstore_strategy(self) -> JobstoreStrategy:
         if True or config.runtime_options().is_multi_process:
             return MemoryJobstoreStrategy()
         return PersistentJobstoreStrategy()
     def __init__(self, strategy: JobstoreStrategy = None, enable_defaults: bool = True):
         self.enable_defaults = enable_defaults
         if strategy is None:
-          strategy = CronManager.__get_jobstore_strategy()
+          strategy = self.__get_jobstore_strategy()
         jobstores = strategy.get_jobstore()
         self.scheduler: BackgroundScheduler = BackgroundScheduler(jobstores=jobstores)
         self.__scheduler_is_running = False

ws_bom_robot_app/llm/agent_handler.py

@@ -60,7 +60,7 @@ class AgentHandler(AsyncCallbackHandler):
         tags: Optional[List[str]] = None,
         **kwargs: Any,
     ) -> None:
-        if token and "llm_chain" not in tags:
+        if token and "llm_chain" not in (tags or []):
             token = _parse_token(self.llm,token)
             if token:
               self.stream_buffer += token  # append new data to pending buffer

ws_bom_robot_app/llm/agent_lcel.py

@@ -24,8 +24,7 @@ class AgentLcel:
 
     async def __create_prompt(self, input: dict) -> ChatPromptTemplate:
         message : LlmMessage = input[self.memory_key][-1]
-        input = message.content
-        rules_prompt = await get_rules(self.embeddings, self.rules, input) if self.rules else ""
+        rules_prompt = await get_rules(self.embeddings, self.rules, message.content) if self.rules else ""
         system = default_prompt + (tool_prompt(render_text_description(self.__tools)) if len(self.__tools)>0 else "") + self.sys_message + rules_prompt
         return ChatPromptTemplate([
                 ("system", system),

ws_bom_robot_app/llm/api.py

@@ -26,6 +26,18 @@ def _stream_headers(rq: StreamRequest) -> Mapping[str, str]:
         "X-thread-id": rq.msg_id or str(uuid4()),
         "X-msg-id": rq.msg_id or str(uuid4()),
         }
+
+@router.get("/cms/app", tags=["cms"])
+async def cms_apps():
+    from ws_bom_robot_app.llm.utils.cms import get_apps
+    return await get_apps()
+
+@router.get("/cms/app/{id}", tags=["cms"])
+async def cms_app_by_id(id: str):
+    from ws_bom_robot_app.llm.utils.cms import get_app_by_id
+    return await get_app_by_id(id)
+
+
 @router.post("/stream")
 async def _stream(rq: StreamRequest, ctx: Request) -> StreamingResponse:
     return StreamingResponse(stream(rq, ctx), media_type="application/json", headers=_stream_headers(rq))

ws_bom_robot_app/llm/feedbacks/feedback_manager.py

@@ -59,14 +59,6 @@ class NebulyFeedback(FeedbackInterface):
         raise Exception(f"Error sending feedback: {response.status_code} - {response.text}")
       return response.text
 
-    def __buildAiMessage(self) -> str:
-        message = eval(self.config.message_output)
-        message_output = ""
-        for chunk in message:
-          if isinstance(chunk, dict) and "text" in chunk:
-            message_output += chunk["text"]
-        return message_output
-
 class FeedbackManager:
     #class variables (static)
     _list: dict[str,FeedbackInterface] = {

ws_bom_robot_app/llm/main.py

@@ -89,6 +89,8 @@ async def __stream(rq: StreamRequest, ctx: Request, queue: Queue,formatted: bool
     callbacks.append(trace)
 
   __llm: LlmInterface =rq.get_llm()
+  for tool in rq.app_tools:
+    tool.thread_id = rq.thread_id
   processor = AgentLcel(
       llm=__llm,
       sys_message=rq.system_message,

ws_bom_robot_app/llm/models/api.py

@@ -36,6 +36,7 @@ class LlmAppToolDbSettings(BaseModel):
 
 class LlmAppTool(BaseModel):
   id: Optional[str] = None
+  thread_id: Optional[str] = Field(None, validation_alias=AliasChoices("threadId","thread_id"))
   name: str
   description: Optional[str] = None
   type: str
@@ -53,6 +54,11 @@ class LlmAppTool(BaseModel):
   vector_type: Optional[str] = Field('faiss', validation_alias=AliasChoices("vectorDbType","vector_type"))
   vector_db: Optional[str] = Field(None, validation_alias=AliasChoices("vectorDbFile","vector_db"))
   is_active: Optional[bool] = Field(True, validation_alias=AliasChoices("isActive","is_active"))
+  def secrets_to_dict(self) -> Dict[str, str]:
+      _secrets = {}
+      for d in self.secrets or []:
+        _secrets[d.get("secretId")] = d.get("secretValue")
+      return _secrets
   def get_vector_filtering(self) -> Optional[Tuple[str, List[AttributeInfo]]]:
       _description = None
       _metadata = None

ws_bom_robot_app/llm/tools/tool_builder.py

@@ -1,12 +1,54 @@
+import asyncio
 from asyncio import Queue
-from langchain.tools import Tool, StructuredTool
+from langchain.tools import StructuredTool
 from ws_bom_robot_app.llm.models.api import LlmAppTool
 from ws_bom_robot_app.llm.tools.tool_manager import ToolManager
 from ws_bom_robot_app.llm.providers.llm_manager import LlmInterface
 
+async def __process_proxy_tool(proxy_tool: LlmAppTool) -> LlmAppTool | None:
+    import os
+    from ws_bom_robot_app.llm.utils.cms import CmsApp, get_app_by_id
+    from ws_bom_robot_app.config import config
+    try:
+        secrets = proxy_tool.secrets_to_dict()
+        app_id = secrets.get("appId")
+        if not app_id:
+            raise ValueError("Tool configuration is invalid. 'appId' is required.")
+        app: CmsApp = await get_app_by_id(app_id)
+        if not app:
+            raise ValueError(f"App with id {app_id} not found.")
+        tool_id = secrets.get("toolId")
+        tool = next((t for t in app.app_tools if t.id == tool_id), None)
+        if not tool:
+            raise ValueError(f"Tool with function_id {tool_id} not found in app {app.name}.")
+        #override derived tool with proxy tool props
+        tool.name = proxy_tool.name if proxy_tool.name else tool.name
+        tool.description = proxy_tool.description if proxy_tool.description else tool.description
+        tool.function_id = proxy_tool.function_id if proxy_tool.function_id else tool.function_id
+        tool.function_description = proxy_tool.function_description if proxy_tool.function_description else tool.function_description
+        #normalize vector_db
+        if tool.vector_db:
+            tool.vector_db = os.path.join(
+               os.path.join(config.robot_data_folder,config.robot_data_db_folder,config.robot_data_db_folder_store),
+               os.path.splitext(os.path.basename(tool.vector_db))[0]) if tool.vector_db else None
+        return tool
+    except Exception as e:
+        print(f"[!] Error in proxy_app_tool: {e}")
+        return None
+
 def get_structured_tools(llm: LlmInterface, tools: list[LlmAppTool], callbacks:list, queue: Queue) -> list[StructuredTool]:
   _structured_tools :list[StructuredTool] = []
   for tool in [tool for tool in tools if tool.is_active]:
+    if tool.function_name == "proxy_app_tool":
+        # override the tool
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+          import nest_asyncio
+          nest_asyncio.apply()
+        processed_tool = loop.run_until_complete(__process_proxy_tool(tool))
+        if processed_tool is None:
+            continue
+        tool = processed_tool
     if _tool_config := ToolManager._list.get(tool.function_name):
       _tool_instance = ToolManager(llm, tool, callbacks, queue)
       _structured_tool = StructuredTool.from_function(

ws_bom_robot_app/llm/tools/tool_manager.py

@@ -1,14 +1,14 @@
 from asyncio import Queue
+import aiohttp
 from typing import  Optional, Type, Callable
-from ws_bom_robot_app.llm.models.api import LlmAppTool
+from ws_bom_robot_app.config import config
+from ws_bom_robot_app.llm.models.api import LlmApp,LlmAppTool
 from ws_bom_robot_app.llm.providers.llm_manager import LlmInterface
+from ws_bom_robot_app.llm.utils.cms import CmsApp, get_app_by_id
 from ws_bom_robot_app.llm.vector_store.db.manager import VectorDbManager
 from ws_bom_robot_app.llm.tools.utils import getRandomWaitingMessage, translate_text
 from ws_bom_robot_app.llm.tools.models.main import NoopInput,DocumentRetrieverInput,ImageGeneratorInput,LlmChainInput,SearchOnlineInput,EmailSenderInput
 from pydantic import BaseModel, ConfigDict
-import smtplib
-from email.mime.multipart import MIMEMultipart
-from email.mime.text import MIMEText
 
 class ToolConfig(BaseModel):
     function: Callable
@@ -165,23 +165,50 @@ class ToolManager:
           result = await chain.ainvoke({"input": input})
           return result
 
+    async def proxy_app_chat(self, query: str) -> str | None:
+        secrets = self.app_tool.secrets_to_dict()
+        app_id = secrets.get("appId")
+        if not app_id:
+            raise ValueError("Tool configuration is invalid. 'appId' is required.")
+        app: CmsApp = await get_app_by_id(app_id)
+        if not app:
+            raise ValueError(f"App with id {app_id} not found.")
+        url = f"{config.robot_cms_host}/api/llm/message?locale=en&raw=true"
+        auth = config.robot_cms_auth
+        headers = {"Authorization": auth} if auth else {}
+        async with aiohttp.ClientSession() as session:
+            data = {
+              "appKey": app.credentials.app_key,
+              "apiKey": app.credentials.api_key,
+              "messages": [
+                {
+                  "role": "user",
+                  "content": query
+                }
+              ]
+            }
+            async with session.post(url, json=data, headers=headers) as response:
+                if response.status == 200:
+                  return await response.text()
+                else:
+                  raise ValueError(f"Error fetching chat response: {response.status}")
+        return None
 
-    async def search_online(self, query: str):
+    async def proxy_app_tool(self) -> None:
+        return None
+
+    async def _fetch_urls(self, urls: list[str]) -> list[dict]:
+        import aiohttp, asyncio
         from ws_bom_robot_app.llm.tools.utils import fetch_page, extract_content_with_trafilatura
-        from langchain_community.utilities import DuckDuckGoSearchAPIWrapper
-        import aiohttp, asyncio, ast
-        # Wrapper DuckDuckGo
-        search = DuckDuckGoSearchAPIWrapper(max_results=10)
-        try:
-          raw_results = search.results(query, max_results=10)
-        except Exception as e:
-            print(f"[!] Errore ricerca: {e}")
-        urls = [r["link"] for r in raw_results]
+        if not urls:
+            return []
         async with aiohttp.ClientSession() as session:
             tasks = [fetch_page(session, url) for url in urls]
-            responses = await asyncio.gather(*tasks)
+            responses = await asyncio.gather(*tasks, return_exceptions=True)
         final_results = []
         for item in responses:
+            if isinstance(item, Exception):
+                continue
             url = item["url"]
             html = item["html"]
             if html:
@@ -194,13 +221,20 @@ class ToolManager:
                 final_results.append({"url": url, "content": "Page not found"})
         return final_results
 
-    async def search_online_google(self, query: str):
+    async def search_online(self, query: str) -> list[dict]:
+        from langchain_community.utilities import DuckDuckGoSearchAPIWrapper
+        # Wrapper DuckDuckGo
+        search = DuckDuckGoSearchAPIWrapper(max_results=10)
+        try:
+          raw_results = search.results(query, max_results=10)
+        except Exception as e:
+            return f"[!] Errore ricerca: {e}"
+        urls = [r["link"] for r in raw_results]
+        return await self._fetch_urls(urls)
+
+    async def search_online_google(self, query: str) -> list[dict]:
       from langchain_google_community import GoogleSearchAPIWrapper
-      from ws_bom_robot_app.llm.tools.utils import fetch_page, extract_content_with_trafilatura
-      import aiohttp, asyncio
-      secrets = {}
-      for d in self.app_tool.secrets:
-        secrets[d.get("secretId")] = d.get("secretValue")
+      secrets = self.app_tool.secrets_to_dict()
       search_type = secrets.get("searchType")
       if search_type:
           search_kwargs = {"searchType" : search_type}
@@ -218,27 +252,19 @@ class ToolManager:
           num_results=secrets.get("num_results", 5)
       )
       urls = [r["link"] for r in raw_results]
-      async with aiohttp.ClientSession() as session:
-          tasks = [fetch_page(session, url) for url in urls]
-          responses = await asyncio.gather(*tasks)
-      final_results = []
-      for item in responses:
-          url = item["url"]
-          html = item["html"]
-          if html:
-              content = await extract_content_with_trafilatura(html)
-              if content:
-                  final_results.append({"url": url, "content": content, "type": "web"})
-              else:
-                  final_results.append({"url": url, "content": "No content found", "type": "web"})
-          else:
-              final_results.append({"url": url, "content": "Page not found", "type": "web"})
-      return final_results
-
+      return await self._fetch_urls(urls)
 
     async def send_email(self, email_subject: str, body: str, to_email:str):
+        import smtplib
+        from email.mime.multipart import MIMEMultipart
+        from email.mime.text import MIMEText
         secrets = self.app_tool.secrets
         secrets = {item["secretId"]: item["secretValue"] for item in secrets}
+        import urllib.parse as urlparse
+        url_preview = secrets.get("url_preview", "")
+        if url_preview and url_preview != "":
+          message_tread = "Puoi visualizzare la chat su questo indirizzo: " + urlparse.urljoin(url_preview, f"?llmThreadId={self.app_tool.thread_id}")
+          body = body.replace("##url_preview##", message_tread)
         # Email configuration
         smtp_server = secrets.get("smtp_server")
         smtp_port = secrets.get("smtp_port")
@@ -274,12 +300,15 @@ class ToolManager:
 
     #class variables (static)
     _list: dict[str,ToolConfig] = {
-        "document_retriever": ToolConfig(function=document_retriever, model=DocumentRetrieverInput),
-        "image_generator": ToolConfig(function=image_generator, model=ImageGeneratorInput),
-        "llm_chain": ToolConfig(function=llm_chain, model=LlmChainInput),
-        "search_online": ToolConfig(function=search_online, model=SearchOnlineInput),
-        "search_online_google": ToolConfig(function=search_online_google, model=SearchOnlineInput),
-        "send_email": ToolConfig(function=send_email, model=EmailSenderInput),
+        f"{document_retriever.__name__}": ToolConfig(function=document_retriever, model=DocumentRetrieverInput),
+        f"{image_generator.__name__}": ToolConfig(function=image_generator, model=ImageGeneratorInput),
+        f"{llm_chain.__name__}": ToolConfig(function=llm_chain, model=LlmChainInput),
+        f"{search_online.__name__}": ToolConfig(function=search_online, model=SearchOnlineInput),
+        f"{search_online_google.__name__}": ToolConfig(function=search_online_google, model=SearchOnlineInput),
+        f"{send_email.__name__}": ToolConfig(function=send_email, model=EmailSenderInput),
+        f"{proxy_app_chat.__name__}": ToolConfig(function=proxy_app_chat, model=DocumentRetrieverInput),
+        f"{proxy_app_tool.__name__}": ToolConfig(function=proxy_app_tool, model=NoopInput),
+
     }
 
     #instance methods

ws_bom_robot_app/llm/utils/agent.py

@@ -5,21 +5,21 @@ from ws_bom_robot_app.llm.utils.print import HiddenPrints
 from ws_bom_robot_app.llm.vector_store.db.manager import VectorDbManager
 import warnings
 
-async def get_rules(embeddings: Embeddings, rules: LlmRules, input: str | list) -> str:
+async def get_rules(embeddings: Embeddings, rules: LlmRules, query: str | list) -> str:
   with warnings.catch_warnings():
     warnings.simplefilter("ignore", category=Warning)
     # check if the input is multimodal and convert it to text
-    if isinstance(input, list):
-      input = " ".join(obj.get("text", "") for obj in input)
+    if isinstance(query, list):
+      query = " ".join(obj.get("text", "") for obj in query)
     # check if the input is empty or the rules are not provided
-    if any([input=="",rules is None,rules and rules.vector_db == "",rules and not os.path.exists(rules.vector_db)]):
+    if any([query=="",rules is None,rules and rules.vector_db == "",rules and not os.path.exists(rules.vector_db)]):
       return ""
     # get the rules from the vector db and return prompt with rules
     rules_prompt = ""
     rules_doc = await VectorDbManager.get_strategy(rules.vector_type).invoke(
       embeddings,
       rules.vector_db,
-      input,
+      query,
       search_type="similarity_score_threshold",
       search_kwargs={
         "score_threshold": rules.threshold,

ws_bom_robot_app/llm/utils/cms.py

@@ -0,0 +1,77 @@
+import logging, aiohttp
+from typing import List, Optional
+
+from pydantic import AliasChoices, BaseModel, ConfigDict, Field
+from ws_bom_robot_app.llm.models.api import LlmAppTool
+from ws_bom_robot_app.util import cache_with_ttl
+
+class CmsAppCredential(BaseModel):
+  app_key: str = Field(..., description="The app key for the credential", validation_alias=AliasChoices("appKey","app_key"))
+  api_key: str = Field(..., description="The api key for the credential", validation_alias=AliasChoices("apiKey","api_key"))
+  model_config = ConfigDict(extra='ignore')
+class CmsApp(BaseModel):
+  id: str = Field(..., description="Unique identifier for the app")
+  name: str = Field(..., description="Name of the app")
+  credentials: CmsAppCredential = None
+  app_tools: Optional[List[LlmAppTool]] = Field([], validation_alias=AliasChoices("appTools","app_tools"))
+  model_config = ConfigDict(extra='ignore')
+
+@cache_with_ttl(600)  # Cache for 10 minutes
+async def get_apps() -> list[CmsApp]:
+  import json, os
+  from ws_bom_robot_app.config import config
+  class DictObject(object):
+      def __init__(self, dict_):
+          self.__dict__.update(dict_)
+      def __repr__(self):
+          return json.dumps(self.__dict__)
+      @classmethod
+      def from_dict(cls, d):
+          return json.loads(json.dumps(d), object_hook=DictObject)
+  def __attr(obj, *attrs, default=None):
+      for attr in attrs:
+          obj = getattr(obj, attr, default)
+          if obj is None:
+              break
+      return obj
+  host = config.robot_cms_host
+  if host:
+    url = f"{host}/api/llmApp?depth=1&pagination=false"
+    auth = config.robot_cms_auth
+    headers = {"Authorization": auth} if auth else {}
+    async with aiohttp.ClientSession() as session:
+      async with session.get(url, headers=headers) as response:
+        if response.status == 200:
+          _apps=[]
+          cms_apps = await response.json()
+          for cms_app in cms_apps:
+             if __attr(cms_app,"isActive",default=True) == True:
+                _cms_app_dict = DictObject.from_dict(cms_app)
+                _app: CmsApp = CmsApp(
+                  id=_cms_app_dict.id,
+                  name=_cms_app_dict.name,
+                  credentials=CmsAppCredential(app_key=_cms_app_dict.settings.credentials.appKey,api_key=_cms_app_dict.settings.credentials.apiKey),
+                  app_tools=[LlmAppTool(**tool) for tool in cms_app.get('settings').get('appTools',[])]
+                )
+                if _app.app_tools:
+                  for tool in _app.app_tools:
+                    _knowledgeBase = tool.knowledgeBase
+                    tool.vector_db = _knowledgeBase.get('vectorDbFile').get('filename') if _knowledgeBase.get('vectorDbFile') else None
+                    tool.vector_type = _knowledgeBase.get('vectorDbType') if _knowledgeBase.get('vectorDbType') else 'faiss'
+                    del tool.knowledgeBase
+                _apps.append(_app)
+          return _apps
+        else:
+          logging.error(f"Error fetching cms apps: {response.status}")
+  else:
+    logging.error("robot_cms_host environment variable is not set.")
+  return []
+
+async def get_app_by_id(app_id: str) -> CmsApp | None:
+    apps = await get_apps()
+    app = next((a for a in apps if a.id == app_id), None)
+    if app:
+        return app
+    else:
+        logging.error(f"App with id {app_id} not found.")
+        return None

ws_bom_robot_app/task_manager.py

@@ -350,13 +350,15 @@ class DatabaseTaskManagerStrategy(TaskManagerStrategy):
             session.commit()
 #endregion
 
-# global instance
+#region global
 def __get_taskmanager_strategy() -> TaskManagerStrategy:
+    """ Factory function to get the appropriate task manager strategy based on the runtime configuration."""
     if config.runtime_options().is_multi_process:
         return DatabaseTaskManagerStrategy()
     return MemoryTaskManagerStrategy()
 task_manager = __get_taskmanager_strategy()
 _log.info(f"Task manager strategy: {task_manager.__class__.__name__}")
+#endregion
 
 #region api
 router = APIRouter(prefix="/api/task", tags=["task"])

ws_bom_robot_app/util.py

@@ -1,6 +1,6 @@
 import logging.handlers
 import os, logging, json
-from typing import TypeVar, Generic
+from typing import Callable, TypeVar, Generic
 from functools import wraps
 from .config import config
 
@@ -23,25 +23,64 @@ _log: logging.Logger = locals().get("_loc", logger_instance(__name__))
 #endregion
 
 #region cache
-class cache(Generic[T]):
-    def _filepath() -> str:
-        return os.path.join('.data',f'{T.__module__}.{T.__name__}.json')
-    @staticmethod
-    def get() -> list[T]:
-        filepath: str = cache._filepath()
-        if os.path.exists(filepath):
-            with open(filepath, 'r') as file:
-                content = file.read()
-            items: list[T] = json.loads(content)
-            return items
-        return None
-    @staticmethod
-    def set(items: list[T]):
-        with open(cache._filepath(), 'w') as file:
-            file.write(json.dumps(items))
-    @staticmethod
-    def clear():
-        os.remove(cache._filepath())
+_cache = {}
+_cache_timestamps = {}
+
+def cache_with_ttl(ttl_seconds: int):
+    """
+    Decorator for caching async function results with TTL (Time To Live)
+
+    Args:
+        ttl_seconds: Cache expiration time in seconds
+    """
+    import time
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            # Create cache key from function name and arguments
+            cache_key = f"{func.__name__}:{hash(str(args) + str(sorted(kwargs.items())))}"
+
+            current_time = time.time()
+
+            # Check if cached result exists and is still valid
+            if (cache_key in _cache and
+                cache_key in _cache_timestamps and
+                current_time - _cache_timestamps[cache_key] < ttl_seconds):
+                return _cache[cache_key]
+
+            # Call the original function and cache the result
+            result = await func(*args, **kwargs)
+            _cache[cache_key] = result
+            _cache_timestamps[cache_key] = current_time
+
+            return result
+        return wrapper
+    return decorator
+
+def clear_cache(id: str = None):
+    """Clear the cache by id function"""
+    cache_key_prefix = f"{id}:"
+    keys_to_remove = [key for key in _cache.keys() if key.startswith(cache_key_prefix)]
+    for key in keys_to_remove:
+        _cache.pop(key, None)
+        _cache_timestamps.pop(key, None)
+
+def get_cache_info(id: str) -> dict:
+    """Get information about current cache status"""
+    import time
+    current_time = time.time()
+    cache_info = {}
+
+    for key, timestamp in _cache_timestamps.items():
+        if key.startswith(f"{id}:"):
+            remaining_ttl = 600 - (current_time - timestamp)
+            cache_info[key] = {
+                "cached_at": timestamp,
+                "remaining_ttl": max(0, remaining_ttl),
+                "is_expired": remaining_ttl <= 0
+            }
+
+    return cache_info
 #endregion
 
 def _get_timer_wrapper(is_async=False):

{ws_bom_robot_app-0.0.61.dist-info → ws_bom_robot_app-0.0.63.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ws_bom_robot_app
-Version: 0.0.61
+Version: 0.0.63
 Summary: A FastAPI application serving ws bom/robot/llm platform ai.
 Home-page: https://github.com/websolutespa/bom
 Author: Websolute Spa
@@ -13,24 +13,23 @@ Description-Content-Type: text/markdown
 Requires-Dist: standardwebhooks==1.0.0
 Requires-Dist: apscheduler==3.11.0
 Requires-Dist: aiofiles==24.1.0
-Requires-Dist: pydantic==2.10.6
-Requires-Dist: pydantic-settings==2.7.1
-Requires-Dist: fastapi[standard]==0.115.8
+Requires-Dist: pydantic==2.11.7
+Requires-Dist: pydantic-settings==2.10.1
+Requires-Dist: fastapi[standard]==0.115.14
 Requires-Dist: chevron==0.14.0
-Requires-Dist: trafilatura==2.0.0
-Requires-Dist: langchain==0.3.25
-Requires-Dist: langchain-community==0.3.24
-Requires-Dist: langchain-core==0.3.59
-Requires-Dist: langchain-openai==0.3.16
+Requires-Dist: langchain==0.3.26
+Requires-Dist: langchain-community==0.3.26
+Requires-Dist: langchain-core==0.3.67
+Requires-Dist: langchain-openai==0.3.27
 Requires-Dist: langchain-anthropic==0.3.6
 Requires-Dist: langchain-google-genai==2.0.7
-Requires-Dist: langchain-google-vertexai==2.0.13
-Requires-Dist: langchain-groq==0.3.2
-Requires-Dist: langchain-ollama==0.3.2
-Requires-Dist: faiss-cpu==1.9.0
-Requires-Dist: chromadb==0.6.3
-Requires-Dist: langchain_chroma==0.2.1
-Requires-Dist: fastembed==0.5.1
+Requires-Dist: langchain-google-vertexai==2.0.27
+Requires-Dist: langchain-groq==0.3.5
+Requires-Dist: langchain-ollama==0.3.3
+Requires-Dist: faiss-cpu==1.11.0
+Requires-Dist: chromadb==1.0.13
+Requires-Dist: langchain_chroma==0.2.4
+Requires-Dist: fastembed==0.7.1
 Requires-Dist: langchain-qdrant==0.2.0
 Requires-Dist: lark==1.2.2
 Requires-Dist: unstructured==0.16.21
@@ -48,9 +47,10 @@ Requires-Dist: unstructured-ingest[sftp]
 Requires-Dist: unstructured-ingest[sharepoint]
 Requires-Dist: unstructured-ingest[slack]
 Requires-Dist: html5lib==1.1
-Requires-Dist: markdownify==0.14.1
+Requires-Dist: markdownify==1.1.0
 Requires-Dist: duckduckgo-search==8.0.4
 Requires-Dist: langchain_google_community==2.0.7
+Requires-Dist: trafilatura==2.0.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{ws_bom_robot_app-0.0.61.dist-info → ws_bom_robot_app-0.0.63.dist-info}/RECORD

@@ -1,38 +1,39 @@
 ws_bom_robot_app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ws_bom_robot_app/auth.py,sha256=84nIbmJsMrNs0sxIQGEHbjsjc2P6ZrZZGSn8dkiL6is,895
-ws_bom_robot_app/config.py,sha256=9W3cz92hbogDrtbCcybpCY29zCka7G225CNQEptpx30,4183
-ws_bom_robot_app/cron_manager.py,sha256=0Yt5AMTPGlXZ_M5ck0SKMX8wvzoPsseEezg_s0Q3HKY,9224
+ws_bom_robot_app/config.py,sha256=JFO4HrFnzUjFfv5MH0Tzwda0krllEqmTufHZ6J-BgEI,4147
+ws_bom_robot_app/cron_manager.py,sha256=pFHV7SZtp6GRmmLD9K1Mb1TE9Ev9n5mIiFScrc7tpCo,9221
 ws_bom_robot_app/main.py,sha256=zO3B-v-v9ESASvw8IaQj9Y9hNvNmOxohFmA0R82EybQ,6518
-ws_bom_robot_app/task_manager.py,sha256=Zedzs2R3O-wNSQOqs4jorgFwPRi-ji_0TN4mGfk-VvE,15958
-ws_bom_robot_app/util.py,sha256=b49ItlZgh2Wzw-6K8k5Wa44eVgjQ0JmWQwJnEaQBVGw,3502
+ws_bom_robot_app/task_manager.py,sha256=Q3Il2TtkP0FoG9zHEBu48pZGXzimTtvWQsoH6wdvQs0,16077
+ws_bom_robot_app/util.py,sha256=RjVD6B9sHje788Lndqq5DHy6TJM0KLs9qx3JYt81Wyk,4834
 ws_bom_robot_app/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ws_bom_robot_app/llm/agent_context.py,sha256=uatHJ8wcRly6h0S762BgfzDMpmcwCHwNzwo37aWjeE0,1305
 ws_bom_robot_app/llm/agent_description.py,sha256=5IP0qFSJvaE3zjGS7f0W1DuiegP0RHXRMBoDC5pCofA,4779
-ws_bom_robot_app/llm/agent_handler.py,sha256=PzdDpBnfUdqxKuMpHcVYgVf0hxIFOJwdxT9YIyFGdYY,7766
-ws_bom_robot_app/llm/agent_lcel.py,sha256=8d10b43BXqE4rfXE5uh8YGT67o1bw0q0l7QXFT6wPKA,2320
-ws_bom_robot_app/llm/api.py,sha256=1nzQ7g2n_DlX6Ixo5ecS10UvyyKJ42qZQ6aD8-EI7BE,4709
+ws_bom_robot_app/llm/agent_handler.py,sha256=-9ia0bpNXgqLGFCSmAiU5ogdoJo30yl-XUNdXONdvbs,7774
+ws_bom_robot_app/llm/agent_lcel.py,sha256=e1ZELfUEpqMXJwLWxyOtgiUmVwoO3Aw-ua4u05XociA,2297
+ws_bom_robot_app/llm/api.py,sha256=2bF-UFczY9LuBqPxKObM0TOWYbZgVztX1RiIz5MSorU,5042
 ws_bom_robot_app/llm/defaut_prompt.py,sha256=D9dn8yPveu0bVwGM1wQWLYftmBs5O76o0R_caLLll8w,1121
-ws_bom_robot_app/llm/main.py,sha256=UK33yI_0zDCdM5zKe9h7c_qzM41PIANvRFCxjGlAzlI,5140
+ws_bom_robot_app/llm/main.py,sha256=je8-Q-WtzQMtwEGzsUqHpLjVtMq8IObLi8VFIa6tbeo,5204
 ws_bom_robot_app/llm/nebuly_handler.py,sha256=w895twhPgtRUH_jZz1pbX4W2leq8A3O_9gUwp_ridoY,8033
 ws_bom_robot_app/llm/settings.py,sha256=DCLaGZwxlw0xE46LpfUgin_FHD8_XJIthCgI6r2UDlM,121
 ws_bom_robot_app/llm/feedbacks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ws_bom_robot_app/llm/feedbacks/feedback_manager.py,sha256=bnP0FEJTyrzT0YzqCVE73EC07Eu_4FLxVu3Cy-5Si0o,3211
+ws_bom_robot_app/llm/feedbacks/feedback_manager.py,sha256=vNcZLG9IKhurAk7hjBqyFgQTjnh3Cd4GnxeYsX7ZdiA,2922
 ws_bom_robot_app/llm/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ws_bom_robot_app/llm/models/api.py,sha256=DPhL_207RRN4qwPlKxbLrARnsYVAkdMYYUV7MkbN7Rk,10751
+ws_bom_robot_app/llm/models/api.py,sha256=rsPH1y-hMkwXnvt5344yIDMY_StbbgB5AS3Gz37bOhs,11036
 ws_bom_robot_app/llm/models/base.py,sha256=1TqxuTK3rjJEALn7lvgoen_1ba3R2brAgGx6EDTtDZo,152
 ws_bom_robot_app/llm/models/feedback.py,sha256=pYNQGxNOBgeAAfdJLI95l7ePLBI5tVdsgnyjp5oMOQU,1722
 ws_bom_robot_app/llm/models/kb.py,sha256=oVSw6_dmNxikAHrPqcfxDXz9M0ezLIYuxpgvzfs_Now,9514
 ws_bom_robot_app/llm/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ws_bom_robot_app/llm/providers/llm_manager.py,sha256=zIkxgTLYQCcup2Ixf4eWap4mNinuJH2YmkjLjZGDyJM,8371
 ws_bom_robot_app/llm/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ws_bom_robot_app/llm/tools/tool_builder.py,sha256=p_Q32_-OSydcxzj69PgPIuiny816zYv5dVsCHSY0ELc,1188
-ws_bom_robot_app/llm/tools/tool_manager.py,sha256=I5HPQov-9ELSiNDhxMsm9-zOqZ77J_E5c6IDOXX_CFk,12935
+ws_bom_robot_app/llm/tools/tool_builder.py,sha256=vQ8BX3MFd3WX2WlYAibbC4PpzxevdrdqKGk0SpKPrPs,3265
+ws_bom_robot_app/llm/tools/tool_manager.py,sha256=I8CHAdXx5KO1aw1NkDEQjCls9a-E8K6JrCQ-rzfImWY,14390
 ws_bom_robot_app/llm/tools/utils.py,sha256=Ba7ScFZPVJ3ke8KLO8ik1wyR2f_zC99Bikqx0OGnKoI,1924
 ws_bom_robot_app/llm/tools/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ws_bom_robot_app/llm/tools/models/main.py,sha256=1hICqHs-KS2heenkH7b2eH0N2GrPaaNGBrn64cl_A40,827
 ws_bom_robot_app/llm/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ws_bom_robot_app/llm/utils/agent.py,sha256=ISF9faaD5tBi-8sbgQpgfqWT1JIVcgv_lRhyaNAkI2Q,1445
+ws_bom_robot_app/llm/utils/agent.py,sha256=uFuSfYMfGIE2WCKGNSKL-T2SDFn-tUKvbAYbGTPIw6g,1445
 ws_bom_robot_app/llm/utils/chunker.py,sha256=N7570xBYlObneg-fsvDhPAJ-Pv8C8OaYZOBK6q7LmMI,607
+ws_bom_robot_app/llm/utils/cms.py,sha256=KlHnJ66h_TX3vy_HQld3PvbXw1hI_wVoOJVPlI1Zi0E,3461
 ws_bom_robot_app/llm/utils/download.py,sha256=GaRypPgkx16HfYRj-upX9kvmjfAdFFb5TP4P97scWeA,3273
 ws_bom_robot_app/llm/utils/kb.py,sha256=jja45WCbNI7SGEgqDS99nErlwB5eY8Ga7BMnhdMHZ90,1279
 ws_bom_robot_app/llm/utils/print.py,sha256=HK3zhZOd4cEyXZ8QcudLtTIfqqtMOERce_yTofS8NXo,803
@@ -65,7 +66,7 @@ ws_bom_robot_app/llm/vector_store/loader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5
 ws_bom_robot_app/llm/vector_store/loader/base.py,sha256=L_ugekNuAq0N9O-24wtlHSNHkqSeD-KsJrfGt_FX9Oc,5340
 ws_bom_robot_app/llm/vector_store/loader/docling.py,sha256=yP0zgXLeFAlByaYuj-6cYariuknckrFds0dxdRcnVz8,3456
 ws_bom_robot_app/llm/vector_store/loader/json_loader.py,sha256=LDppW0ZATo4_1hh-KlsAM3TLawBvwBxva_a7k5Oz1sc,858
-ws_bom_robot_app-0.0.61.dist-info/METADATA,sha256=9Ph9kKWlaMASpyHCpha4k40H2clLDe2KbmUSq2D1uLw,8456
-ws_bom_robot_app-0.0.61.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ws_bom_robot_app-0.0.61.dist-info/top_level.txt,sha256=Yl0akyHVbynsBX_N7wx3H3ZTkcMLjYyLJs5zBMDAKcM,17
-ws_bom_robot_app-0.0.61.dist-info/RECORD,,
+ws_bom_robot_app-0.0.63.dist-info/METADATA,sha256=X2pbeuERrYrwt-8VhjEK19qE027RIRkSu3L5zbeQsaY,8459
+ws_bom_robot_app-0.0.63.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ws_bom_robot_app-0.0.63.dist-info/top_level.txt,sha256=Yl0akyHVbynsBX_N7wx3H3ZTkcMLjYyLJs5zBMDAKcM,17
+ws_bom_robot_app-0.0.63.dist-info/RECORD,,