Update app.py

app.py

@@ -654,47 +654,124 @@ def extract_json_from_llm_response(raw_response: str) -> dict:
         logger.error("Sanitized JSON still invalid:\n%s", json_string)
         raise
 
-def clean_base64_for_model(raw_b64):
-    """
-    Normalize input into a valid data:image/png;base64,<payload> string.
+# def clean_base64_for_model(raw_b64):
+#     """
+#     Normalize input into a valid data:image/png;base64,<payload> string.
+
+#     Accepts:
+#       - a list of base64 strings → picks the first element
+#       - a PIL Image instance       → encodes to PNG/base64
+#       - a raw base64 string        → strips whitespace and data URI prefix
+#     """
+#     if not raw_b64:
+#         return ""
+
+#     # 1. If it’s a list, take its first element
+#     if isinstance(raw_b64, list):
+#         raw_b64 = raw_b64[0] if raw_b64 else ""
+#         if not raw_b64:
+#             return ""
+
+#     # 2. If it’s a PIL Image, convert to base64
+#     if isinstance(raw_b64, Image.Image):
+#         buf = io.BytesIO()
+#         raw_b64.save(buf, format="PNG")
+#         raw_b64 = base64.b64encode(buf.getvalue()).decode()
+
+#     # 3. At this point it must be a string
+#     if not isinstance(raw_b64, str):
+#         raise TypeError(f"Expected base64 string or PIL Image, got {type(raw_b64)}")
+
+#     # 4. Strip any existing data URI prefix, whitespace, or newlines
+#     clean_b64 = re.sub(r"^data:image\/[a-zA-Z]+;base64,", "", raw_b64)
+#     clean_b64 = clean_b64.replace("\n", "").replace("\r", "").strip()
+
+#     # 5. Validate it’s proper base64
+#     try:
+#         base64.b64decode(clean_b64)
+#     except Exception as e:
+#         logger.error(f"Invalid Base64 passed to model: {e}")
+#         raise
+
+#     # 6. Return with the correct data URI prefix
+#     return f"data:image/png;base64,{clean_b64}"
 
-    Accepts:
-      - a list of base64 strings → picks the first element
-      - a PIL Image instance       → encodes to PNG/base64
-      - a raw base64 string        → strips whitespace and data URI prefix
+# reducing imagebase64 size if greater than something 
+def reduce_image_size_to_limit(clean_b64_str, max_kb=4000):
     """
+    Reduce an image's size to be as close as possible to max_kb without exceeding it.
+    Returns the final base64 string and its size in KB.
+    """
+    import re, base64
+    from io import BytesIO
+    from PIL import Image
+
+    # Remove the data URI prefix
+    base64_data = re.sub(r"^data:image\/[a-zA-Z]+;base64,", "", clean_b64_str)
+    image_data = base64.b64decode(base64_data)
+
+    # Load into PIL
+    img = Image.open(BytesIO(image_data))
+
+    low, high = 20, 95  # reasonable JPEG quality range
+    best_b64 = None
+    best_size_kb = 0
+
+    while low <= high:
+        mid = (low + high) // 2
+        buffer = BytesIO()
+        img.save(buffer, format="JPEG", quality=mid)
+        size_kb = len(buffer.getvalue()) / 1024
+
+        if size_kb <= max_kb:
+            # This quality is valid, try higher
+            best_b64 = base64.b64encode(buffer.getvalue()).decode("utf-8")
+            best_size_kb = size_kb
+            low = mid + 1
+        else:
+            # Too big, try lower
+            high = mid - 1
+
+    return f"data:image/jpeg;base64,{best_b64}"
+
+#clean the base64 model here
+def clean_base64_for_model(raw_b64):
+    import io, base64, re
+    from PIL import Image
+
     if not raw_b64:
-        return ""
+        return "", ""
 
-    # 1. If it’s a list, take its first element
     if isinstance(raw_b64, list):
         raw_b64 = raw_b64[0] if raw_b64 else ""
         if not raw_b64:
-            return ""
+            return "", ""
 
-    # 2. If it’s a PIL Image, convert to base64
     if isinstance(raw_b64, Image.Image):
         buf = io.BytesIO()
         raw_b64.save(buf, format="PNG")
         raw_b64 = base64.b64encode(buf.getvalue()).decode()
 
-    # 3. At this point it must be a string
     if not isinstance(raw_b64, str):
         raise TypeError(f"Expected base64 string or PIL Image, got {type(raw_b64)}")
 
-    # 4. Strip any existing data URI prefix, whitespace, or newlines
+    # Remove data URI prefix if present
     clean_b64 = re.sub(r"^data:image\/[a-zA-Z]+;base64,", "", raw_b64)
     clean_b64 = clean_b64.replace("\n", "").replace("\r", "").strip()
 
-    # 5. Validate it’s proper base64
-    try:
-        base64.b64decode(clean_b64)
-    except Exception as e:
-        logger.error(f"Invalid Base64 passed to model: {e}")
-        raise
-
-    # 6. Return with the correct data URI prefix
-    return f"data:image/png;base64,{clean_b64}"
+    # Log original size
+    original_size = len(clean_b64.encode("utf-8"))
+    print(f"Original Base64 size (bytes): {original_size}")
+    if original_size> 4000000:
+        # Reduce size to under 4 MB
+        reduced_b64 = reduce_image_size_to_limit(clean_b64, max_kb=4000)
+        clean_b64_2 = re.sub(r"^data:image\/[a-zA-Z]+;base64,", "", reduced_b64)
+        clean_b64_2 = clean_b64_2.replace("\n", "").replace("\r", "").strip()
+        reduced_size = len(clean_b64_2.encode("utf-8"))
+        print(f"Reduced Base64 size (bytes): {reduced_size}")
+        # Return both prefixed and clean reduced versions
+        return f"data:image/jpeg;base64,{reduced_b64}"
+    return f"data:image/jpeg;base64,{clean_b64}"
 
 def format_scratch_pseudo_code(code_string):
     """