Update app.py

app.py

@@ -1,10 +1,13 @@
+
 import os
 import json
 import time
 import logging
 import asyncio
 import threading
-from typing import Any, Dict, List, Optional
+import re
+import uuid
+from typing import Any, Dict, List, Optional, Tuple
 from collections import OrderedDict
 from fastapi import FastAPI, HTTPException, Request
 from fastapi.responses import StreamingResponse, JSONResponse, Response
@@ -214,6 +217,26 @@ def extract_text_from_content(content) -> str:
             elif isinstance(item, dict):
                 if item.get("type") == "text":
                     parts.append(item.get("text", ""))
+                elif item.get("type") == "tool_result":
+                    # استخراج نتيجة الأداة وتمريرها كنص
+                    tool_content = item.get("content", "")
+                    if isinstance(tool_content, list):
+                        for tc in tool_content:
+                            if isinstance(tc, dict) and tc.get("type") == "text":
+                                parts.append(tc.get("text", ""))
+                            elif isinstance(tc, 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)}]")
                 elif "text" in item:
                     parts.append(item["text"])
                 elif "content" in item:
@@ -223,6 +246,766 @@ def extract_text_from_content(content) -> str:
         return str(content)
     return ""
 
+# =====================================================
+# TOOL CALL PARSER - محلل طلبات الأدوات من النص الخام
+# يكتشف ويحلل وسوم <tool_call> من استجابة النموذج
+# =====================================================
+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]
+    """
+
+    # أنماط regex للكشف عن tool calls
+    PATTERNS = [
+        # النمط 1: <tool_call>JSON</tool_call>
+        re.compile(
+            r'<tool_call>\s*(\{.*?\})\s*</tool_call>',
+            re.DOTALL
+        ),
+        # النمط 2: ```tool_call\nJSON\n```
+        re.compile(
+            r'```(?:tool_call|json)?\s*\n?\s*(\{[^`]*?"(?:name|function)"[^`]*?\})\s*\n?```',
+            re.DOTALL
+        ),
+        # النمط 3: <function=name>JSON</function>
+        re.compile(
+            r'<function=(\w+)>\s*(\{.*?\})\s*</function>',
+            re.DOTALL
+        ),
+        # النمط 4: [TOOL_CALL]...[/TOOL_CALL]
+        re.compile(
+            r'\[TOOL_CALL\]\s*(.*?)\s*\[/TOOL_CALL\]',
+            re.DOTALL
+        ),
+        # النمط 5: ✿FUNCTION✿: name\n✿ARGS✿: JSON\n✿RESULT✿
+        re.compile(
+            r'✿FUNCTION✿:\s*(\w+)\s*\n✿ARGS✿:\s*(\{.*?\})\s*(?:\n✿RESULT✿)?',
+            re.DOTALL
+        ),
+    ]
+
+    # أنماط بداية tool call (للكشف المبكر أثناء الـ streaming)
+    START_MARKERS = [
+        '<tool_call>',
+        '```tool_call',
+        '<function=',
+        '[TOOL_CALL]',
+        '✿FUNCTION✿',
+        '{"tool_calls"',
+        '"tool_calls":',
+    ]
+
+    @staticmethod
+    def generate_tool_id() -> str:
+        """توليد معرف فريد للأداة بصيغة Anthropic"""
+        return f"toolu_{uuid.uuid4().hex[:24]}"
+
+    @classmethod
+    def might_contain_tool_call(cls, text: str) -> bool:
+        """فحص سريع: هل النص قد يحتوي على بداية tool call؟"""
+        text_lower = text.lower()
+        for marker in cls.START_MARKERS:
+            if marker.lower() in text_lower:
+                return True
+        return False
+
+    @classmethod
+    def parse_tool_calls(cls, text: str, available_tools: Optional[List[Dict]] = None) -> Tuple[str, List[Dict]]:
+        """
+        تحليل النص واستخراج tool calls منه.
+        
+        يُرجع:
+        - النص النظيف (بدون وسوم الأدوات)
+        - قائمة بـ tool calls المكتشفة بصيغة Anthropic
+        """
+        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
+        )
+        for match in pattern1_matches:
+            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), "")
+            except json.JSONDecodeError as e:
+                logger.warning(f"Failed to parse tool_call JSON: {e}")
+                # محاولة إصلاح JSON المكسور
+                fixed = cls._try_fix_json(raw_json)
+                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), "")
+
+        # النمط 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
+            )
+            for match in pattern2_matches:
+                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), "")
+                except json.JSONDecodeError:
+                    pass
+
+        # النمط 3: <function=name>JSON</function>
+        if not tool_calls:
+            pattern3_matches = re.finditer(
+                r'<function=(\w+)>\s*(\{.*?\})\s*</function>',
+                text, re.DOTALL
+            )
+            for match in pattern3_matches:
+                try:
+                    func_name = match.group(1)
+                    args_json = json.loads(match.group(2).strip())
+                    tool_call = {
+                        "type": "tool_use",
+                        "id": cls.generate_tool_id(),
+                        "name": func_name,
+                        "input": args_json
+                    }
+                    if available_tools:
+                        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), "")
+                except json.JSONDecodeError:
+                    pass
+
+        # النمط 4: [TOOL_CALL]...[/TOOL_CALL]
+        if not tool_calls:
+            pattern4_matches = re.finditer(
+                r'\[TOOL_CALL\]\s*(.*?)\s*\[/TOOL_CALL\]',
+                text, re.DOTALL
+            )
+            for match in pattern4_matches:
+                content = match.group(1).strip()
+                try:
+                    parsed = json.loads(content)
+                    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), "")
+                except json.JSONDecodeError:
+                    # محاولة تحليل كـ function_name(args)
+                    func_match = re.match(r'(\w+)\s*\((.*)\)', content, re.DOTALL)
+                    if func_match:
+                        try:
+                            func_name = func_match.group(1)
+                            args_str = func_match.group(2).strip()
+                            args = json.loads(args_str) if args_str else {}
+                            tool_call = {
+                                "type": "tool_use",
+                                "id": cls.generate_tool_id(),
+                                "name": func_name,
+                                "input": args
+                            }
+                            tool_calls.append(tool_call)
+                            clean_text = clean_text.replace(match.group(0), "")
+                        except json.JSONDecodeError:
+                            pass
+
+        # النمط 5: ✿FUNCTION✿
+        if not tool_calls:
+            pattern5_matches = re.finditer(
+                r'✿FUNCTION✿:\s*(\w+)\s*\n✿ARGS✿:\s*(\{.*?\})\s*(?:\n✿RESULT✿)?',
+                text, re.DOTALL
+            )
+            for match in pattern5_matches:
+                try:
+                    func_name = match.group(1)
+                    args_json = json.loads(match.group(2).strip())
+                    tool_call = {
+                        "type": "tool_use",
+                        "id": cls.generate_tool_id(),
+                        "name": func_name,
+                        "input": args_json
+                    }
+                    tool_calls.append(tool_call)
+                    clean_text = clean_text.replace(match.group(0), "")
+                except json.JSONDecodeError:
+                    pass
+
+        # النمط 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:
+                    try:
+                        parsed = json.loads(jm.group(0))
+                        if "tool_calls" in parsed:
+                            for tc in parsed["tool_calls"]:
+                                func_data = tc.get("function", tc)
+                                name = func_data.get("name", "")
+                                args = func_data.get("arguments", func_data.get("input", {}))
+                                if isinstance(args, str):
+                                    args = json.loads(args)
+                                if name:
+                                    tool_call = {
+                                        "type": "tool_use",
+                                        "id": cls.generate_tool_id(),
+                                        "name": name,
+                                        "input": args
+                                    }
+                                    tool_calls.append(tool_call)
+                                    clean_text = clean_text.replace(jm.group(0), "")
+                    except json.JSONDecodeError:
+                        pass
+            except Exception:
+                pass
+
+        # تنظيف النص من المسافات الزائدة
+        clean_text = clean_text.strip()
+        # إزالة أسطر فارغة متتالية
+        clean_text = re.sub(r'\n{3,}', '\n\n', 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": {...}}
+        """
+        name = None
+        arguments = {}
+
+        # استخراج الاسم
+        if "function" in parsed and isinstance(parsed["function"], dict):
+            name = parsed["function"].get("name")
+            arguments = parsed["function"].get("arguments", {})
+        elif "name" in parsed:
+            name = parsed["name"]
+            arguments = (
+                parsed.get("arguments") or
+                parsed.get("parameters") or
+                parsed.get("input") or
+                parsed.get("args") or
+                {}
+            )
+        elif "tool" in parsed:
+            name = parsed["tool"]
+            arguments = parsed.get("args", parsed.get("arguments", parsed.get("input", {})))
+
+        if not name:
+            return None
+
+        # تحويل arguments من string إلى dict إذا لزم
+        if isinstance(arguments, str):
+            try:
+                arguments = json.loads(arguments)
+            except json.JSONDecodeError:
+                arguments = {"raw_input": arguments}
+
+        tool_call = {
+            "type": "tool_use",
+            "id": cls.generate_tool_id(),
+            "name": str(name),
+            "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]:
+        """
+        التحقق من أن الأداة المطلوبة موجودة في قائمة الأدوات المتاحة.
+        إذا لم تكن موجودة بالضبط، يحاول إيجاد أقرب تطابق.
+        """
+        requested_name = tool_call["name"]
+        tool_names = []
+
+        for tool in available_tools:
+            tool_name = tool.get("name", "")
+            if not tool_name and "function" in tool:
+                tool_name = tool["function"].get("name", "")
+            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  # استخدام الاسم الصحيح
+                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}")
+        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
+        open_brackets = fixed.count('[') - fixed.count(']')
+        if open_brackets > 0:
+            fixed += ']' * open_brackets
+
+        try:
+            return json.loads(fixed)
+        except json.JSONDecodeError:
+            pass
+
+        # محاولة أخرى: استخراج أول JSON صالح
+        try:
+            # البحث عن بداية ونهاية JSON
+            start = fixed.index('{')
+            depth = 0
+            for i in range(start, len(fixed)):
+                if fixed[i] == '{':
+                    depth += 1
+                elif fixed[i] == '}':
+                    depth -= 1
+                    if depth == 0:
+                        return json.loads(fixed[start:i+1])
+        except (ValueError, json.JSONDecodeError):
+            pass
+
+        return None
+
+
+# =====================================================
+# TOOL CALL STREAM BUFFER - لاكتشاف tool calls أثناء الـ streaming
+# =====================================================
+class StreamToolBuffer:
+    """
+    Buffer ذكي يجمع chunks الـ stream ويكتشف tool calls.
+    يعمل بنمطين:
+    1. نمط النص العادي: يمرر النص مباشرة
+    2. نمط Tool Call: يجمع النص حتى يكتمل الوسم ثم يحلله
+    """
+
+    def __init__(self, available_tools: Optional[List[Dict]] = None):
+        self.buffer = ""
+        self.in_tool_call = False
+        self.tool_call_buffer = ""
+        self.available_tools = available_tools or []
+        self.pending_text = ""
+        self.tool_call_depth = 0
+
+    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  # لم يكتمل الوسم بعد، ننتظر المزيد
+            else:
+                # نمط عادي: نبحث عن بداية tool call
+                events.extend(self._process_text_mode())
+                if self.in_tool_call:
+                    continue  # وجدنا بداية tool call، نكمل المعالجة
+                break  # لا يوجد tool call، ننتظر المزيد
+
+        return events
+
+    def _process_text_mode(self) -> List[Dict]:
+        """معالجة النص في النمط العادي"""
+        events = []
+
+        # البحث عن أي من علامات بداية tool call
+        earliest_pos = -1
+        earliest_marker = ""
+        for marker in ToolCallParser.START_MARKERS:
+            pos = self.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
+            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})
+
+            # الانتقال لنمط tool call
+            self.buffer = self.buffer[earliest_pos:]
+            self.in_tool_call = True
+            self.tool_call_buffer = ""
+
+        return events
+
+    def _process_tool_call_mode(self) -> List[Dict]:
+        """معالجة النص في نمط tool call"""
+        events = []
+
+        # البحث عن نهاية الوسم
+        end_markers = [
+            ('</tool_call>', '<tool_call>'),
+            ('```', '```tool_call'),
+            ('```', '```json'),
+            ('</function>', '<function='),
+            ('[/TOOL_CALL]', '[TOOL_CALL]'),
+        ]
+
+        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)
+
+            if end_pos != -1:
+                # وجدنا النهاية
+                full_tool_text = self.buffer[:end_pos + len(end_marker)]
+                remaining = self.buffer[end_pos + len(end_marker):]
+
+                # تحليل الـ tool call
+                clean_text, tool_calls = ToolCallParser.parse_tool_calls(
+                    full_tool_text, self.available_tools
+                )
+
+                for tc in tool_calls:
+                    events.append(tc)
+
+                # إذا بقي نص نظيف
+                if clean_text.strip():
+                    events.append({"type": "text", "text": clean_text})
+
+                self.buffer = remaining
+                self.in_tool_call = False
+                found_end = True
+                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")
+                events.append({"type": "text", "text": self.buffer})
+                self.buffer = ""
+                self.in_tool_call = False
+
+        return events
+
+    def flush(self) -> List[Dict]:
+        """
+        تفريغ أي محتوى متبقي في الـ buffer.
+        يُستدعى عند انتهاء الـ stream.
+        """
+        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:
+                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})
+
+        self.buffer = ""
+        self.in_tool_call = False
+        return events
+
+
+# =====================================================
+# TOOLS FORMATTER - تحويل أدوات Anthropic إلى نص للنموذج
+# =====================================================
+class ToolsFormatter:
+    """
+    يأخذ مصفوفة tools من طلب Anthropic ويحولها إلى تعليمات نصية
+    تُضاف إلى System Prompt لتوجيه النموذج لاستخدام الأدوات.
+    """
+
+    @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("")
+        lines.append("<tool_call>")
+        lines.append('{"name": "tool_name", "arguments": {"param1": "value1", "param2": "value2"}}')
+        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("")
+        lines.append("## Tool Definitions:")
+        lines.append("")
+
+        for i, tool in enumerate(tools, 1):
+            name = tool.get("name", "unknown")
+            description = tool.get("description", "No description")
+            input_schema = tool.get("input_schema", {})
+
+            lines.append(f"### {i}. `{name}`")
+            lines.append(f"**Description:** {description}")
+
+            # معالجة المعاملات
+            properties = input_schema.get("properties", {})
+            required = input_schema.get("required", [])
+
+            if properties:
+                lines.append("**Parameters:**")
+                for param_name, param_info in properties.items():
+                    param_type = param_info.get("type", "any")
+                    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 إذا وجدت
+                    if "enum" in param_info:
+                        lines.append(f"    Allowed values: {', '.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.")
+                elif tool_choice.get("type") == "any":
+                    lines.append("**IMPORTANT:** You MUST use at least one tool in your response.")
+            elif tool_choice == "auto":
+                lines.append("Use tools when appropriate to accomplish the task.")
+            elif tool_choice == "any":
+                lines.append("**IMPORTANT:** You MUST use at least one tool in your response.")
+
+        lines.append("")
+        lines.append("Remember: Always use <tool_call>JSON</tool_call> format when calling tools.")
+        lines.append("The JSON inside must have 'name' and 'arguments' keys.")
+        lines.append("")
+
+        return "\n".join(lines)
+
+    @staticmethod
+    def format_tool_result_for_message(tool_use_id: str, content: Any) -> str:
+        """تحويل نتيجة أداة إلى نص مفهوم للنموذج"""
+        result_text = ""
+        if isinstance(content, str):
+            result_text = content
+        elif isinstance(content, list):
+            parts = []
+            for item in content:
+                if isinstance(item, dict):
+                    if item.get("type") == "text":
+                        parts.append(item.get("text", ""))
+                    elif item.get("type") == "image":
+                        parts.append("[Image content]")
+                    else:
+                        parts.append(json.dumps(item, ensure_ascii=False))
+                elif isinstance(item, str):
+                    parts.append(item)
+            result_text = "\n".join(parts)
+        elif isinstance(content, dict):
+            result_text = json.dumps(content, ensure_ascii=False, indent=2)
+        else:
+            result_text = str(content) if content else ""
+
+        return f"[Tool Result (id: {tool_use_id})]\n{result_text}\n[/Tool Result]"
+
+
+# =====================================================
+# MESSAGE CONVERTER - تحويل رسائل Anthropic إلى صيغة g4f
+# =====================================================
+class MessageConverter:
+    """
+    يحول رسائل Anthropic (التي قد تحتوي tool_use و tool_result)
+    إلى رسائل نصية بسيطة يفهمها 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: سجل المحادثة
+        """
+        history = []
+        
+        # بناء system prompt مع تعريفات الأدوات
+        full_system = ""
+        if system_prompt:
+            full_system = system_prompt
+
+        if tools:
+            tools_text = ToolsFormatter.format_tools_for_prompt(tools, tool_choice)
+            if full_system:
+                full_system = f"{full_system}\n\n{tools_text}"
+            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}"
+                else:
+                    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}"
+        else:
+            full_message = user_message
+
+        return full_message, history
+
+    @staticmethod
+    def _convert_content(content: Any, role: str) -> str:
+        """تحويل محتوى رسالة واحدة"""
+        if isinstance(content, str):
+            return content
+
+        if isinstance(content, list):
+            parts = []
+            for block in content:
+                if isinstance(block, str):
+                    parts.append(block)
+                elif isinstance(block, dict):
+                    block_type = block.get("type", "")
+
+                    if block_type == "text":
+                        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"</tool_call>"
+                        )
+
+                    elif block_type == "tool_result":
+                        # تحويل نتيجة أداة
+                        tool_use_id = block.get("tool_use_id", "")
+                        result_content = block.get("content", "")
+                        is_error = block.get("is_error", False)
+
+                        result_text = ToolsFormatter.format_tool_result_for_message(
+                            tool_use_id, result_content
+                        )
+                        if is_error:
+                            result_text = f"[ERROR] {result_text}"
+                        parts.append(result_text)
+
+                    elif block_type == "image":
+                        parts.append("[Image content - not supported in text mode]")
+
+                    else:
+                        # نوع غير معروف
+                        if "text" in block:
+                            parts.append(block["text"])
+                        else:
+                            parts.append(json.dumps(block, ensure_ascii=False))
+
+            return "\n".join(parts)
+
+        if content is not None:
+            return str(content)
+        return ""
+
+
 # =====================================================
 # CHAT LOGIC - مع fallback ذكي
 # =====================================================
@@ -233,7 +1016,7 @@ def ask(message: str, history, provider_name: str, model_name: str, stop_flag=No
         return
 
     # مفتاح التخزين المؤقت
-    key = f"{provider_name}|{model_name}|{message}"
+    key = f"{provider_name}|{model_name}|{message[:200]}"
     cached = CACHE.get(key)
     if cached:
         yield cached
@@ -243,21 +1026,22 @@ def ask(message: str, history, provider_name: str, model_name: str, stop_flag=No
     msgs = []
     try:
         if history:
-            if isinstance(history[0], dict):
-                for item in history[-40:]:
-                    role = item.get("role")
-                    content = item.get("content")
-                    if role and content:
-                        text = extract_text_from_content(content)
-                        if text:
-                            msgs.append({"role": str(role), "content": text})
-            else:
-                for item in history[-20:]:
-                    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])})
+            if isinstance(history, list) and len(history) > 0:
+                if isinstance(history[0], dict):
+                    for item in history[-40:]:
+                        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
+                            if text:
+                                msgs.append({"role": str(role), "content": text})
+                else:
+                    for item in history[-20:]:
+                        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}")
 
@@ -327,7 +1111,7 @@ def ask(message: str, history, provider_name: str, model_name: str, stop_flag=No
 # =====================================================
 # FASTAPI
 # =====================================================
-app = FastAPI(title="G4F Smart Router", description="AI Gateway - متعدد المزودات")
+app = FastAPI(title="G4F Smart Router", description="AI Gateway - Protocol Translator for Anthropic")
 
 # إضافة CORS للسماح بالطلبات من أي مصدر
 app.add_middleware(
@@ -392,7 +1176,7 @@ async def head_chat_completions():
     return Response(status_code=200)
 
 # =====================================================
-# نقاط نهاية متوافقة مع Claude Coowork و Anthropic API
+# نقاط نهاية متوافقة مع Claude Cowork و Anthropic API
 # =====================================================
 @app.get("/v1/models")
 async def v1_models(request: Request):
@@ -423,61 +1207,108 @@ async def v1_models(request: Request):
     return {"object": "list", "data": models}
 
 # =====================================================
-# إصلاح: نقطة /v1/messages تدعم stream و non-stream
-# Claude Coowork يرسل stream: true في body نفسه
+# نقطة /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', []))}")
+
     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:
+            if isinstance(sp, dict) and sp.get("type") == "text":
+                sys_parts.append(sp.get("text", ""))
+            elif isinstance(sp, str):
+                sys_parts.append(sp)
+        system_prompt = "\n".join(sys_parts)
+
     is_stream = body.get("stream", False)
     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
+    )
 
-    # استخراج آخر رسالة مستخدم
-    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")
-        content = extract_text_from_content(msg.get("content", ""))
-        if role and content:
-            history.append({"role": role, "content": content})
-
-    # إضافة system prompt إذا وجد
-    full_message = user_message
-    if system_prompt:
-        full_message = f"[System: {system_prompt}]\n\n{user_message}"
+    logger.info(f"Converted message length: {len(full_message)}, history length: {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)
+        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  # إصلاح: += بدلاً من =
+        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(user_message) // 4)
+    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 إذا وجدت
+    for tc in tool_calls:
+        content_blocks.append({
+            "type": "tool_use",
+            "id": tc.get("id", ToolCallParser.generate_tool_id()),
+            "name": tc["name"],
+            "input": tc.get("input", {})
+        })
+
+    # إذا لم يكن هناك أي محتوى
+    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"
+
     return {
         "id": message_id,
         "type": "message",
         "role": "assistant",
-        "content": [{"type": "text", "text": full_response}],
+        "content": content_blocks,
         "model": model,
-        "stop_reason": "end_turn",
+        "stop_reason": stop_reason,
         "stop_sequence": None,
         "usage": {
             "input_tokens": input_tokens,
@@ -487,10 +1318,20 @@ async def v1_messages(request: Request):
 
 # =====================================================
 # معالج الـ streaming بصيغة Anthropic SSE
+# مع دعم كامل لـ Tool Use و Multi-Block Content
 # =====================================================
-async def _handle_anthropic_stream(full_message: str, history: list, model: str, max_tokens: int):
+async def _handle_anthropic_stream(
+    full_message: str,
+    history: list,
+    model: str,
+    max_tokens: int,
+    tools: List[Dict] = None,
+    tool_choice: Any = None,
+    metadata: Dict = None
+):
     async def generate_stream():
         message_id = f"msg_{int(time.time())}_{os.urandom(4).hex()}"
+        tools_list = tools or []
 
         # حدث بداية الرسالة
         msg_start = {
@@ -511,44 +1352,176 @@ async def _handle_anthropic_stream(full_message: str, history: list, model: str,
         }
         yield f"event: message_start\ndata: {json.dumps(msg_start, ensure_ascii=False)}\n\n"
 
-        # حدث بداية كتلة المحتوى
-        block_start = {
-            "type": "content_block_start",
-            "index": 0,
-            "content_block": {
-                "type": "text",
-                "text": ""
-            }
-        }
-        yield f"event: content_block_start\ndata: {json.dumps(block_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
-        for chunk in ask(full_message, history, "Blackbox", model):
-            if chunk:
-                output_tokens += max(1, len(chunk) // 4)
+        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": ""
+                }
+            }
+            return f"event: content_block_start\ndata: {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
+                }
+            }
+            return f"event: content_block_delta\ndata: {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"
+
+        # دالة مساعدة لإرسال tool_use block كامل
+        def make_tool_use_events(index: int, tool_call: Dict) -> str:
+            events_str = ""
+            tool_id = tool_call.get("id", ToolCallParser.generate_tool_id())
+            tool_name = tool_call.get("name", "unknown")
+            tool_input = tool_call.get("input", {})
+
+            # بداية كتلة tool_use
+            block_start = {
+                "type": "content_block_start",
+                "index": index,
+                "content_block": {
+                    "type": "tool_use",
+                    "id": tool_id,
+                    "name": tool_name,
+                    "input": {}
+                }
+            }
+            events_str += f"event: content_block_start\ndata: {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]
                 delta_event = {
                     "type": "content_block_delta",
-                    "index": 0,
+                    "index": index,
                     "delta": {
-                        "type": "text_delta",
-                        "text": chunk
+                        "type": "input_json_delta",
+                        "partial_json": json_chunk
                     }
                 }
-                yield f"event: content_block_delta\ndata: {json.dumps(delta_event, ensure_ascii=False)}\n\n"
+                events_str += f"event: content_block_delta\ndata: {json.dumps(delta_event, ensure_ascii=False)}\n\n"
 
-        # حدث نهاية كتلة المحتوى
-        block_stop = {
-            "type": "content_block_stop",
-            "index": 0
-        }
-        yield f"event: content_block_stop\ndata: {json.dumps(block_stop, ensure_ascii=False)}\n\n"
+            # نهاية كتلة tool_use
+            events_str += make_block_stop(index)
+
+            return events_str
+
+        # ===== بدء معالجة الـ Stream =====
+        try:
+            for chunk in ask(full_message, history, "Blackbox", model):
+                if not chunk:
+                    continue
+
+                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
+                events = tool_buffer.feed(chunk)
+
+                for event in events:
+                    if event.get("type") == "text":
+                        text = event["text"]
+                        if text:
+                            if not text_block_open:
+                                yield make_text_block_start(current_block_index)
+                                text_block_open = True
+                            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
+
+            # ===== تفريغ الـ buffer المتبقي =====
+            remaining_events = tool_buffer.flush()
+            for event in remaining_events:
+                if event.get("type") == "text":
+                    text = event["text"]
+                    if text:
+                        if not text_block_open:
+                            yield make_text_block_start(current_block_index)
+                            text_block_open = True
+                        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
+
+                    has_tool_calls = True
+                    yield make_tool_use_events(current_block_index, event)
+                    current_block_index += 1
+
+        except Exception as 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
+            yield make_text_delta(current_block_index, f"\n\n[Error: {str(e)}]")
+
+        # إغلاق آخر كتلة مفتوحة
+        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": "end_turn",
+                "stop_reason": stop_reason,
                 "stop_sequence": None
             },
             "usage": {
@@ -571,7 +1544,7 @@ async def _handle_anthropic_stream(full_message: str, history: list, model: str,
     )
 
 # =====================================================
-# إصلاح: نقطة /v1/messages/stream منفصلة (للتوافق)
+# نقطة /v1/messages/stream منفصلة (للتوافق)
 # =====================================================
 @app.post("/v1/messages/stream")
 async def v1_messages_stream(request: Request):
@@ -582,29 +1555,30 @@ async def v1_messages_stream(request: Request):
     if not messages:
         raise HTTPException(status_code=400, detail="No messages provided")
 
-    last_message = messages[-1]
-    user_message = extract_text_from_content(last_message.get("content", ""))
     model = body.get("model", "gpt-4o")
     system_prompt = body.get("system", "")
-    max_tokens = body.get("max_tokens", 4096)
+    if isinstance(system_prompt, list):
+        sys_parts = []
+        for sp in system_prompt:
+            if isinstance(sp, dict) and sp.get("type") == "text":
+                sys_parts.append(sp.get("text", ""))
+            elif isinstance(sp, str):
+                sys_parts.append(sp)
+        system_prompt = "\n".join(sys_parts)
 
-    # بناء history
-    history = []
-    for msg in messages[:-1]:
-        role = msg.get("role", "user")
-        content = extract_text_from_content(msg.get("content", ""))
-        if role and content:
-            history.append({"role": role, "content": content})
+    max_tokens = body.get("max_tokens", 4096)
+    tools = body.get("tools", [])
+    tool_choice = body.get("tool_choice", "auto")
 
-    full_message = user_message
-    if system_prompt:
-        full_message = f"[System: {system_prompt}]\n\n{user_message}"
+    # تحويل الرسائل
+    full_message, history = MessageConverter.convert_messages(
+        messages, system_prompt, tools, tool_choice
+    )
 
-    return await _handle_anthropic_stream(full_message, history, model, max_tokens)
+    return await _handle_anthropic_stream(full_message, history, model, max_tokens, tools, tool_choice)
 
 # =====================================================
-# إضافة: نقطة /v1/chat/completions (صيغة OpenAI)
-# بعض العملاء يستخدمون هذه الصيغة
+# نقطة /v1/chat/completions (صيغة OpenAI)
 # =====================================================
 @app.post("/v1/chat/completions")
 async def v1_chat_completions(request: Request):
@@ -706,18 +1680,27 @@ async def v1_chat_completions(request: Request):
 @app.get("/")
 async def root():
     return {
-        "message": "G4F Smart Router is running (Multi-Provider)",
+        "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"
+        ],
         "providers": list(REAL_PROVIDERS.keys()),
         "endpoints": {
             "GET /": "Home",
             "GET /health": "Health check",
             "GET /v1/models": "List models (NO AUTH)",
-            "POST /v1/messages": "Anthropic format - Send message (AUTH, supports stream:true)",
+            "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)",
             "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)",
         },
         "cookies": COOKIE_STATUS,
         "status": "✅ Server is working"
@@ -727,9 +1710,15 @@ async def root():
 async def health():
     return {
         "status": "ok",
+        "version": "2.0.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
+        },
         "timestamp": int(time.time())
     }
 
@@ -745,12 +1734,91 @@ async def get_providers(request: Request):
         }
     return {"providers": result}
 
+# =====================================================
+# نقطة تشخيص: اختبار تحليل tool calls
+# =====================================================
+@app.get("/debug/test-tool-parse")
+async def debug_test_tool_parse(request: Request):
+    verify_api_key(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>',
+        },
+        {
+            "name": "Code block format",
+            "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>',
+        },
+        {
+            "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>',
+        },
+        {
+            "name": "No tool calls (plain text)",
+            "input": "This is just a regular response with no tool calls.",
+        }
+    ]
+
+    results = []
+    for tc in test_cases:
+        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"],
+            "clean_text": clean_text,
+            "tool_calls_found": len(tool_calls),
+            "tool_calls": tool_calls,
+            "has_tool_call_marker": ToolCallParser.might_contain_tool_call(tc["input"])
+        })
+
+    return {"test_results": results}
+
+# =====================================================
+# نقطة تشخيص: اختبار stream buffer
+# =====================================================
+@app.post("/debug/test-stream-buffer")
+async def debug_test_stream_buffer(request: Request):
+    verify_api_key(request)
+    body = await request.json()
+
+    text = body.get("text", "")
+    tools = body.get("tools", [])
+    chunk_size = body.get("chunk_size", 10)
+
+    # محاكاة streaming بتقسيم النص إلى chunks
+    buffer = StreamToolBuffer(available_tools=tools)
+    all_events = []
+
+    for i in range(0, len(text), chunk_size):
+        chunk = text[i:i + chunk_size]
+        events = buffer.feed(chunk)
+        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})
+
+    return {
+        "input_length": len(text),
+        "chunk_size": chunk_size,
+        "total_chunks": (len(text) + chunk_size - 1) // chunk_size,
+        "total_events": len(all_events),
+        "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):
-        result += chunk  # إصلاح: += بدلاً من =
+        result += chunk
     return JSONResponse({"response": result})
 
 @app.post("/chat/stream")
@@ -772,13 +1840,14 @@ async def chat_stream(request: Request, chat_req: ChatRequest):
     )
 
 # =====================================================
-# معالجة الأخطاء العامة
+# معالجة الأخطاء العامة - بصيغة Anthropic
 # =====================================================
 @app.exception_handler(404)
 async def not_found_handler(request: Request, exc: HTTPException):
     return JSONResponse(
         status_code=404,
         content={
+            "type": "error",
             "error": {
                 "type": "not_found_error",
                 "message": f"Endpoint {request.method} {request.url.path} not found"
@@ -792,6 +1861,7 @@ async def internal_error_handler(request: Request, exc: Exception):
     return JSONResponse(
         status_code=500,
         content={
+            "type": "error",
             "error": {
                 "type": "api_error",
                 "message": "Internal server error"
@@ -799,13 +1869,53 @@ async def internal_error_handler(request: Request, exc: Exception):
         }
     )
 
+@app.exception_handler(401)
+async def auth_error_handler(request: Request, exc: HTTPException):
+    return JSONResponse(
+        status_code=401,
+        content={
+            "type": "error",
+            "error": {
+                "type": "authentication_error",
+                "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(
+        status_code=400,
+        content={
+            "type": "error",
+            "error": {
+                "type": "invalid_request_error",
+                "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(
+        status_code=429,
+        content={
+            "type": "error",
+            "error": {
+                "type": "rate_limit_error",
+                "message": "Rate limit exceeded. Please retry after a brief wait."
+            }
+        }
+    )
+
 # =====================================================
 # التشغيل
 # =====================================================
 if __name__ == "__main__":
     import uvicorn
     port = int(os.getenv("PORT", 7860))
-    logger.info(f"Starting G4F Smart Router on port {port}")
+    logger.info(f"Starting G4F Smart Router v2.0 (Protocol Translator) 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")
     uvicorn.run("app:app", host="0.0.0.0", port=port, reload=False)