Upload 2 files

agents.py

@@ -94,6 +94,8 @@ def extract_json_array(text: str):
                 json_str = re.sub(r'"\s*}\s*"', '"}', json_str)
                 # Fix missing commas between objects
                 json_str = re.sub(r'"\s*}\s*{', '"},{', json_str)
+                # Fix extra quotes around individual objects in arrays
+                json_str = re.sub(r'"\s*({[^}]+})\s*"', r'\1', json_str)
                 return json.loads(json_str)
             except Exception as e3:
                 print("[extract_json_array] JSON fixing failed:", e3)
@@ -138,6 +140,8 @@ def safe_json_parse(content: str, fallback_value=None):
                 fixed_content = re.sub(r'"\s*}\s*"', '"}', fixed_content)
                 # Fix missing commas between objects
                 fixed_content = re.sub(r'"\s*}\s*{', '"},{', fixed_content)
+                # Fix extra quotes around individual objects in arrays
+                fixed_content = re.sub(r'"\s*({[^}]+})\s*"', r'\1', fixed_content)
                 return json.loads(fixed_content)
             except Exception as e3:
                 print(f"[safe_json_parse] JSON fixing failed: {e3}")
@@ -229,6 +233,36 @@ async def extract_books_node(state):
                         books = manual_books
                         print("[extract_books_node] Pattern-based extraction successful:", books)
         
+        # Additional fix: if books is a list but contains malformed strings, try to fix them
+        if isinstance(books, list) and books:
+            print("[extract_books_node] Checking for malformed book entries...")
+            fixed_books = []
+            for book in books:
+                if isinstance(book, str):
+                    # Try to parse the string as JSON
+                    try:
+                        # Remove extra quotes around the object
+                        cleaned_book = book.strip()
+                        if cleaned_book.startswith('"') and cleaned_book.endswith('"'):
+                            cleaned_book = cleaned_book[1:-1]
+                        parsed_book = json.loads(cleaned_book)
+                        if isinstance(parsed_book, dict) and parsed_book.get("title"):
+                            fixed_books.append(parsed_book)
+                    except:
+                        # Try regex extraction as fallback
+                        title_match = re.search(r'"title":\s*"([^"]+)"', book)
+                        author_match = re.search(r'"author":\s*"([^"]+)"', book)
+                        if title_match:
+                            title = title_match.group(1)
+                            author = author_match.group(1) if author_match else "Unknown"
+                            fixed_books.append({"title": title, "author": author})
+                elif isinstance(book, dict) and book.get("title"):
+                    fixed_books.append(book)
+            
+            if fixed_books:
+                books = fixed_books
+                print("[extract_books_node] Fixed malformed book entries:", books)
+        
         print("[extract_books_node] Parsed books:", books)
 
         # Ensure books is a list and each book has required fields
@@ -475,6 +509,7 @@ async def reasoning_node(state):
         print("[reasoning_node] Validated final recommendations:", validated_recommendations)
         print("[reasoning_node] Final reasoning:\n", final_reasoning)
 
+        # Return the new state with our data
         result_state = {
             "final_recommendations": validated_recommendations,
             "final_reasoning": final_reasoning
@@ -483,7 +518,8 @@ async def reasoning_node(state):
         print("[reasoning_node] Returning state with keys:", list(result_state.keys()))
         print("[reasoning_node] 👈 exit with", result_state)
         
-        return result_state
+        # Try returning as a dict to ensure proper state handling
+        return dict(result_state)
 
     except Exception as e:
         print("[reasoning_node] ❌ exception:", repr(e))

app.py

@@ -33,14 +33,29 @@ async def run_book_recommender(user_input):
         }
     
     # Ensure we have the expected keys in final_state
+    print(f"🔍 Final state keys: {list(final_state.keys())}")
+    print(f"🔍 Final state content: {final_state}")
+    
     if "final_recommendations" not in final_state:
+        print("⚠️ final_recommendations not found in final state")
         final_state["final_recommendations"] = []
     if "final_reasoning" not in final_state:
+        print("⚠️ final_reasoning not found in final state")
         final_state["final_reasoning"] = "⚠️ Missing reasoning data from graph execution."
 
-    # Access the final state directly - the reasoning node returns these keys directly
+    # Access the final state - check both possible structures
     recs = final_state.get("final_recommendations", [])
     reasoning = final_state.get("final_reasoning", "")
+    
+    # If not found in direct keys, check if they're nested under 'reasoning'
+    if not recs and "reasoning" in final_state:
+        reasoning_data = final_state.get("reasoning", {})
+        if isinstance(reasoning_data, dict):
+            recs = reasoning_data.get("final_recommendations", [])
+            reasoning = reasoning_data.get("final_reasoning", reasoning)
+    
+    print(f"🔍 Extracted recs: {recs}")
+    print(f"🔍 Extracted reasoning (first 200 chars): {reasoning[:200] if reasoning else 'None'}...")
 
     # Defensive formatting of recommendations
     try: