Update app.py

app.py

@@ -483,15 +483,20 @@ You are **GAKR AI**, an expert assistant specializing in depth-calibrated respon
             def normalize_tool_name(name: str) -> str:
                 if not name:
                     return ""
+                # Remove spaces, convert to lowercase, normalize underscores
                 normalized = name.strip().lower().replace(" ", "_").replace("-", "_")
+                # Handle variations: "web search", "websearch", "web_search" -> "web_search"
+                if "web" in normalized and "search" in normalized:
+                    return "web_search"
                 if normalized == "websearch":
                     return "web_search"
                 return normalized
 
             def parse_tool_call(text: str) -> Optional[Dict[str, Any]]:
-                # ==== ENHANCED DETECTOR: Handle incomplete tool calls ====
+                # ==== ENHANCED DETECTOR: Handle incomplete tool calls & variations ====
                 # When <|tool_call_start|> is detected, it's 100% confirmation of a tool call
                 # The model may not always generate <|tool_call_end|>, so we extract what we can
+                # Also handles variations like "web_ Search" (with space/case variations)
                 
                 if "<|tool_call_start|>" in text:
                     start_pos = text.find("<|tool_call_start|>") + len("<|tool_call_start|>")
@@ -503,24 +508,27 @@ You are **GAKR AI**, an expert assistant specializing in depth-calibrated respon
                         print(f"🔍 [PARSE] Complete token pair detected. Payload: {payload[:80]}")
                     else:
                         # Case 2: Incomplete - only start token, extract what we have
-                        # Look for the tool call pattern: [web_search(...)] or web_search(...)
                         remaining = text[start_pos:].strip()
                         print(f"🔍 [PARSE] Incomplete token pair. Remaining buffer: {remaining[:80]}")
+                        payload = None
                         
-                        # Try to extract from brackets first: [web_search(query="...")]
-                        bracket_match = re.search(r'\[([a-zA-Z_]\w*)\s*\((.*?)\)\]', remaining)
+                        # Try to extract from brackets first: [web_search(...)] or [web_ Search(...)]
+                        # Pattern: [word(args)] - allowing for spaces and case variations
+                        bracket_match = re.search(r'\[([a-zA-Z_\s]+?)\s*\((.*?)\)\s*\]', remaining)
                         if bracket_match:
-                            payload = f"{bracket_match.group(1)}({bracket_match.group(2)})"
-                            print(f"🔍 [PARSE] Extracted from brackets: {payload}")
+                            func_base = bracket_match.group(1).replace(" ", "_").lower()  # Normalize spaces
+                            func_args = bracket_match.group(2)
+                            payload = f"{func_base}({func_args})"
+                            print(f"🔍 [PARSE] Extracted from brackets (normalized): {payload}")
                         else:
-                            # Try bare function call: web_search(query="...")
-                            func_match = re.search(r'([a-zA-Z_]\w*)\s*\((.*?)\)', remaining)
+                            # Try bare function call: web_search(...) or web_ Search(...)
+                            # Allow for spaces: web_ search, web_search, etc.
+                            func_match = re.search(r'([a-zA-Z_]+(?:\s+[a-zA-Z_]+)?)\s*\((.*?)\)', remaining)
                             if func_match:
-                                # Extract until first complete closing paren
-                                func_name = func_match.group(1)
-                                args_part = func_match.group(2)
-                                payload = f"{func_name}({args_part})"
-                                print(f"🔍 [PARSE] Extracted bare function: {payload}")
+                                func_base = func_match.group(1).replace(" ", "_").lower()  # Normalize spaces
+                                func_args = func_match.group(2)
+                                payload = f"{func_base}({func_args})"
+                                print(f"🔍 [PARSE] Extracted bare function (normalized): {payload}")
                             else:
                                 print(f"⚠️ [PARSE] Could not extract tool call from: {remaining[:50]}")
                                 return None
@@ -543,9 +551,11 @@ You are **GAKR AI**, an expert assistant specializing in depth-calibrated respon
                         if clean_payload.startswith("[") and clean_payload.endswith("]"):
                             clean_payload = clean_payload[1:-1].strip()
 
-                        m = re.match(r"^([a-zA-Z_]\w*)\s*\((.*)\)\s*$", clean_payload)
+                        m = re.match(r"^([a-zA-Z_]+(?:\s+[a-zA-Z_]+)?)\s*\((.*)\)\s*$", clean_payload)
                         if m:
-                            name = normalize_tool_name(m.group(1))
+                            # Normalize function name: remove spaces, convert to lowercase
+                            name_raw = m.group(1)
+                            name = normalize_tool_name(name_raw)
                             args_str = m.group(2).strip()
                             args: Dict[str, Any] = {}
 
@@ -576,38 +586,33 @@ You are **GAKR AI**, an expert assistant specializing in depth-calibrated respon
                         if isinstance(tc, dict) and "name" in tc and "args" in tc:
                             return {"name": normalize_tool_name(tc.get("name", "")), "args": tc.get("args", {})}
 
-                # 3) Bare Pythonic call without special tokens (fallback)
+                # 3) Bare Pythonic call without special tokens (fallback) - also handle spacing
                 stripped = text.strip()
                 raw = stripped
                 if raw.startswith("[") and raw.endswith("]"):
                     raw = raw[1:-1].strip()
-                if raw.startswith("web_search(") and raw.endswith(")"):
-                    args_str = raw[len("web_search("):-1].strip()
-                    args: Dict[str, Any] = {}
-                    mq = re.search(r'query\s*=\s*\"(.*?)\"|query\s*=\s*\'(.*?)\'', args_str)
-                    if mq:
-                        args["query"] = mq.group(1) or mq.group(2) or ""
-                    else:
-                        mpos = re.match(r'^\"(.*)\"$|^\'(.*)\'$', args_str)
-                        if mpos:
-                            pos = mpos.group(1) or mpos.group(2)
-                            if pos is not None:
-                                args["query"] = pos
-                    return {"name": "web_search", "args": args}
-
-                if raw.startswith("websearch(") and raw.endswith(")"):
-                    args_str = raw[len("websearch("):-1].strip()
-                    args: Dict[str, Any] = {}
-                    mq = re.search(r'query\s*=\s*\"(.*?)\"|query\s*=\s*\'(.*?)\'', args_str)
-                    if mq:
-                        args["query"] = mq.group(1) or mq.group(2) or ""
-                    else:
-                        mpos = re.match(r'^\"(.*)\"$|^\'(.*)\'$', args_str)
-                        if mpos:
-                            pos = mpos.group(1) or mpos.group(2)
-                            if pos is not None:
-                                args["query"] = pos
-                    return {"name": "web_search", "args": args}
+                
+                # Handle: web_search(...), web_Search(...), web_ search(...), etc.
+                bare_match = re.match(r'([a-zA-Z_]+(?:\s+[a-zA-Z_]+)?)\s*\((.*?)\)\s*$', raw)
+                if bare_match:
+                    func_name_raw = bare_match.group(1)
+                    func_name = normalize_tool_name(func_name_raw)
+                    
+                    # Only process if it's a recognized tool (web_search)
+                    if func_name == "web_search":
+                        args_str = bare_match.group(2).strip()
+                        args: Dict[str, Any] = {}
+                        mq = re.search(r'query\s*=\s*\"(.*?)\"|query\s*=\s*\'(.*?)\'', args_str)
+                        if mq:
+                            args["query"] = mq.group(1) or mq.group(2) or ""
+                        else:
+                            mpos = re.match(r'^\"(.*)\"$|^\'(.*)\'$', args_str)
+                            if mpos:
+                                pos = mpos.group(1) or mpos.group(2)
+                                if pos is not None:
+                                    args["query"] = pos
+                        print(f"✅ [PARSE] Bare tool call found: {func_name}({args})")
+                        return {"name": func_name, "args": args}
 
                 return None