fixed injection watcher

backend/app/llm/client.py

@@ -44,6 +44,21 @@ class LLMClient:
 
         return "".join(parts), details
 
+    @staticmethod
+    def _normalize_reasoning_details(details: Any) -> list[Any] | None:
+        if not details:
+            return None
+        items = details if isinstance(details, list) else [details]
+        normalized: list[Any] = []
+        for item in items:
+            if hasattr(item, "model_dump"):
+                normalized.append(item.model_dump())
+            elif isinstance(item, dict):
+                normalized.append(item)
+            else:
+                normalized.append(item)
+        return normalized or None
+
     @staticmethod
     def attach_reasoning_to_message(
         message: dict[str, Any],
@@ -54,8 +69,9 @@ class LLMClient:
         if reasoning:
             message["reasoning"] = reasoning
             message["reasoning_content"] = reasoning
-        if reasoning_details:
-            message["reasoning_details"] = reasoning_details
+        normalized = LLMClient._normalize_reasoning_details(reasoning_details)
+        if normalized:
+            message["reasoning_details"] = normalized
         return message
 
     async def stream_chat(
@@ -126,14 +142,21 @@ class LLMClient:
 
                 if choice.finish_reason:
                     reasoning = "".join(reasoning_parts)
-                    if reasoning or reasoning_details:
+                    normalized_details = self._normalize_reasoning_details(reasoning_details)
+                    if reasoning or normalized_details:
                         yield {
                             "type": "reasoning",
                             "reasoning": reasoning,
-                            "reasoning_details": reasoning_details or None,
+                            "reasoning_details": normalized_details,
                         }
                     if tool_calls:
                         yield {"type": "tool_calls", "tool_calls": list(tool_calls.values())}
+                    logger.debug(
+                        "LLM stream done: finish_reason=%s tool_calls=%d reasoning_len=%d",
+                        choice.finish_reason,
+                        len(tool_calls),
+                        len(reasoning),
+                    )
                     yield {"type": "done", "finish_reason": choice.finish_reason}
         except Exception as exc:
             logger.exception("LLM stream read failed: %s", exc)