fix: Guard against LLM returning JSON array instead of object

services/utils.py

@@ -1,6 +1,7 @@
 import json
 import re
 
+
 def clean_json_string(text: str) -> str:
     if "```json" in text:
         text = text.split("```json")[1].split("```")[0]
@@ -12,22 +13,24 @@ def clean_json_string(text: str) -> str:
             text = parts[1]
     return text.strip()
 
+
 def repair_json(json_str: str) -> str:
     json_str = json_str.strip()
     json_str = json_str.rstrip(", ")
-    
+
     open_braces = json_str.count("{")
     close_braces = json_str.count("}")
     open_brackets = json_str.count("[")
     close_brackets = json_str.count("]")
-    
+
     if open_braces > close_braces:
         json_str += "}" * (open_braces - close_braces)
     if open_brackets > close_brackets:
         json_str += "]" * (open_brackets - close_brackets)
-    
+
     return json_str
 
+
 def parse_and_repair(raw_text: str, max_preview=300):
     cleaned = clean_json_string(raw_text)
     try:
@@ -44,16 +47,17 @@ def parse_and_repair(raw_text: str, max_preview=300):
             except json.JSONDecodeError as e:
                 return None, {"error": str(e), "raw_preview": raw_text[:max_preview]}
 
+
 def repair_json_v2(json_str: str) -> str:
     json_str = json_str.strip()
     json_str = json_str.rstrip(", ")
-    
+
     in_string = False
     escape = False
     brace_depth = 0
     bracket_depth = 0
     last_good_pos = 0
-    
+
     for i, ch in enumerate(json_str):
         if escape:
             escape = False
@@ -66,7 +70,7 @@ def repair_json_v2(json_str: str) -> str:
             continue
         if in_string:
             continue
-        
+
         if ch == '{':
             brace_depth += 1
         elif ch == '}':
@@ -75,52 +79,50 @@ def repair_json_v2(json_str: str) -> str:
             bracket_depth += 1
         elif ch == ']':
             bracket_depth -= 1
-        
+
         if brace_depth >= 0 and bracket_depth >= 0:
             last_good_pos = i + 1
-    
+
     end = last_good_pos
     trimmed = json_str[:end].rstrip(", ")
-    
+
     cb = trimmed.count("{") - trimmed.count("}")
     sb = trimmed.count("[") - trimmed.count("]")
-    
+
     if cb > 0:
         trimmed += "}" * cb
     if sb > 0:
         trimmed += "]" * sb
-    
+
     return trimmed
 
+
 def normalize_field(items, expected_type):
     """Convert model output to match Pydantic expectations."""
     if not isinstance(items, list):
         return items
 
     if expected_type == "object_list":
-        # Items should be [{key: val, ...}, ...] but model gave ["str1", "str2"]
         if items and isinstance(items[0], str):
             return [{"title": s, "expected_ctr": "Medium"} for s in items]
         return items
 
     if expected_type == "string_list":
-        # Items should be ["str1", "str2"] but model gave [{...}, {...}]
         if items and isinstance(items[0], dict):
             extracted = []
             for obj in items:
-                val = obj.get("caption") or obj.get("description") or obj.get("title") or obj.get("name") or obj.get("url") or str(obj)
+                val = obj.get("caption") or obj.get("description") or obj.get("title") or obj.get("name") or obj.get(
+                    "url") or str(obj)
                 extracted.append(val)
             return extracted
         return items
 
     if expected_type == "keyword_list":
-        # Items should be [{keyword, search_volume, competition, relevance}]
         if items and isinstance(items[0], str):
             return [{"keyword": s, "search_volume": "Medium", "competition": "Medium", "relevance": 80} for s in items]
         return items
 
     if expected_type == "hashtag_list":
-        # Items should be [{tag, post_count}] but model gave ["#tag1", "#tag2"]
         if items and isinstance(items[0], str):
             return [{"tag": s, "post_count": "N/A"} for s in items]
         return items
@@ -137,40 +139,37 @@ def normalize_field(items, expected_type):
 
     return items
 
+
 def normalize_response(data: dict) -> dict:
     """Post-process model output to match expected Pydantic schemas."""
-    # YouTube: video_titles expects list of {title, expected_ctr}
     if "video_titles" in data:
         data["video_titles"] = normalize_field(data["video_titles"], "object_list")
     if "thumbnail_ideas" in data:
         data["thumbnail_ideas"] = normalize_field(data["thumbnail_ideas"], "string_list")
 
-    # Instagram
     if "captions" in data:
         data["captions"] = normalize_field(data["captions"], "caption_list")
     if "hashtag_sets" in data and isinstance(data["hashtag_sets"], dict):
         for tier in ["small", "medium", "large"]:
             if tier in data["hashtag_sets"] and isinstance(data["hashtag_sets"][tier], list):
                 if data["hashtag_sets"][tier] and isinstance(data["hashtag_sets"][tier][0], dict):
-                    data["hashtag_sets"][tier] = [obj.get("tag", obj.get("name", str(obj))) for obj in data["hashtag_sets"][tier]]
+                    data["hashtag_sets"][tier] = [obj.get("tag", obj.get("name", str(obj))) for obj in
+                                                  data["hashtag_sets"][tier]]
     if "content_ideas" in data and isinstance(data["content_ideas"], dict):
         for key in ["reels", "carousels", "stories"]:
             if key in data["content_ideas"]:
                 data["content_ideas"][key] = normalize_field(data["content_ideas"][key], "string_list")
 
-    # Generic SEO
     if "core_keywords" in data:
         data["core_keywords"] = normalize_field(data["core_keywords"], "keyword_list")
     if "viral_hashtags" in data:
         data["viral_hashtags"] = normalize_field(data["viral_hashtags"], "hashtag_list")
 
-    # Pinterest
     if "pin_ideas" in data:
         data["pin_ideas"] = normalize_field(data["pin_ideas"], "pin_list")
     if "seo_keywords" in data:
         data["seo_keywords"] = normalize_field(data["seo_keywords"], "string_list")
 
-    # Generic string lists that might have gotten objects
     for field in ["related_phrases", "strategy_tips", "content_titles",
                   "tags", "engagement_strategies", "growth_strategies",
                   "article_topics", "thought_leadership_angles",
@@ -182,31 +181,29 @@ def normalize_response(data: dict) -> dict:
         if field in data:
             data[field] = normalize_field(data[field], "string_list")
 
-    # LinkedIn post_drafts: should be [{headline, body, hook}]
     if "post_drafts" in data:
         if data["post_drafts"] and isinstance(data["post_drafts"][0], str):
             data["post_drafts"] = [{"headline": s, "body": s, "hook": s} for s in data["post_drafts"]]
 
-    # Post ideas: should be [{type, content}]
     if "post_ideas" in data:
         if data["post_ideas"] and isinstance(data["post_ideas"][0], str):
             data["post_ideas"] = [{"type": "text", "content": s} for s in data["post_ideas"]]
 
-    # Tweet threads: should be [{tweets: [str], theme: str}]
     if "tweet_threads" in data:
         if data["tweet_threads"] and isinstance(data["tweet_threads"][0], str):
             data["tweet_threads"] = [{"tweets": [data["tweet_threads"][0]], "theme": "topic"}]
 
-    # Video concepts: should be [{hook, script_snippet, sound_suggestion}]
     if "video_concepts" in data:
         if data["video_concepts"] and isinstance(data["video_concepts"][0], str):
-            data["video_concepts"] = [{"hook": s, "script_snippet": s, "sound_suggestion": "Trending"} for s in data["video_concepts"]]
+            data["video_concepts"] = [{"hook": s, "script_snippet": s, "sound_suggestion": "Trending"} for s in
+                                      data["video_concepts"]]
 
-    # Grammar: corrections should be objects [{original, corrected, error_type, explanation}]
     if "corrections" in data:
         if isinstance(data["corrections"], list) and data["corrections"]:
             if isinstance(data["corrections"][0], str):
-                data["corrections"] = [{"original": s, "corrected": s, "error_type": "grammar", "explanation": "Automatically corrected."} for s in data["corrections"]]
+                data["corrections"] = [
+                    {"original": s, "corrected": s, "error_type": "grammar", "explanation": "Automatically corrected."}
+                    for s in data["corrections"]]
             elif isinstance(data["corrections"][0], dict):
                 for c in data["corrections"]:
                     c.setdefault("error_type", "grammar")
@@ -214,7 +211,8 @@ def normalize_response(data: dict) -> dict:
     if "issues" in data:
         if isinstance(data["issues"], list) and data["issues"]:
             if isinstance(data["issues"][0], str):
-                data["issues"] = [{"issue_type": s, "location": "text", "suggestion": "Review this section."} for s in data["issues"]]
+                data["issues"] = [{"issue_type": s, "location": "text", "suggestion": "Review this section."} for s in
+                                  data["issues"]]
             elif isinstance(data["issues"][0], dict):
                 for iss in data["issues"]:
                     iss.setdefault("issue_type", "style")
@@ -238,22 +236,22 @@ def normalize_response(data: dict) -> dict:
         except (ValueError, TypeError):
             data["sentence_count"] = 0
 
-    # Ensure descriptions are strings, not objects
     if "description_template" in data and isinstance(data["description_template"], dict):
         data["description_template"] = str(data["description_template"])
 
-    # Target audience should be string
     if "target_audience" in data and isinstance(data["target_audience"], dict):
         data["target_audience"] = str(data["target_audience"])
 
     return data
 
+
 def validate_and_fill_data_defaults(data: dict, defaults: dict) -> dict:
     for key, default_val in defaults.items():
         if key not in data or data[key] is None:
             data[key] = default_val
     return data
 
+
 def run_analysis(messages, defaults=None, temperature=0.3, max_new_tokens=2000):
     try:
         from services.model_loader import generate_text
@@ -274,6 +272,11 @@ def run_analysis(messages, defaults=None, temperature=0.3, max_new_tokens=2000):
         base["error"] = "The AI response was malformed. Please try again."
         return base
 
+    if not isinstance(data, dict):
+        print(f"[run_analysis] Expected dict, got {type(data).__name__}")
+        base = dict(defaults) if defaults else {}
+        return base
+
     try:
         data = normalize_response(data)
     except Exception as e: