fix(creative): handle moderation_blocked correctly and avoid false image success

Author: fatihaltiok

agent/agents/creative.py

@@ -139,6 +139,38 @@ async def _execute_with_nemotron(self, image_prompt: str, size: str = "1024x1024
                 "quality": quality,
             })
 
+    @staticmethod
+    def _extract_tool_error(observation: dict) -> tuple[bool, str, str]:
+        """Normalisiert Fehlererkennung aus Tool-Responses."""
+        if not isinstance(observation, dict):
+            return True, "Unerwartetes Antwortformat vom Tool.", ""
+
+        status = str(observation.get("status", "") or "").strip().lower()
+        error_code = str(observation.get("error_code", "") or "").strip().lower()
+
+        if "error" in observation:
+            return True, str(observation.get("error") or "Unbekannter Fehler"), error_code
+        if status in {"error", "failed", "failure"}:
+            msg = str(
+                observation.get("message")
+                or observation.get("error")
+                or "Unbekannter Fehler"
+            )
+            return True, msg, error_code
+        return False, "", error_code
+
+    @staticmethod
+    def _build_safe_retry_prompt(detailed_prompt: str) -> str:
+        """Erzeugt einen moderationsfreundlichen Retry-Prompt fuer Bildgenerierung."""
+        base = str(detailed_prompt or "").strip()
+        safety_clause = (
+            "Original fictional character only, no copyrighted or trademarked characters, "
+            "no logos, no real persons, no violence, no weapons, family-friendly."
+        )
+        if base:
+            return f"{base}. {safety_clause}"
+        return safety_clause
+
     async def run(self, task: str) -> str:
         log.info(f"{self.__class__.__name__} - HYBRID MODE (GPT-5.1 + Nemotron)")
 
@@ -156,12 +188,35 @@ async def run(self, task: str) -> str:
         self._handle_file_artifacts(observation)
 
         if isinstance(observation, dict):
-            if "error" in observation:
-                return f"Fehler bei der Bildgenerierung: {observation['error']}"
+            has_error, error_message, error_code = self._extract_tool_error(observation)
+            if has_error and error_code == "moderation_blocked":
+                safe_prompt = self._build_safe_retry_prompt(detailed_prompt)
+                log.warning("Bildgenerierung moderiert geblockt. Versuche sicheren Retry.")
+                observation_retry = await self._execute_with_nemotron(
+                    safe_prompt, size="1024x1024", quality="high"
+                )
+                self._handle_file_artifacts(observation_retry)
+                if isinstance(observation_retry, dict):
+                    retry_error, retry_message, _ = self._extract_tool_error(observation_retry)
+                    if retry_error:
+                        return f"Fehler bei der Bildgenerierung: {retry_message}"
+                    observation = observation_retry
+                    detailed_prompt = safe_prompt
+                else:
+                    return "Fehler bei der Bildgenerierung: Unerwartetes Antwortformat beim Retry."
+
+            elif has_error:
+                return f"Fehler bei der Bildgenerierung: {error_message}"
 
             saved_path = observation.get("saved_as", "")
             image_url = observation.get("image_url", "")
 
+            if not saved_path and not image_url:
+                return (
+                    "Bildgenerierung abgeschlossen, aber es wurde weder Datei noch URL "
+                    "zurueckgegeben."
+                )
+
             final_answer = "Ich habe das Bild erfolgreich generiert!"
             if saved_path:
                 final_answer += f"\n\nGespeichert unter: {saved_path}"

tests/test_creative_agent_error_handling.py

@@ -0,0 +1,67 @@
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from agent.agents.creative import CreativeAgent
+
+
+@pytest.mark.asyncio
+async def test_creative_agent_reports_status_error():
+    agent = CreativeAgent.__new__(CreativeAgent)
+    agent._handle_file_artifacts = lambda observation: None
+
+    async def _fake_prompt(_task: str) -> str:
+        return "cinematic hero on rooftop"
+
+    async def _fake_exec(_prompt: str, size: str = "1024x1024", quality: str = "high"):
+        return {
+            "status": "error",
+            "message": "moderation blocked",
+            "error_code": "moderation_blocked",
+        }
+
+    agent._generate_image_prompt_with_gpt = _fake_prompt
+    agent._execute_with_nemotron = _fake_exec
+
+    result = await CreativeAgent.run(agent, "male ein bild von einem helden")
+    assert "Fehler bei der Bildgenerierung" in result
+    assert "moderation blocked" in result.lower()
+
+
+@pytest.mark.asyncio
+async def test_creative_agent_retries_once_on_moderation_and_succeeds():
+    agent = CreativeAgent.__new__(CreativeAgent)
+    agent._handle_file_artifacts = lambda observation: None
+    calls = {"n": 0, "prompts": []}
+
+    async def _fake_prompt(_task: str) -> str:
+        return "cinematic superhero scene"
+
+    async def _fake_exec(prompt: str, size: str = "1024x1024", quality: str = "high"):
+        calls["n"] += 1
+        calls["prompts"].append(prompt)
+        if calls["n"] == 1:
+            return {
+                "status": "error",
+                "error": "blocked by moderation",
+                "error_code": "moderation_blocked",
+            }
+        return {
+            "status": "success",
+            "saved_as": "results/hero.png",
+            "message": "ok",
+        }
+
+    agent._generate_image_prompt_with_gpt = _fake_prompt
+    agent._execute_with_nemotron = _fake_exec
+
+    result = await CreativeAgent.run(agent, "male ein bild von einem helden")
+
+    assert calls["n"] == 2
+    assert "copyrighted" in calls["prompts"][1].lower()
+    assert "erfolgreich generiert" in result.lower()
+    assert "results/hero.png" in result
+

tools/creative_tool/tool.py

@@ -104,12 +104,27 @@ async def generate_image(prompt: str, size: str = "1024x1024", quality: str = "s
         }
 
     except Exception as e:
-        # Verbesserte Fehlerbehandlung, um die OpenAI-Fehlermeldung zu extrahieren
+        # Verbesserte Fehlerbehandlung inkl. strukturierter Error-Codes.
         error_message = str(e)
-        if hasattr(e, 'body') and e.body and 'error' in e.body and 'message' in e.body['error']:
-            error_message = f"OpenAI API Fehler: {e.body['error']['message']}"
+        error_code = ""
+        error_type = ""
+
+        body = getattr(e, "body", None)
+        if isinstance(body, dict):
+            err = body.get("error", {}) or {}
+            if isinstance(err, dict):
+                error_message = str(err.get("message") or error_message)
+                error_code = str(err.get("code") or "")
+                error_type = str(err.get("type") or "")
+
         log.error(f"❌ {error_message}", exc_info=True)
-        return {"status": "error", "message": error_message}
+        return {
+            "status": "error",
+            "error": error_message,
+            "message": error_message,
+            "error_code": error_code,
+            "error_type": error_type,
+        }
 
 # ... (deine anderen Methoden wie generate_code, generate_text bleiben unverändert) ...