ws-bom-robot-app 0.0.6__py3-none-any.whl → 0.0.8__py3-none-any.whl

ws_bom_robot_app/cron_manager.py

@@ -1,15 +1,21 @@
-import os
-import threading
-import schedule, time
+from math import floor
+import schedule, time, threading
 import asyncio
 from fastapi import APIRouter
 from ws_bom_robot_app.task_manager import task_manager
 from ws_bom_robot_app.llm.utils.kb import kb_cleanup_data_file
 from ws_bom_robot_app.util import _log
+import random
 
 class RecurringJob():
+    @staticmethod
+    def __add_jitter(interval: int) -> int:
+      #delay proportional with interval, min 10, max 100 sec
+      jitter: int = max(10, min(100, floor(interval * 0.075)))
+      return interval + random.randint(-jitter, jitter)
     def __init__(self, interval: int, job_func, tags: list[str]):
-        self.interval = interval
+        #add a little jitter by default for better concurrency in case of multiple instances
+        self.interval = RecurringJob.__add_jitter(interval)
         self.job_func = job_func
         self.is_coroutine = asyncio.iscoroutinefunction(job_func)
         self.job_func = job_func
@@ -25,8 +31,8 @@ class RecurringJob():
 class CronManager:
 
     _list: dict[str, RecurringJob] = {
-        'cleanup-task': RecurringJob(5*60, task_manager.cleanup_task, tags=["cleanup","cleanup-task"]),
-        'cleanup-data': RecurringJob(180*60, kb_cleanup_data_file, tags=["cleanup","cleanup-data"]),
+      'cleanup-task': RecurringJob(5*60, task_manager.cleanup_task, tags=["cleanup","cleanup-task"]),
+      'cleanup-data': RecurringJob(180*60, kb_cleanup_data_file, tags=["cleanup","cleanup-data"]),
     }
 
     def __init__(self):

ws_bom_robot_app/llm/agent_description.py

@@ -7,6 +7,7 @@ from langchain_core.messages import AIMessage
 from langchain_core.runnables import RunnableSerializable
 from langchain_core.runnables import RunnableLambda
 from bs4 import BeautifulSoup
+from ws_bom_robot_app.llm.models.api import LlmRules
 from ws_bom_robot_app.llm.utils.agent_utils import get_rules
 
 # SafeDict helper class
@@ -85,19 +86,19 @@ class AgentDescriptor:
     def get_strategy(name: str) -> AgentDescriptorStrategy:
         return AgentDescriptor._list.get(name.lower(), DefaultAgentDescriptor())
 
-    def __init__(self, api_key: str, prompt: str, mode: str, rules_folder: str = ""):
+    def __init__(self, api_key: str, prompt: str, mode: str, rules: LlmRules = None):
         self.__prompt = prompt
         self.__llm = ChatOpenAI(model="gpt-4o", temperature=0, api_key=api_key)  # type: ignore
         self.api_key = api_key
-        self.rules_folder = rules_folder
+        self.rules= rules
         self.strategy = self.get_strategy(mode)  # Selects the strategy from the dictionary
 
     async def __create_prompt(self, input_dict: dict):
         input_data = json.loads(input_dict.get("input", {}))
         system = self.strategy.enrich_prompt(self.__prompt, input_data)
-        if self.rules_folder:
+        if self.rules:
             rule_input = self.strategy.rule_input(input_data)
-            rules_prompt = await get_rules(self.rules_folder,self.api_key, rule_input)
+            rules_prompt = await get_rules(self.rules,self.api_key, rule_input)
             system += rules_prompt
         return ChatPromptTemplate.from_messages(
             [

ws_bom_robot_app/llm/agent_lcel.py

@@ -9,20 +9,20 @@ from langchain.agents.output_parsers.openai_tools import OpenAIToolsAgentOutputP
 from langchain_core.runnables import RunnableLambda
 from datetime import datetime
 from langchain_openai import OpenAIEmbeddings
-from ws_bom_robot_app.llm.models.api import LlmMessage, LlmAppTool
+from ws_bom_robot_app.llm.models.api import LlmMessage, LlmRules
 from ws_bom_robot_app.llm.utils.agent_utils import get_rules
 from ws_bom_robot_app.llm.defaut_prompt import default_prompt
 
 class AgentLcel:
 
-    def __init__(self, openai_config: dict, sys_message: str, tools: list, rules_folder: str = ""):
+    def __init__(self, openai_config: dict, sys_message: str, tools: list, rules: LlmRules = None):
         self.__apy_key = openai_config["api_key"]
         self.sys_message = sys_message.format(
             date_stamp=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
             lang="it",
         )
         self.__tools = tools
-        self.rulesPath = rules_folder
+        self.rules = rules
         self.embeddings = OpenAIEmbeddings(api_key= self.__apy_key) # type: ignore
         self.memory_key = "chat_history"
         self.__llm = ChatOpenAI(
@@ -37,7 +37,7 @@ class AgentLcel:
     async def __create_prompt(self, input):
         message : LlmMessage = input["input"]
         input = message.content
-        rules_prompt = await get_rules(self.rulesPath,self.__apy_key, input)
+        rules_prompt = await get_rules(self.rules,self.__apy_key, input) if self.rules else ""
         system = default_prompt + self.sys_message + rules_prompt
         return ChatPromptTemplate.from_messages(
             [

ws_bom_robot_app/llm/api.py

@@ -1,13 +1,15 @@
 import openai
-from fastapi import APIRouter, HTTPException
+from typing import Annotated
+from fastapi import APIRouter, HTTPException, Header
 from fastapi.responses import StreamingResponse
 from ws_bom_robot_app.llm.agent_description import AgentDescriptor
 from ws_bom_robot_app.llm.models.api import InvokeRequest, StreamRequest, RulesRequest, KbRequest, VectorDbResponse
 from ws_bom_robot_app.llm.main import invoke, stream, stream_none
+from ws_bom_robot_app.llm.models.base import IdentifiableEntity
 from ws_bom_robot_app.llm.vector_store.generator import kb, rules, kb_stream_file
 from ws_bom_robot_app.llm.tools.tool_manager import ToolManager
 from ws_bom_robot_app.llm.vector_store.integration.manager import IntegrationManager
-from ws_bom_robot_app.task_manager import task_manager
+from ws_bom_robot_app.task_manager import task_manager, TaskHeader
 
 router = APIRouter(prefix="/api/llm", tags=["llm"])
 
@@ -40,12 +42,16 @@ async def _kb(rq: KbRequest) -> VectorDbResponse:
     return await kb(rq)
 
 @router.post("/kb/task")
-async def _create_kb_task(rq: KbRequest):
-    return {"task_id": task_manager.create_task(kb(rq))}
+async def _kb_task(rq: KbRequest, headers: Annotated[TaskHeader, Header()]) -> IdentifiableEntity:
+    return task_manager.create_task(kb(rq),headers)
 
 @router.post("/rules")
-def _rules(rq: RulesRequest) -> VectorDbResponse:
-    return rules(rq)
+async def _rules(rq: RulesRequest) -> VectorDbResponse:
+    return await rules(rq)
+
+@router.post("/rules/task")
+async def _rules_task(rq: RulesRequest, headers: Annotated[TaskHeader, Header()]) -> IdentifiableEntity:
+    return task_manager.create_task(rules(rq),headers)
 
 @router.get("/kb/file/{filename}")
 async def _kb_get_file(filename: str) -> StreamingResponse:

ws_bom_robot_app/llm/main.py

@@ -17,7 +17,7 @@ async def invoke(rq: InvokeRequest) -> str:
   processor = AgentDescriptor(api_key=rq.secrets["openAIApiKey"],
       prompt=rq.system_message,
       mode = rq.mode,
-      rules_folder=rq.rules_vector_db if rq.rules_vector_db else ""
+      rules=rq.rules if rq.rules else None
   )
   result: AIMessage = await processor.run_agent(_msg)
   return {"result": result.content}
@@ -49,7 +49,7 @@ async def __stream(rq: StreamRequest,formatted: bool = True) -> None:
       openai_config={"api_key": rq.secrets["openAIApiKey"], "openai_model": rq.model, "temperature": rq.temperature},
       sys_message=rq.system_message,
       tools=get_structured_tools(tools=rq.app_tools, api_key=rq.secrets["openAIApiKey"], callbacks=[callbacks[0]]),
-      rules_folder=rq.rules_vector_db if rq.rules_vector_db else ""
+      rules=rq.rules
   )
 
   if "NEBULY_API_KEY" in os.environ:

ws_bom_robot_app/llm/models/api.py

@@ -15,6 +15,10 @@ class LlmSearchSettings(BaseModel):
   score_threshold_id: Optional[float] = Field(None, validation_alias=AliasChoices("scoreThresholdId","score_threshold_id"))
   search_k: Optional[int] = Field(None, validation_alias=AliasChoices("searchK","search_k"))
 
+class LlmRules(BaseModel):
+  vector_db: Optional[str] = Field(None, validation_alias=AliasChoices("rulesVectorDb","vector_db"))
+  threshold: Optional[float] = 0.7
+
 class LlmAppToolChainSettings(BaseModel):
   prompt: Optional[str] = None
   model: Optional[str] = None
@@ -41,7 +45,6 @@ class LlmAppTool(BaseModel):
   endpoints: Optional[List[LlmKbEndpoint]] = Field(None, validation_alias=AliasChoices("externalEndpoints","endpoints"))
   waiting_message: Optional[str] = Field("", validation_alias=AliasChoices("waitingMessage","waiting_message"))
   vector_db: Optional[str] = Field(None, validation_alias=AliasChoices("vectorDbFile","vector_db"))
-  rules_vector_db: Optional[str] = Field(None, validation_alias=AliasChoices("rulesVectorDb","rules_vector_db"))
   is_active: Optional[bool] = Field(True, validation_alias=AliasChoices("isActive","is_active"))
   model_config = ConfigDict(
       extra='allow'
@@ -58,7 +61,7 @@ class LlmApp(BaseModel):
   secrets: Dict[str, str]
   app_tools: Optional[List[LlmAppTool]] = Field([], validation_alias=AliasChoices("appTools","app_tools"))
   vector_db: Optional[str] = Field(None, validation_alias=AliasChoices("vectorDb","vector_db"))
-  rules_vector_db: Optional[str] = Field(None, validation_alias=AliasChoices("rulesVectorDb","rules_vector_db"))
+  rules: Optional[LlmRules] = None
   fine_tuned_model: Optional[str] = Field(None, validation_alias=AliasChoices("fineTunedModel","fine_tuned_model"))
   lang_chain_tracing: Optional[bool] = Field(False, validation_alias=AliasChoices("langChainTracing","lang_chain_tracing"))
   lang_chain_project: Optional[str] = Field(None, validation_alias=AliasChoices("langChainProject","lang_chain_project"))
@@ -68,10 +71,12 @@ class LlmApp(BaseModel):
   def __vector_db_folder(self) -> str:
     return os.path.join(config.robot_data_folder,config.robot_data_db_folder,config.robot_data_db_folder_store)
   def __vector_dbs(self):
-      return   list(set(
-    [os.path.basename(db) for db in [self.vector_db, self.rules_vector_db] +
-    [db for tool in (self.app_tools or []) for db in [tool.vector_db,tool.rules_vector_db]]
-    if db is not None]))
+      return list(set(
+          os.path.basename(db) for db in [self.vector_db] +
+          ([self.rules.vector_db] if self.rules and self.rules.vector_db else []) +
+          [db for tool in (self.app_tools or []) for db in [tool.vector_db]]
+          if db is not None
+      ))
   def __decompress_zip(self,zip_file_path, extract_to):
     shutil.unpack_archive(zip_file_path, extract_to, "zip")
     os.remove(zip_file_path)
@@ -96,7 +101,8 @@ class LlmApp(BaseModel):
   def __normalize_vector_db_path(self) -> None:
     _vector_db_folder = self.__vector_db_folder()
     self.vector_db = os.path.join(_vector_db_folder, os.path.splitext(os.path.basename(self.vector_db))[0]) if self.vector_db else None
-    self.rules_vector_db = os.path.join(_vector_db_folder, os.path.splitext(os.path.basename(self.rules_vector_db))[0]) if self.rules_vector_db else None
+    if self.rules:
+      self.rules.vector_db = os.path.join(_vector_db_folder, os.path.splitext(os.path.basename(self.rules.vector_db))[0]) if self.rules.vector_db else ""
     for tool in self.app_tools or []:
       tool.vector_db = os.path.join(_vector_db_folder, os.path.splitext(os.path.basename(tool.vector_db))[0]) if tool.vector_db else None
   async def initialize(self) -> None:

ws_bom_robot_app/llm/models/base.py

@@ -0,0 +1,6 @@
+from typing import Union
+from uuid import UUID
+from pydantic import BaseModel
+
+class IdentifiableEntity(BaseModel):
+    id: Union[str, int, UUID]

ws_bom_robot_app/llm/utils/agent_utils.py

@@ -1,13 +1,14 @@
 import os
+from ws_bom_robot_app.llm.models.api import LlmRules
 from ws_bom_robot_app.llm.utils.print import HiddenPrints
 from ws_bom_robot_app.llm.utils.faiss_helper import FaissHelper
 
-async def get_rules(rules_folder: str, api_key:str, input: str) -> str:
+async def get_rules(rules: LlmRules, api_key:str, input: str) -> str:
   with HiddenPrints():
-    if input=="" or rules_folder == "" or not os.path.exists(rules_folder):
+    if any([input=="",rules is None,rules.vector_db == "",not os.path.exists(rules.vector_db)]):
       return ""
     rules_prompt = ""
-    rules_doc = await FaissHelper.invoke(rules_folder,api_key,input,search_type="similarity_score_threshold", search_kwargs={"score_threshold": 0.7}) #type: ignore
+    rules_doc = await FaissHelper.invoke(rules.vector_db,api_key,input,search_type="similarity_score_threshold", search_kwargs={"score_threshold": rules.threshold}) #type: ignore
     if len(rules_doc) > 0:
       rules_prompt = "\nFollow this rules: \n RULES: \n"
       for rule_doc in rules_doc:

ws_bom_robot_app/llm/utils/webhooks.py

@@ -0,0 +1,53 @@
+import asyncio
+import base64
+from datetime import datetime, timezone
+from math import floor
+import httpx
+import logging
+from standardwebhooks import Webhook
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
+from typing import Optional
+from ws_bom_robot_app.config import config
+from ws_bom_robot_app.llm.models.base import IdentifiableEntity
+
+class WebhookNotifier:
+    MAX_RETRIES = 10
+    BASE_DELAY = 5  # seconds
+    MAX_DELAY = 120  # maximum delay between retries
+
+    @retry(
+        stop=stop_after_attempt(MAX_RETRIES),
+        wait=wait_exponential(multiplier=BASE_DELAY, max=MAX_DELAY),
+        retry=retry_if_exception_type((httpx.HTTPError, asyncio.TimeoutError)),
+        after=lambda retry_state: logging.warning(
+            f"Webhook notification attempt {retry_state.attempt_number} failed "
+            f"for endpoint {retry_state.args[1]}"
+        )
+    )
+    async def notify_webhook(
+        self,
+        data: IdentifiableEntity,
+        endpoint: str,
+        timeout: Optional[float] = 30.0
+    ) -> None:
+        """
+        Notify a signed webhook. App credentials are used to sign the webhook.
+        Args:
+            task: The task result to send
+            endpoint: Webhook URL to notify
+            timeout: Request timeout in seconds
+        Raises:
+            Exception: If all retry attempts fail
+        """
+        wh = Webhook(base64.b64encode((config.robot_user + ':' + config.robot_password).encode('utf-8')).decode('utf-8'))
+        _data = data.model_dump_json()
+        _datetime = datetime.now(tz=timezone.utc)
+        _signature = wh.sign(data.id,_datetime,_data)
+        _headers = {
+            'webhook-id': data.id,
+            'webhook-timestamp': str(floor(_datetime.replace(tzinfo=timezone.utc).timestamp())),
+            'webhook-signature': _signature
+            }
+        async with httpx.AsyncClient(headers=_headers,verify=False,timeout=timeout) as client:
+          response = await client.post(endpoint, data=_data)
+          response.raise_for_status()

ws_bom_robot_app/llm/vector_store/generator.py

@@ -2,9 +2,7 @@ import os, shutil, traceback
 import asyncio
 from fastapi import HTTPException
 from fastapi.responses import StreamingResponse
-from langchain_openai import OpenAIEmbeddings
 from langchain_core.documents import Document
-from ws_bom_robot_app.llm import api
 from ws_bom_robot_app.llm.vector_store.loader.base import Loader
 from ws_bom_robot_app.llm.models.api import RulesRequest, KbRequest, VectorDbResponse
 from ws_bom_robot_app.llm.vector_store.integration.manager import IntegrationManager

ws_bom_robot_app/main.py

@@ -33,6 +33,7 @@ async def openapi(authenticate: bool = Depends(authenticate)):
 
 @app.get("/diag",tags=["diag"])
 def diag(authenticate: bool = Depends(authenticate)):
+    import pkg_resources
     from ws_bom_robot_app.llm.vector_store.loader.base import Loader as wsll
     from ws_bom_robot_app.llm.vector_store.integration.manager import IntegrationManager as wsim
     from ws_bom_robot_app.llm.tools.tool_manager import ToolManager as wstm
@@ -58,6 +59,7 @@ def diag(authenticate: bool = Depends(authenticate)):
             "os": {
                 "pid": os.getpid(),
                 "cwd": os.getcwd(),
+                "ws_bom_robot_app": pkg_resources.get_distribution("ws_bom_robot_app").version,
                 "env": os.environ,
             },
         },

ws_bom_robot_app/task_manager.py

@@ -1,14 +1,24 @@
+import inspect
 import asyncio, os
 from datetime import datetime, timedelta
 from enum import Enum
-from typing import TypeVar, Optional, Dict, Union
-from pydantic import BaseModel, ConfigDict, computed_field
+from typing import Annotated, TypeVar, Optional, Dict, Union, Any
+from pydantic import BaseModel, ConfigDict, Field, computed_field
 from uuid import uuid4
 from fastapi import APIRouter, HTTPException
 from ws_bom_robot_app.config import config
+from ws_bom_robot_app.llm.models.base import IdentifiableEntity
+from ws_bom_robot_app.llm.utils.webhooks import WebhookNotifier
 
 T = TypeVar('T')
 
+class TaskHeader(BaseModel):
+    x_ws_bom_msg_type: Optional[str] = None
+    x_ws_bom_webhooks: Optional[str] = None
+    model_config = ConfigDict(
+        extra='allow'
+    )
+
 class TaskMetaData(BaseModel):
     start_time: datetime
     end_time: Optional[datetime] = None
@@ -25,38 +35,52 @@ class TaskMetaData(BaseModel):
         }
     )
 
-class TaskStatus(BaseModel):
+class TaskStatus(IdentifiableEntity):
     class TaskStatusEnum(str, Enum):
         pending = "pending"
         completed = "completed"
         failure = "failure"
-    task_id: str
+    type: Optional[str] = None
     status: TaskStatusEnum
-    #result: Optional[Dict[str, Any]] = None
     result: Optional[T] = None
     metadata: TaskMetaData = None
     error: Optional[str] = None
 
-class TaskEntry(BaseModel):
-    id: str
-    task: Union[asyncio.Task, None] = None
-    status: TaskStatus = None
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self.status = TaskStatus(
-            task_id=self.id,
-            status=TaskStatus.TaskStatusEnum.pending,
-            metadata=TaskMetaData(start_time=datetime.now(), source=str(self.task), pid=os.getpid())
-            )
+class TaskEntry(IdentifiableEntity):
+    task: Annotated[asyncio.Task, Field(default=None, validate_default=False)] = None
+    headers: TaskHeader | None = None
+    status: Union[TaskStatus, None] = None
+    def _get_coroutine_name(self, coroutine: asyncio.coroutines) -> str:
+        if inspect.iscoroutine(coroutine):
+            return coroutine.cr_code.co_name
+        return "<unknown>"
+    def __init__(self, **data):
+        #separate task from data to handle asyncio.Task
+        task = data.pop('task',None)
+        super().__init__(**data)
+        #bypass pydantic validation
+        object.__setattr__(self, 'task', task)
+        #init status
+        if not self.status:
+          self.status = TaskStatus(
+              id=self.id,
+              type=self.headers.x_ws_bom_msg_type if self.headers and self.headers.x_ws_bom_msg_type else self._get_coroutine_name(task._coro) if task else None,
+              status=TaskStatus.TaskStatusEnum.pending,
+              metadata=TaskMetaData(
+                 start_time=datetime.now(),
+                 source=self._get_coroutine_name(task._coro) if task else None,
+                 pid=os.getpid())
+              )
     model_config = ConfigDict(
-        arbitrary_types_allowed=True
+        arbitrary_types_allowed=True,
+        validate_assignment=True
     )
 
 class TaskManager:
     def __init__(self):
         self.tasks: Dict[str, TaskEntry] = {}
 
-    def _task_done_callback(self, task_id: str):
+    def _task_done_callback(self, task_id: str, headers: TaskHeader | None = None):
         def callback(task: asyncio.Task):
             if _task := self.tasks.get(task_id):
               try:
@@ -68,14 +92,21 @@ class TaskManager:
                   _task.status.error = str(e)
               finally:
                   _task.status.metadata.end_time = datetime.now()
+                  if headers and headers.x_ws_bom_webhooks:
+                        asyncio.create_task(
+                            WebhookNotifier().notify_webhook(_task.status,headers.x_ws_bom_webhooks)
+                            )
         return callback
 
-    def create_task(self, coroutine: asyncio.coroutines) -> str:
+    def create_task(self, coroutine: asyncio.coroutines, headers: TaskHeader | None = None) -> IdentifiableEntity:
         _task = asyncio.create_task(coroutine)
-        task = TaskEntry(id=str(uuid4()),task=_task)
-        task.task.add_done_callback(self._task_done_callback(task.id))
+        task = TaskEntry(
+            id=str(uuid4()),
+            task=_task,
+            headers=headers)
+        task.task.add_done_callback(self._task_done_callback(task.id, headers))
         self.tasks[task.id] = task
-        return task.id
+        return IdentifiableEntity(id=task.id)
 
     def get_task(self, task_id: str) -> TaskEntry | None:
         if _task := self.tasks.get(task_id):

{ws_bom_robot_app-0.0.6.dist-info → ws_bom_robot_app-0.0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ws_bom_robot_app
-Version: 0.0.6
+Version: 0.0.8
 Summary: A FastAPI application serving ws bom/robot/llm platform ai.
 Home-page: https://github.com/websolutespa/bom
 Author: Websolute Spa
@@ -10,6 +10,8 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
+Requires-Dist: standardwebhooks
+Requires-Dist: schedule
 Requires-Dist: aiofiles
 Requires-Dist: pydantic==2.9.2
 Requires-Dist: pydantic-settings==2.6.0

{ws_bom_robot_app-0.0.6.dist-info → ws_bom_robot_app-0.0.8.dist-info}/RECORD

@@ -1,20 +1,21 @@
 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=VUoE6MBpYnZ8FQvUjWOLCzfs35aUvpwrz4ROFVbO3AA,1831
-ws_bom_robot_app/cron_manager.py,sha256=p0l0ybwfNhPn-R0kr3sq4rmR9VW3XDrsOu1BgvapYKc,3163
-ws_bom_robot_app/main.py,sha256=OZ0s2L2fKEwH46Vnt5KGEbuq-udEJH4WsinR2Ws8B4E,3433
-ws_bom_robot_app/task_manager.py,sha256=O6ZiQto0SxqZWja8bVc-Sok5roT_ja-uOISDYs0oBGE,4284
+ws_bom_robot_app/cron_manager.py,sha256=Gd76VwhvlauZ5jCrZa4gyM1NoQdynzskfRYPw6niFyk,3548
+ws_bom_robot_app/main.py,sha256=UPRqJkdhFBS8vmJYFJb4hgpx4pMFwOCrbJwt5MTQymE,3556
+ws_bom_robot_app/task_manager.py,sha256=aiQV5EJ_Q0B0mTcERVbzgaEepEUf4OtljC_UACs6pr8,5837
 ws_bom_robot_app/util.py,sha256=3aBK-bhsvKJwJeWOHh0c1B1BOyJ_tnUxOa1mJmFKwYQ,2618
 ws_bom_robot_app/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ws_bom_robot_app/llm/agent_description.py,sha256=9gK7MfsPvk7YTvk-bbLU_r4ygoEUUrepKxuj9zLxsgI,4681
+ws_bom_robot_app/llm/agent_description.py,sha256=SDJYMmwfdMxEK3a_HDEQ19bfNKmwMSFf5hqU0VSCCIE,4705
 ws_bom_robot_app/llm/agent_handler.py,sha256=hbOf9i-ynDL3bcClqtUG-yWY8ohbCxONfT5ek9Cv0gY,5667
-ws_bom_robot_app/llm/agent_lcel.py,sha256=FzRt_u-zC78-DLS9cigO2oA6bsX6SOERuAFbevSXpT8,2701
-ws_bom_robot_app/llm/api.py,sha256=A1IFiiBLHdCJsFDllWTAdQEgkRm5a0BjU-oKozxlhiw,2880
+ws_bom_robot_app/llm/agent_lcel.py,sha256=mOh9jfqAuN8XGNqreAXt4xw_PMydqlglIcXfkw3ppBk,2706
+ws_bom_robot_app/llm/api.py,sha256=5cO49yhU5EXvl20zJORmrZZPc1G_nlvftdcF7cyn4Qc,3252
 ws_bom_robot_app/llm/defaut_prompt.py,sha256=pn5a4lNLWE1NngHYjA_7tD8GasePMgsgude5fIJxsW0,756
-ws_bom_robot_app/llm/main.py,sha256=Q3A_Vgz09fhj78_PNVpDL9VQCYQd2lW_hmfyEKa_17Q,3667
+ws_bom_robot_app/llm/main.py,sha256=HWTaAmxZpVo9HEc2cfv9DqA3tlaVGl1NdBONgEI16ds,3595
 ws_bom_robot_app/llm/settings.py,sha256=EkFGCppORenStH9W4e6_dYvQ-5p6xiEMpmUHBqNqG9M,117
 ws_bom_robot_app/llm/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ws_bom_robot_app/llm/models/api.py,sha256=Bi9YwNBJExoZzPVCerAoweWCY9zGAF9rn_N_aBNKmrU,6922
+ws_bom_robot_app/llm/models/api.py,sha256=IGeHJhyMaZ5iqOPNj6Bko2jp6R9yALMfpyeOzwW_NGk,6982
+ws_bom_robot_app/llm/models/base.py,sha256=1TqxuTK3rjJEALn7lvgoen_1ba3R2brAgGx6EDTtDZo,152
 ws_bom_robot_app/llm/models/kb.py,sha256=EqC9M_nQzDKX9ttL5QG2d04aH19sh-svJdw1MinvGfk,8925
 ws_bom_robot_app/llm/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ws_bom_robot_app/llm/tools/tool_builder.py,sha256=rkYu0PrXV84PMi7INjCSWlrWMykUCI8aeF-QjZgLysM,854
@@ -23,13 +24,14 @@ ws_bom_robot_app/llm/tools/utils.py,sha256=Cx_6L1IpJCEQ9j0zd1Z3iou5li9mnuZbVilOY
 ws_bom_robot_app/llm/tools/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ws_bom_robot_app/llm/tools/models/main.py,sha256=LsOJ7vkcSzYLoE1oa3TG0Rs0pr9J5VS_e4li6aDx_fw,260
 ws_bom_robot_app/llm/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ws_bom_robot_app/llm/utils/agent_utils.py,sha256=vdX_1Kxn6RcBljOSBlee1avi_0TyIk-rm0RGGeLt468,707
+ws_bom_robot_app/llm/utils/agent_utils.py,sha256=OdrFcu2WAUFfsxj7moEehaYrUp-PX82KGIHgaWetXQ4,794
 ws_bom_robot_app/llm/utils/download.py,sha256=iAUxH_NiCpTPtGzhC4hBtxotd2HPFt2MBhttslIxqiI,3194
 ws_bom_robot_app/llm/utils/faiss_helper.py,sha256=DowmroVT6eIbvnA-TG84PS_D7ujvxSRIKdLuIcJmd6Q,4650
 ws_bom_robot_app/llm/utils/kb.py,sha256=jja45WCbNI7SGEgqDS99nErlwB5eY8Ga7BMnhdMHZ90,1279
 ws_bom_robot_app/llm/utils/print.py,sha256=bpLWY0KHXe7x7PWcWy8NS54ZWzHY8b4jrLRkpnDl108,818
+ws_bom_robot_app/llm/utils/webhooks.py,sha256=Sdwu4dkbUC3JEf9ck1hsu4gSGQdj7gcsIrhs3cOVXxk,2112
 ws_bom_robot_app/llm/vector_store/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ws_bom_robot_app/llm/vector_store/generator.py,sha256=_39HONBDSnIVOECoxyVHStg2XX4-m9Enm4pECm7wRBI,5816
+ws_bom_robot_app/llm/vector_store/generator.py,sha256=HRVqUNoNvSmiktdeBbKzGwqDm3UYXz_yfDdk_piq8_4,5733
 ws_bom_robot_app/llm/vector_store/integration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ws_bom_robot_app/llm/vector_store/integration/base.py,sha256=eCKD3U0KPoVDMtKr2iZqauMFEKd9b2k6rqPG_YjDy0g,626
 ws_bom_robot_app/llm/vector_store/integration/manager.py,sha256=cSFlE2erMv3Uchy788mlCFdcvmyeoqdeIiGmJ9QbLhY,583
@@ -37,7 +39,7 @@ ws_bom_robot_app/llm/vector_store/integration/sitemap.py,sha256=bdrgHBVB8Jt3xiRu
 ws_bom_robot_app/llm/vector_store/loader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ws_bom_robot_app/llm/vector_store/loader/base.py,sha256=YKtJWTVQuOvRR2CLYTa0bGEbjqgmYVVud1YKQ9QLibc,4536
 ws_bom_robot_app/llm/vector_store/loader/json_loader.py,sha256=G9BoxwsevgqL72h2n28O2LpzaCYNymBkX66wru9GkCw,884
-ws_bom_robot_app-0.0.6.dist-info/METADATA,sha256=yqHVLq9hxD1bLRF76x0wXmknbh2HK6lPTFTOxvJUOOU,5583
-ws_bom_robot_app-0.0.6.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-ws_bom_robot_app-0.0.6.dist-info/top_level.txt,sha256=Yl0akyHVbynsBX_N7wx3H3ZTkcMLjYyLJs5zBMDAKcM,17
-ws_bom_robot_app-0.0.6.dist-info/RECORD,,
+ws_bom_robot_app-0.0.8.dist-info/METADATA,sha256=qdJuZ_aTS1xhXtkFxEGWQocb5a5swxhglUR3tdw-UZE,5641
+ws_bom_robot_app-0.0.8.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+ws_bom_robot_app-0.0.8.dist-info/top_level.txt,sha256=Yl0akyHVbynsBX_N7wx3H3ZTkcMLjYyLJs5zBMDAKcM,17
+ws_bom_robot_app-0.0.8.dist-info/RECORD,,