Polishing loggings conventions

Author: mc-dorzo

src/parlant/core/engines/alpha/guideline_proposer.py

@@ -222,14 +222,19 @@ async def _process_guideline_batch(
         with self._logger.operation(
             f"[GuidelineProposer] Guideline evaluation batch ({len(guidelines_dict)} guidelines)"
         ):
-            propositions_generation_response = await self._schematic_generator.generate(
+            self._logger.debug(f"[GuidelineProposer][Prompt] {prompt}")
+
+            inference = await self._schematic_generator.generate(
                 prompt=prompt,
                 hints={"temperature": 0.3},
             )
 
+            log_message = json.dumps(inference.content.model_dump(mode="json"), indent=2)
+            self._logger.debug(f"[GuidelineProposer][Completion] {log_message}")
+
         propositions = []
 
-        for proposition in propositions_generation_response.content.checks:
+        for proposition in inference.content.checks:
             guideline = guidelines_dict[int(proposition.guideline_number)]
 
             self._logger.debug(
@@ -258,7 +263,7 @@ async def _process_guideline_batch(
                     )
                 )
 
-        return propositions_generation_response.info, propositions
+        return inference.info, propositions
 
     async def shots(self) -> Sequence[GuidelinePropositionShot]:
         return await shot_collection.list()

src/parlant/core/engines/alpha/message_event_generator.py

@@ -138,8 +138,7 @@ async def generate_events(
                 return []
 
             self._logger.debug(
-<<<<<<< HEAD
-                f"""Guidelines applied: {
+                f"""[MessageEventGenerator] Guidelines applied: {
                     json.dumps(
                         [
                             {
@@ -156,14 +155,6 @@ async def generate_events(
                         indent=2,
                     )
                 }"""
-=======
-                f"""[MessageEventGenerator] Guidelines applied: {json.dumps([{
-                    "condition": p.guideline.content.condition,
-                    "action": p.guideline.content.action,
-                    "rationale": p.rationale,
-                    "score": p.score}
-                for p in  chain(ordinary_guideline_propositions, tool_enabled_guideline_propositions.keys())], indent=2)}"""
->>>>>>> a3660ffc (Add [MessageEventGenerator] to logs in messge_event_generator)
             )
 
             prompt = self._format_prompt(
@@ -178,8 +169,6 @@ async def generate_events(
                 shots=await self.shots(),
             )
 
-            self._logger.debug(f"[MessageEventGenerator][Prompt]:\n{prompt}")
-
             last_known_event_offset = interaction_history[-1].offset if interaction_history else -1
 
             await event_emitter.emit_status_event(
@@ -199,6 +188,8 @@ async def generate_events(
 
             last_generation_exception: Exception | None = None
 
+            self._logger.debug(f"[MessageEventGenerator][Prompt] \n{prompt}")
+
             for generation_attempt in range(3):
                 try:
                     generation_info, response_message = await self._generate_response_message(
@@ -209,7 +200,9 @@ async def generate_events(
                     )
 
                     if response_message is not None:
-                        self._logger.debug(f'[MessageEventGenerator][Result]: "{response_message}"')
+                        self._logger.debug(
+                            f'[MessageEventGenerator][GeneratedMessage] "{response_message}"'
+                        )
 
                         event = await event_emitter.emit_message_event(
                             correlation_id=self._correlator.correlation_id,
@@ -530,6 +523,9 @@ async def _generate_response_message(
             hints={"temperature": temperature},
         )
 
+        log_message = json.dumps(message_event_response.content.model_dump(mode="json"), indent=2)
+        self._logger.debug(f"[MessageEventGenerator][Completion] \n{log_message}")
+
         if not message_event_response.content.produced_reply:
             self._logger.debug(
                 f"[MessageEventGenerator] produced no reply: {message_event_response}"
@@ -538,12 +534,12 @@ async def _generate_response_message(
 
         if message_event_response.content.evaluation_for_each_instruction:
             self._logger.debug(
-                "[MessageEventGenerator][Evaluations]: "
+                "[MessageEventGenerator][Evaluations] "
                 f"{json.dumps([e.model_dump(mode='json') for e in message_event_response.content.evaluation_for_each_instruction], indent=2)}"
             )
 
         self._logger.debug(
-            "[MessageEventGenerator][Revisions]: "
+            "[MessageEventGenerator][Revisions] "
             f"{json.dumps([r.model_dump(mode='json') for r in message_event_response.content.revisions], indent=2)}"
         )
 

src/parlant/core/engines/alpha/tool_caller.py

@@ -548,16 +548,15 @@ async def _run_inference(
         self,
         prompt: str,
     ) -> tuple[GenerationInfo, Sequence[ToolCallEvaluation]]:
-        self._logger.debug(f"[ToolCaller][Prompt]: {prompt}")
+        self._logger.debug(f"[ToolCaller][Prompt] \n{prompt}")
 
         inference = await self._schematic_generator.generate(
             prompt=prompt,
             hints={"temperature": 0.0},
         )
 
         log_message = json.dumps(inference.content.model_dump(mode="json"), indent=2)
-
-        self._logger.debug(f"[ToolCaller][RequestResults]: {log_message}")
+        self._logger.debug(f"[ToolCaller][Completion] \n{log_message}")
 
         return inference.info, inference.content.tool_calls_for_candidate_tool
 
@@ -569,7 +568,12 @@ async def _run_tool(
     ) -> ToolCallResult:
         try:
             self._logger.debug(
-                f"[ToolCaller] Tool call executing: {tool_call.tool_id.to_string()}/{tool_call.id}"
+                f"[ToolCaller][ToolCall] {tool_call.tool_id.to_string()}/{tool_call.id}, "
+                + (
+                    f"arguments=\n{json.dumps(tool_call.arguments, indent=2)}"
+                    if tool_call.arguments
+                    else ""
+                )
             )
             service = await self._service_registry.read_tool_service(tool_id.service_name)
             result = await service.call_tool(
@@ -578,7 +582,7 @@ async def _run_tool(
                 tool_call.arguments,
             )
             self._logger.debug(
-                f"[ToolCaller][ToolResult]: {tool_call.tool_id.to_string()}/{tool_call.id}: {json.dumps(asdict(result), indent=2)}"
+                f"[ToolCaller][ToolResult] {tool_call.tool_id.to_string()}/{tool_call.id}\n{json.dumps(asdict(result), indent=2)}"
             )
 
             return ToolCallResult(
@@ -592,8 +596,9 @@ async def _run_tool(
             )
         except Exception as e:
             self._logger.error(
-                f"[ToolCaller] Tool execution error (tool='{tool_call.tool_id.to_string()}', "
-                f"arguments={tool_call.arguments}): " + "\n".join(traceback.format_exception(e)),
+                f"[ToolCaller][ExecutionError] (tool='{tool_call.tool_id.to_string()}', "
+                f"arguments=\n{json.dumps(tool_call.arguments, indent=2)}"
+                + "\n".join(traceback.format_exception(e)),
             )
 
             return ToolCallResult(