Update hedis_engine.py

hedis_engine.py

@@ -75,33 +75,34 @@ class InteractiveHedisComplianceEngine:
         Get HEDIS criteria from expert and present to user for feedback.
         Returns approved criteria or None if user exits.
         """
-        # Create task for getting HEDIS criteria
-        hedis_task_description = (
-            f"Provide the official criteria for HEDIS measure {self.measure_code}, including:\n"
-            "- Required tests or procedures\n"
-            "- Diagnosis/procedure codes\n"
-            "- Required medications\n"
-            "- Inclusion and exclusion criteria\n"
-            f"- Timeframes for each requirement (e.g., within X years of {self.measurement_year})\n\n"
-            f"You MUST compute and include absolute date ranges using {self.measurement_year}.\n"
-        )
-        
+        # Build the task description carefully to avoid string formatting issues
+        base_description = f"""Provide the official criteria for HEDIS measure {self.measure_code}, including:
+- Required tests or procedures
+- Diagnosis/procedure codes  
+- Required medications
+- Inclusion and exclusion criteria
+- Timeframes for each requirement (compute absolute date ranges using {self.measurement_year})
+
+You MUST compute and include absolute date ranges using {self.measurement_year}."""
+
         if suggestions:
-            hedis_task_description += f"\n\nIncorporate these suggestions: {suggestions}\n"
-        
-        hedis_task_description += (
-            "\n\nCRITICAL FORMATTING REQUIREMENTS:\n"
-            "- Return ONLY valid JSON without any markdown formatting, code blocks, or extra text\n"
-            "- Do not wrap the JSON in ```json``` blocks\n"
-            "- Do not add any explanatory text before or after the JSON\n"
-            "- The response must start with { and end with }\n"
-            "- Ensure all JSON keys and string values are properly quoted\n"
-            "- Example format: {\"measure\":\"...\",\"required_tests\":[...],\"codes\":{...}}"
-        )
+            base_description += f"\n\nIncorporate these suggestions: {suggestions}"
+
+        formatting_requirements = """
+
+CRITICAL FORMATTING REQUIREMENTS:
+- Return ONLY valid JSON without any markdown formatting, code blocks, or extra text
+- Do not wrap the JSON in code blocks
+- Do not add any explanatory text before or after the JSON
+- The response must start with {{ and end with }}
+- Ensure all JSON keys and string values are properly quoted
+- Required JSON fields: measure, required_tests, required_medications, codes, timeframes, inclusions, exclusions"""
+
+        full_description = base_description + formatting_requirements
 
         hedis_task = Task(
-            description=hedis_task_description,
-            expected_output="Valid JSON object (no markdown, no code blocks) with fields: 'measure','required_tests','required_medications','codes','timeframes','inclusions','exclusions'.",
+            description=full_description,
+            expected_output="Valid JSON object with required fields (no markdown, no code blocks)",
             agent=self.hedis_expert,
         )
 
@@ -119,7 +120,13 @@ class InteractiveHedisComplianceEngine:
             "measurement_year": self.measurement_year,
         }
         
-        result = criteria_crew.kickoff(inputs=inputs)
+        try:
+            result = criteria_crew.kickoff(inputs=inputs)
+            print(f"Raw crew result type: {type(result)}")
+            print(f"Raw crew result: {repr(str(result)[:200])}...")  # Show first 200 chars
+        except Exception as e:
+            print(f"Crew execution error: {e}")
+            return {"raw_output": f"Crew execution failed: {str(e)}", "parse_error": str(e)}
         
         try:
             # Clean the result string - remove markdown code blocks and extra whitespace
@@ -153,12 +160,66 @@ class InteractiveHedisComplianceEngine:
             # Try to parse as JSON
             criteria_json = json.loads(result_str)
             return criteria_json
-        except json.JSONDecodeError as e:
+    def get_hedis_criteria_simple(self, suggestions: str = "") -> dict:
+        """
+        Simplified method to get HEDIS criteria with minimal string formatting.
+        """
+        try:
+            # Create a simple, direct prompt
+            prompt_parts = [
+                f"Provide HEDIS measure {self.measure_code} criteria for year {self.measurement_year}.",
+                "Include: required tests, medications, codes, timeframes, inclusions, exclusions.",
+            ]
+            
+            if suggestions:
+                prompt_parts.append(f"Suggestions: {suggestions}")
+            
+            prompt_parts.append("Respond with valid JSON only. No markdown, no code blocks, just JSON.")
+            
+            simple_description = " ".join(prompt_parts)
+            
+            hedis_task = Task(
+                description=simple_description,
+                expected_output="JSON object with measure criteria",
+                agent=self.hedis_expert,
+            )
+
+            # Create temporary crew
+            criteria_crew = Crew(
+                agents=[self.hedis_expert],
+                tasks=[hedis_task],
+                process=Process.sequential,
+                verbose=True,
+            )
+
+            # Execute
+            inputs = {"measure_code": self.measure_code, "measurement_year": self.measurement_year}
+            result = criteria_crew.kickoff(inputs=inputs)
+            
+            # Try to parse the result
+            result_str = str(result).strip()
+            
+            # Basic cleaning
+            if result_str.startswith("```"):
+                lines = result_str.split('\n')
+                # Remove first and last lines if they contain ```
+                if lines[0].strip().startswith('```'):
+                    lines = lines[1:]
+                if lines and lines[-1].strip() == '```':
+                    lines = lines[:-1]
+                result_str = '\n'.join(lines).strip()
+            
+            return json.loads(result_str)
+            
+        except Exception as e:
+            print(f"Simple method error: {e}")
+            return {"raw_output": str(result) if 'result' in locals() else "No result", "parse_error": str(e)}
             print(f"JSON parsing error: {e}")
+            print(f"Raw result type: {type(result)}")
             print(f"Raw result: {repr(str(result))}")
-            print(f"Cleaned result: {repr(result_str)}")
+            print(f"Cleaned result: {repr(result_str if 'result_str' in locals() else 'N/A')}")
             # If not valid JSON, return as string
-            return {"raw_output": str(result), "parse_error": str(e)}
+            return {"raw_output": str(result), "parse_error": f"JSON parsing failed: {str(e)}"}
 
     def display_criteria(self, criteria: dict) -> None:
         """Display the HEDIS criteria in a user-friendly format."""