Update app.py

app.py

@@ -143,7 +143,7 @@ def find_file(path: str) -> Optional[Path]:
 # =============================================================================
 
 class PlanInput(BaseModel):
-    question: str = Field(description="The question to create a plan for")
+    question: str = Field(description="Brief summary of the task (keep under 100 chars)")
 
 @tool(args_schema=PlanInput)
 def create_plan(question: str) -> str:
@@ -157,6 +157,8 @@ def create_plan(question: str) -> str:
     3. What tools will you use?
     
     After calling this, execute the plan step-by-step.
+    
+    NOTE: Keep the question summary brief (under 100 chars) to avoid errors.
     """
     print(f"📋 Planning phase initiated for: {question[:100]}...")
     
@@ -172,7 +174,7 @@ Now proceed with Step 1 of your plan."""
 
 
 class ReflectInput(BaseModel):
-    current_situation: str = Field(description="Brief summary of what you've tried and where you are stuck")
+    current_situation: str = Field(description="What you've tried so far (keep brief, under 100 chars)")
 
 @tool(args_schema=ReflectInput)
 def reflect_on_progress(current_situation: str) -> str:
@@ -186,6 +188,8 @@ def reflect_on_progress(current_situation: str) -> str:
     - You've taken 5+ steps without getting closer to the answer
     
     This helps you step back and reconsider your approach.
+    
+    NOTE: Keep the situation summary brief (under 100 chars).
     """
     print(f"🤔 Reflection initiated: {current_situation[:100]}...")
     
@@ -527,6 +531,7 @@ def audio_transcription_tool(file_path: str) -> str:
     except Exception as e:
         return f"Error transcribing '{file_path}': {str(e)}"
 
+
 class YoutubeInput(BaseModel):
     video_url: str = Field(description="YouTube video URL")
 
@@ -720,45 +725,87 @@ def parse_tool_call_from_string(content: str, tools: List) -> List[ToolCall]:
     tool_input = None
     cleaned_str = None
 
-    func_match = re.search(
-        r"<function[(=]\s*([^)]+)\s*[)>](.*)",
+    # STRATEGY 1: Parse Groq's <function=name{...}> format
+    groq_match = re.search(
+        r"<function=(\w+)\s*(\{.*?\})\s*(?:>|</function>)",
         content,
-        re.DOTALL | re.IGNORECASE
+        re.DOTALL
     )
     
-    if func_match:
+    if groq_match:
         try:
-            tool_name = func_match.group(1).strip().replace("'", "").replace('"', '')
-            remaining_content = func_match.group(2)
+            tool_name = groq_match.group(1).strip()
+            json_str = groq_match.group(2).strip()
             
-            json_start_index = remaining_content.find('{')
-            if json_start_index != -1:
-                json_str = remaining_content[json_start_index:]
-                cleaned_str = json_str.strip()
-                cleaned_str = ''.join(c for c in cleaned_str if c.isprintable() or c in '\n\r\t')
-                cleaned_str = cleaned_str.strip().rstrip(',')
-                
-                tool_input = json.loads(cleaned_str)
-                print(f"🔧 Fallback: Parsed tool call for '{tool_name}'")
-            else:
-                print(f"⚠️ Fallback: Found <function> but no JSON blob.")
-                tool_name = None
-                
-        except json.JSONDecodeError as e:
-            print(f"⚠️ Fallback: json.loads failed, trying ast.literal_eval.")
+            # Unescape unicode and clean up
+            json_str = json_str.encode().decode('unicode_escape')
+            
+            tool_input = json.loads(json_str)
+            print(f"🔧 Fallback: Parsed Groq format for '{tool_name}'")
+            
+        except Exception as e:
+            print(f"⚠️ Fallback: Failed to parse Groq format: {e}")
+            tool_name = None
+
+    # STRATEGY 2: Try original <function(tool_name)>...{json_string}... format
+    if not tool_name:
+        func_match = re.search(
+            r"<function[(=]\s*([^)]+)\s*[)>](.*)",
+            content,
+            re.DOTALL | re.IGNORECASE
+        )
+        
+        if func_match:
             try:
-                if cleaned_str:
-                    potential_input = ast.literal_eval(cleaned_str)
-                    if isinstance(potential_input, dict):
-                        tool_input = potential_input
-                        print(f"🔧 Fallback: Parsed with ast.literal_eval for '{tool_name}'")
+                tool_name = func_match.group(1).strip().replace("'", "").replace('"', '')
+                remaining_content = func_match.group(2)
+                
+                json_start_index = remaining_content.find('{')
+                if json_start_index != -1:
+                    json_str = remaining_content[json_start_index:]
+                    cleaned_str = json_str.strip()
+                    cleaned_str = ''.join(c for c in cleaned_str if c.isprintable() or c in '\n\r\t')
+                    cleaned_str = cleaned_str.strip().rstrip(',')
+                    
+                    tool_input = json.loads(cleaned_str)
+                    print(f"🔧 Fallback: Parsed standard format for '{tool_name}'")
+                else:
+                    print(f"⚠️ Fallback: Found <function> but no JSON blob.")
+                    tool_name = None
+                    
+            except json.JSONDecodeError as e:
+                print(f"⚠️ Fallback: json.loads failed, trying ast.literal_eval.")
+                try:
+                    if cleaned_str:
+                        potential_input = ast.literal_eval(cleaned_str)
+                        if isinstance(potential_input, dict):
+                            tool_input = potential_input
+                            print(f"🔧 Fallback: Parsed with ast.literal_eval for '{tool_name}'")
+                        else:
+                            tool_name = None
                     else:
                         tool_name = None
-                else:
+                except:
                     tool_name = None
-            except:
-                tool_name = None
     
+    # STRATEGY 3: Look for simple tool mentions and create default calls
+    if not tool_name and content:
+        # Look for tool name mentions
+        for tool in tools:
+            if tool.name in content.lower():
+                tool_name = tool.name
+                # Create minimal valid input
+                tool_input = {}
+                if tool.args_schema:
+                    schema = tool.args_schema.model_json_schema()
+                    for prop, details in schema.get('properties', {}).items():
+                        if prop in schema.get('required', []):
+                            # Extract value from content if possible
+                            tool_input[prop] = "summarized_input"
+                print(f"🔧 Fallback: Created default call for mentioned tool '{tool_name}'")
+                break
+    
+    # FINAL VALIDATION
     if tool_name and tool_input is not None:
         if any(t.name == tool_name for t in tools):
             tool_call = ToolCall(
@@ -987,7 +1034,7 @@ Turn 7: final_answer_tool("1.796 trillion")
                 )
                 messages_to_send.append(hint)
             
-            # Invoke LLM
+            # Invoke LLM with better error handling
             max_retries = 3
             ai_message = None
             for attempt in range(max_retries):
@@ -995,12 +1042,39 @@ Turn 7: final_answer_tool("1.796 trillion")
                     ai_message = self.llm_with_tools.invoke(messages_to_send)
                     break
                 except Exception as e:
-                    print(f"⚠️ LLM attempt {attempt+1}/{max_retries} failed: {e}")
+                    error_str = str(e)
+                    print(f"⚠️ LLM attempt {attempt+1}/{max_retries} failed: {error_str[:200]}")
+                    
+                    # If it's a tool_use_failed error, try without forcing tools
+                    if "tool_use_failed" in error_str and attempt < max_retries - 1:
+                        print("🔧 Retrying without strict tool enforcement...")
+                        try:
+                            # Try with a simpler LLM call
+                            simple_llm = ChatGroq(
+                                temperature=0,
+                                groq_api_key=os.getenv("GROQ_API_KEY"),
+                                model_name="llama-3.3-70b-versatile",
+                                max_tokens=4096,
+                                timeout=60
+                            )
+                            ai_message = simple_llm.invoke(messages_to_send)
+                            # Manually parse for tool calls
+                            if ai_message.content:
+                                parsed_calls = parse_tool_call_from_string(ai_message.content, self.tools)
+                                if parsed_calls:
+                                    ai_message.tool_calls = parsed_calls
+                                    ai_message.content = ""
+                            break
+                        except Exception as e2:
+                            print(f"⚠️ Simple LLM also failed: {e2}")
+                    
                     if attempt == max_retries - 1:
+                        # Last resort: return a message asking to proceed differently
                         ai_message = AIMessage(
-                            content=f"Error: LLM failed after {max_retries} attempts: {e}"
+                            content="I need to approach this differently. Let me try a more direct method."
                         )
-                    time.sleep(2 ** attempt)
+                    else:
+                        time.sleep(2 ** attempt)
             
             # Fallback Parsing
             if not ai_message.tool_calls and isinstance(ai_message.content, str) and ai_message.content.strip():
@@ -1071,8 +1145,7 @@ Turn 7: final_answer_tool("1.796 trillion")
         
         self.graph = graph_builder.compile()
         print("✅ Planning & Reflection Agent graph compiled successfully.")
-
-
+        
 
     def __call__(self, question: str) -> str:
         print(f"\n--- Starting Agent Run for Question ---")