Update app.py

app.py

@@ -806,126 +806,157 @@ stack_opcodes_functionalities = "\n".join([
 ALL_SCRATCH_BLOCKS_CATALOG = _load_block_catalog(BLOCK_CATALOG_PATH)
 
 # Helper function to extract JSON from LLM response
-def extract_json_from_llm_response(raw_response: str) -> dict:
-    """
-    Improved JSON extraction with better error handling and validation
-    """
-    print(f"Raw LLM response: {raw_response[:200]}...")
+# def extract_json_from_llm_response(raw_response: str) -> dict:
+#     """
+#     Improved JSON extraction with better error handling and validation
+#     """
+#     print(f"Raw LLM response: {raw_response[:200]}...")
     
-    # Try to find JSON in code blocks first
-    md = re.search(r"```(?:json)?\s*([\s\S]*?)\s*```", raw_response)
-    if md:
-        json_string = md.group(1).strip()
-    else:
-        json_string = raw_response.strip()
-
-    # Find the first complete JSON object (handle cases with multiple objects/arrays)
-    first_brace = json_string.find('{')
-    if first_brace == -1:
-        print("No JSON object found in response")
-        return {
-            "refined_logic": {
-                "name_variable": "No Code-blocks",
-                "pseudocode": "No Code-blocks"
-            }
-        }
+#     # Try to find JSON in code blocks first
+#     md = re.search(r"```(?:json)?\s*([\s\S]*?)\s*```", raw_response)
+#     if md:
+#         json_string = md.group(1).strip()
+#     else:
+#         json_string = raw_response.strip()
+
+#     # Find the first complete JSON object (handle cases with multiple objects/arrays)
+#     first_brace = json_string.find('{')
+#     if first_brace == -1:
+#         print("No JSON object found in response")
+#         return {
+#             "refined_logic": {
+#                 "name_variable": "No Code-blocks",
+#                 "pseudocode": "No Code-blocks"
+#             }
+#         }
     
-    # Find the matching closing brace for the first opening brace
-    brace_count = 0
-    last_brace = -1
-    for i, char in enumerate(json_string[first_brace:], first_brace):
-        if char == '{':
-            brace_count += 1
-        elif char == '}':
-            brace_count -= 1
-            if brace_count == 0:
-                last_brace = i
-                break
+#     # Find the matching closing brace for the first opening brace
+#     brace_count = 0
+#     last_brace = -1
+#     for i, char in enumerate(json_string[first_brace:], first_brace):
+#         if char == '{':
+#             brace_count += 1
+#         elif char == '}':
+#             brace_count -= 1
+#             if brace_count == 0:
+#                 last_brace = i
+#                 break
     
-    if last_brace == -1:
-        print("No matching closing brace found")
-        return {
-            "refined_logic": {
-                "name_variable": "Parse Error",
-                "pseudocode": "Malformed JSON"
-            }
-        }
+#     if last_brace == -1:
+#         print("No matching closing brace found")
+#         return {
+#             "refined_logic": {
+#                 "name_variable": "Parse Error",
+#                 "pseudocode": "Malformed JSON"
+#             }
+#         }
     
-    json_string = json_string[first_brace:last_brace+1]
+#     json_string = json_string[first_brace:last_brace+1]
     
-    # Simple cleanup - just handle the most common issues
-    # 1. Remove trailing commas
-    json_string = re.sub(r',\s*}', '}', json_string)
-    json_string = re.sub(r',\s*]', ']', json_string)
+#     # Simple cleanup - just handle the most common issues
+#     # 1. Remove trailing commas
+#     json_string = re.sub(r',\s*}', '}', json_string)
+#     json_string = re.sub(r',\s*]', ']', json_string)
     
-    # 2. Fix single quotes around simple values (not containing quotes)
-    json_string = re.sub(r"'([^'\"]*)'(\s*:)", r'"\1"\2', json_string)  # Keys
-    json_string = re.sub(r"(:\s*)'([^'\"]*)'(\s*[,}])", r'\1"\2"\3', json_string)  # Simple values
+#     # 2. Fix single quotes around simple values (not containing quotes)
+#     json_string = re.sub(r"'([^'\"]*)'(\s*:)", r'"\1"\2', json_string)  # Keys
+#     json_string = re.sub(r"(:\s*)'([^'\"]*)'(\s*[,}])", r'\1"\2"\3', json_string)  # Simple values
     
-    print(f"Cleaned JSON string: {json_string[:200]}...")
+#     print(f"Cleaned JSON string: {json_string[:200]}...")
     
-    try:
-        parsed = json.loads(json_string)
+#     try:
+#         parsed = json.loads(json_string)
         
-        # Validate the expected structure
-        if not isinstance(parsed, dict):
-            raise ValueError("Response is not a JSON object")
+#         # Validate the expected structure
+#         if not isinstance(parsed, dict):
+#             raise ValueError("Response is not a JSON object")
             
-        if "refined_logic" not in parsed:
-            raise ValueError("Missing 'refined_logic' key")
+#         if "refined_logic" not in parsed:
+#             raise ValueError("Missing 'refined_logic' key")
             
-        refined_logic = parsed["refined_logic"]
-        if not isinstance(refined_logic, dict):
-            raise ValueError("'refined_logic' is not an object")
+#         refined_logic = parsed["refined_logic"]
+#         if not isinstance(refined_logic, dict):
+#             raise ValueError("'refined_logic' is not an object")
             
-        if "name_variable" not in refined_logic or "pseudocode" not in refined_logic:
-            raise ValueError("Missing required keys in 'refined_logic'")
+#         if "name_variable" not in refined_logic or "pseudocode" not in refined_logic:
+#             raise ValueError("Missing required keys in 'refined_logic'")
         
-        print("Successfully parsed and validated JSON")
-        return parsed
+#         print("Successfully parsed and validated JSON")
+#         return parsed
         
-    except (json.JSONDecodeError, ValueError) as e:
-        print(f"JSON parsing failed: {e}")
+#     except (json.JSONDecodeError, ValueError) as e:
+#         print(f"JSON parsing failed: {e}")
         
-        # Try to extract meaningful data even from malformed JSON using regex
-        try:
-            # Look for name_variable and pseudocode patterns with more flexible matching
-            name_match = re.search(r'"name_variable":\s*["\']([^"\']*)["\']', raw_response)
-            pseudo_match = re.search(r'"pseudocode":\s*["\']([^"\']*)["\']', raw_response)
+#         # Try to extract meaningful data even from malformed JSON using regex
+#         try:
+#             # Look for name_variable and pseudocode patterns with more flexible matching
+#             name_match = re.search(r'"name_variable":\s*["\']([^"\']*)["\']', raw_response)
+#             pseudo_match = re.search(r'"pseudocode":\s*["\']([^"\']*)["\']', raw_response)
             
-            if name_match and pseudo_match:
-                print("Extracted data using regex fallback")
-                return {
-                    "refined_logic": {
-                        "name_variable": name_match.group(1),
-                        "pseudocode": pseudo_match.group(1)
-                    }
-                }
+#             if name_match and pseudo_match:
+#                 print("Extracted data using regex fallback")
+#                 return {
+#                     "refined_logic": {
+#                         "name_variable": name_match.group(1),
+#                         "pseudocode": pseudo_match.group(1)
+#                     }
+#                 }
             
-            # Try to find any valid JSON-like structure in the response
-            # Look for patterns like {'refined_logic': 'pseudocode', 'block_relationships': [...]}
-            alt_match = re.search(r"'name_variable':\s*'([^']*)'.*?'pseudocode':\s*'([^']*)'", raw_response, re.DOTALL)
-            if alt_match:
-                print("Extracted data using alternative pattern")
-                return {
-                    "refined_logic": {
-                        "name_variable": alt_match.group(1),
-                        "pseudocode": alt_match.group(2)
-                    }
-                }
+#             # Try to find any valid JSON-like structure in the response
+#             # Look for patterns like {'refined_logic': 'pseudocode', 'block_relationships': [...]}
+#             alt_match = re.search(r"'name_variable':\s*'([^']*)'.*?'pseudocode':\s*'([^']*)'", raw_response, re.DOTALL)
+#             if alt_match:
+#                 print("Extracted data using alternative pattern")
+#                 return {
+#                     "refined_logic": {
+#                         "name_variable": alt_match.group(1),
+#                         "pseudocode": alt_match.group(2)
+#                     }
+#                 }
                 
-        except Exception as regex_error:
-            print(f"Regex extraction also failed: {regex_error}")
+#         except Exception as regex_error:
+#             print(f"Regex extraction also failed: {regex_error}")
         
-        # Return a default structure on parsing failure
-        return {
-            "refined_logic": {
-                "name_variable": "Parse Error",
-                "pseudocode": "Failed to parse response"
-            }
-        }
+#         # Return a default structure on parsing failure
+#         return {
+#             "refined_logic": {
+#                 "name_variable": "Parse Error",
+#                 "pseudocode": "Failed to parse response"
+#             }
+#         }
         
+def extract_json_from_llm_response(raw_response: str) -> dict:
+    """
+    Finds and parses the first valid JSON object from a raw LLM response string.
+    """
+    logger.debug("Attempting to extract JSON from raw LLM response...")
 
+    # 1. Look for a JSON markdown block first
+    match = re.search(r"```(?:json)?\s*({[\s\S]*?})\s*```", raw_response)
+    if match:
+        json_string = match.group(1)
+        logger.debug("Found JSON inside a markdown block.")
+        try:
+            return json.loads(json_string)
+        except json.JSONDecodeError as e:
+            logger.warning(f"Failed to parse JSON from markdown block: {e}")
+            # Fall through to the next method if parsing fails
+    
+    # 2. If no block is found (or it failed), find the outermost braces
+    logger.debug("Markdown block not found or failed. Searching for outermost braces.")
+    try:
+        first_brace = raw_response.find('{')
+        last_brace = raw_response.rfind('}')
+        if first_brace != -1 and last_brace != -1 and first_brace < last_brace:
+            json_string = raw_response[first_brace : last_brace + 1]
+            return json.loads(json_string)
+        else:
+            logger.error("Could not find a valid JSON structure (outermost braces).")
+            raise json.JSONDecodeError("No valid JSON object found in the response.", raw_response, 0)
+    except json.JSONDecodeError as e:
+        logger.error(f"Final JSON parsing attempt failed: {e}")
+        # Re-raise the exception to be caught by the calling logic (to invoke the corrector agent)
+        raise
 # def extract_json_from_llm_response(raw_response: str) -> dict:
 #     # --- 1) Pull out the JSON code‑block if present ---
 #     md = re.search(r"```(?:json)?\s*([\s\S]*?)\s*```", raw_response)