ws-bom-robot-app 0.0.101__tar.gz → 0.0.103__tar.gz

{ws_bom_robot_app-0.0.101/ws_bom_robot_app.egg-info → ws_bom_robot_app-0.0.103}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ws_bom_robot_app
-Version: 0.0.101
+Version: 0.0.103
 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.101 → ws_bom_robot_app-0.0.103}/setup.py

@@ -4,7 +4,7 @@ _requirements = [line.split('#')[0].strip() for line in open("requirements.txt")
 
 setup(
     name="ws_bom_robot_app",
-    version="0.0.101",
+    version="0.0.103",
     description="A FastAPI application serving ws bom/robot/llm platform ai.",
     long_description=open("README.md", encoding='utf-8').read(),
     long_description_content_type="text/markdown",

{ws_bom_robot_app-0.0.101 → ws_bom_robot_app-0.0.103}/ws_bom_robot_app/llm/agent_context.py

@@ -7,7 +7,7 @@ class AgentContext(BaseModel):
     class _i18n(BaseModel):
         lg: Optional[str] = "en"
         country: Optional[str] = "US"
-        timestamp: Optional[str] = Field(default_factory=lambda: datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
+        timestamp: Optional[str] = Field(default_factory=lambda: datetime.now().strftime("%Y-%m-%d %H:%M:%S %A"))
         timezone: Optional[str] = "UTC"
         model_config = ConfigDict(extra='allow')
     class _user(BaseModel):

{ws_bom_robot_app-0.0.101 → ws_bom_robot_app-0.0.103}/ws_bom_robot_app/llm/agent_lcel.py

@@ -22,13 +22,9 @@ class AgentLcel:
         self.embeddings = llm.get_embeddings()
         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()
-
-        # Configura l'LLM in base alla modalità
         if self.json_schema:
-            # JSON mode: usa with_structured_output per output strutturato mantenendo i tool
             self.__pydantic_schema = self.__create_pydantic_schema()
         else:
-            # Agent mode standard
             self.__pydantic_schema = None
 
         self.executor = self.__create_agent()
@@ -68,13 +64,7 @@ class AgentLcel:
         return create_model('JsonSchema', **fields)
 
     def __get_output_parser(self):
-        """Restituisce il parser appropriato in base alla modalità."""
-        if self.json_schema and self.__pydantic_schema:
-            # In modalità JSON, usa with_structured_output direttamente nell'agent
-            # Il parser qui serve solo per compatibilità, la conversione avviene prima
-            return self.__llm.get_parser()
-        else:
-            return self.__llm.get_parser()
+        return self.__llm.get_parser()
 
     async def __create_prompt(self, input: dict) -> ChatPromptTemplate:
         from langchain_core.messages import SystemMessage
@@ -82,9 +72,14 @@ class AgentLcel:
         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
 
-        # Aggiungere istruzioni per output strutturato se è presente json_schema
+        # Aggiungi istruzioni per output JSON strutturato se necessario
         if self.json_schema and self.__pydantic_schema:
-            system += f"\n\nYou must respond with a JSON object matching this schema: {self.__pydantic_schema.schema_json()}"
+            json_instructions = f"\n\nIMPORTANT: You must format your final response as a JSON object with the following structure:\n"
+            for field_name, field_info in self.__pydantic_schema.model_fields.items():
+                field_type = field_info.annotation.__name__ if hasattr(field_info.annotation, '__name__') else str(field_info.annotation)
+                json_instructions += f"- {field_name}: {field_type}\n"
+            json_instructions += "\nProvide ONLY the JSON object in your response, no additional text."
+            system += json_instructions
 
         messages = [
             SystemMessage(content=system),
@@ -98,14 +93,15 @@ class AgentLcel:
         )
         return prompt
 
-    def __create_agent(self) -> AgentExecutor:
-      agent: Any = (
-          {
-            "agent_scratchpad": lambda x: self.__llm.get_formatter(x["intermediate_steps"]),
-             str(self.memory_key): lambda x: x[self.memory_key],
-          }
-          | RunnableLambda(self.__create_prompt)
-          | self.__llm_with_tools
-          | self.__get_output_parser()
-      )
-      return AgentExecutor(agent=agent,tools=self.__tools,verbose=False)
+    def __create_agent(self):
+        # Un solo AgentExecutor per entrambe le modalità
+        agent = (
+            {
+                "agent_scratchpad": lambda x: self.__llm.get_formatter(x["intermediate_steps"]),
+                self.memory_key: lambda x: x[self.memory_key],
+            }
+            | RunnableLambda(self.__create_prompt)
+            | self.__llm_with_tools
+            | self.__get_output_parser()
+        )
+        return AgentExecutor(agent=agent, tools=self.__tools, verbose=False)

{ws_bom_robot_app-0.0.101 → ws_bom_robot_app-0.0.103}/ws_bom_robot_app/llm/tools/tool_manager.py

@@ -1,5 +1,5 @@
 from asyncio import Queue
-import aiohttp
+import aiohttp, re
 from typing import  Optional, Type, Callable
 from ws_bom_robot_app.config import config
 from ws_bom_robot_app.llm.models.api import LlmApp,LlmAppTool
@@ -200,10 +200,21 @@ class ToolManager:
         else:  # default
           try:
             from ws_bom_robot_app.llm.main import stream
+            import json
             chunks = []
             async for chunk in stream(rq=app.rq, ctx=None, formatted=False):
                 chunks.append(chunk)
             rs = ''.join(chunks) if chunks else None
+
+            # if the app has output_structure, parse the JSON and return dict
+            if rs and app.rq.output_structure:
+                try:
+                    cleaned_rs = re.sub(r'^```(?:json)?\s*\n?', '', rs.strip())
+                    cleaned_rs = re.sub(r'\n?```\s*$', '', cleaned_rs)
+                    return json.loads(cleaned_rs)
+                except json.JSONDecodeError:
+                    print(f"[!] Failed to parse JSON output from proxy_app_chat: {rs}")
+                    return rs
             return rs
           except Exception as e:
             print(f"[!] Error in proxy_app_chat: {e}")

{ws_bom_robot_app-0.0.101 → ws_bom_robot_app-0.0.103}/ws_bom_robot_app/llm/utils/cms.py

@@ -37,6 +37,14 @@ async def get_apps() -> list[CmsApp]:
           if obj is None:
               break
       return obj
+  def __to_dict(obj):
+      """Converts DictObject to dict recursively"""
+      if isinstance(obj, DictObject):
+          return {k: __to_dict(v) for k, v in obj.__dict__.items()}
+      elif isinstance(obj, list):
+          return [__to_dict(item) for item in obj]
+      else:
+          return obj
   host = config.robot_cms_host
   if host:
     url = f"{host}/api/llmApp?depth=1&pagination=false&locale=it"
@@ -77,7 +85,8 @@ async def get_apps() -> list[CmsApp]:
                         ) if __attr(_cms_app_dict.settings,'rules','vectorDbFile','filename') else None,
                       #fine_tuned_model=__attr(_cms_app_dict.settings,'llmConfig','fineTunedModel'),
                       lang_chain_tracing= __attr(_cms_app_dict.settings,'llmConfig','langChainTracing', default=False),
-                      lang_chain_project= __attr(_cms_app_dict.settings,'llmConfig','langChainProject', default='')
+                      lang_chain_project= __attr(_cms_app_dict.settings,'llmConfig','langChainProject', default=''),
+                      output_structure= __to_dict(__attr(_cms_app_dict.settings,'llmConfig','outputStructure')) if __attr(_cms_app_dict.settings,'llmConfig','outputStructure') else None
                     ))
                 except Exception as e:
                   import traceback

{ws_bom_robot_app-0.0.101 → ws_bom_robot_app-0.0.103/ws_bom_robot_app.egg-info}/PKG-INFO

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