ws-bom-robot-app 0.0.42__py3-none-any.whl → 0.0.44__py3-none-any.whl

ws_bom_robot_app/config.py

@@ -21,6 +21,7 @@ class Settings(BaseSettings):
     robot_cms_db_folder: str = 'llmVectorDb'
     robot_cms_kb_folder: str ='llmKbFile'
     ANTHROPIC_API_KEY: str = ''
+    DEEPSEEK_API_KEY: str = ''
     OPENAI_API_KEY: str = '' # used also for saas dall-e api
     OLLAMA_API_URL: str = 'http://localhost:11434'
     GROQ_API_KEY: str = ''
@@ -36,6 +37,7 @@ class Settings(BaseSettings):
         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
+        os.environ["DEEPSEEK_API_KEY"] = self.DEEPSEEK_API_KEY
         os.environ["GROQ_API_KEY"] = self.GROQ_API_KEY
         os.environ["GOOGLE_API_KEY"] = self.GOOGLE_API_KEY
         os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = self.GOOGLE_APPLICATION_CREDENTIALS

ws_bom_robot_app/llm/agent_handler.py

@@ -2,14 +2,14 @@ from asyncio import Queue
 from langchain_core.agents import AgentFinish
 from langchain_core.outputs import ChatGenerationChunk, GenerationChunk
 from langchain.callbacks.base import AsyncCallbackHandler
-from ws_bom_robot_app.llm.utils.print import printJson, printString
+from ws_bom_robot_app.llm.utils.print import print_json, print_string
 from typing import Any, Dict, List, Optional, Union
 from uuid import UUID
 import ws_bom_robot_app.llm.settings as settings
 from langchain_core.callbacks.base import AsyncCallbackHandler
 from langchain_core.outputs import ChatGenerationChunk, GenerationChunk
 from langchain_core.messages import BaseMessage, HumanMessage, AIMessage
-import json
+import json, logging, re
 
 # Here is a custom handler that will print the tokens to stdout.
 # Instead of printing to stdout you can send the data elsewhere; e.g., to a streaming API response
@@ -31,34 +31,25 @@ class AgentHandler(AsyncCallbackHandler):
     def __init__(self, queue: Queue, llm:str, threadId: str = None) -> None:
         super().__init__()
         self._threadId = threadId
-        self.json_block = ""
-        self.is_json_block = False
-        self.backtick_count = 0  # Conteggio dei backticks per il controllo accurato
         self.queue = queue
         self.llm = llm
-
-    async def on_llm_start(
-        self,
-        serialized: Dict[str, Any],
-        prompts: List[str],
-        *,
-        run_id: UUID,
-        parent_run_id: UUID = None,
-        tags: List[str] = None,
-        metadata: Dict[str, Any] = None,
-        **kwargs: Any,
-    ) -> None:
-        firstChunk = {
-            "type": "info",
-            "threadId": self._threadId,
-        }
-        await self.queue.put(printString(firstChunk))
-
-    """async def on_chat_model_start(self, serialized: Dict[str, Any], messages: List[List[BaseMessage]], *, run_id: UUID = None, parent_run_id = None, tags = None, metadata = None, **kwargs: Any) -> Any:
-        pass"""
-
-    async def on_tool_end(self, output: Any, *, run_id: UUID, parent_run_id: UUID = None, tags: List[str] = None, **kwargs: Any) -> None:
-      pass
+        self.__started: bool = False
+        # on new token event
+        self.stream_buffer = ""      # accumulates text that hasn't been processed yet
+        self.in_json_block = False
+        self.json_buffer = ""
+        self.json_start_regex = re.compile(r'(`{1,3}\s*json\b)') # detect a potential json start fence.
+        self.json_end_regex = re.compile(r'(`{1,3})')         # an end fence (one to three backticks).
+        self.stream_cut_last_output_chunk_size = 16  # safe cut last chunk size to output if no markers are found
+
+    async def on_chat_model_start(self, serialized, messages, *, run_id, parent_run_id = None, tags = None, metadata = None, **kwargs):
+        if not self.__started:
+          self.__started = True
+          firstChunk = {
+              "type": "info",
+              "threadId": self._threadId,
+          }
+          await self.queue.put(print_json(firstChunk))
 
     async def on_llm_new_token(
         self,
@@ -70,27 +61,54 @@ class AgentHandler(AsyncCallbackHandler):
         tags: Optional[List[str]] = None,
         **kwargs: Any,
     ) -> None:
-        """Gestisce i nuovi token durante lo streaming."""
-
         if token:
             token = _parse_token(self.llm,token)
             if token:
-              self.backtick_count += token.count("`")
-
-              if self.backtick_count >= 3:
-                  if not self.is_json_block:
-                      self.is_json_block = True
-                      self.json_block = ""
-                  else:
-                      self.is_json_block = False
-                      self.json_block += token.replace("```json", '')
-                      await self.process_json_block(self.json_block)
-                      self.json_block = ""
-                  self.backtick_count = 0
-              elif self.is_json_block:
-                  self.json_block += token
+              self.stream_buffer += token  # append new data to pending buffer
+              if not self.in_json_block:
+                # search for the start of a json block.
+                start_match = self.json_start_regex.search(self.stream_buffer)
+                if start_match:
+                    start_index = start_match.start()
+                    # everything before the start marker is normal content.
+                    if start_index > 0:
+                        _before = self.stream_buffer[:start_index].replace('`','').strip() # remove eventual preceding backticks.
+                        if _before:
+                            await self.queue.put(print_string(_before))
+                    # remove the start marker from pending.
+                    self.stream_buffer = self.stream_buffer[start_match.end():]
+                    # switch into json mode.
+                    self.in_json_block = True
+                    self.json_buffer = ""
+                else:
+                    # no json start marker found. It might be because the marker is split between chunks.
+                    # to avoid losing potential marker fragments, output what we can safely process:
+                    # if the pending text is long, we output most of it except the last few characters.
+                    if len(self.stream_buffer) > self.stream_cut_last_output_chunk_size:
+                        safe_cut = self.stream_buffer[:-3]
+                        await self.queue.put(print_string(safe_cut))
+                        self.stream_buffer = self.stream_buffer[-3:]
               else:
-                  await self.queue.put(printString(token))
+                  # in json block: look for an end fence.
+                  end_match = self.json_end_regex.search(self.stream_buffer)
+                  if end_match:
+                      end_index = end_match.start()
+                      self.json_buffer += self.stream_buffer[:end_index]
+                      try:
+                          data = json.loads(self.json_buffer.replace('`',''))
+                          await self.queue.put(print_json(data))
+                      except json.JSONDecodeError as e:
+                          logging.error(f"on_token: invalid json: {e} | {self.json_buffer}")
+                      finally:
+                          self.json_buffer = ""
+                      # remove the end fence from pending.
+                      self.stream_buffer = self.stream_buffer[end_match.end():].replace('`','').strip()
+                      self.in_json_block = False
+                  else:
+                      # no end marker found
+                      # accumulate everything and break to wait for more data.
+                      self.json_buffer += self.stream_buffer
+                      self.stream_buffer = ""
 
     async def on_agent_finish(
         self,
@@ -106,23 +124,21 @@ class AgentHandler(AsyncCallbackHandler):
                 AIMessage(content=_parse_token(self.llm,finish.return_values["output"])),
             ]
         )
+        # end-of-stream: flush any remaining text
+        if self.in_json_block:
+            try:
+                data = json.loads(self.json_buffer)
+                await self.queue.put(print_json(data))
+            except json.JSONDecodeError as e  :
+                logging.error(f"on_agent_finish: invalid json: {e} | {self.json_buffer}")
+                #await self.queue.put(print_string(self.json_buffer))
+        elif self.stream_buffer:
+            await self.queue.put(print_string(self.stream_buffer))
+
         finalChunk = {"type": "end"}
-        await self.queue.put(printJson(finalChunk))
+        await self.queue.put(print_json(finalChunk))
         await self.queue.put(None)
 
-    async def process_json_block(self, json_block: str):
-      """Processa il blocco JSON completo."""
-      # Rimuove il delimitatore iniziale '```json' se presente, e spazi vuoti
-      json_block_clean = json_block.replace('```', '').replace('json', '').strip()
-      # Verifica che il blocco non sia vuoto prima di tentare il parsing
-      if json_block_clean:
-          try:
-              # Prova a fare il parsing del JSON
-              parsed_json = json.loads(json_block_clean)
-              await self.queue.put(printJson(parsed_json))
-          except json.JSONDecodeError as e:
-              # Se il JSON è malformato, logga l'errore
-              raise e
 
 class RawAgentHandler(AsyncCallbackHandler):
 
@@ -130,24 +146,6 @@ class RawAgentHandler(AsyncCallbackHandler):
         super().__init__()
         self.queue = queue
         self.llm = llm
-    async def on_llm_start(
-        self,
-        serialized: Dict[str, Any],
-        prompts: List[str],
-        *,
-        run_id: UUID,
-        parent_run_id: UUID = None,
-        tags: List[str] = None,
-        metadata: Dict[str, Any] = None,
-        **kwargs: Any,
-    ) -> None:
-        pass
-
-    """async def on_chat_model_start(self, serialized: Dict[str, Any], messages: List[List[BaseMessage]], *, run_id: UUID = None, parent_run_id = None, tags = None, metadata = None, **kwargs: Any) -> Any:
-        pass"""
-
-    async def on_tool_end(self, output: Any, *, run_id: UUID, parent_run_id: UUID = None, tags: List[str] = None, **kwargs: Any) -> None:
-      pass
 
     async def on_llm_new_token(
         self,
@@ -160,7 +158,7 @@ class RawAgentHandler(AsyncCallbackHandler):
         **kwargs: Any,
     ) -> None:
         """Handles new tokens during streaming."""
-        if token:  # Only process non-empty tokens
+        if token:  # only process non-empty tokens
             await self.queue.put(_parse_token(self.llm,token))
 
     async def on_agent_finish(

ws_bom_robot_app/llm/agent_lcel.py

@@ -20,32 +20,26 @@ class AgentLcel:
         self.__tools = tools
         self.rules = rules
         self.embeddings = llm.get_embeddings()
-        self.memory_key = "chat_history"
+        self.memory_key: str = "chat_history"
         self.__llm_with_tools = llm.get_llm().bind_tools(self.__tools) if len(self.__tools) > 0 else llm.get_llm()
         self.executor = self.__create_agent()
 
     async def __create_prompt(self, input: dict) -> ChatPromptTemplate:
-        message : LlmMessage = input["input"]
+        message : LlmMessage = input[self.memory_key][-1]
         input = message.content
         rules_prompt = await get_rules(self.embeddings, self.rules, input) 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.from_messages(
-            [
-                (
-                    "system", system
-                ),
+        return ChatPromptTemplate([
+                ("system", system),
                 MessagesPlaceholder(variable_name=self.memory_key),
-                ("user", "{input}"),
                 MessagesPlaceholder(variable_name="agent_scratchpad"),
-            ]
-        )
+            ])
 
     def __create_agent(self) -> AgentExecutor:
       agent: Any = (
           {
-            "input": lambda x: x["input"],
             "agent_scratchpad": lambda x: self.__llm.get_formatter(x["intermediate_steps"]),
-            "chat_history": lambda x: x["chat_history"],
+             str(self.memory_key): lambda x: x[self.memory_key],
           }
           | RunnableLambda(self.__create_prompt)
           | self.__llm_with_tools

ws_bom_robot_app/llm/api.py

@@ -1,4 +1,4 @@
-from typing import Annotated, Any
+from typing import Annotated, Any, Mapping
 from fastapi import APIRouter, HTTPException, Request, Header
 from fastapi.responses import StreamingResponse
 from ws_bom_robot_app.llm.agent_description import AgentDescriptor
@@ -9,7 +9,7 @@ from ws_bom_robot_app.llm.vector_store.generator import kb, rules, kb_stream_fil
 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, TaskHeader
-
+from uuid import uuid4
 router = APIRouter(prefix="/api/llm", tags=["llm"])
 
 @router.get("/")
@@ -20,13 +20,15 @@ async def root():
 async def _invoke(rq: InvokeRequest):
     return await invoke(rq)
 
+def _stream_headers(rq: StreamRequest) -> Mapping[str, str]:
+    return {"X-thread-id": rq.thread_id or str(uuid4())}
 @router.post("/stream")
 async def _stream(rq: StreamRequest, ctx: Request) -> StreamingResponse:
-    return StreamingResponse(stream(rq, ctx), media_type="application/json")
+    return StreamingResponse(stream(rq, ctx), media_type="application/json", headers=_stream_headers(rq))
 
 @router.post("/stream/raw")
 async def _stream_raw(rq: StreamRequest, ctx: Request) -> StreamingResponse:
-    return StreamingResponse(stream(rq, ctx, formatted=False), media_type="application/json")
+    return StreamingResponse(stream(rq, ctx, formatted=False), media_type="application/json", headers=_stream_headers(rq))
 
 @router.post("/kb")
 async def _kb(rq: KbRequest) -> VectorDbResponse:

ws_bom_robot_app/llm/main.py

@@ -103,11 +103,9 @@ async def __stream(rq: StreamRequest, ctx: Request, queue: Queue,formatted: bool
         )
     callbacks.append(nebuly_callback)
 
-  #with warnings.catch_warnings():
-  #  warnings.simplefilter("ignore", UserWarning)
   try:
     await processor.executor.ainvoke(
-        {"input": rq.messages[-1], "chat_history": settings.chat_history},
+        {"chat_history": settings.chat_history},
         {"callbacks": callbacks},
     )
   except Exception as e:

ws_bom_robot_app/llm/providers/llm_manager.py

@@ -64,7 +64,7 @@ class DeepSeek(LlmInterface):
         return ChatOpenAI(
             api_key=self.config.api_key or os.getenv("DEEPSEEK_API_KEY"),
             model=self.config.model,
-            base_url="https://api.deepseek.com/v1",
+            base_url="https://api.deepseek.com",
             max_tokens=8192,
             temperature=self.config.temperature,
             streaming=True,
@@ -91,7 +91,7 @@ class Google(LlmInterface):
     from langchain_google_genai.embeddings import GoogleGenerativeAIEmbeddings
     return GoogleGenerativeAIEmbeddings(
       google_api_key=self.config.api_key,
-      model="models/text-embedding-004")
+      model="models/text-embedding-005")
 
   def get_models(self):
     import google.generativeai as genai
@@ -114,7 +114,7 @@ class Gvertex(LlmInterface):
         )
     def get_embeddings(self):
         from langchain_google_vertexai import VertexAIEmbeddings
-        return VertexAIEmbeddings(model_name="text-embedding-004")
+        return VertexAIEmbeddings(model_name="text-embedding-005")
     def get_models(self):
         #from google.cloud import aiplatform
         #aiplatform.init()
@@ -125,7 +125,7 @@ class Gvertex(LlmInterface):
         #see https://cloud.google.com/vertex-ai/generative-ai/docs/learn/locations#united-states for available models
         return [
               {"id":"gemini-2.0-flash-001"},
-              {"id":"gemini-1.5-pro-001"},
+              {"id":"gemini-2.0-flash-lite-001"},
               {"id":"gemini-1.5-pro-002"}
             ]
 

ws_bom_robot_app/llm/tools/utils.py

@@ -2,10 +2,10 @@ import random, os
 from langchain_openai import ChatOpenAI
 from langchain_core.prompts import PromptTemplate
 from ws_bom_robot_app.llm.providers.llm_manager import LlmInterface
-from ws_bom_robot_app.llm.utils.print import printString
+from ws_bom_robot_app.llm.utils.print import print_string
 
 def __print_output(data: str) -> str:
-  return printString(data) if os.environ.get("AGENT_HANDLER_FORMATTED") == str(True) else f"{data} "
+  return print_string(data) if os.environ.get("AGENT_HANDLER_FORMATTED") == str(True) else f"{data} "
 
 def getRandomWaitingMessage(waiting_messages: str, traduction: bool = True) -> str:
   if not waiting_messages: return ""

ws_bom_robot_app/llm/utils/print.py

@@ -14,16 +14,16 @@ class HiddenPrints:
         sys.stdout = self._original_stdout
         sys.stderr = self._original_stderr
 
-def printJson(data) -> str:
-    return f"{json.dumps(data, indent=2, sort_keys=True)},"
+def print_json(data) -> str:
+    return print_single_json(data) + ","
 
-def printSingleJson(data) -> str:
-    return f"{json.dumps(data, indent=2, sort_keys=True)}"
+def print_single_json(data) -> str:
+    return json.dumps(data, sort_keys=True)
 
-def printString(data: str) -> str:
+def print_string(data: str) -> str:
     if data != "":
-        return printJson(data)
+        return print_json(data)
 
-def printSingleString(data: str) -> str:
+def print_single_string(data: str) -> str:
     if data != "":
-        return printSingleJson(data)
+        return print_single_json(data)

{ws_bom_robot_app-0.0.42.dist-info → ws_bom_robot_app-0.0.44.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ws_bom_robot_app
-Version: 0.0.42
+Version: 0.0.44
 Summary: A FastAPI application serving ws bom/robot/llm platform ai.
 Home-page: https://github.com/websolutespa/bom
 Author: Websolute Spa

{ws_bom_robot_app-0.0.42.dist-info → ws_bom_robot_app-0.0.44.dist-info}/RECORD

@@ -1,28 +1,28 @@
 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=6Rz6-KGYMloekkLL9DUsyPAbdtN5iSTiPzRCuhymJFI,3872
+ws_bom_robot_app/config.py,sha256=RBdpzFMKUiEgVU1omxQhcYxjJVQVOeX9vR2xUlrLd8s,3968
 ws_bom_robot_app/cron_manager.py,sha256=0Yt5AMTPGlXZ_M5ck0SKMX8wvzoPsseEezg_s0Q3HKY,9224
 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/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ws_bom_robot_app/llm/agent_description.py,sha256=DKPGchYXrkxt8pRpOabn5QE_qn8jSKl92pLpnVLHG5I,4657
-ws_bom_robot_app/llm/agent_handler.py,sha256=4zdpSf5iVLxMZ90c_vUl_k-O9SF6u_h7GOB24y4mhIo,6435
-ws_bom_robot_app/llm/agent_lcel.py,sha256=Yt-hbKarLktv5BBiTp9OHYRdwOTRu5ogyTrYapFdiTU,2389
-ws_bom_robot_app/llm/api.py,sha256=UaD1oJyAOe7ASoXxPNJcth3kDuWcjk1xqUNEjuPWbR4,3759
+ws_bom_robot_app/llm/agent_handler.py,sha256=zRjUZ9D3GIAfmKl1473k2b8YHswZy5rTWdS5BCbZyaY,7578
+ws_bom_robot_app/llm/agent_lcel.py,sha256=iF03Q2fiJ60Zv-ia0eYwz46IPMTJaijb6xcn6cJIUZc,2260
+ws_bom_robot_app/llm/api.py,sha256=BIytnysVK_Iz2RmYmD314cduWAh55l_YcEUvPvb3-oI,3968
 ws_bom_robot_app/llm/defaut_prompt.py,sha256=LlCd_nSMkMmHESfiiiQYfnJyB6Pp-LSs4CEKdYW4vFk,1106
-ws_bom_robot_app/llm/main.py,sha256=YcfenQkBFpXGgFdU2NgHutBs6saPzJzcFMmJ6nwdg0Q,5084
+ws_bom_robot_app/llm/main.py,sha256=tr7gPjSzO2w85ipSxWVcathNxJC3NKTdJKY89VhhKOM,4973
 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=mLbPG7jHh1EjgQG-xpBhEgiTIHpK35HZ51obgqQSfq4,8890
 ws_bom_robot_app/llm/models/base.py,sha256=1TqxuTK3rjJEALn7lvgoen_1ba3R2brAgGx6EDTtDZo,152
 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=XQpTmJ-ChituFyKMv_UOPwNr1aJgihAlsuq0kw2YLVo,8109
+ws_bom_robot_app/llm/providers/llm_manager.py,sha256=vaSVbCKV5tbNg9cCVRa9KgeOoSqIbaSuG1DeIERl90M,8113
 ws_bom_robot_app/llm/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ws_bom_robot_app/llm/tools/tool_builder.py,sha256=OaA0jReNUpjfe7c8TVLM86acQ4w0cQaR3NE22hGKJb0,1165
 ws_bom_robot_app/llm/tools/tool_manager.py,sha256=RZcJVPyWT9D3HUxSO1d5kSfTQtJB2CG5hocuFa01AzY,5816
-ws_bom_robot_app/llm/tools/utils.py,sha256=SPC8pj2bt_xWO7wNR_5YBwUUvjJIK1xlavR4yfW4J-0,1320
+ws_bom_robot_app/llm/tools/utils.py,sha256=tFrH6ehTAakyltAi9J6Pbqe8j1_alyV660fADhkNO-8,1322
 ws_bom_robot_app/llm/tools/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ws_bom_robot_app/llm/tools/models/main.py,sha256=o3Rwbn5nsugKOgLG0FUIuvtPPHYhfVpqG4E3BQB2nWM,388
 ws_bom_robot_app/llm/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -30,7 +30,7 @@ ws_bom_robot_app/llm/utils/agent.py,sha256=9fdnVMHpSEBdmYef6NFXtMIXa8EB4QQICfXsX
 ws_bom_robot_app/llm/utils/chunker.py,sha256=N7570xBYlObneg-fsvDhPAJ-Pv8C8OaYZOBK6q7LmMI,607
 ws_bom_robot_app/llm/utils/download.py,sha256=iAUxH_NiCpTPtGzhC4hBtxotd2HPFt2MBhttslIxqiI,3194
 ws_bom_robot_app/llm/utils/kb.py,sha256=jja45WCbNI7SGEgqDS99nErlwB5eY8Ga7BMnhdMHZ90,1279
-ws_bom_robot_app/llm/utils/print.py,sha256=ZonoLPcfM6Cpw4_Ec455LiCovExOwvnIgvw1QORSCBY,799
+ws_bom_robot_app/llm/utils/print.py,sha256=IsPYEWRJqu-dqlJA3F9OnnIS4rOq_EYX1Ljp3BvDnww,774
 ws_bom_robot_app/llm/utils/secrets.py,sha256=-HtqLIDVIJrpvGC5YhPAVyLsq8P4ChVM5g3GOfdwqVk,878
 ws_bom_robot_app/llm/utils/webhooks.py,sha256=LAAZqyN6VhV13wu4X-X85TwdDgAV2rNvIwQFIIc0FJM,2114
 ws_bom_robot_app/llm/vector_store/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -60,7 +60,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=qo9ejRZyKv_k6jnGgXnu1W5uqsMMtgqK_uvPpZQ0p74,833
-ws_bom_robot_app-0.0.42.dist-info/METADATA,sha256=oqyzo0YlOL6buOYsrDYoRSj0-SkyD3hJU0uwJ5gtcQA,8348
-ws_bom_robot_app-0.0.42.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-ws_bom_robot_app-0.0.42.dist-info/top_level.txt,sha256=Yl0akyHVbynsBX_N7wx3H3ZTkcMLjYyLJs5zBMDAKcM,17
-ws_bom_robot_app-0.0.42.dist-info/RECORD,,
+ws_bom_robot_app-0.0.44.dist-info/METADATA,sha256=O1jDMPmtgtInI9ZgEHnupOy1ZW9oF6FKa-BD9fdwy4M,8348
+ws_bom_robot_app-0.0.44.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+ws_bom_robot_app-0.0.44.dist-info/top_level.txt,sha256=Yl0akyHVbynsBX_N7wx3H3ZTkcMLjYyLJs5zBMDAKcM,17
+ws_bom_robot_app-0.0.44.dist-info/RECORD,,

{ws_bom_robot_app-0.0.42.dist-info → ws_bom_robot_app-0.0.44.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: setuptools (76.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any