Update app.py

app.py

@@ -1,4 +1,3 @@
-
 import os
 import json
 import time
@@ -25,7 +24,7 @@ logging.basicConfig(
 logger = logging.getLogger("g4f-smart-router")
 
 # =====================================================
-# COOKIES (للمزودات التي تحتاجها مثل Perplexity)
+# COOKIES
 # =====================================================
 def _load_cookies_raw() -> Dict[str, Any]:
     raw_env = (os.getenv("COOKIES_JSON") or "").strip()
@@ -102,7 +101,7 @@ class TTLCache:
 CACHE = TTLCache(max_size=100, ttl_seconds=300)
 
 # =====================================================
-# PROVIDERS - قائمة مزودات قد تعمل
+# PROVIDERS
 # =====================================================
 def get_provider(name: str):
     try:
@@ -110,7 +109,6 @@ def get_provider(name: str):
     except Exception:
         return None
 
-# ترتيب المزودات حسب احتمال النجاح
 REAL_PROVIDERS = {
     "Blackbox": get_provider("Blackbox"),
     "DeepSeek": get_provider("DeepSeek"),
@@ -122,9 +120,6 @@ REAL_PROVIDERS = {
 }
 REAL_PROVIDERS = {k: v for k, v in REAL_PROVIDERS.items() if v}
 
-# =====================================================
-# MODELS - قائمة نماذج لكل مزود
-# =====================================================
 PROVIDER_MODELS_FALLBACK = {
     "Blackbox": ["gpt-4o", "claude-3.5-sonnet", "llama-3.1-70b", "gemini-pro"],
     "DeepSeek": ["deepseek-chat", "deepseek-coder"],
@@ -135,15 +130,11 @@ PROVIDER_MODELS_FALLBACK = {
     "Qwen": ["qwen-max", "qwen-plus", "qwen-turbo"],
 }
 
-# =====================================================
-# MODEL DISCOVERY
-# =====================================================
 _PROVIDER_MODEL_CACHE = {}
 
 def discover_provider_models(provider_obj: Any, provider_name: str) -> List[str]:
     if provider_name in _PROVIDER_MODEL_CACHE:
         return _PROVIDER_MODEL_CACHE[provider_name]
-
     candidates = []
     for attr in ("models", "model", "default_model", "available_models", "supported_models"):
         try:
@@ -157,17 +148,15 @@ def discover_provider_models(provider_obj: Any, provider_name: str) -> List[str]
                     candidates.append(str(val))
         except Exception:
             pass
-
     if not candidates:
         candidates = PROVIDER_MODELS_FALLBACK.get(provider_name, ["gpt-4o"])
-
     seen = set()
     unique = [m for m in candidates if not (m in seen or seen.add(m))]
     _PROVIDER_MODEL_CACHE[provider_name] = unique
     return unique
 
 # =====================================================
-# STREAM CLEANER - لتنظيف شذرات الرد
+# STREAM CLEANER
 # =====================================================
 def clean_stream(chunk):
     try:
@@ -203,8 +192,7 @@ def clean_stream(chunk):
         return ""
 
 # =====================================================
-# استخراج النص من content (يدعم string و list)
-# إصلاح: Claude يرسل content كـ list من الكائنات
+# استخراج النص من content
 # =====================================================
 def extract_text_from_content(content) -> str:
     if isinstance(content, str):
@@ -218,8 +206,13 @@ def extract_text_from_content(content) -> str:
                 if item.get("type") == "text":
                     parts.append(item.get("text", ""))
                 elif item.get("type") == "tool_result":
-                    # استخراج نتيجة الأداة وتمريرها كنص
                     tool_content = item.get("content", "")
+                    tool_use_id = item.get("tool_use_id", "")
+                    # ======================================================
+                    # [إصلاح #3] - ربط نتيجة الأداة بمعرفها tool_use_id
+                    # ======================================================
+                    if tool_use_id:
+                        parts.append(f"[Tool Result for {tool_use_id}]:")
                     if isinstance(tool_content, list):
                         for tc in tool_content:
                             if isinstance(tc, dict) and tc.get("type") == "text":
@@ -228,15 +221,15 @@ def extract_text_from_content(content) -> str:
                                 parts.append(tc)
                     elif isinstance(tool_content, str):
                         parts.append(tool_content)
-                    # إضافة معلومات عن الأداة
-                    tool_use_id = item.get("tool_use_id", "")
-                    if tool_use_id:
-                        parts.insert(len(parts) - 1, f"[Tool Result for {tool_use_id}]: ")
                 elif item.get("type") == "tool_use":
-                    # تحويل طلب الأداة إلى نص مفهوم للنموذج
                     tool_name = item.get("name", "unknown")
                     tool_input = item.get("input", {})
-                    parts.append(f"[Called tool: {tool_name} with input: {json.dumps(tool_input, ensure_ascii=False)}]")
+                    # الحفاظ على tool_id لربط الاستجابة لاحقاً
+                    tool_id = item.get("id", "")
+                    parts.append(
+                        f"[Called tool: {tool_name} (id:{tool_id}) "
+                        f"with input: {json.dumps(tool_input, ensure_ascii=False)}]"
+                    )
                 elif "text" in item:
                     parts.append(item["text"])
                 elif "content" in item:
@@ -247,54 +240,57 @@ def extract_text_from_content(content) -> str:
     return ""
 
 # =====================================================
-# TOOL CALL PARSER - محلل طلبات الأدوات من النص الخام
-# يكتشف ويحلل وسوم <tool_call> من استجابة النموذج
+# TOOL CALL PARSER
 # =====================================================
 class ToolCallParser:
     """
-    يكتشف أنماط Tool Call المختلفة من النماذج المفتوحة:
-    1. <tool_call>{"name": "...", "arguments": {...}}</tool_call>
-    2. ```tool_call\n{"name": "...", "arguments": {...}}\n```
-    3. {"tool_calls": [{"function": {"name": "...", "arguments": {...}}}]}
-    4. <function=name>{"arg": "val"}</function>
-    5. [TOOL_CALL] name(args) [/TOOL_CALL]
+    يكتشف ويحلل وسوم Tool Call من استجابة النموذج.
+    يدعم أنماطاً متعددة مع regex محسّن يقبل المسافات والأسطر الجديدة.
     """
 
-    # أنماط regex للكشف عن tool calls
+    # ======================================================
+    # [إصلاح #2] - تحديث الـ Regex ليكون non-greedy
+    # ويقبل المسافات البيضاء والأسطر الجديدة قبل وبعد الوسوم
+    # ======================================================
     PATTERNS = [
-        # النمط 1: <tool_call>JSON</tool_call>
+        # النمط 1: <tool_call> مع مسافات مرنة حول الوسم والـ JSON
         re.compile(
-            r'<tool_call>\s*(\{.*?\})\s*</tool_call>',
-            re.DOTALL
+            r'\s*<tool_call>\s*(\{.*?\})\s*</tool_call>\s*',
+            re.DOTALL | re.IGNORECASE
         ),
-        # النمط 2: ```tool_call\nJSON\n```
+        # النمط 2: ```tool_call أو ```json مع مسافات مرنة
         re.compile(
-            r'```(?:tool_call|json)?\s*\n?\s*(\{[^`]*?"(?:name|function)"[^`]*?\})\s*\n?```',
-            re.DOTALL
+            r'```(?:tool_call|json)?\s*\n?\s*(\{.*?"(?:name|function)".*?\})\s*\n?\s*```',
+            re.DOTALL | re.IGNORECASE
         ),
         # النمط 3: <function=name>JSON</function>
         re.compile(
-            r'<function=(\w+)>\s*(\{.*?\})\s*</function>',
-            re.DOTALL
+            r'\s*<function=(\w+)>\s*(\{.*?\})\s*</function>\s*',
+            re.DOTALL | re.IGNORECASE
         ),
         # النمط 4: [TOOL_CALL]...[/TOOL_CALL]
         re.compile(
-            r'\[TOOL_CALL\]\s*(.*?)\s*\[/TOOL_CALL\]',
-            re.DOTALL
+            r'\s*\[TOOL_CALL\]\s*(.*?)\s*\[/TOOL_CALL\]\s*',
+            re.DOTALL | re.IGNORECASE
         ),
-        # النمط 5: ✿FUNCTION✿: name\n✿ARGS✿: JSON\n✿RESULT✿
+        # النمط 5: ✿FUNCTION✿
         re.compile(
             r'✿FUNCTION✿:\s*(\w+)\s*\n✿ARGS✿:\s*(\{.*?\})\s*(?:\n✿RESULT✿)?',
             re.DOTALL
         ),
     ]
 
-    # أنماط بداية tool call (للكشف المبكر أثناء الـ streaming)
+    # ======================================================
+    # [إصلاح #2] - علامات البداية محدّثة لتشمل المسافات
+    # ======================================================
     START_MARKERS = [
         '<tool_call>',
         '```tool_call',
+        '```json',
         '<function=',
+        '[tool_call]',        # نسخة lowercase للمرونة
         '[TOOL_CALL]',
+        '✿function✿',
         '✿FUNCTION✿',
         '{"tool_calls"',
         '"tool_calls":',
@@ -307,72 +303,79 @@ class ToolCallParser:
 
     @classmethod
     def might_contain_tool_call(cls, text: str) -> bool:
-        """فحص سريع: هل النص قد يحتوي على بداية tool call؟"""
-        text_lower = text.lower()
+        """
+        فحص سريع: هل النص قد يحتوي على بداية tool call؟
+        [إصلاح #2] - يتجاهل حالة الأحرف ويتعامل مع المسافات
+        """
+        # تنظيف النص من المسافات الزائدة للفحص
+        text_stripped = text.strip().lower()
         for marker in cls.START_MARKERS:
-            if marker.lower() in text_lower:
+            if marker.lower() in text_stripped:
                 return True
+        # فحص إضافي: هل يبدأ بـ { ويحتوي "name"؟ (JSON مباشر)
+        if text_stripped.startswith('{') and '"name"' in text_stripped:
+            return True
         return False
 
     @classmethod
-    def parse_tool_calls(cls, text: str, available_tools: Optional[List[Dict]] = None) -> Tuple[str, List[Dict]]:
+    def parse_tool_calls(
+        cls,
+        text: str,
+        available_tools: Optional[List[Dict]] = None
+    ) -> Tuple[str, List[Dict]]:
         """
         تحليل النص واستخراج tool calls منه.
-        
-        يُرجع:
-        - النص النظيف (بدون وسوم الأدوات)
-        - قائمة بـ tool calls المكتشفة بصيغة Anthropic
+        [إصلاح #2] - regex محسّن مع non-greedy matching
         """
         tool_calls = []
         clean_text = text
 
-        # النمط 1: <tool_call>JSON</tool_call>
-        pattern1_matches = re.finditer(
-            r'<tool_call>\s*(\{.*?\})\s*</tool_call>',
-            text, re.DOTALL
+        # ---- النمط 1: <tool_call>JSON</tool_call> ----
+        pattern1 = re.compile(
+            r'\s*<tool_call>\s*(\{.*?\})\s*</tool_call>\s*',
+            re.DOTALL | re.IGNORECASE
         )
-        for match in pattern1_matches:
+        for match in pattern1.finditer(text):
             try:
                 raw_json = match.group(1).strip()
                 parsed = json.loads(raw_json)
                 tool_call = cls._normalize_tool_call(parsed, available_tools)
                 if tool_call:
                     tool_calls.append(tool_call)
-                    clean_text = clean_text.replace(match.group(0), "")
+                    clean_text = clean_text.replace(match.group(0), " ", 1)
             except json.JSONDecodeError as e:
-                logger.warning(f"Failed to parse tool_call JSON: {e}")
-                # محاولة إصلاح JSON المكسور
-                fixed = cls._try_fix_json(raw_json)
+                logger.warning(f"[Parser] Failed to parse tool_call JSON: {e}")
+                fixed = cls._try_fix_json(match.group(1).strip())
                 if fixed:
                     tool_call = cls._normalize_tool_call(fixed, available_tools)
                     if tool_call:
                         tool_calls.append(tool_call)
-                        clean_text = clean_text.replace(match.group(0), "")
+                        clean_text = clean_text.replace(match.group(0), " ", 1)
 
-        # النمط 2: ```tool_call\nJSON\n```
+        # ---- النمط 2: ```tool_call\nJSON\n``` ----
         if not tool_calls:
-            pattern2_matches = re.finditer(
-                r'```(?:tool_call|json)?\s*\n?\s*(\{[^`]*?"(?:name|function)"[^`]*?\})\s*\n?```',
-                text, re.DOTALL
+            pattern2 = re.compile(
+                r'```(?:tool_call|json)?\s*\n?\s*(\{.*?"(?:name|function)".*?\})\s*\n?\s*```',
+                re.DOTALL | re.IGNORECASE
             )
-            for match in pattern2_matches:
+            for match in pattern2.finditer(text):
                 try:
                     raw_json = match.group(1).strip()
                     parsed = json.loads(raw_json)
                     tool_call = cls._normalize_tool_call(parsed, available_tools)
                     if tool_call:
                         tool_calls.append(tool_call)
-                        clean_text = clean_text.replace(match.group(0), "")
+                        clean_text = clean_text.replace(match.group(0), " ", 1)
                 except json.JSONDecodeError:
                     pass
 
-        # النمط 3: <function=name>JSON</function>
+        # ---- النمط 3: <function=name>JSON</function> ----
         if not tool_calls:
-            pattern3_matches = re.finditer(
-                r'<function=(\w+)>\s*(\{.*?\})\s*</function>',
-                text, re.DOTALL
+            pattern3 = re.compile(
+                r'\s*<function=(\w+)>\s*(\{.*?\})\s*</function>\s*',
+                re.DOTALL | re.IGNORECASE
             )
-            for match in pattern3_matches:
+            for match in pattern3.finditer(text):
                 try:
                     func_name = match.group(1)
                     args_json = json.loads(match.group(2).strip())
@@ -386,27 +389,26 @@ class ToolCallParser:
                         tool_call = cls._validate_against_tools(tool_call, available_tools)
                     if tool_call:
                         tool_calls.append(tool_call)
-                        clean_text = clean_text.replace(match.group(0), "")
+                        clean_text = clean_text.replace(match.group(0), " ", 1)
                 except json.JSONDecodeError:
                     pass
 
-        # النمط 4: [TOOL_CALL]...[/TOOL_CALL]
+        # ---- النمط 4: [TOOL_CALL]...[/TOOL_CALL] ----
         if not tool_calls:
-            pattern4_matches = re.finditer(
-                r'\[TOOL_CALL\]\s*(.*?)\s*\[/TOOL_CALL\]',
-                text, re.DOTALL
+            pattern4 = re.compile(
+                r'\s*\[TOOL_CALL\]\s*(.*?)\s*\[/TOOL_CALL\]\s*',
+                re.DOTALL | re.IGNORECASE
             )
-            for match in pattern4_matches:
-                content = match.group(1).strip()
+            for match in pattern4.finditer(text):
+                content_inner = match.group(1).strip()
                 try:
-                    parsed = json.loads(content)
+                    parsed = json.loads(content_inner)
                     tool_call = cls._normalize_tool_call(parsed, available_tools)
                     if tool_call:
                         tool_calls.append(tool_call)
-                        clean_text = clean_text.replace(match.group(0), "")
+                        clean_text = clean_text.replace(match.group(0), " ", 1)
                 except json.JSONDecodeError:
-                    # محاولة تحليل كـ function_name(args)
-                    func_match = re.match(r'(\w+)\s*\((.*)\)', content, re.DOTALL)
+                    func_match = re.match(r'(\w+)\s*\((.*)\)', content_inner, re.DOTALL)
                     if func_match:
                         try:
                             func_name = func_match.group(1)
@@ -419,17 +421,17 @@ class ToolCallParser:
                                 "input": args
                             }
                             tool_calls.append(tool_call)
-                            clean_text = clean_text.replace(match.group(0), "")
+                            clean_text = clean_text.replace(match.group(0), " ", 1)
                         except json.JSONDecodeError:
                             pass
 
-        # النمط 5: ✿FUNCTION✿
+        # ---- النمط 5: ✿FUNCTION✿ ----
         if not tool_calls:
-            pattern5_matches = re.finditer(
+            pattern5 = re.compile(
                 r'✿FUNCTION✿:\s*(\w+)\s*\n✿ARGS✿:\s*(\{.*?\})\s*(?:\n✿RESULT✿)?',
-                text, re.DOTALL
+                re.DOTALL
             )
-            for match in pattern5_matches:
+            for match in pattern5.finditer(text):
                 try:
                     func_name = match.group(1)
                     args_json = json.loads(match.group(2).strip())
@@ -440,16 +442,18 @@ class ToolCallParser:
                         "input": args_json
                     }
                     tool_calls.append(tool_call)
-                    clean_text = clean_text.replace(match.group(0), "")
+                    clean_text = clean_text.replace(match.group(0), " ", 1)
                 except json.JSONDecodeError:
                     pass
 
-        # النمط 6: JSON مباشر يحتوي tool_calls
+        # ---- النمط 6: JSON مباشر يحتوي tool_calls ----
         if not tool_calls:
             try:
-                # البحث عن JSON كامل في النص
-                json_matches = re.finditer(r'\{[^{}]*"tool_calls"[^{}]*\[.*?\]\s*\}', text, re.DOTALL)
-                for jm in json_matches:
+                json_pattern = re.compile(
+                    r'\{[^{}]*"tool_calls"[^{}]*\[.*?\]\s*\}',
+                    re.DOTALL
+                )
+                for jm in json_pattern.finditer(text):
                     try:
                         parsed = json.loads(jm.group(0))
                         if "tool_calls" in parsed:
@@ -458,7 +462,10 @@ class ToolCallParser:
                                 name = func_data.get("name", "")
                                 args = func_data.get("arguments", func_data.get("input", {}))
                                 if isinstance(args, str):
-                                    args = json.loads(args)
+                                    try:
+                                        args = json.loads(args)
+                                    except json.JSONDecodeError:
+                                        args = {"raw": args}
                                 if name:
                                     tool_call = {
                                         "type": "tool_use",
@@ -467,34 +474,29 @@ class ToolCallParser:
                                         "input": args
                                     }
                                     tool_calls.append(tool_call)
-                                    clean_text = clean_text.replace(jm.group(0), "")
+                                    clean_text = clean_text.replace(jm.group(0), " ", 1)
                     except json.JSONDecodeError:
                         pass
             except Exception:
                 pass
 
-        # تنظيف النص من المسافات الزائدة
+        # تنظيف النص
         clean_text = clean_text.strip()
-        # إزالة أسطر فارغة متتالية
         clean_text = re.sub(r'\n{3,}', '\n\n', clean_text)
+        clean_text = re.sub(r'  +', ' ', clean_text)
 
         return clean_text, tool_calls
 
     @classmethod
-    def _normalize_tool_call(cls, parsed: Dict, available_tools: Optional[List[Dict]] = None) -> Optional[Dict]:
-        """
-        توحيد صيغة tool call من أشكال مختلفة إلى صيغة Anthropic.
-        يدعم:
-        - {"name": "x", "arguments": {...}}
-        - {"name": "x", "parameters": {...}}
-        - {"name": "x", "input": {...}}
-        - {"function": {"name": "x", "arguments": {...}}}
-        - {"tool": "x", "args": {...}}
-        """
+    def _normalize_tool_call(
+        cls,
+        parsed: Dict,
+        available_tools: Optional[List[Dict]] = None
+    ) -> Optional[Dict]:
+        """توحيد صيغة tool call من أشكال مختلفة إلى صيغة Anthropic"""
         name = None
         arguments = {}
 
-        # استخراج الاسم
         if "function" in parsed and isinstance(parsed["function"], dict):
             name = parsed["function"].get("name")
             arguments = parsed["function"].get("arguments", {})
@@ -514,7 +516,6 @@ class ToolCallParser:
         if not name:
             return None
 
-        # تحويل arguments من string إلى dict إذا لزم
         if isinstance(arguments, str):
             try:
                 arguments = json.loads(arguments)
@@ -528,18 +529,18 @@ class ToolCallParser:
             "input": arguments if isinstance(arguments, dict) else {"value": arguments}
         }
 
-        # التحقق من صحة الأداة مقابل القائمة المتاحة
         if available_tools:
             tool_call = cls._validate_against_tools(tool_call, available_tools)
 
         return tool_call
 
     @classmethod
-    def _validate_against_tools(cls, tool_call: Dict, available_tools: List[Dict]) -> Optional[Dict]:
-        """
-        التحقق من أن الأداة المطلوبة موجودة في قائمة الأدوات المتاحة.
-        إذا لم تكن موجودة بالضبط، يحاول إيجاد أقرب تطابق.
-        """
+    def _validate_against_tools(
+        cls,
+        tool_call: Dict,
+        available_tools: List[Dict]
+    ) -> Optional[Dict]:
+        """التحقق من أن الأداة موجودة في القائمة المتاحة"""
         requested_name = tool_call["name"]
         tool_names = []
 
@@ -550,31 +551,25 @@ class ToolCallParser:
             tool_names.append(tool_name)
 
             if tool_name == requested_name:
-                # تطابق مباشر - التحقق من المعاملات
                 return tool_call
 
-        # محاولة تطابق جزئي (fuzzy matching)
         requested_lower = requested_name.lower().replace("_", "").replace("-", "")
         for tool_name in tool_names:
             tool_lower = tool_name.lower().replace("_", "").replace("-", "")
             if requested_lower == tool_lower:
-                tool_call["name"] = tool_name  # استخدام الاسم الصحيح
+                tool_call["name"] = tool_name
                 return tool_call
-            # تطابق يحتوي
             if requested_lower in tool_lower or tool_lower in requested_lower:
                 tool_call["name"] = tool_name
                 return tool_call
 
-        # لم يتم العثور على تطابق - إرسالها كما هي (قد تكون أداة MCP)
-        logger.warning(f"Tool '{requested_name}' not found in available tools: {tool_names}")
+        logger.warning(f"[Validator] Tool '{requested_name}' not found in: {tool_names}")
         return tool_call
 
     @classmethod
     def _try_fix_json(cls, broken_json: str) -> Optional[Dict]:
         """محاولة إصلاح JSON مكسور"""
-        # إزالة trailing commas
         fixed = re.sub(r',\s*([}\]])', r'\1', broken_json)
-        # إضافة أقواس مفقودة
         open_braces = fixed.count('{') - fixed.count('}')
         if open_braces > 0:
             fixed += '}' * open_braces
@@ -587,9 +582,7 @@ class ToolCallParser:
         except json.JSONDecodeError:
             pass
 
-        # محاولة أخرى: استخراج أول JSON صالح
         try:
-            # البحث عن بداية ونهاية JSON
             start = fixed.index('{')
             depth = 0
             for i in range(start, len(fixed)):
@@ -598,7 +591,7 @@ class ToolCallParser:
                 elif fixed[i] == '}':
                     depth -= 1
                     if depth == 0:
-                        return json.loads(fixed[start:i+1])
+                        return json.loads(fixed[start:i + 1])
         except (ValueError, json.JSONDecodeError):
             pass
 
@@ -606,14 +599,12 @@ class ToolCallParser:
 
 
 # =====================================================
-# TOOL CALL STREAM BUFFER - لاكتشاف tool calls أثناء الـ streaming
+# STREAM TOOL BUFFER - محسّن
 # =====================================================
 class StreamToolBuffer:
     """
     Buffer ذكي يجمع chunks الـ stream ويكتشف tool calls.
-    يعمل بنمطين:
-    1. نمط النص العادي: يمرر النص مباشرة
-    2. نمط Tool Call: يجمع النص حتى يكتمل الوسم ثم يحلله
+    [إصلاح #2] - تحديث _process_text_mode لاكتشاف أفضل
     """
 
     def __init__(self, available_tools: Optional[List[Dict]] = None):
@@ -627,60 +618,68 @@ class StreamToolBuffer:
     def feed(self, chunk: str) -> List[Dict]:
         """
         إطعام chunk جديد للـ buffer.
-        يُرجع قائمة من الأحداث (events) الجاه��ة للإرسال.
-        
-        كل حدث يكون إما:
-        - {"type": "text", "text": "..."} 
-        - {"type": "tool_use", "id": "...", "name": "...", "input": {...}}
+        يُرجع قائمة من الأحداث الجاهزة للإرسال.
         """
         events = []
         self.buffer += chunk
 
         while self.buffer:
             if self.in_tool_call:
-                # نحن داخل وسم tool_call، نجمع حتى نجد الإغلاق
                 events.extend(self._process_tool_call_mode())
                 if self.in_tool_call:
-                    break  # لم يكتمل الوسم بعد، ننتظر المزيد
+                    break
             else:
-                # نمط عادي: نبحث عن بداية tool call
                 events.extend(self._process_text_mode())
                 if self.in_tool_call:
-                    continue  # وجدنا بداية tool call، نكمل المعالجة
-                break  # لا يوجد tool call، ننتظر المزيد
+                    continue
+                break
 
         return events
 
     def _process_text_mode(self) -> List[Dict]:
-        """معالجة النص في النمط العادي"""
+        """
+        معالجة النص في النمط العادي.
+        [إصلاح #2] - يتجاهل حالة الأحرف ويتعامل مع المسافات قبل الوسوم
+        """
         events = []
 
-        # البحث عن أي من علامات بداية tool call
+        # ======================================================
+        # [إصلاح #2] البحث بدون حساسية لحالة الأحرف
+        # ======================================================
+        buffer_lower = self.buffer.lower()
+
         earliest_pos = -1
         earliest_marker = ""
+
         for marker in ToolCallParser.START_MARKERS:
-            pos = self.buffer.lower().find(marker.lower())
+            # البحث بدون حساسية لحالة الأحرف
+            pos = buffer_lower.find(marker.lower())
             if pos != -1 and (earliest_pos == -1 or pos < earliest_pos):
                 earliest_pos = pos
                 earliest_marker = marker
 
         if earliest_pos == -1:
-            # لا يوجد tool call - لكن نحتفظ بآخر 50 حرف كاحتياط
-            # (قد يكون بداية وسم مقطوع)
-            safe_length = len(self.buffer) - 50
+            # لا يوجد tool call - احتفظ بـ 100 حرف كاحتياط (زيادة من 50)
+            # لأن بعض الوسوم قد تكون أطول
+            safe_length = len(self.buffer) - 100
             if safe_length > 0:
                 text_to_send = self.buffer[:safe_length]
                 self.buffer = self.buffer[safe_length:]
                 if text_to_send:
                     events.append({"type": "text", "text": text_to_send})
-            # إذا كان الـ buffer صغير جداً، لا نرسل شيء حتى يكبر
         else:
-            # وجدنا بداية tool call
-            if earliest_pos > 0:
-                # إرسال النص قبل الـ tool call
-                text_before = self.buffer[:earliest_pos]
-                if text_before.strip():
-                    events.append({"type": "text", "text": text_before})
+            # ======================================================
+            # [إصلاح #2] تخطي المسافات البيضاء قبل الوسم
+            # ======================================================
+            # إرسال النص قبل الوسم (مع إزالة المسافات الزائدة قبله)
+            text_before = self.buffer[:earliest_pos]
+
+            # لا نرسل إذا كان النص قبله مجرد مسافات
+            if text_before and not text_before.isspace():
+                events.append({"type": "text", "text": text_before})
+            elif text_before and text_before.isspace():
+                # مسافات قبل الوسم - نرسلها كمسافة واحدة
+                events.append({"type": "text", "text": " "})
 
             # الانتقال لنمط tool call
             self.buffer = self.buffer[earliest_pos:]
@@ -690,26 +689,39 @@ class StreamToolBuffer:
         return events
 
     def _process_tool_call_mode(self) -> List[Dict]:
-        """معالجة النص في نمط tool call"""
+        """
+        معالجة النص في نمط tool call.
+        [إصلاح #2] - تحسين اكتشاف نهاية الوسوم مع المسافات
+        """
         events = []
 
-        # البحث عن نهاية الوسم
-        end_markers = [
+        # أزواج (نهاية الوسم، بداية الوسم) مع دعم حالة الأحرف
+        end_markers_pairs = [
             ('</tool_call>', '<tool_call>'),
             ('```', '```tool_call'),
             ('```', '```json'),
             ('</function>', '<function='),
+            ('[/tool_call]', '[tool_call]'),
             ('[/TOOL_CALL]', '[TOOL_CALL]'),
         ]
 
+        buffer_lower = self.buffer.lower()
         found_end = False
-        for end_marker, start_marker in end_markers:
-            # تخطي علامة البداية والبحث عن النهاية
-            search_start = len(start_marker) if self.buffer.lower().startswith(start_marker.lower()) else 0
-            end_pos = self.buffer.lower().find(end_marker.lower(), search_start)
+
+        for end_marker, start_marker in end_markers_pairs:
+            end_lower = end_marker.lower()
+            start_lower = start_marker.lower()
+
+            # التحقق أن الـ buffer يبدأ بعلامة البداية (بدون حساسية)
+            if not buffer_lower.startswith(start_lower):
+                continue
+
+            # البحث عن نهاية الوسم بعد البداية
+            search_from = len(start_marker)
+            end_pos = buffer_lower.find(end_lower, search_from)
 
             if end_pos != -1:
-                # وجدنا النهاية
+                # وجدنا النهاية - استخراج النص الكامل للوسم
                 full_tool_text = self.buffer[:end_pos + len(end_marker)]
                 remaining = self.buffer[end_pos + len(end_marker):]
 
@@ -718,10 +730,19 @@ class StreamToolBuffer:
                     full_tool_text, self.available_tools
                 )
 
+                # ======================================================
+                # [إصلاح #3] إرسال tool calls مع تأكيد المعرف
+                # ======================================================
                 for tc in tool_calls:
+                    # التأكد من وجود معرف صحيح
+                    if not tc.get("id"):
+                        tc["id"] = ToolCallParser.generate_tool_id()
+                    logger.info(
+                        f"[Buffer] Tool call detected: {tc['name']} "
+                        f"(id: {tc['id']})"
+                    )
                     events.append(tc)
 
-                # إذا بقي نص نظيف
                 if clean_text.strip():
                     events.append({"type": "text", "text": clean_text})
 
@@ -731,10 +752,12 @@ class StreamToolBuffer:
                 break
 
         if not found_end:
-            # لم نجد نهاية بعد - نتحقق من الحجم
+            # لم نجد نهاية - تحقق من الحجم
             if len(self.buffer) > 5000:
-                # Buffer كبير جداً بدون إغلاق - على الأرجح ليس tool call حقيقي
-                logger.warning("Tool call buffer too large without closing tag, treating as text")
+                logger.warning(
+                    "[Buffer] Tool call buffer too large without closing tag, "
+                    "treating as text"
+                )
                 events.append({"type": "text", "text": self.buffer})
                 self.buffer = ""
                 self.in_tool_call = False
@@ -742,23 +765,20 @@ class StreamToolBuffer:
         return events
 
     def flush(self) -> List[Dict]:
-        """
-        تفريغ أي محتوى متبقي في الـ buffer.
-        يُستدعى عند انتهاء الـ stream.
-        """
+        """تفريغ أي محتوى متبقي في الـ buffer"""
         events = []
 
         if self.in_tool_call and self.buffer:
-            # محاولة تحليل ما تبقى كـ tool call
             clean_text, tool_calls = ToolCallParser.parse_tool_calls(
                 self.buffer, self.available_tools
             )
             for tc in tool_calls:
+                if not tc.get("id"):
+                    tc["id"] = ToolCallParser.generate_tool_id()
                 events.append(tc)
             if clean_text.strip():
                 events.append({"type": "text", "text": clean_text})
         elif self.buffer:
-            # نص عادي متبقي
             if self.buffer.strip():
                 events.append({"type": "text", "text": self.buffer})
 
@@ -768,34 +788,38 @@ class StreamToolBuffer:
 
 
 # =====================================================
-# TOOLS FORMATTER - تحويل أدوات Anthropic إلى نص للنموذج
+# TOOLS FORMATTER
 # =====================================================
 class ToolsFormatter:
-    """
-    يأخذ مصفوفة tools من طلب Anthropic ويحولها إلى تعليمات نصية
-    تُضاف إلى System Prompt لتوجيه النموذج لاستخدام الأدوات.
-    """
+    """تحويل أدوات Anthropic إلى نص للنموذج"""
 
     @staticmethod
     def format_tools_for_prompt(tools: List[Dict], tool_choice: Any = None) -> str:
-        """
-        تحويل تعريفات الأدوات إلى نص يُضاف للـ system prompt.
-        """
         if not tools:
             return ""
 
         lines = []
         lines.append("# Available Tools")
         lines.append("")
-        lines.append("You have access to the following tools. To use a tool, respond with a tool_call block.")
-        lines.append("IMPORTANT: When you need to use a tool, you MUST format your response EXACTLY like this:")
+        lines.append(
+            "You have access to the following tools. "
+            "To use a tool, respond with a tool_call block."
+        )
+        lines.append(
+            "IMPORTANT: When you need to use a tool, you MUST format "
+            "your response EXACTLY like this:"
+        )
         lines.append("")
         lines.append("<tool_call>")
-        lines.append('{"name": "tool_name", "arguments": {"param1": "value1", "param2": "value2"}}')
+        lines.append('{"name": "tool_name", "arguments": {"param1": "value1"}}')
         lines.append("</tool_call>")
         lines.append("")
-        lines.append("You can include text explanation before and/or after the tool_call block.")
-        lines.append("You can make multiple tool calls in a single response by using multiple <tool_call> blocks.")
+        lines.append(
+            "You can include text explanation before and/or after the tool_call block."
+        )
+        lines.append(
+            "You can make multiple tool calls by using multiple <tool_call> blocks."
+        )
         lines.append("")
         lines.append("## Tool Definitions:")
         lines.append("")
@@ -808,7 +832,6 @@ class ToolsFormatter:
             lines.append(f"### {i}. `{name}`")
             lines.append(f"**Description:** {description}")
 
-            # معالجة المعاملات
             properties = input_schema.get("properties", {})
             required = input_schema.get("required", [])
 
@@ -819,32 +842,38 @@ class ToolsFormatter:
                     param_desc = param_info.get("description", "")
                     is_required = param_name in required
                     req_marker = " (required)" if is_required else " (optional)"
-                    lines.append(f"  - `{param_name}` ({param_type}{req_marker}): {param_desc}")
-
-                    # إضافة enum values إذا وجدت
+                    lines.append(
+                        f"  - `{param_name}` ({param_type}{req_marker}): {param_desc}"
+                    )
                     if "enum" in param_info:
-                        lines.append(f"    Allowed values: {', '.join(str(v) for v in param_info['enum'])}")
+                        lines.append(
+                            f"    Allowed values: "
+                            f"{', '.join(str(v) for v in param_info['enum'])}"
+                        )
             else:
                 lines.append("**Parameters:** None")
 
             lines.append("")
 
-        # إضافة تعليمات خاصة بـ tool_choice
         if tool_choice:
             if isinstance(tool_choice, dict):
                 if tool_choice.get("type") == "tool":
                     forced_tool = tool_choice.get("name", "")
                     if forced_tool:
-                        lines.append(f"**IMPORTANT:** You MUST use the `{forced_tool}` tool in your response.")
+                        lines.append(
+                            f"**IMPORTANT:** You MUST use the `{forced_tool}` tool."
+                        )
                 elif tool_choice.get("type") == "any":
-                    lines.append("**IMPORTANT:** You MUST use at least one tool in your response.")
+                    lines.append(
+                        "**IMPORTANT:** You MUST use at least one tool."
+                    )
             elif tool_choice == "auto":
-                lines.append("Use tools when appropriate to accomplish the task.")
+                lines.append("Use tools when appropriate.")
             elif tool_choice == "any":
-                lines.append("**IMPORTANT:** You MUST use at least one tool in your response.")
+                lines.append("**IMPORTANT:** You MUST use at least one tool.")
 
         lines.append("")
-        lines.append("Remember: Always use <tool_call>JSON</tool_call> format when calling tools.")
+        lines.append("Remember: Always use <tool_call>JSON</tool_call> format.")
         lines.append("The JSON inside must have 'name' and 'arguments' keys.")
         lines.append("")
 
@@ -852,7 +881,10 @@ class ToolsFormatter:
 
     @staticmethod
     def format_tool_result_for_message(tool_use_id: str, content: Any) -> str:
-        """تحويل نتيجة أداة إلى نص مفهوم للنموذج"""
+        """
+        تحويل نتيجة أداة إلى نص مفهوم للنموذج.
+        [إصلاح #3] - ربط النتيجة بمعرف الأداة tool_use_id
+        """
         result_text = ""
         if isinstance(content, str):
             result_text = content
@@ -874,32 +906,34 @@ class ToolsFormatter:
         else:
             result_text = str(content) if content else ""
 
-        return f"[Tool Result (id: {tool_use_id})]\n{result_text}\n[/Tool Result]"
+        # ======================================================
+        # [إصلاح #3] - تأكيد ربط النتيجة بالمعرف الصحيح
+        # ======================================================
+        return (
+            f"[Tool Result]\n"
+            f"tool_use_id: {tool_use_id}\n"
+            f"status: success\n"
+            f"output:\n{result_text}\n"
+            f"[/Tool Result]"
+        )
 
 
 # =====================================================
-# MESSAGE CONVERTER - تحويل رسائل Anthropic إلى صيغة g4f
+# MESSAGE CONVERTER
 # =====================================================
 class MessageConverter:
-    """
-    يحول رسائل Anthropic (التي قد تحتوي tool_use و tool_result)
-    إلى رسائل نصية بسيطة يفهمها g4f.
-    """
+    """تحويل رسائل Anthropic إلى صيغة g4f"""
 
     @staticmethod
-    def convert_messages(messages: List[Dict], system_prompt: str = "",
-                         tools: Optional[List[Dict]] = None,
-                         tool_choice: Any = None) -> Tuple[str, List[Dict]]:
-        """
-        تحويل رسائل Anthropic إلى (full_message, history) لـ g4f.
-        
-        يُرجع:
-        - full_message: الرسالة الأخيرة مع system prompt
-        - history: سجل المحادثة
-        """
+    def convert_messages(
+        messages: List[Dict],
+        system_prompt: str = "",
+        tools: Optional[List[Dict]] = None,
+        tool_choice: Any = None
+    ) -> Tuple[str, List[Dict]]:
+        """تحويل رسائل Anthropic إلى (full_message, history) لـ g4f"""
         history = []
-        
-        # بناء system prompt مع تعريفات الأدوات
+
         full_system = ""
         if system_prompt:
             full_system = system_prompt
@@ -911,13 +945,11 @@ class MessageConverter:
             else:
                 full_system = tools_text
 
-        # تحويل كل رسالة
         for msg in messages:
             role = msg.get("role", "user")
             content = msg.get("content", "")
 
             if role == "system":
-                # إضافة system message إلى system prompt
                 sys_text = extract_text_from_content(content)
                 if full_system:
                     full_system = f"{full_system}\n\n{sys_text}"
@@ -925,24 +957,23 @@ class MessageConverter:
                     full_system = sys_text
                 continue
 
-            # تحويل content المعقد
             converted_text = MessageConverter._convert_content(content, role)
 
             if converted_text:
-                # تحويل role
                 g4f_role = "user" if role == "user" else "assistant"
                 history.append({"role": g4f_role, "content": converted_text})
 
-        # استخراج آخر رسالة كـ user message
         if history:
             last_msg = history.pop()
             user_message = last_msg["content"]
         else:
             user_message = ""
 
-        # إضافة system prompt
         if full_system:
-            full_message = f"[System Instructions]\n{full_system}\n[/System Instructions]\n\n{user_message}"
+            full_message = (
+                f"[System Instructions]\n{full_system}\n"
+                f"[/System Instructions]\n\n{user_message}"
+            )
         else:
             full_message = user_message
 
@@ -966,18 +997,21 @@ class MessageConverter:
                         parts.append(block.get("text", ""))
 
                     elif block_type == "tool_use":
-                        # تحويل طلب أداة سابق إلى نص
                         name = block.get("name", "unknown")
                         input_data = block.get("input", {})
                         tool_id = block.get("id", "")
                         parts.append(
                             f"<tool_call>"
-                            f'{{"name": "{name}", "arguments": {json.dumps(input_data, ensure_ascii=False)}}}'
+                            f'{{"name": "{name}", '
+                            f'"id": "{tool_id}", '
+                            f'"arguments": {json.dumps(input_data, ensure_ascii=False)}}}'
                             f"</tool_call>"
                         )
 
                     elif block_type == "tool_result":
-                        # تحويل نتيجة أداة
+                        # ======================================================
+                        # [إصلاح #3] - ربط نتيجة الأداة بمعرفها الصحيح
+                        # ======================================================
                         tool_use_id = block.get("tool_use_id", "")
                         result_content = block.get("content", "")
                         is_error = block.get("is_error", False)
@@ -993,7 +1027,6 @@ class MessageConverter:
                         parts.append("[Image content - not supported in text mode]")
 
                     else:
-                        # نوع غير معروف
                         if "text" in block:
                             parts.append(block["text"])
                         else:
@@ -1007,7 +1040,7 @@ class MessageConverter:
 
 
 # =====================================================
-# CHAT LOGIC - مع fallback ذكي
+# CHAT LOGIC - مع إصلاح الذاكرة الانتقائية
 # =====================================================
 def ask(message: str, history, provider_name: str, model_name: str, stop_flag=None):
     message = (message or "").strip()
@@ -1015,39 +1048,68 @@ def ask(message: str, history, provider_name: str, model_name: str, stop_flag=No
         yield ""
         return
 
-    # مفتاح التخزين المؤقت
     key = f"{provider_name}|{model_name}|{message[:200]}"
     cached = CACHE.get(key)
     if cached:
         yield cached
         return
 
-    # بناء سجل المحادثة
     msgs = []
     try:
         if history:
             if isinstance(history, list) and len(history) > 0:
                 if isinstance(history[0], dict):
-                    for item in history[-40:]:
+                    # ======================================================
+                    # [إصلاح #1] - الذاكرة الانتقائية (Selective History)
+                    # الاحتفاظ بأول 10 رسائل (System Prompt + Tool Definitions)
+                    # ودمجها مع آخر 50 رسالة للسياق الحالي
+                    # السطر 1031 المشار إليه في التقرير
+                    # ======================================================
+                    if len(history) > 60:
+                        # الاحتفاظ بأول 10 رسائل + آخر 50 رسالة
+                        smart_history = history[:10] + history[-50:]
+                        logger.info(
+                            f"[Memory] Smart history: keeping first 10 + "
+                            f"last 50 from {len(history)} total messages"
+                        )
+                    else:
+                        # إذا كانت الرسائل أقل من 60، نأخذها كلها
+                        smart_history = history
+                        logger.info(
+                            f"[Memory] Full history: {len(history)} messages "
+                            f"(under threshold)"
+                        )
+
+                    for item in smart_history:
                         role = item.get("role")
                         content = item.get("content")
                         if role and content:
-                            text = extract_text_from_content(content) if not isinstance(content, str) else content
+                            text = (
+                                extract_text_from_content(content)
+                                if not isinstance(content, str)
+                                else content
+                            )
                             if text:
                                 msgs.append({"role": str(role), "content": text})
                 else:
-                    for item in history[-20:]:
+                    # صيغة قديمة (list of tuples)
+                    if len(history) > 30:
+                        smart_history_tuples = history[:5] + history[-25:]
+                    else:
+                        smart_history_tuples = history
+
+                    for item in smart_history_tuples:
                         if isinstance(item, (list, tuple)) and len(item) == 2:
                             if item[0]:
                                 msgs.append({"role": "user", "content": str(item[0])})
                             if item[1]:
                                 msgs.append({"role": "assistant", "content": str(item[1])})
     except Exception as e:
-        logger.warning(f"History error: {e}")
+        logger.warning(f"[Memory] History error: {e}")
 
     msgs.append({"role": "user", "content": message})
 
-    # قائمة المزودات التي سنحاولها
+    # قائمة المزودات للـ fallback
     fallback_providers = [
         provider_name,
         "Blackbox",
@@ -1066,12 +1128,12 @@ def ask(message: str, history, provider_name: str, model_name: str, stop_flag=No
         used.append(pname)
         pobj = REAL_PROVIDERS.get(pname)
         if not pobj:
-            logger.info(f"Provider {pname} not available, skipping")
+            logger.info(f"[Fallback] Provider {pname} not available, skipping")
             continue
 
         models_list = discover_provider_models(pobj, pname)
         if not models_list:
-            logger.warning(f"No models for provider {pname}")
+            logger.warning(f"[Fallback] No models for provider {pname}")
             continue
 
         if model_name in models_list:
@@ -1081,7 +1143,7 @@ def ask(message: str, history, provider_name: str, model_name: str, stop_flag=No
 
         for m in model_candidates[:10]:
             try:
-                logger.info(f"Trying provider {pname} with model {m}")
+                logger.info(f"[Fallback] Trying provider {pname} with model {m}")
                 stream = g4f.ChatCompletion.create(
                     model=m,
                     provider=pobj,
@@ -1103,17 +1165,22 @@ def ask(message: str, history, provider_name: str, model_name: str, stop_flag=No
                     CACHE.set(key, full)
                     return
             except Exception as e:
-                logger.warning(f"Provider {pname} model {m} failed: {str(e)[:200]}")
+                logger.warning(
+                    f"[Fallback] Provider {pname} model {m} failed: {str(e)[:200]}"
+                )
                 continue
 
     yield "❌ فشلت جميع المزودات. تأكد من اتصال الإنترنت أو حاول لاحقاً."
 
+
 # =====================================================
 # FASTAPI
 # =====================================================
-app = FastAPI(title="G4F Smart Router", description="AI Gateway - Protocol Translator for Anthropic")
+app = FastAPI(
+    title="G4F Smart Router",
+    description="AI Gateway - Protocol Translator for Anthropic"
+)
 
-# إضافة CORS للسماح بالطلبات من أي مصدر
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -1124,12 +1191,14 @@ app.add_middleware(
 
 API_KEY = os.getenv("API_KEY", "mysecretkey123")
 
+
 class ChatRequest(BaseModel):
     message: str
     provider: str = "Blackbox"
     model: str = "gpt-4o"
     history: List[Any] = []
 
+
 # =====================================================
 # التحقق من المفتاح
 # =====================================================
@@ -1152,8 +1221,9 @@ def verify_api_key(request: Request):
         detail="Invalid API key. Use 'Authorization: Bearer KEY' or 'X-API-Key: KEY'"
     )
 
+
 # =====================================================
-# دعم HEAD (لإصلاح 405)
+# دعم HEAD
 # =====================================================
 @app.head("/")
 async def head_root():
@@ -1175,8 +1245,9 @@ async def head_messages():
 async def head_chat_completions():
     return Response(status_code=200)
 
+
 # =====================================================
-# نقاط نهاية متوافقة مع Claude Cowork و Anthropic API
+# نقاط نهاية متوافقة مع Anthropic API
 # =====================================================
 @app.get("/v1/models")
 async def v1_models(request: Request):
@@ -1206,26 +1277,28 @@ async def v1_models(request: Request):
         }]
     return {"object": "list", "data": models}
 
+
 # =====================================================
 # نقطة /v1/messages - بروتوكول Anthropic الكامل
-# مع دعم Tools و Multi-Block Content
 # =====================================================
 @app.post("/v1/messages")
 async def v1_messages(request: Request):
     verify_api_key(request)
     body = await request.json()
 
-    logger.info(f"Received /v1/messages request: model={body.get('model')}, stream={body.get('stream')}, "
-                f"tools_count={len(body.get('tools', []))}")
+    logger.info(
+        f"[API] /v1/messages - model={body.get('model')}, "
+        f"stream={body.get('stream')}, "
+        f"tools_count={len(body.get('tools', []))}"
+    )
 
     messages = body.get("messages", [])
     if not messages:
         raise HTTPException(status_code=400, detail="No messages provided")
 
-    # استخراج المعاملات
     model = body.get("model", "gpt-4o")
     system_prompt = body.get("system", "")
-    # دعم system كـ string أو list
+
     if isinstance(system_prompt, list):
         sys_parts = []
         for sp in system_prompt:
@@ -1239,68 +1312,64 @@ async def v1_messages(request: Request):
     max_tokens = body.get("max_tokens", 4096)
     tools = body.get("tools", [])
     tool_choice = body.get("tool_choice", "auto")
-    stop_sequences = body.get("stop_sequences", [])
-    temperature = body.get("temperature", 1.0)
-    top_p = body.get("top_p", None)
-    top_k = body.get("top_k", None)
     metadata = body.get("metadata", {})
 
-    # تحويل الرسائل باستخدام MessageConverter
     full_message, history = MessageConverter.convert_messages(
         messages, system_prompt, tools, tool_choice
     )
 
-    logger.info(f"Converted message length: {len(full_message)}, history length: {len(history)}, "
-                f"tools: {[t.get('name', '') for t in tools]}")
+    logger.info(
+        f"[API] Message length: {len(full_message)}, "
+        f"history: {len(history)}, "
+        f"tools: {[t.get('name', '') for t in tools]}"
+    )
 
-    # إذا كان stream مطلوب
     if is_stream:
         return await _handle_anthropic_stream(
             full_message, history, model, max_tokens, tools, tool_choice, metadata
         )
 
-    # وضع non-stream: تجميع الرد كاملاً ثم تحليله
+    # Non-stream: تجميع الرد كاملاً
     full_response = ""
     for chunk in ask(full_message, history, "Blackbox", model):
         full_response += chunk
 
-    # تحليل الرد للبحث عن tool calls
     clean_text, tool_calls = ToolCallParser.parse_tool_calls(full_response, tools)
 
     message_id = f"msg_{int(time.time())}_{os.urandom(4).hex()}"
     input_tokens = max(1, len(full_message) // 4)
     output_tokens = max(1, len(full_response) // 4)
 
-    # بناء content blocks
     content_blocks = []
 
-    # إضافة النص إذا وجد
     if clean_text.strip():
         content_blocks.append({
             "type": "text",
             "text": clean_text.strip()
         })
 
-    # إضافة tool calls إذا وجدت
+    # ======================================================
+    # [إصلاح #3] - إرسال tool calls مع معرفات صحيحة
+    # ======================================================
     for tc in tool_calls:
+        tool_id = tc.get("id") or ToolCallParser.generate_tool_id()
         content_blocks.append({
             "type": "tool_use",
-            "id": tc.get("id", ToolCallParser.generate_tool_id()),
+            "id": tool_id,
             "name": tc["name"],
             "input": tc.get("input", {})
         })
+        logger.info(
+            f"[API] Tool call in response: {tc['name']} (id: {tool_id})"
+        )
 
-    # إذا لم يكن هناك أي محتوى
     if not content_blocks:
         content_blocks.append({
             "type": "text",
             "text": full_response or ""
         })
 
-    # تحديد stop_reason
-    stop_reason = "end_turn"
-    if tool_calls:
-        stop_reason = "tool_use"
+    stop_reason = "tool_use" if tool_calls else "end_turn"
 
     return {
         "id": message_id,
@@ -1316,9 +1385,9 @@ async def v1_messages(request: Request):
         }
     }
 
+
 # =====================================================
 # معالج الـ streaming بصيغة Anthropic SSE
-# مع دعم كامل لـ Tool Use و Multi-Block Content
 # =====================================================
 async def _handle_anthropic_stream(
     full_message: str,
@@ -1350,59 +1419,68 @@ async def _handle_anthropic_stream(
                 }
             }
         }
-        yield f"event: message_start\ndata: {json.dumps(msg_start, ensure_ascii=False)}\n\n"
+        yield (
+            f"event: message_start\n"
+            f"data: {json.dumps(msg_start, ensure_ascii=False)}\n\n"
+        )
 
-        # إنشاء StreamToolBuffer
         tool_buffer = StreamToolBuffer(available_tools=tools_list)
 
-        # متتبع الكتل (blocks)
         current_block_index = 0
-        block_started = False
         text_block_open = False
         output_tokens = 0
         has_tool_calls = False
-        accumulated_text = ""
 
-        # دالة مساعدة لبدء كتلة نصية
+        # ---- دوال مساعدة ----
         def make_text_block_start(index: int) -> str:
             block_start = {
                 "type": "content_block_start",
                 "index": index,
-                "content_block": {
-                    "type": "text",
-                    "text": ""
-                }
+                "content_block": {"type": "text", "text": ""}
             }
-            return f"event: content_block_start\ndata: {json.dumps(block_start, ensure_ascii=False)}\n\n"
+            return (
+                f"event: content_block_start\n"
+                f"data: {json.dumps(block_start, ensure_ascii=False)}\n\n"
+            )
 
-        # دالة مساعدة لإرسال text delta
         def make_text_delta(index: int, text: str) -> str:
             delta_event = {
                 "type": "content_block_delta",
                 "index": index,
-                "delta": {
-                    "type": "text_delta",
-                    "text": text
-                }
+                "delta": {"type": "text_delta", "text": text}
             }
-            return f"event: content_block_delta\ndata: {json.dumps(delta_event, ensure_ascii=False)}\n\n"
+            return (
+                f"event: content_block_delta\n"
+                f"data: {json.dumps(delta_event, ensure_ascii=False)}\n\n"
+            )
 
-        # دالة مساعدة لإنهاء كتلة
         def make_block_stop(index: int) -> str:
             block_stop = {
                 "type": "content_block_stop",
                 "index": index
             }
-            return f"event: content_block_stop\ndata: {json.dumps(block_stop, ensure_ascii=False)}\n\n"
+            return (
+                f"event: content_block_stop\n"
+                f"data: {json.dumps(block_stop, ensure_ascii=False)}\n\n"
+            )
 
-        # دالة مساعدة لإرسال tool_use block كامل
         def make_tool_use_events(index: int, tool_call: Dict) -> str:
+            """
+            إنشاء أحداث tool_use للـ stream.
+            [إصلاح #3] - استخدام المعرف الصحيح من tool_call
+            """
             events_str = ""
-            tool_id = tool_call.get("id", ToolCallParser.generate_tool_id())
+            # ======================================================
+            # [إصلاح #3] - ضمان وجود معرف ص��يح
+            # ======================================================
+            tool_id = tool_call.get("id") or ToolCallParser.generate_tool_id()
             tool_name = tool_call.get("name", "unknown")
             tool_input = tool_call.get("input", {})
 
-            # بداية كتلة tool_use
+            logger.info(
+                f"[Stream] Sending tool_use: {tool_name} (id: {tool_id})"
+            )
+
             block_start = {
                 "type": "content_block_start",
                 "index": index,
@@ -1413,11 +1491,13 @@ async def _handle_anthropic_stream(
                     "input": {}
                 }
             }
-            events_str += f"event: content_block_start\ndata: {json.dumps(block_start, ensure_ascii=False)}\n\n"
+            events_str += (
+                f"event: content_block_start\n"
+                f"data: {json.dumps(block_start, ensure_ascii=False)}\n\n"
+            )
 
             # إرسال input كـ JSON delta
             input_json = json.dumps(tool_input, ensure_ascii=False)
-            # تقسيم JSON إلى أجزاء للـ streaming
             chunk_size = 100
             for i in range(0, len(input_json), chunk_size):
                 json_chunk = input_json[i:i + chunk_size]
@@ -1429,14 +1509,15 @@ async def _handle_anthropic_stream(
                         "partial_json": json_chunk
                     }
                 }
-                events_str += f"event: content_block_delta\ndata: {json.dumps(delta_event, ensure_ascii=False)}\n\n"
+                events_str += (
+                    f"event: content_block_delta\n"
+                    f"data: {json.dumps(delta_event, ensure_ascii=False)}\n\n"
+                )
 
-            # نهاية كتلة tool_use
             events_str += make_block_stop(index)
-
             return events_str
 
-        # ===== بدء معالجة الـ Stream =====
+        # ===== معالجة الـ Stream =====
         try:
             for chunk in ask(full_message, history, "Blackbox", model):
                 if not chunk:
@@ -1444,15 +1525,15 @@ async def _handle_anthropic_stream(
 
                 output_tokens += max(1, len(chunk) // 4)
 
-                # إذا لا توجد أدوات معرفة، نرسل كنص مباشرة (أسرع)
                 if not tools_list:
+                    # لا أدوات - نرسل كنص مباشرة
                     if not text_block_open:
                         yield make_text_block_start(current_block_index)
                         text_block_open = True
                     yield make_text_delta(current_block_index, chunk)
                     continue
 
-                # هناك أدوات - نستخدم الـ buffer للكشف عن tool calls
+                # هناك أدوات - نستخدم الـ buffer
                 events = tool_buffer.feed(chunk)
 
                 for event in events:
@@ -1465,13 +1546,12 @@ async def _handle_anthropic_stream(
                             yield make_text_delta(current_block_index, text)
 
                     elif event.get("type") == "tool_use":
-                        # إغلاق كتلة النص المفتوحة أولاً
+                        # إغلاق كتلة النص المفتوحة
                         if text_block_open:
                             yield make_block_stop(current_block_index)
                             current_block_index += 1
                             text_block_open = False
 
-                        # إرسال كتلة tool_use
                         has_tool_calls = True
                         yield make_tool_use_events(current_block_index, event)
                         current_block_index += 1
@@ -1498,8 +1578,7 @@ async def _handle_anthropic_stream(
                     current_block_index += 1
 
         except Exception as e:
-            logger.error(f"Stream error: {str(e)}")
-            # إرسال رسالة خطأ كنص
+            logger.error(f"[Stream] Error: {str(e)}")
             if not text_block_open:
                 yield make_text_block_start(current_block_index)
                 text_block_open = True
@@ -1509,29 +1588,26 @@ async def _handle_anthropic_stream(
         if text_block_open:
             yield make_block_stop(current_block_index)
         elif current_block_index == 0 and not has_tool_calls:
-            # لم يتم إرسال أي كتلة - نرسل كتلة نصية فارغة
             yield make_text_block_start(0)
             yield make_text_delta(0, "")
             yield make_block_stop(0)
 
-        # تحديد stop_reason
         stop_reason = "tool_use" if has_tool_calls else "end_turn"
 
-        # حدث دلتا الرسالة (نهاية)
         msg_delta = {
             "type": "message_delta",
             "delta": {
                 "stop_reason": stop_reason,
                 "stop_sequence": None
             },
-            "usage": {
-                "output_tokens": output_tokens
-            }
+            "usage": {"output_tokens": output_tokens}
         }
-        yield f"event: message_delta\ndata: {json.dumps(msg_delta, ensure_ascii=False)}\n\n"
+        yield (
+            f"event: message_delta\n"
+            f"data: {json.dumps(msg_delta, ensure_ascii=False)}\n\n"
+        )
 
-        # حدث توقف الرسالة
-        yield f"event: message_stop\ndata: {{\"type\": \"message_stop\"}}\n\n"
+        yield 'event: message_stop\ndata: {"type": "message_stop"}\n\n'
 
     return StreamingResponse(
         generate_stream(),
@@ -1543,8 +1619,9 @@ async def _handle_anthropic_stream(
         }
     )
 
+
 # =====================================================
-# نقطة /v1/messages/stream منفصلة (للتوافق)
+# نقطة /v1/messages/stream
 # =====================================================
 @app.post("/v1/messages/stream")
 async def v1_messages_stream(request: Request):
@@ -1570,12 +1647,14 @@ async def v1_messages_stream(request: Request):
     tools = body.get("tools", [])
     tool_choice = body.get("tool_choice", "auto")
 
-    # تحويل الرسائل
     full_message, history = MessageConverter.convert_messages(
         messages, system_prompt, tools, tool_choice
     )
 
-    return await _handle_anthropic_stream(full_message, history, model, max_tokens, tools, tool_choice)
+    return await _handle_anthropic_stream(
+        full_message, history, model, max_tokens, tools, tool_choice
+    )
+
 
 # =====================================================
 # نقطة /v1/chat/completions (صيغة OpenAI)
@@ -1592,11 +1671,9 @@ async def v1_chat_completions(request: Request):
     model = body.get("model", "gpt-4o")
     is_stream = body.get("stream", False)
 
-    # استخراج آخر رسالة
     last_message = messages[-1]
     user_message = extract_text_from_content(last_message.get("content", ""))
 
-    # بناء history
     history = []
     for msg in messages[:-1]:
         role = msg.get("role", "user")
@@ -1607,7 +1684,6 @@ async def v1_chat_completions(request: Request):
     completion_id = f"chatcmpl-{int(time.time())}_{os.urandom(4).hex()}"
 
     if is_stream:
-        # OpenAI streaming format
         async def openai_stream():
             for chunk in ask(user_message, history, "Blackbox", model):
                 if chunk:
@@ -1624,7 +1700,6 @@ async def v1_chat_completions(request: Request):
                     }
                     yield f"data: {json.dumps(data, ensure_ascii=False)}\n\n"
 
-            # إرسال حدث النهاية
             final_data = {
                 "id": completion_id,
                 "object": "chat.completion.chunk",
@@ -1649,7 +1724,6 @@ async def v1_chat_completions(request: Request):
             }
         )
 
-    # Non-stream OpenAI format
     full_response = ""
     for chunk in ask(user_message, history, "Blackbox", model):
         full_response += chunk
@@ -1674,6 +1748,7 @@ async def v1_chat_completions(request: Request):
         }
     }
 
+
 # =====================================================
 # نقاط نهاية إضافية
 # =====================================================
@@ -1681,47 +1756,47 @@ async def v1_chat_completions(request: Request):
 async def root():
     return {
         "message": "G4F Smart Router - Protocol Translator (Anthropic Compatible)",
-        "version": "2.0.0",
-        "features": [
-            "Tool Call Detection & Translation",
-            "Multi-Block Content Support",
-            "Anthropic Protocol Full Compliance",
-            "Tool Definitions Forwarding",
-            "Stream & Non-Stream Support"
+        "version": "2.1.0",
+        "fixes_applied": [
+            "[Fix #1] Selective Memory: history[:10] + history[-50:]",
+            "[Fix #2] Improved Regex: non-greedy + case-insensitive + whitespace handling",
+            "[Fix #3] Tool ID Binding: tool_use_id properly linked in results"
         ],
         "providers": list(REAL_PROVIDERS.keys()),
         "endpoints": {
             "GET /": "Home",
             "GET /health": "Health check",
-            "GET /v1/models": "List models (NO AUTH)",
-            "POST /v1/messages": "Anthropic format - Full tool support (AUTH, supports stream:true)",
-            "POST /v1/messages/stream": "Anthropic format - Stream only (AUTH)",
-            "POST /v1/chat/completions": "OpenAI format - Send message (AUTH, supports stream:true)",
+            "GET /v1/models": "List models",
+            "POST /v1/messages": "Anthropic format (AUTH)",
+            "POST /v1/messages/stream": "Anthropic stream (AUTH)",
+            "POST /v1/chat/completions": "OpenAI format (AUTH)",
             "POST /chat": "Simple chat (AUTH)",
             "POST /chat/stream": "Simple stream (AUTH)",
             "GET /providers": "Providers list (AUTH)",
-            "GET /debug/test-tool-parse": "Test tool call parsing (AUTH)",
+            "GET /debug/test-tool-parse": "Test tool parsing (AUTH)",
         },
         "cookies": COOKIE_STATUS,
         "status": "✅ Server is working"
     }
 
+
 @app.get("/health")
 async def health():
     return {
         "status": "ok",
-        "version": "2.0.0",
+        "version": "2.1.0",
         "cookies": COOKIE_STATUS,
         "providers": list(REAL_PROVIDERS.keys()),
         "provider_count": len(REAL_PROVIDERS),
-        "features": {
-            "tool_call_detection": True,
-            "multi_block_content": True,
-            "anthropic_protocol": True
+        "fixes": {
+            "selective_memory": True,
+            "improved_regex": True,
+            "tool_id_binding": True
         },
         "timestamp": int(time.time())
     }
 
+
 @app.get("/providers")
 async def get_providers(request: Request):
     verify_api_key(request)
@@ -1734,6 +1809,7 @@ async def get_providers(request: Request):
         }
     return {"providers": result}
 
+
 # =====================================================
 # نقطة تشخيص: اختبار تحليل tool calls
 # =====================================================
@@ -1744,19 +1820,58 @@ async def debug_test_tool_parse(request: Request):
     test_cases = [
         {
             "name": "Standard tool_call tags",
-            "input": 'I will create the file now.\n<tool_call>{"name": "write_file", "arguments": {"path": "test.py", "content": "print(\'hello\')"}}</tool_call>',
+            "input": (
+                'I will create the file now.\n'
+                '<tool_call>{"name": "write_file", '
+                '"arguments": {"path": "test.py", "content": "print(\'hello\')"}}'
+                '</tool_call>'
+            ),
+        },
+        {
+            "name": "Tool call with leading whitespace/newlines",
+            "input": (
+                'Let me help you.\n\n\n'
+                '   <tool_call>\n'
+                '{"name": "read_file", "arguments": {"path": "config.json"}}\n'
+                '</tool_call>'
+            ),
         },
         {
             "name": "Code block format",
-            "input": 'Let me write that.\n```tool_call\n{"name": "read_file", "arguments": {"path": "config.json"}}\n```',
+            "input": (
+                'Let me write that.\n'
+                '```tool_call\n'
+                '{"name": "read_file", "arguments": {"path": "config.json"}}\n'
+                '```'
+            ),
         },
         {
             "name": "Function tag format",
-            "input": 'Creating file:\n<function=write_file>{"path": "app.js", "content": "console.log(1)"}</function>',
+            "input": (
+                'Creating file:\n'
+                '<function=write_file>'
+                '{"path": "app.js", "content": "console.log(1)"}'
+                '</function>'
+            ),
         },
         {
             "name": "Multiple tool calls",
-            "input": 'First read, then write.\n<tool_call>{"name": "read_file", "arguments": {"path": "old.txt"}}</tool_call>\nNow writing:\n<tool_call>{"name": "write_file", "arguments": {"path": "new.txt", "content": "data"}}</tool_call>',
+            "input": (
+                'First read, then write.\n'
+                '<tool_call>{"name": "read_file", "arguments": {"path": "old.txt"}}'
+                '</tool_call>\n'
+                'Now writing:\n'
+                '<tool_call>{"name": "write_file", "arguments": {"path": "new.txt", "content": "data"}}'
+                '</tool_call>'
+            ),
+        },
+        {
+            "name": "Case insensitive detection",
+            "input": (
+                'Using uppercase:\n'
+                '<TOOL_CALL>{"name": "list_files", "arguments": {"path": "."}}'
+                '</TOOL_CALL>'
+            ),
         },
         {
             "name": "No tool calls (plain text)",
@@ -1769,7 +1884,11 @@ async def debug_test_tool_parse(request: Request):
         clean_text, tool_calls = ToolCallParser.parse_tool_calls(tc["input"])
         results.append({
             "test_name": tc["name"],
-            "input_preview": tc["input"][:100] + "..." if len(tc["input"]) > 100 else tc["input"],
+            "input_preview": (
+                tc["input"][:100] + "..."
+                if len(tc["input"]) > 100
+                else tc["input"]
+            ),
             "clean_text": clean_text,
             "tool_calls_found": len(tool_calls),
             "tool_calls": tool_calls,
@@ -1778,6 +1897,7 @@ async def debug_test_tool_parse(request: Request):
 
     return {"test_results": results}
 
+
 # =====================================================
 # نقطة تشخيص: اختبار stream buffer
 # =====================================================
@@ -1790,7 +1910,6 @@ async def debug_test_stream_buffer(request: Request):
     tools = body.get("tools", [])
     chunk_size = body.get("chunk_size", 10)
 
-    # محاكاة streaming بتقسيم النص إلى chunks
     buffer = StreamToolBuffer(available_tools=tools)
     all_events = []
 
@@ -1800,7 +1919,6 @@ async def debug_test_stream_buffer(request: Request):
         for event in events:
             all_events.append({"chunk_index": i // chunk_size, "event": event})
 
-    # تفريغ المتبقي
     remaining = buffer.flush()
     for event in remaining:
         all_events.append({"chunk_index": "flush", "event": event})
@@ -1813,20 +1931,26 @@ async def debug_test_stream_buffer(request: Request):
         "events": all_events
     }
 
+
 @app.post("/chat")
 async def chat(request: Request, chat_req: ChatRequest):
     verify_api_key(request)
     result = ""
-    for chunk in ask(chat_req.message, chat_req.history, chat_req.provider, chat_req.model):
+    for chunk in ask(
+        chat_req.message, chat_req.history, chat_req.provider, chat_req.model
+    ):
         result += chunk
     return JSONResponse({"response": result})
 
+
 @app.post("/chat/stream")
 async def chat_stream(request: Request, chat_req: ChatRequest):
     verify_api_key(request)
 
     async def generate():
-        for chunk in ask(chat_req.message, chat_req.history, chat_req.provider, chat_req.model):
+        for chunk in ask(
+            chat_req.message, chat_req.history, chat_req.provider, chat_req.model
+        ):
             yield f"data: {json.dumps({'delta': chunk}, ensure_ascii=False)}\n\n"
         yield "data: [DONE]\n\n"
 
@@ -1839,8 +1963,9 @@ async def chat_stream(request: Request, chat_req: ChatRequest):
         }
     )
 
+
 # =====================================================
-# معالجة الأخطاء العامة - بصيغة Anthropic
+# معالجة الأخطاء العامة
 # =====================================================
 @app.exception_handler(404)
 async def not_found_handler(request: Request, exc: HTTPException):
@@ -1850,11 +1975,14 @@ async def not_found_handler(request: Request, exc: HTTPException):
             "type": "error",
             "error": {
                 "type": "not_found_error",
-                "message": f"Endpoint {request.method} {request.url.path} not found"
+                "message": (
+                    f"Endpoint {request.method} {request.url.path} not found"
+                )
             }
         }
     )
 
+
 @app.exception_handler(500)
 async def internal_error_handler(request: Request, exc: Exception):
     logger.error(f"Internal error: {str(exc)}")
@@ -1869,6 +1997,7 @@ async def internal_error_handler(request: Request, exc: Exception):
         }
     )
 
+
 @app.exception_handler(401)
 async def auth_error_handler(request: Request, exc: HTTPException):
     return JSONResponse(
@@ -1877,11 +2006,14 @@ async def auth_error_handler(request: Request, exc: HTTPException):
             "type": "error",
             "error": {
                 "type": "authentication_error",
-                "message": exc.detail if hasattr(exc, 'detail') else "Invalid API key"
+                "message": (
+                    exc.detail if hasattr(exc, 'detail') else "Invalid API key"
+                )
             }
         }
     )
 
+
 @app.exception_handler(400)
 async def bad_request_handler(request: Request, exc: HTTPException):
     return JSONResponse(
@@ -1890,11 +2022,14 @@ async def bad_request_handler(request: Request, exc: HTTPException):
             "type": "error",
             "error": {
                 "type": "invalid_request_error",
-                "message": exc.detail if hasattr(exc, 'detail') else "Bad request"
+                "message": (
+                    exc.detail if hasattr(exc, 'detail') else "Bad request"
+                )
             }
         }
     )
 
+
 @app.exception_handler(429)
 async def rate_limit_handler(request: Request, exc: HTTPException):
     return JSONResponse(
@@ -1908,14 +2043,16 @@ async def rate_limit_handler(request: Request, exc: HTTPException):
         }
     )
 
+
 # =====================================================
 # التشغيل
 # =====================================================
 if __name__ == "__main__":
     import uvicorn
     port = int(os.getenv("PORT", 7860))
-    logger.info(f"Starting G4F Smart Router v2.0 (Protocol Translator) on port {port}")
+    logger.info(f"Starting G4F Smart Router v2.1 on port {port}")
     logger.info(f"Cookies: {COOKIE_STATUS}")
-    logger.info(f"Available providers: {list(REAL_PROVIDERS.keys())}")
-    logger.info(f"Features: Tool Call Detection, Multi-Block Content, Full Anthropic Protocol")
+    logger.info(f"Providers: {list(REAL_PROVIDERS.keys())}")
+    logger.info("Fixes: [Memory] [Regex] [Tool-ID-Binding]")
     uvicorn.run("app:app", host="0.0.0.0", port=port, reload=False)
+